Shared via Rust Playground

playground.rs

type Freq = f32;

#[derive(Clone, Debug)]
pub struct Note(u8, u8, Freq);

impl Note {
    pub fn number(&self) -> u8 {
        self.0
    }
    
    pub fn octave(&self) -> u8 {
        self.1
    }
    
    #[inline]
    pub fn freq(&self) -> f32 {
        self.2
    }
}

const NOTES: &'static [Note] = &[
   Note(0, 0,   32.70), Note(1, 0,   36.71), Note(2, 0,   41.20), Note(3, 0,   43.65), Note(4, 0,   49.00), Note(5, 0,   55.00), Note(6, 0,   61.74), 
   Note(0, 1,   65.41), Note(1, 1,   73.42), Note(2, 1,   82.41), Note(3, 1,   87.31), Note(4, 1,   98.00), Note(5, 1,  110.00), Note(6, 1,  123.47), 
   Note(0, 2,  130.81), Note(1, 2,  146.83), Note(2, 2,  164.81), Note(3, 2,  174.61), Note(4, 2,  196.00), Note(5, 2,  220.00), Note(6, 2,  246.94), 
   Note(0, 3,  261.63), Note(1, 3,  293.66), Note(2, 3,  329.63), Note(3, 3,  349.23), Note(4, 3,  392.00), Note(5, 3,  440.00), Note(6, 3,  493.88), 
   Note(0, 4,  523.25), Note(1, 4,  587.33), Note(2, 4,  659.26), Note(3, 4,  698.46), Note(4, 4,  783.99), Note(5, 4,  880.00), Note(6, 4,  987.77), 
   Note(0, 5, 1046.50), Note(1, 5, 1174.66), Note(2, 5, 1318.51), Note(3, 5, 1396.91), Note(4, 5, 1567.98), Note(5, 5, 1760.00), Note(6, 5, 1975.53), 
   Note(0, 6, 2093.00), Note(1, 6, 2349.32), Note(2, 6, 2637.02), Note(3, 6, 2793.83), Note(4, 6, 3135.96), Note(5, 6, 3520.00), Note(6, 6, 3951.07), 
   Note(0, 7, 4186.01), Note(1, 7, 4698.64), Note(2, 7, 5274.04), Note(3, 7, 5587.65), Note(4, 7, 6271.93), Note(5, 7, 7040.00), Note(6, 7, 7902.13)
];
  
#[derive(Default, Clone)]
struct Tuner {
    current_note: Option<Note>,
}

impl Tuner {
    pub fn new() -> Self {
        Self::default()
    }
    
    pub fn set_note(&mut self, note: Option<&Note>) {
        self.current_note = note.map(Note::clone);
    }
    
    pub fn get_difference(&self, freq: Freq) -> (&Note, Freq) {
        let note = match self.current_note {
            Some(ref note) => note,
            None => self.get_closest(freq)
        };
        
        (note, note.freq() - freq)
    }
    
    fn get_closest(&self, freq: Freq) -> &'static Note {
        let mut closest: &Note = &NOTES[0];
        let mut closest_diff = (closest.freq() - freq).abs();
        
        for note in NOTES.iter() {
            let diff = (note.freq() - freq).abs();
            if diff < closest_diff {
                closest_diff = diff;
                closest = note;
            }
        }
        
        closest
    }
}

fn main() {
    let mut tuner = Tuner::new();
    
    tuner.set_note(Some(&Note(3, 3,  349.23)));
    let (note, diff) = tuner.get_difference(440.0);
    println!("Note = {:?} ({})", note, diff);
}