CyberChaos(さいばかおす)

プログラミング言語、トランスパイラ、RPA、ChatGPT、データマイニング、リバースエンジニアリングのための忘備録

Rust製データベースSurreal

2024-07-07 16:50:43 | Rust

Rust製データベースSurrealDBの紹介 - Qiita

Rust製データベースSurrealDBの紹介 - Qiita

はじめにこの資料は、2022年7月に公開されたSurrealDBについてまとめたものです。SurrealDBの歴史公開されてからの期間は浅いが2016年から開発が始まっている2016年 Fe…

Qiita


Rustは挫折してから1年以上経つのだが、とりあえずRust製DBについての記事が見つかったので載せてみた。

インストールは簡単らしい。

ちなみに当分の間、Rustは再開するつもりはない。
Rustを再開させるならCOBOLとSQLとGoの独学に時間を使うべきだという方針。

他にも…
COBOL↔SQL(Oracle、MongoDB、CockroachDB→Go言語)↔Excel↔VisualBasic.NET↔給料計算・経理・会計・積算(Revit)等+C++(Object ARX、デバイスドライバ等プラットフォームエンジニアリング)

Rustでラ・カンパネラwww

2023-03-07 22:48:15 | Rust
Rust言語でhoundライブラリーを使ってリストのラ・カンパネラを鳴らすプログラムを書いてください

以下はRust言語でhoundライブラリーを使ってリストの「ラ・カンパネラ」を鳴らすプログラムです。注意:このプログラムは音声データを生成するだけで、音楽ファイルを再生するためのコードは含まれていません。

