math.ltl

// Lateralus Standard Library — math.ltl  (v1.5.0)
// Extended mathematical functions

module stdlib.math

pub const PI: float  = 3.141592653589793
pub const E:  float  = 2.718281828459045
pub const TAU: float = 6.283185307179586
pub const PHI: float = 1.618033988749895
pub const INF: float = 1.7976931348623157e+308
pub const SQRT2: float = 1.4142135623730951

// -- Core arithmetic ----------------------------------------------------------

pub fn abs_val(x: float) -> float {
    if x < 0.0 { return -x }
    return x
}

pub fn sqrt(x: float) -> float {
    if x < 0.0 {
        throw ValueError("sqrt of negative number")
    }
    // Newton-Raphson
    let mut guess = x / 2.0
    let mut prev  = 0.0
    while abs_val(guess - prev) > 0.0000001 {
        prev  = guess
        guess = (guess + x / guess) / 2.0
    }
    return guess
}

pub fn pow(base: float, exp: int) -> float {
    if exp == 0 { return 1.0 }
    if exp < 0  { return 1.0 / pow(base, -exp) }
    let mut result = 1.0
    let mut i = 0
    while i < exp {
        result = result * base
        i += 1
    }
    return result
}

pub fn floor(x: float) -> int {
    let n = x as int
    if x < 0.0 && (x as float) != (n as float) {
        return n - 1
    }
    return n
}

pub fn ceil(x: float) -> int {
    let n = x as int
    if x > 0.0 && (x as float) != (n as float) {
        return n + 1
    }
    return n
}

pub fn round_val(x: float) -> int {
    return floor(x + 0.5)
}

pub fn clamp(x: float, lo: float, hi: float) -> float {
    if x < lo { return lo }
    if x > hi { return hi }
    return x
}

pub fn sign(x: float) -> int {
    if x > 0.0 { return 1 }
    if x < 0.0 { return -1 }
    return 0
}

pub fn lerp(a: float, b: float, t: float) -> float {
    return a + (b - a) * t
}

pub fn hypot(a: float, b: float) -> float {
    return sqrt(a * a + b * b)
}

// -- Number theory ------------------------------------------------------------

pub fn factorial(n: int) -> int {
    if n <= 1 { return 1 }
    return n * factorial(n - 1)
}

pub fn gcd(a: int, b: int) -> int {
    let mut aa = a
    let mut bb = b
    while bb != 0 {
        let t = bb
        bb = aa % bb
        aa = t
    }
    return aa
}

pub fn lcm(a: int, b: int) -> int {
    return (a * b) / gcd(a, b)
}

pub fn is_prime(n: int) -> bool {
    if n < 2 { return false }
    if n == 2 { return true }
    if n % 2 == 0 { return false }
    let mut i = 3
    while i * i <= n {
        if n % i == 0 { return false }
        i += 2
    }
    return true
}

pub fn isqrt(n: int) -> int {
    if n < 0 { throw ValueError("isqrt of negative") }
    return floor(sqrt(n as float))
}

// Fibonacci (iterative, fast)
pub fn fibonacci(n: int) -> int {
    if n <= 0 { return 0 }
    if n == 1 { return 1 }
    let mut a = 0
    let mut b = 1
    let mut i = 2
    while i <= n {
        let c = a + b
        a = b
        b = c
        i += 1
    }
    return b
}

// -- Trigonometry (Taylor series) ---------------------------------------------

pub fn sin(x: float) -> float {
    let mut r = x
    while r > PI  { r = r - TAU }
    while r < -PI { r = r + TAU }
    let mut term = r
    let mut result = r
    let mut i = 1
    while abs_val(term) > 1e-12 {
        term = -term * r * r / (((2*i) * (2*i + 1)) as float)
        result = result + term
        i += 1
    }
    return result
}

pub fn cos(x: float) -> float {
    return sin(PI / 2.0 - x)
}

pub fn tan(x: float) -> float {
    let c = cos(x)
    if abs_val(c) < 1e-12 { throw ValueError("tan undefined at this value") }
    return sin(x) / c
}

pub fn radians(deg: float) -> float {
    return deg * PI / 180.0
}

pub fn degrees(rad: float) -> float {
    return rad * 180.0 / PI
}

// -- Logarithms ---------------------------------------------------------------

pub fn ln(x: float) -> float {
    if x <= 0.0 { throw ValueError("ln of non-positive number") }
    let LN2: float = 0.6931471805599453
    let mut k = 0
    let mut m = x
    while m > 1.5 { m = m / 2.0; k += 1 }
    while m < 0.5 { m = m * 2.0; k -= 1 }
    let y = (m - 1.0) / (m + 1.0)
    let y2 = y * y
    let mut s = 0.0
    let mut term = y
    let mut i = 1
    while abs_val(term) > 1e-12 {
        s = s + term / (i as float)
        term = term * y2
        i += 2
    }
    return 2.0 * s + (k as float) * LN2
}

pub fn log2(x: float) -> float {
    if x <= 0.0 { throw ValueError("log2 of non-positive number") }
    return ln(x) / ln(2.0)
}

pub fn log10(x: float) -> float {
    if x <= 0.0 { throw ValueError("log10 of non-positive number") }
    return ln(x) / ln(10.0)
}