pipeline_script/core/

math.rs

/// 计算正弦值
///
/// # 参数
/// * `x` - 输入角度（弧度）
///
/// # 返回值
/// 返回x的正弦值
pub extern "C" fn sin(x: f64) -> f64 {
    x.sin()
}

/// 计算余弦值
///
/// # 参数
/// * `x` - 输入角度（弧度）
///
/// # 返回值
/// 返回x的余弦值
pub extern "C" fn cos(x: f64) -> f64 {
    x.cos()
}

/// 计算正切值
///
/// # 参数
/// * `x` - 输入角度（弧度）
///
/// # 返回值
/// 返回x的正切值
pub extern "C" fn tan(x: f64) -> f64 {
    x.tan()
}

/// 计算反正弦值
///
/// # 参数
/// * `x` - 输入值（范围：-1到1）
///
/// # 返回值
/// 返回x的反正弦值（弧度）
pub extern "C" fn asin(x: f64) -> f64 {
    x.asin()
}

/// 计算反余弦值
///
/// # 参数
/// * `x` - 输入值（范围：-1到1）
///
/// # 返回值
/// 返回x的反余弦值（弧度）
pub extern "C" fn acos(x: f64) -> f64 {
    x.acos()
}

/// 计算反正切值
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的反正切值（弧度）
pub extern "C" fn atan(x: f64) -> f64 {
    x.atan()
}

/// 计算两点间的反正切值
///
/// # 参数
/// * `y` - y坐标
/// * `x` - x坐标
///
/// # 返回值
/// 返回从x轴到点(x,y)的角度（弧度）
pub extern "C" fn atan2(y: f64, x: f64) -> f64 {
    y.atan2(x)
}

/// 计算自然指数函数
///
/// # 参数
/// * `x` - 指数
///
/// # 返回值
/// 返回e的x次方
pub extern "C" fn exp(x: f64) -> f64 {
    x.exp()
}

/// 计算2的x次方
///
/// # 参数
/// * `x` - 指数
///
/// # 返回值
/// 返回2的x次方
pub extern "C" fn exp2(x: f64) -> f64 {
    x.exp2()
}

/// 计算自然对数
///
/// # 参数
/// * `x` - 输入值（必须大于0）
///
/// # 返回值
/// 返回x的自然对数
pub extern "C" fn ln(x: f64) -> f64 {
    x.ln()
}

/// 计算以10为底的对数
///
/// # 参数
/// * `x` - 输入值（必须大于0）
///
/// # 返回值
/// 返回x的常用对数
pub extern "C" fn log10(x: f64) -> f64 {
    x.log10()
}

/// 计算以2为底的对数
///
/// # 参数
/// * `x` - 输入值（必须大于0）
///
/// # 返回值
/// 返回x的二进制对数
pub extern "C" fn log2(x: f64) -> f64 {
    x.log2()
}

/// 计算幂函数
///
/// # 参数
/// * `base` - 底数
/// * `exponent` - 指数
///
/// # 返回值
/// 返回base的exponent次方
pub extern "C" fn pow(base: f64, exponent: f64) -> f64 {
    base.powf(exponent)
}

/// 计算平方根
///
/// # 参数
/// * `x` - 输入值（必须大于等于0）
///
/// # 返回值
/// 返回x的平方根
pub extern "C" fn sqrt(x: f64) -> f64 {
    x.sqrt()
}

/// 计算立方根
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的立方根
pub extern "C" fn cbrt(x: f64) -> f64 {
    x.cbrt()
}

/// 向下取整
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回不大于x的最大整数
pub extern "C" fn floor(x: f64) -> f64 {
    x.floor()
}

/// 向上取整
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回不小于x的最小整数
pub extern "C" fn ceil(x: f64) -> f64 {
    x.ceil()
}

/// 四舍五入
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回最接近x的整数
pub extern "C" fn round(x: f64) -> f64 {
    x.round()
}

/// 截断小数部分
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的整数部分
pub extern "C" fn trunc(x: f64) -> f64 {
    x.trunc()
}

/// 计算绝对值（浮点数版本）
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的绝对值
pub extern "C" fn abs_f64(x: f64) -> f64 {
    x.abs()
}