extern crate hound; fn main() { // サンプルレートを設定 let sample_rate = 44100; // 出力する音声データの長さを秒単位で指定 let duration_sec = 60.0; // 出力する音声データの長さをサンプル単位で計算 let num_samples = (duration_sec * sample_rate as f32) as usize; // 出力する音声データを格納するためのベクターを作成 let mut samples = Vec::with_capacity(num_samples); // ピアノの音階を定義 let notes = [("E5", 0.125), ("D#5", 0.125), ("E5", 0.125), ("D#5", 0.125), ("E5", 0.125), ("B4", 0.125), ("D5", 0.125), ("C5", 0.125), ("A4", 0.125), ("A#4", 0.125), ("B4", 0.125), ("C5", 0.125), ("D5", 0.125), ("E5", 0.125), ("C5", 0.125), ("A4", 0.125), ("E5", 0.125), ("D#5", 0.125), ("E5", 0.125), ("D#5", 0.125), ("E5", 0.125), ("B4", 0.125), ("D5", 0.125), ("C5", 0.125), ("A4", 0.125), ("A#4", 0.125), ("B4", 0.125), ("C5", 0.125), ("D5", 0.125), ("E5", 0.125), ("C5", 0.125), ("A4", 0.125)]; // ピアノの音を生成し、samplesベクターに追加する for &(note, duration) in &notes { let freq = get_frequency(note); let num_samples_for_note = (duration * sample_rate as f32) as usize; for i in 0..num_samples_for_note { let t = i as f32 / sample_rate as f32; let sample = (2.0 * std::f32::consts::PI * freq * t).sin(); samples.push(sample); } } // 音声ファイルに書き出すための設定を行う let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; // 音声ファ

…おや?死亡しましたか?www
ふざけんな!


Rustでラフマニノフピアノ協奏曲第二番一楽章をプログラミング!

2023-03-07 22:41:22 | Rust
Rust言語でhoundライブラリーを使ってラフマニノフピアノ協奏曲第二番一楽章の最初から15小節まで鳴らすプログラムを書いてください

(・・・5小節で死亡www Orz)
以下は、Rustのmidirとhoundライブラリを使用して、ショパンの幻想即興曲の最初から20小節目までの楽譜を再現する例です。midiデータから各音符の周波数を計算し、それを使用して波形を生成しています。また、楽譜を簡単に指定できるように、notes配列に音符の高さ、長さ、タイミングを指定しています。

extern crate hound; use std::f32::consts::PI; use std::i16; use std::time::Duration; fn main() { // midiから取得した各音符の周波数を格納する配列 let mut frequencies = vec![0.0; 128]; // midiから各音符の周波数を計算する for note in 0..128 { frequencies[note] = 440.0 * 2.0_f32.powf((note as f32 - 69.0) / 12.0); } // ラフマニノフのピアノ協奏曲第2番の第1楽章の楽譜を定義する let notes = vec![ // 小節1 (48, 2.0, 0.0), (48, 0.5, 2.0), (50, 0.5, 2.5), (53, 0.5, 3.0), (57, 0.5, 3.5), (60, 0.5, 4.0), (57, 0.5, 4.5), (53, 0.5, 5.0), (50, 0.5, 5.5), (48, 0.5, 6.0), (53, 0.5, 6.5), (57, 0.5, 7.0), // 小節2 (60, 0.5, 7.5), (65, 0.5, 8.0), (72, 0.5, 8.5), (60, 0.5, 9.0), (65, 0.5, 9.5), (72, 0.5, 10.0), // 小節3 (60, 0.5, 10.5), (65, 0.5, 11.0), (72, 0.5, 11.5), (60, 0.5, 12.0), (65, 0.5, 12.5), (72, 0.5, 13.0), // 小節4 (60, 0.5, 13.5), (65, 0.5, 14.0), (72, 0.5, 14.5), (60, 0.5, 15.0), (65, 0.5, 15.5), (72, 0.5, 16.0), // 小節5
2回目
以下は、RustのHoundライブラリと、音楽ファイルを再生するためのCPALライブラリを使用して、ラフマニノフのピアノ協奏曲第2番の1楽章の最初の15小節を再現する例です。楽譜は、ノートの高さ、長さ、開始時刻を含むnotesベクターで指定されています。

extern crate hound; extern crate cpal; use std::f32::consts::PI; use std::i16; use std::time::Duration; fn main() { // ノートの高さ、長さ、開始時刻を格納する配列 let notes = vec![ (60, 0.5, 0.0), (67, 0.5, 0.5), (64, 0.5, 1.0), (67, 0.5, 1.5), (60, 0.5, 2.0), (67, 0.5, 2.5), (64, 0.5, 3.0), (67, 0.5, 3.5), (60, 0.5, 4.0), (64, 0.5, 4.5), (67, 0.5, 5.0), (60, 0.5, 5.5), (64

ダメだこりゃwww

P.S.
参考までに、BingのチャットAIで同じ質問をした場合の回答は・・・

Rust言語のhoundライブラリを使って、ラフマニノフのピアノ協奏曲第二番一楽章を鳴らすプログラムは以下のようになります。

extern crate hound;

use std::i16;
use std::f32::consts::PI;

fn main() {
let spec = hound::WavSpec {
channels: 1,
sample_rate: 44100,
bits_per_sample: 16,
sample_format: hound::SampleFormat::Int,
};
let mut writer = hound::WavWriter::create("sine.wav", spec).unwrap();
for t in (0..44100).map(|x| x as f32 / 44100.0) {
let sample = (t * 440.0 * 2.0 * PI).sin();
let amplitude = i16::MAX as f32;
writer.write_sample((sample * amplitude) as i16).unwrap();
}
}
ただし、このプログラムは440Hzの正弦波を生成するだけであり、実際にラフマニノフのピアノ協奏曲第二番一楽章を鳴らすためには、さらに詳細な音符データと演奏方法が必要です。

結論。ChatGPTの方が良い。

Rustでショパンの幻想即興曲を演奏するプログラム

2023-03-07 22:29:51 | Rust
ショパンの幻想即興曲の最初から20小節目までのプログラムを書いてください
(中途半端でとまってしまった。)

以下は、Rustのmidirとhoundライブラリを使用して、ショパンの幻想即興曲の最初から20小節目までの楽譜を再現する例です。midiデータから各音符の周波数を計算し、それを使用して波形を生成しています。また、楽譜を簡単に指定できるように、notes配列に音符の高さ、長さ、タイミングを指定しています。

extern crate hound; extern crate midir; use std::f32::consts::PI; use std::i16; use std::time::Duration; fn main() { // midiから取得した各音符の周波数を格納する配列 let mut frequencies = vec![0.0; 128]; // midiから各音符の周波数を計算する for note in 0..128 { frequencies[note] = 440.0 * 2.0_f32.powf((note as f32 - 69.0) / 12.0); } // 幻想即興曲の楽譜を定義する let notes = vec![ //小節1 (60, 0.5, 0.0), (63, 0.5, 0.5), (67, 0.5, 1.0), (72, 1.0, 1.5), //小節2 (60, 0.5, 2.5), (63, 0.5, 3.0), (67, 0.5, 3.5), (72, 1.0, 4.0), //小節3 (64, 0.25, 5.0), (68, 0.25, 5.25), (71, 0.25, 5.5), (76, 0.5, 5.75), (76, 0.25, 6.25), (79, 0.25, 6.5), (83, 0.5, 6.75), (83, 0.25, 7.25), //小節4 (84, 0.25, 7.5), (79, 0.5, 7.75), (79, 0.25, 8.25), (76, 0.25, 8.5), (71, 0.5, 8.75), (71, 0.25, 9.25), (67, 0.25, 9.5), (63, 0.5, 9.75), //小節5 (60, 0.25, 10.5), (63, 0.5, 10.75), (60, 0.25, 11.25), (55, 0.25, 11.5), (52, 0.5, 11.75), (52, 0.25, 12.25), (48, 0.25, 12.5), (44, 0.5, 12.75),


Rustで二つの旋律を鳴らすプログラム

2023-03-07 22:20:30 | Rust
二つの旋律を鳴らすプログラムは?

二つの旋律を同時に鳴らすプログラムを作成するには、各音声データのサンプル値を合算する必要があります。以下は、Rustのhoundライブラリを使用して、二つの旋律を同時に生成する例です。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let duration = 1.0; let a_frequency = 440.0; // A4の周波数 let c_sharp_frequency = a_frequency * 2.0f32.powf(4.0 / 12.0); // C#5の周波数 let flute = vec![1.0, 0.8, 0.6, 0.4, 0.2]; // フルートの音色 let bassoon = vec![1.0, 0.6, 0.3, 0.1]; // バスーンの音色 // A4の音を生成する let mut a_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * duration) as usize { let t = i as f32 / sample_rate as f32; let mut sample = 0.0; for (j, &weight) in flute.iter().enumerate() { let frequency = a_frequency * (j as f32 + 1.0); sample += weight * (t * frequency * 2.0 * PI).sin(); } a_samples.push((sample * i16::MAX as f32) as i16); } // C#5の音を生成する let mut c_sharp_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * duration) as usize { let t = i as f32 / sample_rate as f32; let mut sample = 0.0; for (j, &weight) in bassoon.iter().enumerate() { let frequency = c_sharp_frequency * (j as f32 + 1.0); sample += weight * (t * frequency * 2.0 * PI).sin(); } c_sharp_samples.push((sample * i16::MAX as f32) as i16); } // 二つの音声データを合算する let mixed_samples: Vec<i16> = a_samples.iter().zip(c_sharp_samples.iter()).map(|(&a, &b)| { let mixed = a as i32 + b as i32; if mixed > i16::MAX as i32 { i16::MAX } else if mixed < i16::MIN as i32 { i16::MIN } else { mixed as i16 } }).collect(); // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; let mut writer = hound::WavWriter::create("mixed_notes.wav


Rustでフルートの音を鳴らすプログラム

2023-03-07 22:03:10 | Rust
ではフルートの音を鳴らすプログラムは?

フルートの音を生成するためには、各音に対応する周波数と音量のエンベロープを知る必要があります。以下は、Rustのhoundライブラリを使用して、特定の周波数でフルートの音を生成する例です。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let duration = 1.0; let a_frequency = 440.0; // A4の周波数 let c_sharp_frequency = a_frequency * 2.0f32.powf(4.0 / 12.0); // C#5の周波数 let flute = vec![1.0, 0.8, 0.6, 0.4, 0.2]; // フルートの音色 // A4の音を生成する let mut a_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * duration) as usize { let t = i as f32 / sample_rate as f32; let mut sample = 0.0; for (j, &weight) in flute.iter().enumerate() { let frequency = a_frequency * (j as f32 + 1.0); sample += weight * (t * frequency * 2.0 * PI).sin(); } a_samples.push((sample * i16::MAX as f32) as i16); } // C#5の音を生成する let mut c_sharp_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * duration) as usize { let t = i as f32 / sample_rate as f32; let mut sample = 0.0; for (j, &weight) in flute.iter().enumerate() { let frequency = c_sharp_frequency * (j as f32 + 1.0); sample += weight * (t * frequency * 2.0 * PI).sin(); } c_sharp_samples.push((sample * i16::MAX as f32) as i16); } // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; let mut writer = hound::WavWriter::create("flute_notes.wav", spec).unwrap(); for sample in a_samples.iter().chain(c_sharp_samples.iter()) { writer.write_sample(*sample).unwrap(); } writer.finalize().unwrap(); }


Rustでピアノの音を鳴らすプログラム

2023-03-07 21:55:46 | Rust
ではピアノの音を鳴らすプログラムは?

ピアノの音を生成するプログラムを作成するには、各音に対応する周波数を知る必要があります。以下は、Rustのhoundライブラリを使用して、特定の周波数でピアノの音を生成する例です。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let duration = 1.0; let a_frequency = 440.0; // A4の周波数 let c_sharp_frequency = a_frequency * 2.0f32.powf(4.0 / 12.0); // C#5の周波数 // A4の音を生成する let mut a_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); a_samples.push((sample * i16::MAX as f32) as i16); } // C#5の音を生成する let mut c_sharp_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * c_sharp_frequency * 2.0 * PI).sin(); c_sharp_samples.push((sample * i16::MAX as f32) as i16); } // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; let mut writer = hound::WavWriter::create("piano_notes.wav", spec).unwrap(); for sample in a_samples.iter().chain(c_sharp_samples.iter()) { writer.write_sample(*sample).unwrap(); } writer.finalize().unwrap(); }
この例では、A4とC#5の音を1秒間生成しています。生成された音声は、piano_notes.wavというファイル名で保存されます。このようにして、Pianoの音を生成することができます。




Rustで7連符と9連符を鳴らすプログラム

2023-03-07 21:52:19 | Rust
では7連符と9連符はどう書けばいいの?

7連符や9連符を生成するには、基本的には3連符の計算方法を拡張する必要があります。以下は、7連符と9連符を生成するためのサンプルコードです。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let bpm = 120; let quarter_note_duration = 60.0 / bpm as f32; let triplet_duration = quarter_note_duration / 3.0; let sevenlet_duration = quarter_note_duration / 7.0; let ninetuplet_duration = quarter_note_duration / 9.0; let a_frequency = 440.0; // 3連符を生成する let mut triplet_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * triplet_duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); triplet_samples.push((sample * i16::MAX as f32) as i16); } // 7連符を生成する let mut sevenlet_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * sevenlet_duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); sevenlet_samples.push((sample * i16::MAX as f32) as i16); } // 9連符を生成する let mut ninetuplet_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * ninetuplet_duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); ninetuplet_samples.push((sample * i16::MAX as f32) as i16); } // 3連符を7回、7連符を1回、3連符を1回、9連符を1回繰り返す let mut samples: Vec<i16> = Vec::new(); for _ in 0..7 { samples.extend(&triplet_samples); } samples.extend(&sevenlet_samples); samples.extend(&triplet_samples); samples.extend(&ninetuplet_samples); // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; let mut writer = hound::WavWriter::create("notes.wav", spec).unwrap(); for sample in samples { writer.write_sample(sample).unwrap(); } writer.finalize().unwrap(); }
この例では、7連符を生成するために、7分の1の長さの音符を1回、3連符を7回繰り返しています。同様に、9連符を生成


Rust言語で8分音符と16分音符と32分音符と三連符のプログラムの書き方

2023-03-07 21:49:25 | Rust
では8分音符と16分音符と32分音符と三連符はどう書けばいいの?

音符の長さについては、サンプリングレートとBPMを使って計算することができます。以下は、基本的な8分音符、16分音符、32分音符、および3連符を生成するためのサンプルコードです。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let bpm = 120; let quarter_note_duration = 60.0 / bpm as f32; let eighth_note_duration = quarter_note_duration / 2.0; let sixteenth_note_duration = quarter_note_duration / 4.0; let thirtysecond_note_duration = quarter_note_duration / 8.0; let triplet_duration = eighth_note_duration / 3.0; let a_frequency = 440.0; // 8分音符を生成する let mut samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * eighth_note_duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); samples.push((sample * i16::MAX as f32) as i16); } // 16分音符を生成する let mut sixteenth_note_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * sixteenth_note_duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); sixteenth_note_samples.push((sample * i16::MAX as f32) as i16); } samples.extend(&sixteenth_note_samples); samples.extend(&sixteenth_note_samples); // 32分音符を生成する let mut thirtysecond_note_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * thirtysecond_note_duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); thirtysecond_note_samples.push((sample * i16::MAX as f32) as i16); } samples.extend(&thirtysecond_note_samples); samples.extend(&thirtysecond_note_samples); samples.extend(&thirtysecond_note_samples); samples.extend(&thirtysecond_note_samples); // 3連符を生成する let mut triplet_samples: Vec<i16> = Vec::new(); for i in 0..(sample_rate as f32 * triplet_duration) as usize { let t = i as f32 / sample_rate as f32; let sample = (t * a_frequency * 2.0 * PI).sin(); triplet_samples.push((sample * i16::MAX as f32) as i16); } samples.extend(&triplet_samples); samples.extend(&triplet_samples); samples.extend(&triplet_samples); // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample:







Rust言語でB♭を鳴らすプログラム

2023-03-07 21:40:06 | Rust
ではB♭を鳴らすプログラムは?

B♭の音を生成するには、Aの音から半音上げた周波数を計算する必要があります。具体的には、Aの周波数に1.0595を乗算することで、B♭の周波数を計算できます。

以下は、B♭の音を生成するために、Aの周波数を基に計算したプログラム例です。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let duration_ms = 1000; let a_frequency = 440.0; // A4 // B♭の周波数を計算する let b_flat_frequency = a_frequency * 1.0595; // 音声データを格納するベクターを作成 let num_samples = (sample_rate as f32 / 1000.0 * duration_ms as f32) as usize; let mut samples: Vec<i16> = Vec::with_capacity(num_samples); // 音声データを生成 for i in 0..num_samples { let t = i as f32 / sample_rate as f32; let a_sample = (t * a_frequency * 2.0 * PI).sin(); let b_flat_sample = (t * b_flat_frequency * 2.0 * PI).sin(); let sample = (a_sample + b_flat_sample) / 2.0; samples.push((sample * i16::MAX as f32) as i16); } // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; let mut writer = hound::WavWriter::create("output.wav", spec).unwrap(); for sample in samples { writer.write_sample(sample).unwrap(); } writer.finalize().unwrap(); }

このプログラムは、A4とB♭4の音を合成して、output.wavファイルに保存します。合成した音の周波数比率を調整することで、他のフラットの音を生成することもできます。

Rust言語でD#を鳴らすプログラム

2023-03-07 21:33:35 | Rust
ではD#を鳴らすプログラムは?

D#の音を生成するには、C#と同様に周波数を計算する式を少し変更する必要があります。例えば、D#の周波数は、C#の周波数に対して、1.0595を再び乗算したものになります。

以下は、D#の音を生成するために、C#の周波数を基に計算したプログラム例です。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let duration_ms = 1000; let c_sharp_frequency = 277.18; // C#4 // D#の周波数を計算する let d_sharp_frequency = c_sharp_frequency * 1.0595; // 音声データを格納するベクターを作成 let num_samples = (sample_rate as f32 / 1000.0 * duration_ms as f32) as usize; let mut samples: Vec<i16> = Vec::with_capacity(num_samples); // 音声データを生成 for i in 0..num_samples { let t = i as f32 / sample_rate as f32; let c_sharp_sample = (t * c_sharp_frequency * 2.0 * PI).sin(); let d_sharp_sample = (t * d_sharp_frequency * 2.0 * PI).sin(); let sample = (c_sharp_sample + d_sharp_sample) / 2.0; samples.push((sample * i16::MAX as f32) as i16); } // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; let mut writer = hound::WavWriter::create("output.wav", spec).unwrap(); for sample in samples { writer.write_sample(sample).unwrap(); } writer.finalize().unwrap(); }

このプログラムは、C#4とD#4の音を合成して、output.wavファイルに保存します。合成した音の周波数比率を調整することで、他のシャープの音を生成することもできます。

Rust言語でドのシャープの音を鳴らすプログラム

2023-03-07 21:26:52 | Rust
ちなみにシャープの音を鳴らすプログラムはどう書けばいいの?

シャープの音を生成するには、周波数を計算する式を少し変更する必要があります。例えば、C#の周波数は、Cの周波数に対して、1.0595を乗算したものになります。

以下は、C#の音を生成するために、Cの周波数に1.0595を乗算するプログラム例です。

extern crate hound; use std::f32::consts::PI; use std::i16; fn main() { // 生成する音のパラメータを設定 let sample_rate = 44100; let duration_ms = 1000; let c_frequency = 261.63; // C4 // C#の周波数を計算する let c_sharp_frequency = c_frequency * 1.0595; // 音声データを格納するベクターを作成 let num_samples = (sample_rate as f32 / 1000.0 * duration_ms as f32) as usize; let mut samples: Vec<i16> = Vec::with_capacity(num_samples); // 音声データを生成 for i in 0..num_samples { let t = i as f32 / sample_rate as f32; let c_sample = (t * c_frequency * 2.0 * PI).sin(); let c_sharp_sample = (t * c_sharp_frequency * 2.0 * PI).sin(); let sample = (c_sample + c_sharp_sample) / 2.0; samples.push((sample * i16::MAX as f32) as i16); } // 音声ファイルに書き出す let spec = hound::WavSpec { channels: 1, sample_rate: sample_rate, bits_per_sample: 16, sample_format: hound::SampleFormat::Int, }; let mut writer = hound::WavWriter::create("output.wav", spec).unwrap(); for sample in samples { writer.write_sample(sample).unwrap(); } writer.finalize().unwrap(); }

このプログラムは、C4とC#4の音を合成して、output.wavファイルに保存します。合成した音の周波数比率を調整することで、他のシャープの音を生成することもできます。

BingのAIチャットの回答は・・・

Houndライブラリを使用して、Rust言語でC#の音を鳴らすプログラムの例は次のとおりです。

extern crate hound;

use std::f32::consts::PI;
use std::i16;

fn main() {
    let sample_rate = 44100;
    let frequency = 440.0;
    let amplitude = i16::MAX as f32;
    let duration = 1.0;

    let spec = hound::WavSpec {
        channels: 1,
        sample_rate: sample_rate,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };
    let mut writer = hound::WavWriter::create("sine.wav", spec).unwrap();
    for t in (0..(sample_rate as f32 * duration) as usize).map(|x| x as f32 / sample_rate as f32) {
        let sample = (t * frequency * 2.0 * PI).sin();
        let amplitude_sample = (sample * amplitude) as i16;
        writer.write_sample(amplitude_sample).unwrap();
    }
}

このプログラムは、指定された周波数(この場合は440Hz)と振幅でサイン波を生成し、それをWAVファイルに書き込みます。このWAVファイルを再生することで、C#の音が鳴ります。