Struct TuningTable 

pub struct TuningTable {
    pub frequencies: Vec<f32>,
    pub name: String,
    pub description: String,
}

Maps MIDI note numbers (0–127) to frequencies in Hz. Stored as Vec for serde compatibility.

Fields

frequencies: Vec<f32>

Frequency in Hz for each MIDI note 0–127.

name: String

Human-readable name.

description: String

Description of the tuning system.

Implementations

impl TuningTable

pub fn equal_temperament(concert_a: f32) -> Self

Standard 12-tone equal temperament. A4 (MIDI note 69) = concert_a Hz (typically 440.0).

Examples found in repository

examples/tuning_comparison.rs (line 15)

fn main() {
    println!("AetherDSP MIDI - Tuning System Comparison");
    println!("==========================================\n");

    // Create tuning tables (all use A4=440Hz)
    let equal_temp = TuningTable::equal_temperament(440.0);
    let tizita = TuningTable::ethiopian_tizita(440.0);
    let rast = TuningTable::arabic_maqam_rast(440.0);
    let yaman = TuningTable::indian_raga_yaman(440.0);

    println!("Comparing tuning systems for one octave (C4-C5):\n");
    println!("{:4} | {:>10} | {:>10} | {:>10} | {:>10} | {:>8}",
        "MIDI", "12-TET", "Tizita", "Rast", "Yaman", "Cents");
    println!("{}", "-".repeat(70));

    // Compare middle C octave (MIDI 60-72)
    for midi_note in 60..=72 {
        let freq_12tet = equal_temp.frequency(midi_note);
        let freq_tizita = tizita.frequency(midi_note);
        let freq_rast = rast.frequency(midi_note);
        let freq_yaman = yaman.frequency(midi_note);

        // Calculate cents deviation from 12-TET
        let cents_tizita: f32 = 1200.0 * (freq_tizita / freq_12tet).log2();
        let cents_rast: f32 = 1200.0 * (freq_rast / freq_12tet).log2();
        let cents_yaman: f32 = 1200.0 * (freq_yaman / freq_12tet).log2();

        let note_name = get_note_name(midi_note);

        println!("{:4} | {:10.2} | {:10.2} | {:10.2} | {:10.2} | {:+8.1}",
            format!("{} ({})", midi_note, note_name),
            freq_12tet,
            freq_tizita,
            freq_rast,
            freq_yaman,
            cents_tizita.max(cents_rast).max(cents_yaman)
        );
    }

    println!("\n📊 Key Observations:");
    println!("  • Ethiopian Tizita: Pentatonic scale with characteristic flat intervals");
    println!("  • Arabic Maqam Rast: Quarter-tone flats on 3rd and 7th degrees");
    println!("  • Indian Raga Yaman: Just intonation with raised 4th (Kalyan thaat)");
    println!("  • Cents: Deviation from 12-TET (100 cents = 1 semitone)");

    println!("\n✓ Try these tuning systems in your music!");
}

pub fn from_cents_offsets(concert_a: f32, offsets: &[f32; 12]) -> Self

