Float Precision & Decimal Types

print(0.1 + 0.2 == 0.3)   // false — binary FP noise
print(0.1 + 0.2)           // 0.30000000000000004 (not exactly 0.3)

print(0.1 + 0.2 ~= 0.3)             // true — FP noise within default tol
print(1.0 + 0.1 - 0.1 ~= 1.0)       // true — rearrangement noise handled
print(1.0 ~= 2.0)                    // false — clearly different
print(1e10 + 1.0 ~= 1e10)           // true — noise at this magnitude is expected

// Near-zero velocity check — anything below 1e-6 counts as "stopped"
fn is_stopped(velocity: float) -> bool {
    return velocity ~= 0.0 within 1e-6
}
print(is_stopped(0.0000001))   // true
print(is_stopped(0.1))         // false

// Sensor tolerance: ±0.01 degrees is acceptable
fn temperatures_match(a: float, b: float) -> bool {
    return a ~= b within 0.01
}
print(temperatures_match(36.6, 36.605))   // true
print(temperatures_match(36.6, 36.7))     // false

// 0.1% relative tolerance — works at any magnitude
print(1e10 ~= 1.0000001e10 within 0.001 relative)    // true (0.000001%)
print(1.0 ~= 1.5 within 0.001 relative)              // false (50% difference)

// Useful for comparing measurements of vastly different scales
fn is_within_percent(a: float, b: float, pct: float) -> bool {
    return a ~= b within (pct / 100.0) relative
}
print(is_within_percent(100_000.0, 100_001.0, 0.01))   // true (0.001%)
print(is_within_percent(100_000.0, 101_000.0, 0.01))   // false (1%)

use std::math

// 0.1 + 0.2 vs 0.3: differs by exactly 1 ULP at this magnitude
print((0.1 + 0.2) ~= 0.3 within 0 ulps)   // false — not bit-exact
print((0.1 + 0.2) ~= 0.3 within 1 ulps)   // true
print((0.1 + 0.2) ~= 0.3 within 4 ulps)   // true (4 ULPs is very permissive)

// Exact match: 0 ULPs
print(1.0 ~= 1.0 within 0 ulps)           // true (literally identical bits)

// Distinctly different values are many ULPs apart
print(1.0 ~= 1.001 within 100 ulps)       // false (1.0 vs 1.001 ≈ 4.5e12 ULPs)

// sqrt round-trip: a few ULPs of error is typical
let two = math.sqrt(2.0) * math.sqrt(2.0)
print(two ~= 2.0 within 4 ulps)           // true — roundtrip to within 4 bits
print(two ~= 2.0 within 0 ulps)           // probably false — tiny error introduced

// Iterative convergence — loop while "not yet converged"
let mut x = 1.0
let mut prev = 0.0
while prev !~= x within 1e-10 {
    prev = x
    x = (x + 2.0 / x) * 0.5    // Newton step toward sqrt(2)
}
print("sqrt(2) ≈ {x}")    // ≈ 1.4142...

// Guard clause in a test helper
fn assert_close(a: float, b: float, label: str) {
    if a !~= b within 1e-9 {
        print("FAIL {label}: {a} is not close to {b}")
    } else {
        print("OK {label}")
    }
}
assert_close(0.1 + 0.2, 0.3, "fp_noise")   // OK fp_noise

// With all tolerance modes
print(1.0 !~= 2.0)                              // true (default tol)
print(1.0 !~= 1.0001 within 0.001)             // false (within tol → NOT not-equal)
print(100.0 !~= 101.0 within 0.001 relative)   // true (1% > 0.1% rtol)
print(1.0 !~= 2.0 within 4 ulps)               // true (distinctly unequal)

use std::math

let nan = 0.0 / 0.0
print(nan == nan)           // false — IEEE 754 rule, not a Zolo quirk
print(math.is_nan(nan))     // true  — always use this
print(nan.is_nan())         // true  — method form, same result

