Struct Quantizer

pub struct Quantizer { /* private fields */ }

A quantizer which converts smooth inputs into stairsteps is represented here.

Implementations

impl Quantizer

pub fn new() -> Self

Quantizer::new() is a new quantizer with all notes allowed.

pub fn convert(&mut self, v_in: f32) -> Conversion

q.convert(val) is the quantized version of the input value.

The input is split into a stairstep component and fractional component.

Arguments

• v_in - the value to quantize, in volts, clamped to [0.0, V_MAX]

Returns

• Conversion - the input split into a stairstep and fractional portion

Examples

let mut q = quantizer::Quantizer::new();
// input is a bit above C#, but C# is the closest note number
assert_eq!(q.convert(1.5 / 12.).note_num, 1);

// same input, but since C# is forbidden now D is the closest note
q.forbid(&[quantizer::Note::CSHARP]);
assert_eq!(q.convert(1.5 / 12.).note_num, 2);

pub fn allow(&mut self, notes: &[Note])

q.allow(ns) allows notes ns, meaning they will be included in conversions

Any notes in ns that are already allowed are left unchanged

pub fn forbid(&mut self, notes: &[Note])

q.forbid(ns) forbids notes ns, they will not be included in conversions even if they are the nearest note

Any notes in ns that are already forbidden are left unchanged

At least one note must always be left allowed. If ns would forbid every note, the last note in ns will not be forbidden and instead will be left allowed.

pub fn is_allowed(&self, note: Note) -> bool

q.is_allowed(n) is true iff note n is allowed