/// 计算绝对值（32位浮点数版本）
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的绝对值
pub extern "C" fn abs_f32(x: f32) -> f32 {
    x.abs()
}

/// 计算绝对值（64位整数版本）
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的绝对值
pub extern "C" fn abs_i64(x: i64) -> i64 {
    x.abs()
}

/// 计算绝对值（32位整数版本）
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的绝对值
pub extern "C" fn abs_i32(x: i32) -> i32 {
    x.abs()
}

/// 计算两个数的最大值（浮点数版本）
///
/// # 参数
/// * `a` - 第一个数
/// * `b` - 第二个数
///
/// # 返回值
/// 返回a和b中的较大值
pub extern "C" fn max_f64(a: f64, b: f64) -> f64 {
    a.max(b)
}

/// 计算两个数的最小值（浮点数版本）
///
/// # 参数
/// * `a` - 第一个数
/// * `b` - 第二个数
///
/// # 返回值
/// 返回a和b中的较小值
pub extern "C" fn min_f64(a: f64, b: f64) -> f64 {
    a.min(b)
}

/// 计算两个数的最大值（64位整数版本）
///
/// # 参数
/// * `a` - 第一个数
/// * `b` - 第二个数
///
/// # 返回值
/// 返回a和b中的较大值
pub extern "C" fn max_i64(a: i64, b: i64) -> i64 {
    a.max(b)
}

/// 计算两个数的最小值（64位整数版本）
///
/// # 参数
/// * `a` - 第一个数
/// * `b` - 第二个数
///
/// # 返回值
/// 返回a和b中的较小值
pub extern "C" fn min_i64(a: i64, b: i64) -> i64 {
    a.min(b)
}

/// 将值限制在指定范围内
///
/// # 参数
/// * `value` - 要限制的值
/// * `min` - 最小值
/// * `max` - 最大值
///
/// # 返回值
/// 返回限制在[min, max]范围内的值
pub extern "C" fn clamp_f64(value: f64, min: f64, max: f64) -> f64 {
    value.clamp(min, max)
}

/// 将值限制在指定范围内（整数版本）
///
/// # 参数
/// * `value` - 要限制的值
/// * `min` - 最小值
/// * `max` - 最大值
///
/// # 返回值
/// 返回限制在[min, max]范围内的值
pub extern "C" fn clamp_i64(value: i64, min: i64, max: i64) -> i64 {
    value.clamp(min, max)
}

/// 计算两个数的余数
///
/// # 参数
/// * `dividend` - 被除数
/// * `divisor` - 除数
///
/// # 返回值
/// 返回dividend除以divisor的余数
pub extern "C" fn fmod(dividend: f64, divisor: f64) -> f64 {
    dividend % divisor
}

/// 计算双曲正弦值
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的双曲正弦值
pub extern "C" fn sinh(x: f64) -> f64 {
    x.sinh()
}

/// 计算双曲余弦值
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的双曲余弦值
pub extern "C" fn cosh(x: f64) -> f64 {
    x.cosh()
}

/// 计算双曲正切值
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 返回x的双曲正切值
pub extern "C" fn tanh(x: f64) -> f64 {
    x.tanh()
}

/// 将角度转换为弧度
///
/// # 参数
/// * `degrees` - 角度值
///
/// # 返回值
/// 返回对应的弧度值
pub extern "C" fn to_radians(degrees: f64) -> f64 {
    degrees.to_radians()
}

/// 将弧度转换为角度
///
/// # 参数
/// * `radians` - 弧度值
///
/// # 返回值
/// 返回对应的角度值
pub extern "C" fn to_degrees(radians: f64) -> f64 {
    radians.to_degrees()
}

/// 判断浮点数是否为NaN
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 如果x是NaN返回true，否则返回false
pub extern "C" fn is_nan(x: f64) -> bool {
    x.is_nan()
}

/// 判断浮点数是否为无穷大
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 如果x是无穷大返回true，否则返回false
pub extern "C" fn is_infinite(x: f64) -> bool {
    x.is_infinite()
}