// NaN propagates through every operation
print(math.is_nan(nan + 1.0))    // true
print(math.is_nan(nan * 0.0))    // true

// ~= also returns false for any comparison involving NaN
print(nan ~= nan)                // false
print(nan ~= 1.0)                // false

// Use math.is_nan or .is_nan() for explicit sentinel detection
let unset: float = math.nan
if unset.is_nan() {
    print("value not yet set")
}

use std::math

print(math.is_infinite(math.huge))    // true
print(math.is_infinite(-math.huge))   // true
print(math.is_inf(1.0 / 0.0))        // true (+inf from division)
print(math.is_infinite(42.0))         // false
print(math.is_infinite(0.0 / 0.0))   // false (that's NaN, not Inf)

// Method form
print(math.huge.is_infinite())        // true

use std::math

fn area_of_circle(radius: float) -> float? {
    if !radius.is_finite() { return nil }   // reject NaN, ±inf
    if radius < 0.0 { return nil }
    return math.pi * radius * radius
}
print(area_of_circle(2.0))          // 12.566...
print(area_of_circle(-1.0))         // nil
print(area_of_circle(math.huge))    // nil
print(area_of_circle(float.NAN))    // nil

use std::math

print(float.EPSILON)         // 2.220446049250313e-16
print(float.INFINITY)        // inf
print(float.NEG_INFINITY)    // -inf
print(float.MAX)             // 1.7976931348623157e308
print(float.MIN_POSITIVE)    // 2.2250738585072014e-308
print(math.is_nan(float.NAN))   // true

// Using EPSILON as a lower-bound threshold
fn is_negligible(x: float) -> bool {
    return x.abs() <= float.EPSILON * 8.0
}

use std::Array

let x: float = 0.1 + 0.2

// Predicate methods
print(x.is_nan())           // false
print(x.is_finite())        // true
print(x.is_infinite())      // false

// Arithmetic
print((-3.14).abs())        // 3.14
print(x.abs_diff(0.3))      // ~5.55e-17 (the actual FP noise)

// Approximate equality methods (parallel to ~= operator)
print(x.approx_eq(0.3))                    // true  — same as: x ~= 0.3
print(x.approx_eq_abs(0.3, 1e-9))          // true  — same as: x ~= 0.3 within 1e-9
print(x.approx_eq_rel(0.3, 0.001))         // true  — same as: x ~= 0.3 within 0.001 relative
print(x.approx_eq_ulps(0.3, 4))            // true  — same as: x ~= 0.3 within 4 ulps

// First-class usage: pass a method as a callable
let values = [0.301, 0.299, 0.30000001, 0.5, 0.7]
let near = Array.filter(values, |m| m.approx_eq_abs(0.3, 0.01))
print(near)   // [0.301, 0.299, 0.30000001]

// float: binary noise
print(0.1 + 0.2)           // 0.30000000000000004  ← wrong for money
print(0.1 + 0.2 == 0.3)    // false

// decimal: exact
print(0.1d + 0.2d)         // 0.3
print(0.1d + 0.2d == 0.3d) // true — no lint warning, comparison is exact

let price: decimal = 9.99d
let tax_rate: decimal = 0.08d
let quantity: decimal = 100d     // integer form — exact

print(price * quantity + price * quantity * tax_rate)   // 1078.92

let a: decimal = 2.5d
let b: decimal = 1.5d
print(a + b)          // 4.0
print(a - b)          // 1.0
print(a * b)          // 3.75
print(a / b)          // 1.6666...
print(a % b)          // 1.0

print(0.1d + 0.2d == 0.3d)    // true (exact)
print(0.5d < 1.0d)            // true
print(0.5d <= 0.5d)           // true

// decimal → float: may lose precision (28 digits → 15-17 digits)
let f: float = 0.3d as float
print(f)                    // 0.3

// float → decimal: reveals the binary FP representation
let d: decimal = 0.1 as decimal
print(d)                    // 0.1000000000000000055511151231...

