Skip to main content

vibe/stdlib_v2/num_and_autodiff/
math_ext.rs

1//! Euclidean Division/Modulo, GCD/LCM, Neumaier Compensated Sum, Safe Iterable Extrema,
2//! Checked/Saturating Arithmetic, and Seeded SplitMix64 PRNG (`math.*`) for VibeScript v0.02.
3
4use std::collections::BTreeMap;
5
6use crate::error::{DiagCode, Diagnostic};
7use crate::span::Span;
8use crate::value::Value;
9
10use super::decimal::{coerce_dec, format_dec, round_dec};
11use super::{extract_f64, extract_i64, extract_list, opt_i64, opt_str};
12
13/// Dispatch a `math.*` call from `stdlib_v2`.
14pub fn call_math_ext(
15    path: &str,
16    args: &[Value],
17    span: Span,
18) -> Result<Option<Value>, Diagnostic> {
19    match path {
20        "math.idiv" => {
21            let a = extract_i64(args, 0, "math.idiv(a, b)", span)?;
22            let b = extract_i64(args, 1, "math.idiv(a, b)", span)?;
23            if b == 0 {
24                return Err(Diagnostic::new(
25                    DiagCode::E600,
26                    span,
27                    "math.idiv: division by zero",
28                ));
29            }
30            Ok(Some(Value::I64(floor_div(a, b))))
31        }
32        "math.imod" => {
33            let a = extract_i64(args, 0, "math.imod(a, b)", span)?;
34            let b = extract_i64(args, 1, "math.imod(a, b)", span)?;
35            if b == 0 {
36                return Err(Diagnostic::new(
37                    DiagCode::E600,
38                    span,
39                    "math.imod: modulo by zero",
40                ));
41            }
42            Ok(Some(Value::I64(a.rem_euclid(b))))
43        }
44        "math.divmod" => {
45            let a = extract_i64(args, 0, "math.divmod(a, b)", span)?;
46            let b = extract_i64(args, 1, "math.divmod(a, b)", span)?;
47            if b == 0 {
48                return Err(Diagnostic::new(
49                    DiagCode::E600,
50                    span,
51                    "math.divmod: division by zero",
52                ));
53            }
54            let q = floor_div(a, b);
55            let r = a.rem_euclid(b);
56            let mut rec = BTreeMap::new();
57            rec.insert("quotient".into(), Value::I64(q));
58            rec.insert("remainder".into(), Value::I64(r));
59            Ok(Some(Value::Record(rec)))
60        }
61        "math.gcd" => {
62            let a = extract_i64(args, 0, "math.gcd(a, b)", span)?;
63            let b = extract_i64(args, 1, "math.gcd(a, b)", span)?;
64            Ok(Some(Value::I64(gcd_i64(a, b))))
65        }
66        "math.lcm" => {
67            let a = extract_i64(args, 0, "math.lcm(a, b)", span)?;
68            let b = extract_i64(args, 1, "math.lcm(a, b)", span)?;
69            if a == 0 || b == 0 {
70                return Ok(Some(Value::I64(0)));
71            }
72            let g = gcd_i64(a, b) as i128;
73            let l = ((a as i128).abs() / g).saturating_mul((b as i128).abs());
74            Ok(Some(Value::I64(l.min(i64::MAX as i128) as i64)))
75        }
76        "math.lerp" => {
77            let a = extract_f64(args, 0, "math.lerp(a, b, t)", span)?;
78            let b = extract_f64(args, 1, "math.lerp(a, b, t)", span)?;
79            let t = extract_f64(args, 2, "math.lerp(a, b, t)", span)?;
80            Ok(Some(Value::F64(a + (b - a) * t)))
81        }
82        "math.sum_precise" => {
83            let list = extract_list(args, 0, "math.sum_precise(list)", span)?;
84            let mut sum = 0.0_f64;
85            let mut c = 0.0_f64;
86            for (idx, item) in list.iter().enumerate() {
87                let x = item.as_f64().ok_or_else(|| {
88                    Diagnostic::new(
89                        DiagCode::E100,
90                        span,
91                        format!("math.sum_precise: element #{idx} must be a number"),
92                    )
93                })?;
94                let t = sum + x;
95                if sum.abs() >= x.abs() {
96                    c += (sum - t) + x;
97                } else {
98                    c += (x - t) + sum;
99                }
100                sum = t;
101            }
102            Ok(Some(Value::F64(sum + c)))
103        }
104        "math.min_list" => eval_list_extrema(args, span, true),
105        "math.max_list" => eval_list_extrema(args, span, false),
106        "math.add_checked" => {
107            let a = extract_i64(args, 0, "math.add_checked(a, b)", span)?;
108            let b = extract_i64(args, 1, "math.add_checked(a, b)", span)?;
109            Ok(Some(checked_record(a.checked_add(b))))
110        }
111        "math.sub_checked" => {
112            let a = extract_i64(args, 0, "math.sub_checked(a, b)", span)?;
113            let b = extract_i64(args, 1, "math.sub_checked(a, b)", span)?;
114            Ok(Some(checked_record(a.checked_sub(b))))
115        }
116        "math.mul_checked" => {
117            let a = extract_i64(args, 0, "math.mul_checked(a, b)", span)?;
118            let b = extract_i64(args, 1, "math.mul_checked(a, b)", span)?;
119            Ok(Some(checked_record(a.checked_mul(b))))
120        }
121        "math.add_saturating" => {
122            let a = extract_i64(args, 0, "math.add_saturating(a, b)", span)?;
123            let b = extract_i64(args, 1, "math.add_saturating(a, b)", span)?;
124            Ok(Some(Value::I64(a.saturating_add(b))))
125        }
126        "math.sub_saturating" => {
127            let a = extract_i64(args, 0, "math.sub_saturating(a, b)", span)?;
128            let b = extract_i64(args, 1, "math.sub_saturating(a, b)", span)?;
129            Ok(Some(Value::I64(a.saturating_sub(b))))
130        }
131        "math.mul_saturating" => {
132            let a = extract_i64(args, 0, "math.mul_saturating(a, b)", span)?;
133            let b = extract_i64(args, 1, "math.mul_saturating(a, b)", span)?;
134            Ok(Some(Value::I64(a.saturating_mul(b))))
135        }
136        "math.round_mode" => {
137            let d = coerce_dec(args.first(), "math.round_mode(x, decimals, mode)", span)?;
138            let decimals = opt_i64(args, 1, 0).clamp(0, 20) as u32;
139            let mode = opt_str(args, 2, "half_away_from_zero");
140            let r = round_dec(d, decimals, &mode, span)?;
141            let s = format_dec(r.mantissa, r.scale);
142            let f = s.parse::<f64>().unwrap_or(0.0);
143            Ok(Some(Value::F64(f)))
144        }
145        "math.prng_seed" => {
146            let seed = extract_i64(args, 0, "math.prng_seed(seed)", span)?;
147            Ok(Some(make_prng_rec(seed as u64)))
148        }
149        "math.prng_next_u64" => {
150            let st = extract_prng_state(args.first(), "math.prng_next_u64", span)?;
151            let (val, next_st) = splitmix64_next(st);
152            let mut rec = BTreeMap::new();
153            rec.insert("value".into(), Value::U64(val));
154            rec.insert("state".into(), make_prng_rec(next_st));
155            Ok(Some(Value::Record(rec)))
156        }
157        "math.prng_next_f64" => {
158            let st = extract_prng_state(args.first(), "math.prng_next_f64", span)?;
159            let (val, next_st) = splitmix64_next(st);
160            let unit_f64 = (val >> 11) as f64 * (1.0 / ((1u64 << 53) as f64));
161            let mut rec = BTreeMap::new();
162            rec.insert("value".into(), Value::F64(unit_f64));
163            rec.insert("state".into(), make_prng_rec(next_st));
164            Ok(Some(Value::Record(rec)))
165        }
166        "math.prng_range" => {
167            let st = extract_prng_state(args.first(), "math.prng_range", span)?;
168            let lo = extract_i64(args, 1, "math.prng_range(prng, lo, hi)", span)?;
169            let hi = extract_i64(args, 2, "math.prng_range(prng, lo, hi)", span)?;
170            if lo > hi {
171                return Err(Diagnostic::new(
172                    DiagCode::E100,
173                    span,
174                    "math.prng_range: lo must be <= hi",
175                ));
176            }
177            let (val, next_st) = splitmix64_next(st);
178            let span_u = (hi as i128 - lo as i128 + 1) as u64;
179            let sampled = if span_u == 0 {
180                val as i64
181            } else {
182                lo + (val % span_u) as i64
183            };
184            let mut rec = BTreeMap::new();
185            rec.insert("value".into(), Value::I64(sampled));
186            rec.insert("state".into(), make_prng_rec(next_st));
187            Ok(Some(Value::Record(rec)))
188        }
189        _ => Ok(None),
190    }
191}
192
193fn floor_div(a: i64, b: i64) -> i64 {
194    let d = a / b;
195    let r = a % b;
196    if (r > 0 && b < 0) || (r < 0 && b > 0) {
197        d - 1
198    } else {
199        d
200    }
201}
202
203fn gcd_i64(a: i64, b: i64) -> i64 {
204    let mut x = (a as i128).abs();
205    let mut y = (b as i128).abs();
206    while y != 0 {
207        let t = y;
208        y = x % y;
209        x = t;
210    }
211    x.min(i64::MAX as i128) as i64
212}
213
214fn eval_list_extrema(
215    args: &[Value],
216    span: Span,
217    is_min: bool,
218) -> Result<Option<Value>, Diagnostic> {
219    let list = extract_list(args, 0, "math.min_list/max_list(list)", span)?;
220    if list.is_empty() {
221        return Ok(Some(Value::Null));
222    }
223    let mut all_int = true;
224    let mut best_f = if is_min {
225        f64::INFINITY
226    } else {
227        f64::NEG_INFINITY
228    };
229    let mut best_i = if is_min { i64::MAX } else { i64::MIN };
230    for (idx, item) in list.iter().enumerate() {
231        match item {
232            Value::I64(n) => {
233                if (is_min && *n < best_i) || (!is_min && *n > best_i) {
234                    best_i = *n;
235                }
236                let f = *n as f64;
237                if (is_min && f < best_f) || (!is_min && f > best_f) {
238                    best_f = f;
239                }
240            }
241            other => {
242                all_int = false;
243                let f = other.as_f64().ok_or_else(|| {
244                    Diagnostic::new(
245                        DiagCode::E100,
246                        span,
247                        format!("list extrema: element #{idx} must be a number"),
248                    )
249                })?;
250                if (is_min && f < best_f) || (!is_min && f > best_f) {
251                    best_f = f;
252                }
253            }
254        }
255    }
256    if all_int {
257        Ok(Some(Value::I64(best_i)))
258    } else {
259        Ok(Some(Value::F64(best_f)))
260    }
261}
262
263fn checked_record(opt: Option<i64>) -> Value {
264    let mut rec = BTreeMap::new();
265    match opt {
266        Some(v) => {
267            rec.insert("ok".into(), Value::Bool(true));
268            rec.insert("value".into(), Value::I64(v));
269        }
270        None => {
271            rec.insert("ok".into(), Value::Bool(false));
272            rec.insert("value".into(), Value::Null);
273        }
274    }
275    Value::Record(rec)
276}
277
278fn make_prng_rec(state: u64) -> Value {
279    let mut rec = BTreeMap::new();
280    rec.insert("__prng".into(), Value::Bool(true));
281    rec.insert("state".into(), Value::U64(state));
282    Value::Record(rec)
283}
284
285fn extract_prng_state(
286    arg: Option<&Value>,
287    ctx: &str,
288    span: Span,
289) -> Result<u64, Diagnostic> {
290    match arg {
291        Some(Value::Record(m)) => match m.get("state") {
292            Some(Value::U64(u)) => Ok(*u),
293            Some(Value::I64(i)) => Ok(*i as u64),
294            _ => Err(Diagnostic::new(
295                DiagCode::E100,
296                span,
297                format!("{ctx}: PRNG record missing 'state'"),
298            )),
299        },
300        Some(Value::U64(u)) => Ok(*u),
301        Some(Value::I64(i)) => Ok(*i as u64),
302        _ => Err(Diagnostic::new(
303            DiagCode::E100,
304            span,
305            format!("{ctx}: expected PRNG state record or integer seed"),
306        )),
307    }
308}
309
310fn splitmix64_next(state: u64) -> (u64, u64) {
311    let next_state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
312    let mut z = next_state;
313    z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
314    z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
315    let val = z ^ (z >> 31);
316    (val, next_state)
317}