1use 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
13pub 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}