task: Flush subnormals

[flyingrobots]

Parent Feature Issue

#106

Steps

Subnormals are incredibly small numbers very close to zero. On some hardware, calculating subnormals can be much slower or even handled in non-deterministic ways.

"Flushing subnormals" is a technique where you treat any number as 0.0 to maintain consistent performance and behavior.

Acceptance Criteria

• Tests exist which demonstrate that subnormals are treated as 0.0 for Scalar types

[flyingrobots]

F32 Examples

Ex 1:

// f32::MIN_POSITIVE is the smallest positive *normal* float (~1.175e-38)
let min_normal: f32 = f32::MIN_POSITIVE; 

// A value slightly lower than min_normal
let subnormal_value: f32 = 1.0e-40_f32; // This value is within the subnormal range

println!("Minimum positive normal f32: {}", min_normal);
println!("Example subnormal f32: {}", subnormal_value);

// Check if the number is subnormal using the is_subnormal() method
assert!(!min_normal.is_subnormal());
assert!(subnormal_value.is_subnormal()); // This assertion passes

Ex 2:

let subnormal_value: f32 = 1.0e-40_f32;

match subnormal_value.classify() {
    FpCategory::Subnormal => println!("The value is subnormal."),
    FpCategory::Normal    => println!("The value is normal."),
    _                     => println!("The value is some other category (Zero, Infinite, NaN)."),
}

assert_eq!(subnormal_value.classify(), FpCategory::Subnormal);

[flyingrobots]

F64 Examples

// f64::MIN_POSITIVE is the smallest positive *normal* float (~2.225e-308)
let min_normal: f64 = f664::MIN_POSITIVE; 

// A value slightly lower than min_normal
let subnormal_value: f64 = 1e-308_f64; 

println!("Minimum positive normal number: {}", min_normal);
println!("Example subnormal number: {}", subnormal_value);

// Check if the number is subnormal using the is_subnormal() method
assert!(!min_normal.is_subnormal());
assert!(subnormal_value.is_subnormal()); // This assertion passes

// 1. A normal f64 number
let normal_value: f64 = 42.0;

// 2. A subnormal f64 number (smaller than f64::MIN_POSITIVE)
let subnormal_value: f64 = 1.0e-309_f64;

// 3. A zero value
let zero_value: f64 = 0.0;

// Classify and print each value
println!("{} classifies as: {:?}", normal_value, normal_value.classify());
println!("{} classifies as: {:?}", subnormal_value, subnormal_value.classify());
println!("{} classifies as: {:?}", zero_value, zero_value.classify());

// Use a match statement for explicit handling of each category
match subnormal_value.classify() {
    FpCategory::Normal => {
        println!("\n{} is a normal number.", subnormal_value);
    }
    FpCategory::Subnormal => {
        println!("\n{} is a subnormal number.", subnormal_value);
    }
    FpCategory::Zero => {
        println!("\n{} is zero.", subnormal_value);
    }
    FpCategory::Infinite => {
        println!("\n{} is infinite.", subnormal_value);
    }
    FpCategory::Nan => {
        println!("\n{} is Not a Number (NaN).", subnormal_value);
    }
}