// int → decimal: always exact
let n: decimal = 42 as decimal
print(n)                    // 42

// decimal → int: truncates toward zero (does not round)
let i: int = 99.9d as int
print(i)                    // 99

// decimal ↔ bigdecimal
let bd: bigdecimal = 3.14d as bigdecimal
print(bd)                   // 3.14

let d: decimal = 3.14159d
print(d.round(2))    // 3.14
print(d.round(4))    // 3.1416  (half-to-even)
print(d.ceil())      // 4
print(d.floor())     // 3
print(d.trunc())     // 3
print(d.scale())     // 5

let neg: decimal = -2.7d
print(neg.ceil())    // -2  (toward +∞, i.e., less negative)
print(neg.floor())   // -3  (toward -∞, i.e., more negative)
print(neg.trunc())   // -2  (toward zero, same as ceil for negatives)

fn invoice_total(items: [decimal], tax_rate: decimal) -> decimal {
    let mut subtotal: decimal = 0d
    for item in items {
        subtotal = subtotal + item
    }
    return subtotal + subtotal * tax_rate
}

let items: [decimal] = [19.99d, 4.50d, 12.00d]
let total = invoice_total(items, 0.08d)
print(total)    // 39.7692  — exact, no floating-point drift
print(total.round(2))   // 39.77 — banker's rounding for presentation

let a: bigdecimal = 0.1bd
let b: bigdecimal = 0.2bd
print(a + b)           // 0.3  (exact)
print(a + b == 0.3bd)  // true

// Values beyond decimal's range
let huge: bigdecimal = 1234567890123456789012345678901234567890bd
let one: bigdecimal = 1bd
print(huge + one)      // 1234567890123456789012345678901234567891

let bd: bigdecimal = 99.999999bd
print(bd.round(2))     // 100.00
print(bd.ceil())       // 100
print(bd.floor())      // 99
print(bd.trunc())      // 99
print(bd.scale())      // 6

// Cross-cast with decimal
let d: decimal = 3.14d
let from_d: bigdecimal = d as bigdecimal
print(from_d)          // 3.14

use std::Array
use std::math

// Operator and function are semantically equivalent
print((0.1 + 0.2) ~= 0.3)                    // true
print(math.approx_eq(0.1 + 0.2, 0.3))        // true — same result

// First-class usage: use the function form to filter
let measurements = [0.301, 0.299, 0.30000001, 0.5, 0.7]
let near = Array.filter(measurements, |m| math.approx_eq_abs(m, 0.3, 0.01))
print(near)   // [0.301, 0.299, 0.30000001]

// Reduce: find first sample within tolerance
fn first_near(samples: [float], target: float, tol: float) -> float? {
    for s in samples {
        if math.approx_eq_abs(s, target, tol) { return s }
    }
    return nil
}
print(first_near([1.0, 1.5, 1.999, 2.0001], 2.0, 0.01))   // 1.999

let x: float = 0.1 + 0.2

x == 0.3          // lint: float-equality — consider using ~=
x != 0.3          // lint: float-equality — consider using !~=
0.1 + 0.2 == 0.3  // lint: float-equality

// Before (lint fires)
if x == 0.3 { ... }

// After (lint clear)
if x ~= 0.3 { ... }
if x ~= 0.3 within 1e-9 { ... }   // with explicit tolerance

// Also lint-free; preferred in higher-order contexts
if x.approx_eq(0.3) { ... }
if x.approx_eq_abs(0.3, 1e-9) { ... }

// When the values are exact decimals (money, fixed quantities)
let x: decimal = 0.1d + 0.2d
if x == 0.3d { ... }    // exact — no lint

// When the intent is to detect NaN — don't use x == float.NAN
if x.is_nan() { ... }   // correct; lint-free

// Explicitly: "I want exact bit-pattern equality"
if x ~= y within 0 ulps { ... }