/// 判断浮点数是否为有限数
///
/// # 参数
/// * `x` - 输入值
///
/// # 返回值
/// 如果x是有限数返回true，否则返回false
pub extern "C" fn is_finite(x: f64) -> bool {
    x.is_finite()
}

/// 生成随机数（0到1之间）
///
/// # 返回值
/// 返回0到1之间的随机浮点数
pub extern "C" fn random() -> f64 {
    use std::collections::hash_map::DefaultHasher;
    use std::hash::{Hash, Hasher};
    use std::time::{SystemTime, UNIX_EPOCH};

    // 使用当前时间作为种子生成伪随机数
    let mut hasher = DefaultHasher::new();
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_nanos()
        .hash(&mut hasher);

    let hash = hasher.finish();
    // 将hash值转换为0-1之间的浮点数
    (hash as f64) / (u64::MAX as f64)
}

/// 生成指定范围内的随机整数
///
/// # 参数
/// * `min` - 最小值（包含）
/// * `max` - 最大值（不包含）
///
/// # 返回值
/// 返回[min, max)范围内的随机整数
pub extern "C" fn random_range_i64(min: i64, max: i64) -> i64 {
    if min >= max {
        return min;
    }
    let range = (max - min) as u64;
    let random_val = random();
    min + ((random_val * range as f64) as i64)
}

/// 生成指定范围内的随机浮点数
///
/// # 参数
/// * `min` - 最小值（包含）
/// * `max` - 最大值（不包含）
///
/// # 返回值
/// 返回[min, max)范围内的随机浮点数
pub extern "C" fn random_range_f64(min: f64, max: f64) -> f64 {
    if min >= max {
        return min;
    }
    let range = max - min;
    min + (random() * range)
}

/// 计算阶乘
///
/// # 参数
/// * `n` - 输入的非负整数
///
/// # 返回值
/// 返回n的阶乘，如果n < 0则返回1
pub extern "C" fn factorial(n: i64) -> i64 {
    if n < 0 {
        return 1;
    }
    if n <= 1 {
        return 1;
    }

    let mut result = 1i64;
    for i in 2..=n {
        result = result.saturating_mul(i); // 防止溢出
    }
    result
}

/// 计算最大公约数
///
/// # 参数
/// * `a` - 第一个数
/// * `b` - 第二个数
///
/// # 返回值
/// 返回a和b的最大公约数
pub extern "C" fn gcd(a: i64, b: i64) -> i64 {
    let mut a = a.abs();
    let mut b = b.abs();

    while b != 0 {
        let temp = b;
        b = a % b;
        a = temp;
    }
    a
}

/// 计算最小公倍数
///
/// # 参数
/// * `a` - 第一个数
/// * `b` - 第二个数
///
/// # 返回值
/// 返回a和b的最小公倍数
pub extern "C" fn lcm(a: i64, b: i64) -> i64 {
    if a == 0 || b == 0 {
        return 0;
    }
    (a.abs() / gcd(a, b)) * b.abs()
}

/// 数学常量：圆周率π
pub extern "C" fn get_pi() -> f64 {
    std::f64::consts::PI
}

/// 数学常量：自然常数e
pub extern "C" fn get_e() -> f64 {
    std::f64::consts::E
}

/// 数学常量：黄金比例φ
pub extern "C" fn get_phi() -> f64 {
    (1.0 + 5.0_f64.sqrt()) / 2.0
}

/// 数学常量：ln(2)
pub extern "C" fn get_ln2() -> f64 {
    std::f64::consts::LN_2
}

/// 数学常量：ln(10)
pub extern "C" fn get_ln10() -> f64 {
    std::f64::consts::LN_10
}

/// 数学常量：log₁₀(e)
pub extern "C" fn get_log10_e() -> f64 {
    std::f64::consts::LOG10_E
}

/// 数学常量：log₂(e)
pub extern "C" fn get_log2_e() -> f64 {
    std::f64::consts::LOG2_E
}

/// 数学常量：√2
pub extern "C" fn get_sqrt2() -> f64 {
    std::f64::consts::SQRT_2
}

/// 数学常量：1/√2
pub extern "C" fn get_frac_1_sqrt2() -> f64 {
    std::f64::consts::FRAC_1_SQRT_2
}