mirror of
https://github.com/pjh456/OxideJS.git
synced 2026-10-24 02:31:13 +08:00
268 lines
9.6 KiB
Rust
268 lines
9.6 KiB
Rust
use oxide_types::value::JsValue;
|
||
|
||
use oxide_runtime_api::{NativeResult, VmHost};
|
||
|
||
fn num<H: VmHost>(vm: &mut H, reg: u8) -> f64 {
|
||
vm.coerce_number_bounded(vm.reg(reg)).unwrap_or(f64::NAN)
|
||
}
|
||
|
||
fn arg1<H: VmHost>(vm: &mut H, args: &[u8]) -> f64 {
|
||
if args.len() < 2 {
|
||
f64::NAN
|
||
} else {
|
||
num(vm, args[1])
|
||
}
|
||
}
|
||
|
||
fn arg2<H: VmHost>(vm: &mut H, args: &[u8]) -> (f64, f64) {
|
||
// 顺序求值（非元组字面量）：两次 coercion 各自单独借用 &mut H。
|
||
let a = if args.len() > 1 { num(vm, args[1]) } else { f64::NAN };
|
||
let b = if args.len() > 2 { num(vm, args[2]) } else { f64::NAN };
|
||
(a, b)
|
||
}
|
||
|
||
/// `Math.abs`：返回参数的绝对值。int 参数走 int 运算，其余按 double 返回。
|
||
pub fn math_abs<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
if args.len() < 2 {
|
||
return NativeResult::Ok(JsValue::float(f64::NAN));
|
||
}
|
||
let x = vm.reg(args[1]);
|
||
if x.is_int() {
|
||
NativeResult::Ok(JsValue::int(x.as_int().abs()))
|
||
} else {
|
||
NativeResult::Ok(JsValue::float(num(vm, args[1]).abs()))
|
||
}
|
||
}
|
||
|
||
macro_rules! math_unary {
|
||
($name:ident, $op:ident) => {
|
||
/// 一元数学函数（`Math.acos` 等）：对首个参数做 Rust 同名浮点运算，
|
||
/// 返回 double 结果；缺参或不可转数字时按 NaN 处理。
|
||
pub fn $name<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
NativeResult::Ok(JsValue::float(arg1(vm, args).$op()))
|
||
}
|
||
};
|
||
}
|
||
|
||
math_unary!(math_acos, acos);
|
||
math_unary!(math_acosh, acosh);
|
||
math_unary!(math_asin, asin);
|
||
math_unary!(math_asinh, asinh);
|
||
math_unary!(math_atan, atan);
|
||
math_unary!(math_atanh, atanh);
|
||
math_unary!(math_cbrt, cbrt);
|
||
math_unary!(math_ceil, ceil);
|
||
math_unary!(math_cos, cos);
|
||
math_unary!(math_cosh, cosh);
|
||
math_unary!(math_exp, exp);
|
||
math_unary!(math_expm1, exp_m1);
|
||
math_unary!(math_floor, floor);
|
||
math_unary!(math_log, ln);
|
||
math_unary!(math_log10, log10);
|
||
math_unary!(math_log1p, ln_1p);
|
||
math_unary!(math_log2, log2);
|
||
math_unary!(math_sin, sin);
|
||
math_unary!(math_sinh, sinh);
|
||
math_unary!(math_sqrt, sqrt);
|
||
math_unary!(math_tan, tan);
|
||
math_unary!(math_tanh, tanh);
|
||
math_unary!(math_trunc, trunc);
|
||
|
||
/// `Math.atan2(y, x)`：返回 y/x 的反正切角（弧度）。
|
||
pub fn math_atan2<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let (a, b) = arg2(vm, args);
|
||
NativeResult::Ok(JsValue::float(a.atan2(b)))
|
||
}
|
||
|
||
/// `Math.round`：四舍五入到最接近的整数，.5 时向正无穷取整（JS 语义）。
|
||
pub fn math_round<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let x = arg1(vm, args);
|
||
let r = if x < 0.0 { (x - 0.5).ceil() } else { (x + 0.5).floor() };
|
||
NativeResult::Ok(JsValue::float(r))
|
||
}
|
||
|
||
/// `Math.sign`：返回 1 / -1 / 0 / -0 / NaN。
|
||
pub fn math_sign<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let x = arg1(vm, args);
|
||
if x.is_nan() {
|
||
NativeResult::Ok(JsValue::float(f64::NAN))
|
||
} else if x > 0.0 {
|
||
NativeResult::Ok(JsValue::int(1))
|
||
} else if x < 0.0 {
|
||
NativeResult::Ok(JsValue::int(-1))
|
||
} else {
|
||
NativeResult::Ok(JsValue::float(x))
|
||
}
|
||
}
|
||
|
||
/// `Math.clz32`：返回 32 位无符号整数表示的前导零个数。
|
||
pub fn math_clz32<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let n = arg1(vm, args) as u32;
|
||
NativeResult::Ok(JsValue::int(n.leading_zeros() as i32))
|
||
}
|
||
|
||
/// `Math.fround`：把 double 舍入到 float32 精度再还原为 double。
|
||
pub fn math_fround<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
NativeResult::Ok(JsValue::float(arg1(vm, args) as f32 as f64))
|
||
}
|
||
|
||
/// IEEE 754 binary16（float16）舍入：f64 → binary16（round-to-nearest-even）→ 还原为 f64。
|
||
///
|
||
/// # 步骤
|
||
/// 1. 拆 f64 位（符号 / 指数 / 尾数），特殊值（±0 / 无穷 / NaN）直接保位
|
||
/// 2. 正规 f16 路径：53 位有效位收缩到 11 位（丢 42 位）做 RNE，进位溢出则指数 +1
|
||
/// 3. 次正规 f16 路径：指数 < -14 时右移舍入到 10 位尾数（步长 2⁻²⁴），
|
||
/// 溢出进位到最小正规 2⁻¹⁴；指数 < -25 时塌缩到 ±0
|
||
///
|
||
/// # 边界与前提
|
||
/// - RNE 半位判定：丢弃部分 > 半位进位；== 半位且保留位末位为 1 进位（round-half-even）
|
||
/// - 尾数进位溢出到指数后若超出 f16 指数上限 15 → ±Infinity（与规范溢出点一致）
|
||
/// - 输出直接以 f16 的 u16 位模式给出，供 Math.f16round 还原为 f64
|
||
/// 或 DataView setFloat16 写缓冲复用
|
||
fn f64_to_f16_bits(x: f64) -> u16 {
|
||
let bits = x.to_bits();
|
||
let sign = ((bits >> 63) & 1) as u16;
|
||
let exp = ((bits >> 52) & 0x7FF) as i32;
|
||
let mant = bits & 0xF_FFFF_FFFF_FFFF;
|
||
|
||
// 零与次正规 f64（exp==0）：粒度不足 binary16，直接塌缩到 ±0。
|
||
if exp == 0 {
|
||
return sign << 15;
|
||
}
|
||
// 无穷 / NaN：exp 字段全 1，NaN 尾数置非零位（保持 NaN 语义）。
|
||
if exp == 0x7FF {
|
||
let mant16 = if mant == 0 { 0 } else { 0x200 };
|
||
return (sign << 15) | 0x7C00 | mant16;
|
||
}
|
||
|
||
let e = exp - 1023; // 真实二进制指数（含隐含位）。
|
||
let significand = (1u64 << 52) | mant; // 53 位有效位。
|
||
|
||
if e > 15 {
|
||
// 值 ≥ 2¹⁶：必大于溢出舍入阈值（65520 起进 Inf），直接返回 ±Infinity。
|
||
return (sign << 15) | 0x7C00;
|
||
}
|
||
if e >= -14 {
|
||
// 正规 f16：11 位有效位，收缩 42 位做 RNE。
|
||
let shift = 42;
|
||
let dropped = significand & ((1u64 << shift) - 1);
|
||
let half = 1u64 << (shift - 1);
|
||
let mut q = significand >> shift;
|
||
if dropped > half || (dropped == half && (q & 1) == 1) {
|
||
q += 1;
|
||
}
|
||
if q == (1u64 << 11) {
|
||
// 11 位有效位溢出进位到指数；指数再溢出 → Infinity。
|
||
let e16 = e + 1;
|
||
if e16 > 15 {
|
||
return (sign << 15) | 0x7C00;
|
||
}
|
||
return (sign << 15) | (((e16 + 15) as u16) << 10);
|
||
}
|
||
return (sign << 15) | (((e + 15) as u16) << 10) | ((q & 0x3FF) as u16);
|
||
}
|
||
if e < -25 {
|
||
// 小于最小次正规一半（2⁻²⁵）→ RNE 塌缩到 ±0。
|
||
return sign << 15;
|
||
}
|
||
// 次正规 f16：值 = 10 位尾数 × 2⁻²⁴，右移 (28 - e) 位做 RNE。
|
||
let shift = (28 - e) as u32;
|
||
let dropped = significand & ((1u64 << shift) - 1);
|
||
let half = 1u64 << (shift - 1);
|
||
let mut q = significand >> shift;
|
||
if dropped > half || (dropped == half && (q & 1) == 1) {
|
||
q += 1;
|
||
}
|
||
// q 进位到 1024 → 最小正规 2⁻¹⁴（exp 字段 1，尾数 0）；否则次正规（exp 字段 0）。
|
||
if q == 1024 {
|
||
return (sign << 15) | (1 << 10);
|
||
}
|
||
(sign << 15) | (q as u16)
|
||
}
|
||
|
||
/// IEEE 754 binary16 → f64 精确还原（f16 有效位 ≤ 11 bit，f64 全可精确表示）。
|
||
/// 供 Math.f16round 与 DataView getFloat16 复用。
|
||
fn f16_bits_to_f64(h: u16) -> f64 {
|
||
let sign = ((h >> 15) & 1) as f64;
|
||
let exp = ((h >> 10) & 0x1F) as i32;
|
||
let mant = (h & 0x3FF) as f64;
|
||
let v = if exp == 0 {
|
||
// 零与次正规：mant × 2⁻²⁴。
|
||
mant * 2.0f64.powi(-24)
|
||
} else if exp == 0x1F {
|
||
if mant == 0.0 {
|
||
return if sign == 1.0 { f64::NEG_INFINITY } else { f64::INFINITY };
|
||
}
|
||
return f64::NAN;
|
||
} else {
|
||
// 正规：(1 + mant/2¹⁰) × 2^(exp-15)。
|
||
(1.0 + mant / 1024.0) * 2.0f64.powi(exp - 15)
|
||
};
|
||
if sign == 1.0 { -v } else { v }
|
||
}
|
||
|
||
/// `Math.f16round`：把 double 舍入到 binary16 精度再还原为 double。
|
||
pub fn math_f16round<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
NativeResult::Ok(JsValue::float(f16_bits_to_f64(f64_to_f16_bits(arg1(vm, args)))))
|
||
}
|
||
|
||
/// `Math.hypot`：返回 sqrt(a²+b²)（当前仅支持两个参数）。
|
||
pub fn math_hypot<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let (a, b) = arg2(vm, args);
|
||
NativeResult::Ok(JsValue::float(a.hypot(b)))
|
||
}
|
||
|
||
/// `Math.imul`：按 32 位整数做 wrap-around 乘法。
|
||
pub fn math_imul<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let (a, b) = arg2(vm, args);
|
||
NativeResult::Ok(JsValue::int((a as i32).wrapping_mul(b as i32)))
|
||
}
|
||
|
||
/// `Math.pow(base, exp)`：返回幂运算结果。
|
||
pub fn math_pow<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let (a, b) = arg2(vm, args);
|
||
NativeResult::Ok(JsValue::float(a.powf(b)))
|
||
}
|
||
|
||
/// `Math.max`：返回参数中的最大值；任一无参时返回 -Infinity，任一 NaN 时返回 NaN。
|
||
pub fn math_max<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
if args.len() < 2 {
|
||
return NativeResult::Ok(JsValue::float(f64::NEG_INFINITY));
|
||
}
|
||
let mut m = f64::NEG_INFINITY;
|
||
for &r in args.iter().skip(1) {
|
||
let x = num(vm, r);
|
||
if x.is_nan() {
|
||
return NativeResult::Ok(JsValue::float(f64::NAN));
|
||
}
|
||
if x > m {
|
||
m = x;
|
||
}
|
||
}
|
||
NativeResult::Ok(JsValue::float(m))
|
||
}
|
||
|
||
/// `Math.min`：返回参数中的最小值；无参时返回 Infinity，任一 NaN 时返回 NaN。
|
||
pub fn math_min<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
if args.len() < 2 {
|
||
return NativeResult::Ok(JsValue::float(f64::INFINITY));
|
||
}
|
||
let mut m = f64::INFINITY;
|
||
for &r in args.iter().skip(1) {
|
||
let x = num(vm, r);
|
||
if x.is_nan() {
|
||
return NativeResult::Ok(JsValue::float(f64::NAN));
|
||
}
|
||
if x < m {
|
||
m = x;
|
||
}
|
||
}
|
||
NativeResult::Ok(JsValue::float(m))
|
||
}
|
||
|
||
/// `Math.random`：推进 RNG 并返回 [0, 1) 的伪随机浮点数。
|
||
pub fn math_random<H: VmHost>(vm: &mut H, _args: &[u8]) -> NativeResult {
|
||
vm.step_rng();
|
||
NativeResult::Ok(JsValue::float(vm.math_rng_value()))
|
||
}
|