w shiz

fixed_point.rs

fn main() {
    let w = 128.1337f32;
    let w_inverse = 1.0 / w;
    
    println!("w: {}", w);
    println!("w_inverse: {}", w_inverse);
    
    fn to_fixed(x: f32, fract_bits: i32) -> i32 {
        let bits = x.to_bits() as i32;
        let exponent = ((bits >> 23) & 0xff) - 127 - 23 + fract_bits;
        let mut result = (bits & 0x7fffff) | 0x800000;
        if exponent < 0 {
            if exponent > -32 {
                result >>= -exponent;
            } else {
                result = 0;
            }
        } else {
            if exponent < 32 {
                result <<= exponent;
            } else {
                result = 0x7fffffff;
            }
        }
        if ((bits as u32) & 0x80000000) != 0 {
            result = -result;
        }
        result
    }

    fn to_float(x: i32, fract_bits: i32) -> f32 {
        // TODO: More careful conversion? This is only used for testing anyways..
        (x as f32) / ((1 << fract_bits) as f32)
    }
    
    let w_inverse_fract_bits = 30;
    let w_inverse = to_fixed(w_inverse, w_inverse_fract_bits);
    //let w = 1.0 / to_float(w_inverse, w_inverse_fract_bits);
    
    println!("w_inverse: 0x{:08x}", w_inverse);
    
    let one = 1 << w_inverse_fract_bits; // 1 scaled to match w_inverse_fract_bits
    let w = ((one as i64) << w_inverse_fract_bits) / (w_inverse as i64);
    
    let w_fractional_bits = 8; // Must be less than w_inverse_fractional_bits, and probably needs tweaking
    let w = (w >> (w_inverse_fract_bits - w_fractional_bits)) as i32;
    
    println!("w: 0x{:08x}", w);
    
    let w = to_float(w, w_fractional_bits);
    
    println!("w: {}", w);

    //println!("{} -> 0x{:08x}", x, to_fixed(x, 4));
}