Static fractions

Static fractions, as introduced in this crate, are numeric data types that represent a fraction, store their numerator in memory and their denominator in code. They are a generalization of fixed-point numbers.

For example (and not all of this is implemented yet)::

// The range 0-255 means voltages from 0V (0/1) to 1.25V (125/100).
StaticFractionType!(VoltageFromADC, 0u8, 255u8, 0, 1, 125, 100);

fn adc_read() -> VoltageFromADC {
    let adc_readout: u8 = lowlevel_adc_read();
    VoltageFromADC::new_from_stored(adc_readout)
}

let current = static_fraction(10, 1000); // 10mA
let resistance_at_zero = 100; // 100ohm
let resistance_per_deg = static_fraction(4, 100); // 0.04ohm/degC

let resistance = adc_read() / current;
let temperature = 0 + (resistance - resistance_at_zero) / resistance_per_deg; // in degC

if temperature > 30 { fan_on(); }
if temperature < 20 { fan_off(); }

The idea is that

• raw data can be stored in as compact a data type as it arrives
• any datum can be used in calculations without needing to know more than its unit
• all operations can be performed in integer arithmetic (so they don't pull floating point emulation onto devices without floating point support)
• possibly, intermediate results can be stored in a compact way (where it's as of now completely unclear how the tradeof between precision and storage will be decided)

State of the crate

This project is in a very early state, in which it first tries to demonstrate that what is to be achieved is possible in Rust.

So far, comparisons between different fractions are almost fully implemented, showing how each fraction type's parameters are stored and accessed.