Build a tuning table from cents offsets per semitone within an octave. offsets is a 12-element array of cent offsets from 12-TET for each pitch class (C, C#, D, D#, E, F, F#, G, G#, A, A#, B).

pub fn from_frequencies( freqs: Vec<f32>, name: &str, description: &str, ) -> Option<Self>

Build from explicit frequency list. Length must be 128.

pub fn frequency(&self, note: u8) -> f32

Get frequency for a MIDI note number.

Examples found in repository

examples/tuning_comparison.rs (line 27)

fn main() {
    println!("AetherDSP MIDI - Tuning System Comparison");
    println!("==========================================\n");

    // Create tuning tables (all use A4=440Hz)
    let equal_temp = TuningTable::equal_temperament(440.0);
    let tizita = TuningTable::ethiopian_tizita(440.0);
    let rast = TuningTable::arabic_maqam_rast(440.0);
    let yaman = TuningTable::indian_raga_yaman(440.0);

    println!("Comparing tuning systems for one octave (C4-C5):\n");
    println!("{:4} | {:>10} | {:>10} | {:>10} | {:>10} | {:>8}",
        "MIDI", "12-TET", "Tizita", "Rast", "Yaman", "Cents");
    println!("{}", "-".repeat(70));

    // Compare middle C octave (MIDI 60-72)
    for midi_note in 60..=72 {
        let freq_12tet = equal_temp.frequency(midi_note);
        let freq_tizita = tizita.frequency(midi_note);
        let freq_rast = rast.frequency(midi_note);
        let freq_yaman = yaman.frequency(midi_note);

        // Calculate cents deviation from 12-TET
        let cents_tizita: f32 = 1200.0 * (freq_tizita / freq_12tet).log2();
        let cents_rast: f32 = 1200.0 * (freq_rast / freq_12tet).log2();
        let cents_yaman: f32 = 1200.0 * (freq_yaman / freq_12tet).log2();

        let note_name = get_note_name(midi_note);

        println!("{:4} | {:10.2} | {:10.2} | {:10.2} | {:10.2} | {:+8.1}",
            format!("{} ({})", midi_note, note_name),
            freq_12tet,
            freq_tizita,
            freq_rast,
            freq_yaman,
            cents_tizita.max(cents_rast).max(cents_yaman)
        );
    }

    println!("\n📊 Key Observations:");
    println!("  • Ethiopian Tizita: Pentatonic scale with characteristic flat intervals");
    println!("  • Arabic Maqam Rast: Quarter-tone flats on 3rd and 7th degrees");
    println!("  • Indian Raga Yaman: Just intonation with raised 4th (Kalyan thaat)");
    println!("  • Cents: Deviation from 12-TET (100 cents = 1 semitone)");

    println!("\n✓ Try these tuning systems in your music!");
}

pub fn freq_to_note_cents(&self, freq: f32) -> (u8, f32)

Convert frequency to the nearest MIDI note + cents deviation.

pub fn ethiopian_tizita(concert_a: f32) -> Self

Ethiopian Kiñit (pentatonic) approximation. Uses the Tizita major scale pattern.

Examples found in repository

examples/tuning_comparison.rs (line 16)

fn main() {
    println!("AetherDSP MIDI - Tuning System Comparison");
    println!("==========================================\n");

    // Create tuning tables (all use A4=440Hz)
    let equal_temp = TuningTable::equal_temperament(440.0);
    let tizita = TuningTable::ethiopian_tizita(440.0);
    let rast = TuningTable::arabic_maqam_rast(440.0);
    let yaman = TuningTable::indian_raga_yaman(440.0);

    println!("Comparing tuning systems for one octave (C4-C5):\n");
    println!("{:4} | {:>10} | {:>10} | {:>10} | {:>10} | {:>8}",
        "MIDI", "12-TET", "Tizita", "Rast", "Yaman", "Cents");
    println!("{}", "-".repeat(70));

    // Compare middle C octave (MIDI 60-72)
    for midi_note in 60..=72 {
        let freq_12tet = equal_temp.frequency(midi_note);
        let freq_tizita = tizita.frequency(midi_note);
        let freq_rast = rast.frequency(midi_note);
        let freq_yaman = yaman.frequency(midi_note);

        // Calculate cents deviation from 12-TET
        let cents_tizita: f32 = 1200.0 * (freq_tizita / freq_12tet).log2();
        let cents_rast: f32 = 1200.0 * (freq_rast / freq_12tet).log2();
        let cents_yaman: f32 = 1200.0 * (freq_yaman / freq_12tet).log2();

        let note_name = get_note_name(midi_note);

        println!("{:4} | {:10.2} | {:10.2} | {:10.2} | {:10.2} | {:+8.1}",
            format!("{} ({})", midi_note, note_name),
            freq_12tet,
            freq_tizita,
            freq_rast,
            freq_yaman,
            cents_tizita.max(cents_rast).max(cents_yaman)
        );
    }

    println!("\n📊 Key Observations:");
    println!("  • Ethiopian Tizita: Pentatonic scale with characteristic flat intervals");
    println!("  • Arabic Maqam Rast: Quarter-tone flats on 3rd and 7th degrees");
    println!("  • Indian Raga Yaman: Just intonation with raised 4th (Kalyan thaat)");
    println!("  • Cents: Deviation from 12-TET (100 cents = 1 semitone)");

    println!("\n✓ Try these tuning systems in your music!");
}

pub fn just_intonation(concert_a: f32) -> Self

Just intonation (pure intervals based on harmonic series).

impl TuningTable

pub fn arabic_maqam_rast(concert_a: f32) -> Self

Arabic Maqam Rast — the most common Arabic maqam. Uses quarter-tone flats on the 3rd and 7th scale degrees.

Examples found in repository

examples/tuning_comparison.rs (line 17)

fn main() {
    println!("AetherDSP MIDI - Tuning System Comparison");
    println!("==========================================\n");

    // Create tuning tables (all use A4=440Hz)
    let equal_temp = TuningTable::equal_temperament(440.0);
    let tizita = TuningTable::ethiopian_tizita(440.0);
    let rast = TuningTable::arabic_maqam_rast(440.0);
    let yaman = TuningTable::indian_raga_yaman(440.0);

    println!("Comparing tuning systems for one octave (C4-C5):\n");
    println!("{:4} | {:>10} | {:>10} | {:>10} | {:>10} | {:>8}",
        "MIDI", "12-TET", "Tizita", "Rast", "Yaman", "Cents");
    println!("{}", "-".repeat(70));

    // Compare middle C octave (MIDI 60-72)
    for midi_note in 60..=72 {
        let freq_12tet = equal_temp.frequency(midi_note);
        let freq_tizita = tizita.frequency(midi_note);
        let freq_rast = rast.frequency(midi_note);
        let freq_yaman = yaman.frequency(midi_note);

        // Calculate cents deviation from 12-TET
        let cents_tizita: f32 = 1200.0 * (freq_tizita / freq_12tet).log2();
        let cents_rast: f32 = 1200.0 * (freq_rast / freq_12tet).log2();
        let cents_yaman: f32 = 1200.0 * (freq_yaman / freq_12tet).log2();

        let note_name = get_note_name(midi_note);

        println!("{:4} | {:10.2} | {:10.2} | {:10.2} | {:10.2} | {:+8.1}",
            format!("{} ({})", midi_note, note_name),
            freq_12tet,
            freq_tizita,
            freq_rast,
            freq_yaman,
            cents_tizita.max(cents_rast).max(cents_yaman)
        );
    }

    println!("\n📊 Key Observations:");
    println!("  • Ethiopian Tizita: Pentatonic scale with characteristic flat intervals");
    println!("  • Arabic Maqam Rast: Quarter-tone flats on 3rd and 7th degrees");
    println!("  • Indian Raga Yaman: Just intonation with raised 4th (Kalyan thaat)");
    println!("  • Cents: Deviation from 12-TET (100 cents = 1 semitone)");

    println!("\n✓ Try these tuning systems in your music!");
}

pub fn arabic_maqam_bayati(concert_a: f32) -> Self

Arabic Maqam Bayati — second most common Arabic maqam. Characteristic half-flat on the 2nd degree.

pub fn ethiopian_bati(concert_a: f32) -> Self

Ethiopian Bati scale — minor pentatonic variant.

pub fn indian_raga_yaman(concert_a: f32) -> Self

Indian Raga Yaman (Kalyan thaat) — the most common North Indian raga. Uses a raised 4th (Ma tivra).

Examples found in repository

examples/tuning_comparison.rs (line 18)

fn main() {
    println!("AetherDSP MIDI - Tuning System Comparison");
    println!("==========================================\n");

    // Create tuning tables (all use A4=440Hz)
    let equal_temp = TuningTable::equal_temperament(440.0);
    let tizita = TuningTable::ethiopian_tizita(440.0);
    let rast = TuningTable::arabic_maqam_rast(440.0);
    let yaman = TuningTable::indian_raga_yaman(440.0);

    println!("Comparing tuning systems for one octave (C4-C5):\n");
    println!("{:4} | {:>10} | {:>10} | {:>10} | {:>10} | {:>8}",
        "MIDI", "12-TET", "Tizita", "Rast", "Yaman", "Cents");
    println!("{}", "-".repeat(70));

    // Compare middle C octave (MIDI 60-72)
    for midi_note in 60..=72 {
        let freq_12tet = equal_temp.frequency(midi_note);
        let freq_tizita = tizita.frequency(midi_note);
        let freq_rast = rast.frequency(midi_note);
        let freq_yaman = yaman.frequency(midi_note);

        // Calculate cents deviation from 12-TET
        let cents_tizita: f32 = 1200.0 * (freq_tizita / freq_12tet).log2();
        let cents_rast: f32 = 1200.0 * (freq_rast / freq_12tet).log2();
        let cents_yaman: f32 = 1200.0 * (freq_yaman / freq_12tet).log2();

        let note_name = get_note_name(midi_note);

        println!("{:4} | {:10.2} | {:10.2} | {:10.2} | {:10.2} | {:+8.1}",
            format!("{} ({})", midi_note, note_name),
            freq_12tet,
            freq_tizita,
            freq_rast,
            freq_yaman,
            cents_tizita.max(cents_rast).max(cents_yaman)
        );
    }

    println!("\n📊 Key Observations:");
    println!("  • Ethiopian Tizita: Pentatonic scale with characteristic flat intervals");
    println!("  • Arabic Maqam Rast: Quarter-tone flats on 3rd and 7th degrees");
    println!("  • Indian Raga Yaman: Just intonation with raised 4th (Kalyan thaat)");
    println!("  • Cents: Deviation from 12-TET (100 cents = 1 semitone)");

    println!("\n✓ Try these tuning systems in your music!");
}

pub fn gamelan_slendro(_concert_a: f32) -> Self

Javanese Gamelan Slendro — 5-tone scale. Approximate equal division of the octave into 5 parts.

pub fn gamelan_pelog(concert_a: f32) -> Self

Javanese Gamelan Pelog — 7-tone scale with characteristic large and small intervals.

Trait Implementations

impl Clone for TuningTable

fn clone(&self) -> TuningTable

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TuningTable

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TuningTable

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TuningTable

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TuningTable

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.