buildlang 1.15.0

BuildLang (buildc): an effects-oriented compiler with a verified C path, shader output, experimental backends, opt-in linear types, and re-checkable accountability + scientific-runtime receipts
Documentation
// BuildLang Standard Library - Core Module
// Basic constants, integer utilities, float utilities, and comparison helpers.

// ---------------------------------------------------------------------------
// Math constants
// ---------------------------------------------------------------------------

fn pi() -> f64 { 3.14159265358979323846 }
fn e() -> f64 { 2.71828182845904523536 }
fn tau() -> f64 { 6.28318530717958647692 }

// ---------------------------------------------------------------------------
// Integer utilities
// ---------------------------------------------------------------------------

fn i32_min(a: i32, b: i32) -> i32 {
    if a < b { a } else { b }
}

fn i32_max(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }
}

fn i32_abs(n: i32) -> i32 {
    if n < 0 { -n } else { n }
}

fn i32_clamp(value: i32, low: i32, high: i32) -> i32 {
    if value < low { low }
    else if value > high { high }
    else { value }
}

// ---------------------------------------------------------------------------
// Float utilities
// ---------------------------------------------------------------------------

fn f64_min(a: f64, b: f64) -> f64 {
    if a < b { a } else { b }
}

fn f64_max(a: f64, b: f64) -> f64 {
    if a > b { a } else { b }
}

fn f64_abs(n: f64) -> f64 {
    if n < 0.0 { -n } else { n }
}

fn f64_clamp(value: f64, low: f64, high: f64) -> f64 {
    if value < low { low }
    else if value > high { high }
    else { value }
}

// ---------------------------------------------------------------------------
// Comparison helpers
// ---------------------------------------------------------------------------

fn is_even(n: i32) -> bool { n % 2 == 0 }
fn is_odd(n: i32) -> bool { n % 2 != 0 }
fn is_positive(n: i32) -> bool { n > 0 }
fn is_negative(n: i32) -> bool { n < 0 }
fn is_zero(n: i32) -> bool { n == 0 }

// ---------------------------------------------------------------------------
// Higher-order math utilities
// ---------------------------------------------------------------------------

fn gcd(a: i32, b: i32) -> i32 {
    let mut x = i32_abs(a);
    let mut y = i32_abs(b);
    while y != 0 {
        let temp = y;
        y = x % y;
        x = temp;
    }
    x
}

fn lcm(a: i32, b: i32) -> i32 {
    if a == 0 || b == 0 {
        0
    } else {
        i32_abs(a) / gcd(a, b) * i32_abs(b)
    }
}

fn factorial(n: i32) -> i32 {
    if n <= 1 { 1 } else { n * factorial(n - 1) }
}

fn fibonacci(n: i32) -> i32 {
    if n <= 1 { n } else { fibonacci(n - 1) + fibonacci(n - 2) }
}

fn power(base: i32, exp: i32) -> i32 {
    if exp == 0 { 1 }
    else {
        let mut result: i32 = 1;
        let mut i: i32 = 0;
        while i < exp {
            result = result * base;
            i = i + 1;
        }
        result
    }
}