Skip to main content

sheetkit_core/formula/functions/
engineering.rs

1//! Engineering formula functions: base conversion (BIN2DEC, BIN2HEX, etc.),
2//! complex numbers (COMPLEX, IMREAL, IMAGINARY, etc.), DELTA, GESTEP,
3//! ERF, ERFC, CONVERT, and Bessel functions.
4
5use crate::cell::CellValue;
6use crate::error::Result;
7use crate::formula::ast::Expr;
8use crate::formula::eval::{coerce_to_number, coerce_to_string, Evaluator};
9use crate::formula::functions::conversion::{checked_trunc_i32_in, checked_trunc_i64};
10use crate::formula::functions::{check_arg_count, finite_number_or_num_error};
11
12/// BIN2DEC(number)
13pub fn fn_bin2dec(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
14    check_arg_count("BIN2DEC", args, 1, 1)?;
15    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
16    let s = s.trim();
17    if s.len() > 10 || s.is_empty() || s.chars().any(|c| c != '0' && c != '1') {
18        return Ok(CellValue::Error("#NUM!".to_string()));
19    }
20    let val = i64::from_str_radix(s, 2).unwrap_or(0);
21    let result = if s.len() == 10 && s.starts_with('1') {
22        val - 1024
23    } else {
24        val
25    };
26    Ok(CellValue::Number(result as f64))
27}
28
29/// BIN2HEX(number, \[places\])
30pub fn fn_bin2hex(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
31    check_arg_count("BIN2HEX", args, 1, 2)?;
32    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
33    let s = s.trim();
34    if s.len() > 10 || s.is_empty() || s.chars().any(|c| c != '0' && c != '1') {
35        return Ok(CellValue::Error("#NUM!".to_string()));
36    }
37    let val = i64::from_str_radix(s, 2).unwrap_or(0);
38    let result = if s.len() == 10 && s.starts_with('1') {
39        val - 1024
40    } else {
41        val
42    };
43    format_hex(result, args, ctx, 1)
44}
45
46/// BIN2OCT(number, \[places\])
47pub fn fn_bin2oct(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
48    check_arg_count("BIN2OCT", args, 1, 2)?;
49    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
50    let s = s.trim();
51    if s.len() > 10 || s.is_empty() || s.chars().any(|c| c != '0' && c != '1') {
52        return Ok(CellValue::Error("#NUM!".to_string()));
53    }
54    let val = i64::from_str_radix(s, 2).unwrap_or(0);
55    let result = if s.len() == 10 && s.starts_with('1') {
56        val - 1024
57    } else {
58        val
59    };
60    format_oct(result, args, ctx, 1)
61}
62
63/// DEC2BIN(number, \[places\])
64pub fn fn_dec2bin(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
65    check_arg_count("DEC2BIN", args, 1, 2)?;
66    let value = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
67    let Some(n) = checked_truncated_i64(value, -512, 511) else {
68        return Ok(CellValue::Error("#NUM!".to_string()));
69    };
70    format_bin(n, args, ctx, 1)
71}
72
73/// DEC2HEX(number, \[places\])
74pub fn fn_dec2hex(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
75    check_arg_count("DEC2HEX", args, 1, 2)?;
76    let value = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
77    let Some(n) = checked_truncated_i64(value, -549_755_813_888, 549_755_813_887) else {
78        return Ok(CellValue::Error("#NUM!".to_string()));
79    };
80    format_hex(n, args, ctx, 1)
81}
82
83/// DEC2OCT(number, \[places\])
84pub fn fn_dec2oct(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
85    check_arg_count("DEC2OCT", args, 1, 2)?;
86    let value = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
87    let Some(n) = checked_truncated_i64(value, -536_870_912, 536_870_911) else {
88        return Ok(CellValue::Error("#NUM!".to_string()));
89    };
90    format_oct(n, args, ctx, 1)
91}
92
93/// HEX2BIN(number, \[places\])
94pub fn fn_hex2bin(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
95    check_arg_count("HEX2BIN", args, 1, 2)?;
96    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
97    let s = s.trim();
98    if s.len() > 10 || s.is_empty() || !s.chars().all(|c| c.is_ascii_hexdigit()) {
99        return Ok(CellValue::Error("#NUM!".to_string()));
100    }
101    let val = i64::from_str_radix(s, 16).unwrap_or(0);
102    let result = if val > 0x7FFFFFFFFF {
103        val - 0x10000000000_i64
104    } else {
105        val
106    };
107    if !(-512..=511).contains(&result) {
108        return Ok(CellValue::Error("#NUM!".to_string()));
109    }
110    format_bin(result, args, ctx, 1)
111}
112
113/// HEX2DEC(number)
114pub fn fn_hex2dec(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
115    check_arg_count("HEX2DEC", args, 1, 1)?;
116    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
117    let s = s.trim();
118    if s.len() > 10 || s.is_empty() || !s.chars().all(|c| c.is_ascii_hexdigit()) {
119        return Ok(CellValue::Error("#NUM!".to_string()));
120    }
121    let val = i64::from_str_radix(s, 16).unwrap_or(0);
122    let result = if val > 0x7FFFFFFFFF {
123        val - 0x10000000000_i64
124    } else {
125        val
126    };
127    Ok(CellValue::Number(result as f64))
128}
129
130/// HEX2OCT(number, \[places\])
131pub fn fn_hex2oct(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
132    check_arg_count("HEX2OCT", args, 1, 2)?;
133    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
134    let s = s.trim();
135    if s.len() > 10 || s.is_empty() || !s.chars().all(|c| c.is_ascii_hexdigit()) {
136        return Ok(CellValue::Error("#NUM!".to_string()));
137    }
138    let val = i64::from_str_radix(s, 16).unwrap_or(0);
139    let result = if val > 0x7FFFFFFFFF {
140        val - 0x10000000000_i64
141    } else {
142        val
143    };
144    if !(-536_870_912..=536_870_911).contains(&result) {
145        return Ok(CellValue::Error("#NUM!".to_string()));
146    }
147    format_oct(result, args, ctx, 1)
148}
149
150/// OCT2BIN(number, \[places\])
151pub fn fn_oct2bin(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
152    check_arg_count("OCT2BIN", args, 1, 2)?;
153    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
154    let s = s.trim();
155    if s.len() > 10 || s.is_empty() || s.chars().any(|c| !('0'..='7').contains(&c)) {
156        return Ok(CellValue::Error("#NUM!".to_string()));
157    }
158    let val = i64::from_str_radix(s, 8).unwrap_or(0);
159    // 30-bit two's complement: values above 2^29-1 are negative.
160    let result = if val > 0x1FFFFFFF {
161        val - 0x40000000
162    } else {
163        val
164    };
165    if !(-512..=511).contains(&result) {
166        return Ok(CellValue::Error("#NUM!".to_string()));
167    }
168    format_bin(result, args, ctx, 1)
169}
170
171/// OCT2DEC(number)
172pub fn fn_oct2dec(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
173    check_arg_count("OCT2DEC", args, 1, 1)?;
174    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
175    let s = s.trim();
176    if s.len() > 10 || s.is_empty() || s.chars().any(|c| !('0'..='7').contains(&c)) {
177        return Ok(CellValue::Error("#NUM!".to_string()));
178    }
179    let val = i64::from_str_radix(s, 8).unwrap_or(0);
180    // 30-bit two's complement: values above 2^29-1 are negative.
181    let result = if val > 0x1FFFFFFF {
182        val - 0x40000000
183    } else {
184        val
185    };
186    Ok(CellValue::Number(result as f64))
187}
188
189/// OCT2HEX(number, \[places\])
190pub fn fn_oct2hex(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
191    check_arg_count("OCT2HEX", args, 1, 2)?;
192    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
193    let s = s.trim();
194    if s.len() > 10 || s.is_empty() || s.chars().any(|c| !('0'..='7').contains(&c)) {
195        return Ok(CellValue::Error("#NUM!".to_string()));
196    }
197    let val = i64::from_str_radix(s, 8).unwrap_or(0);
198    // 30-bit two's complement: values above 2^29-1 are negative.
199    let result = if val > 0x1FFFFFFF {
200        val - 0x40000000
201    } else {
202        val
203    };
204    format_hex(result, args, ctx, 1)
205}
206
207/// DELTA(number1, \[number2\])
208pub fn fn_delta(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
209    check_arg_count("DELTA", args, 1, 2)?;
210    let n1 = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
211    let n2 = if args.len() > 1 {
212        coerce_to_number(&ctx.eval_expr(&args[1])?)?
213    } else {
214        0.0
215    };
216    // Excel DELTA uses exact bitwise equality, not epsilon comparison.
217    Ok(CellValue::Number(if n1 == n2 { 1.0 } else { 0.0 }))
218}
219
220/// GESTEP(number, \[step\])
221pub fn fn_gestep(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
222    check_arg_count("GESTEP", args, 1, 2)?;
223    let n = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
224    let step = if args.len() > 1 {
225        coerce_to_number(&ctx.eval_expr(&args[1])?)?
226    } else {
227        0.0
228    };
229    Ok(CellValue::Number(if n >= step { 1.0 } else { 0.0 }))
230}
231
232/// ERF(lower_limit, \[upper_limit\])
233pub fn fn_erf(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
234    check_arg_count("ERF", args, 1, 2)?;
235    let lower = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
236    if args.len() > 1 {
237        let upper = coerce_to_number(&ctx.eval_expr(&args[1])?)?;
238        Ok(CellValue::Number(erf_approx(upper) - erf_approx(lower)))
239    } else {
240        Ok(CellValue::Number(erf_approx(lower)))
241    }
242}
243
244/// ERFC(x)
245pub fn fn_erfc(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
246    check_arg_count("ERFC", args, 1, 1)?;
247    let x = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
248    Ok(CellValue::Number(1.0 - erf_approx(x)))
249}
250
251/// COMPLEX(real_num, i_num, \[suffix\])
252pub fn fn_complex(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
253    check_arg_count("COMPLEX", args, 2, 3)?;
254    let real = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
255    let imag = coerce_to_number(&ctx.eval_expr(&args[1])?)?;
256    let suffix = if args.len() > 2 {
257        let s = coerce_to_string(&ctx.eval_expr(&args[2])?);
258        if s != "i" && s != "j" {
259            return Ok(CellValue::Error("#VALUE!".to_string()));
260        }
261        s
262    } else {
263        "i".to_string()
264    };
265    Ok(CellValue::String(format_complex(real, imag, &suffix)))
266}
267
268/// IMREAL(inumber)
269pub fn fn_imreal(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
270    check_arg_count("IMREAL", args, 1, 1)?;
271    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
272    match parse_complex(&s) {
273        Some((real, _)) => Ok(CellValue::Number(real)),
274        None => Ok(CellValue::Error("#NUM!".to_string())),
275    }
276}
277
278/// IMAGINARY(inumber)
279pub fn fn_imaginary(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
280    check_arg_count("IMAGINARY", args, 1, 1)?;
281    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
282    match parse_complex(&s) {
283        Some((_, imag)) => Ok(CellValue::Number(imag)),
284        None => Ok(CellValue::Error("#NUM!".to_string())),
285    }
286}
287
288/// IMABS(inumber)
289pub fn fn_imabs(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
290    check_arg_count("IMABS", args, 1, 1)?;
291    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
292    match parse_complex(&s) {
293        Some((r, i)) => Ok(CellValue::Number((r * r + i * i).sqrt())),
294        None => Ok(CellValue::Error("#NUM!".to_string())),
295    }
296}
297
298/// IMARGUMENT(inumber)
299pub fn fn_imargument(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
300    check_arg_count("IMARGUMENT", args, 1, 1)?;
301    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
302    match parse_complex(&s) {
303        Some((r, i)) => {
304            if r == 0.0 && i == 0.0 {
305                return Ok(CellValue::Error("#DIV/0!".to_string()));
306            }
307            Ok(CellValue::Number(i.atan2(r)))
308        }
309        None => Ok(CellValue::Error("#NUM!".to_string())),
310    }
311}
312
313/// IMCONJUGATE(inumber)
314pub fn fn_imconjugate(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
315    check_arg_count("IMCONJUGATE", args, 1, 1)?;
316    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
317    match parse_complex(&s) {
318        Some((r, i)) => Ok(CellValue::String(format_complex(r, -i, "i"))),
319        None => Ok(CellValue::Error("#NUM!".to_string())),
320    }
321}
322
323/// IMSUM(inumber1, \[inumber2\], ...)
324pub fn fn_imsum(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
325    check_arg_count("IMSUM", args, 1, 255)?;
326    let mut real_sum = 0.0;
327    let mut imag_sum = 0.0;
328    let values = ctx.flatten_args_to_values(args)?;
329    for v in &values {
330        let s = coerce_to_string(v);
331        match parse_complex(&s) {
332            Some((r, i)) => {
333                real_sum += r;
334                imag_sum += i;
335            }
336            None => return Ok(CellValue::Error("#NUM!".to_string())),
337        }
338    }
339    Ok(CellValue::String(format_complex(real_sum, imag_sum, "i")))
340}
341
342/// IMSUB(inumber1, inumber2)
343pub fn fn_imsub(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
344    check_arg_count("IMSUB", args, 2, 2)?;
345    let s1 = coerce_to_string(&ctx.eval_expr(&args[0])?);
346    let s2 = coerce_to_string(&ctx.eval_expr(&args[1])?);
347    match (parse_complex(&s1), parse_complex(&s2)) {
348        (Some((r1, i1)), Some((r2, i2))) => {
349            Ok(CellValue::String(format_complex(r1 - r2, i1 - i2, "i")))
350        }
351        _ => Ok(CellValue::Error("#NUM!".to_string())),
352    }
353}
354
355/// IMPRODUCT(inumber1, \[inumber2\], ...)
356pub fn fn_improduct(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
357    check_arg_count("IMPRODUCT", args, 1, 255)?;
358    let values = ctx.flatten_args_to_values(args)?;
359    let mut real = 1.0;
360    let mut imag = 0.0;
361    for v in &values {
362        let s = coerce_to_string(v);
363        match parse_complex(&s) {
364            Some((r, i)) => {
365                let new_real = real * r - imag * i;
366                let new_imag = real * i + imag * r;
367                real = new_real;
368                imag = new_imag;
369            }
370            None => return Ok(CellValue::Error("#NUM!".to_string())),
371        }
372    }
373    Ok(CellValue::String(format_complex(real, imag, "i")))
374}
375
376/// IMDIV(inumber1, inumber2)
377pub fn fn_imdiv(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
378    check_arg_count("IMDIV", args, 2, 2)?;
379    let s1 = coerce_to_string(&ctx.eval_expr(&args[0])?);
380    let s2 = coerce_to_string(&ctx.eval_expr(&args[1])?);
381    match (parse_complex(&s1), parse_complex(&s2)) {
382        (Some((r1, i1)), Some((r2, i2))) => {
383            let denom = r2 * r2 + i2 * i2;
384            if denom == 0.0 {
385                return Ok(CellValue::Error("#NUM!".to_string()));
386            }
387            let real = (r1 * r2 + i1 * i2) / denom;
388            let imag = (i1 * r2 - r1 * i2) / denom;
389            Ok(CellValue::String(format_complex(real, imag, "i")))
390        }
391        _ => Ok(CellValue::Error("#NUM!".to_string())),
392    }
393}
394
395/// IMPOWER(inumber, number)
396pub fn fn_impower(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
397    check_arg_count("IMPOWER", args, 2, 2)?;
398    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
399    let n = coerce_to_number(&ctx.eval_expr(&args[1])?)?;
400    match parse_complex(&s) {
401        Some((r, i)) => {
402            let modulus = (r * r + i * i).sqrt();
403            if modulus == 0.0 {
404                if n > 0.0 {
405                    return Ok(CellValue::String("0".to_string()));
406                }
407                return Ok(CellValue::Error("#NUM!".to_string()));
408            }
409            let arg = i.atan2(r);
410            let new_mod = modulus.powf(n);
411            let new_arg = arg * n;
412            let real = new_mod * new_arg.cos();
413            let imag = new_mod * new_arg.sin();
414            Ok(CellValue::String(format_complex(real, imag, "i")))
415        }
416        None => Ok(CellValue::Error("#NUM!".to_string())),
417    }
418}
419
420/// IMSQRT(inumber)
421pub fn fn_imsqrt(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
422    check_arg_count("IMSQRT", args, 1, 1)?;
423    let s = coerce_to_string(&ctx.eval_expr(&args[0])?);
424    match parse_complex(&s) {
425        Some((r, i)) => {
426            let modulus = (r * r + i * i).sqrt();
427            let arg = i.atan2(r);
428            let new_mod = modulus.sqrt();
429            let new_arg = arg / 2.0;
430            let real = new_mod * new_arg.cos();
431            let imag = new_mod * new_arg.sin();
432            Ok(CellValue::String(format_complex(real, imag, "i")))
433        }
434        None => Ok(CellValue::Error("#NUM!".to_string())),
435    }
436}
437
438/// CONVERT(number, from_unit, to_unit)
439pub fn fn_convert(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
440    check_arg_count("CONVERT", args, 3, 3)?;
441    let n = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
442    let from = coerce_to_string(&ctx.eval_expr(&args[1])?);
443    let to = coerce_to_string(&ctx.eval_expr(&args[2])?);
444    match convert_units(n, &from, &to) {
445        Some(result) => Ok(CellValue::Number(result)),
446        None => Ok(CellValue::Error("#N/A".to_string())),
447    }
448}
449
450/// BESSELI(x, n)
451pub fn fn_besseli(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
452    check_arg_count("BESSELI", args, 2, 2)?;
453    let x = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
454    let order = coerce_to_number(&ctx.eval_expr(&args[1])?)?;
455    let Some(n) = checked_nonnegative_i32(order) else {
456        return Ok(CellValue::Error("#NUM!".to_string()));
457    };
458    if !x.is_finite() {
459        return Ok(CellValue::Error("#NUM!".to_string()));
460    }
461    finite_number_or_num_error(bessel_i(x, f64::from(n)))
462}
463
464/// BESSELJ(x, n)
465pub fn fn_besselj(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
466    check_arg_count("BESSELJ", args, 2, 2)?;
467    let x = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
468    let order = coerce_to_number(&ctx.eval_expr(&args[1])?)?;
469    let Some(n) = checked_nonnegative_i32(order) else {
470        return Ok(CellValue::Error("#NUM!".to_string()));
471    };
472    if !x.is_finite() {
473        return Ok(CellValue::Error("#NUM!".to_string()));
474    }
475    finite_number_or_num_error(bessel_j(x, f64::from(n)))
476}
477
478/// BESSELK(x, n)
479pub fn fn_besselk(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
480    check_arg_count("BESSELK", args, 2, 2)?;
481    let x = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
482    let order = coerce_to_number(&ctx.eval_expr(&args[1])?)?;
483    let Some(n) = checked_nonnegative_i32(order) else {
484        return Ok(CellValue::Error("#NUM!".to_string()));
485    };
486    if !x.is_finite() || x <= 0.0 {
487        return Ok(CellValue::Error("#NUM!".to_string()));
488    }
489    if x > 15.0 {
490        ctx.charge_evaluation_work(u64::try_from(n.saturating_sub(1).max(0)).unwrap_or(u64::MAX))?;
491    }
492    finite_number_or_num_error(bessel_k(x, n))
493}
494
495/// BESSELY(x, n)
496pub fn fn_bessely(args: &[Expr], ctx: &mut Evaluator) -> Result<CellValue> {
497    check_arg_count("BESSELY", args, 2, 2)?;
498    let x = coerce_to_number(&ctx.eval_expr(&args[0])?)?;
499    let order = coerce_to_number(&ctx.eval_expr(&args[1])?)?;
500    let Some(n) = checked_nonnegative_i32(order) else {
501        return Ok(CellValue::Error("#NUM!".to_string()));
502    };
503    if !x.is_finite() || x <= 0.0 {
504        return Ok(CellValue::Error("#NUM!".to_string()));
505    }
506    if x > 15.0 {
507        ctx.charge_evaluation_work(u64::try_from(n.saturating_sub(1).max(0)).unwrap_or(u64::MAX))?;
508    }
509    finite_number_or_num_error(bessel_y(x, n))
510}
511
512const MAX_ENGINEERING_PLACES: f64 = 10.0;
513
514#[derive(Clone, Copy)]
515enum EngineeringPlaces {
516    Omitted,
517    Width(usize),
518    Invalid,
519}
520
521fn checked_truncated_i64(value: f64, min: i64, max: i64) -> Option<i64> {
522    checked_trunc_i64(value, min, max)
523}
524
525fn checked_nonnegative_i32(value: f64) -> Option<i32> {
526    checked_trunc_i32_in(value, 0, i32::MAX)
527}
528
529fn engineering_places(
530    args: &[Expr],
531    ctx: &mut Evaluator,
532    places_idx: usize,
533) -> Result<EngineeringPlaces> {
534    if args.len() <= places_idx {
535        return Ok(EngineeringPlaces::Omitted);
536    }
537    let places = coerce_to_number(&ctx.eval_expr(&args[places_idx])?)?;
538    if !places.is_finite() {
539        return Ok(EngineeringPlaces::Invalid);
540    }
541    let truncated = places.trunc();
542    if !(1.0..=MAX_ENGINEERING_PLACES).contains(&truncated) {
543        return Ok(EngineeringPlaces::Invalid);
544    }
545    Ok(EngineeringPlaces::Width(truncated as usize))
546}
547
548fn format_bin(n: i64, args: &[Expr], ctx: &mut Evaluator, places_idx: usize) -> Result<CellValue> {
549    let places = engineering_places(args, ctx, places_idx)?;
550    if matches!(places, EngineeringPlaces::Invalid) {
551        return Ok(CellValue::Error("#NUM!".to_string()));
552    }
553    let s = if n >= 0 {
554        format!("{n:b}")
555    } else {
556        let bits = (n as u64) & 0x3FF;
557        format!("{bits:010b}")
558    };
559    if let EngineeringPlaces::Width(width) = places {
560        if n >= 0 && s.len() > width {
561            return Ok(CellValue::Error("#NUM!".to_string()));
562        }
563        if n >= 0 {
564            ctx.check_output_bytes(u64::try_from(width).unwrap_or(u64::MAX))?;
565            return Ok(CellValue::String(format!("{s:0>width$}")));
566        }
567    }
568    ctx.check_output_bytes(u64::try_from(s.len()).unwrap_or(u64::MAX))?;
569    Ok(CellValue::String(s))
570}
571
572fn format_hex(n: i64, args: &[Expr], ctx: &mut Evaluator, places_idx: usize) -> Result<CellValue> {
573    let places = engineering_places(args, ctx, places_idx)?;
574    if matches!(places, EngineeringPlaces::Invalid) {
575        return Ok(CellValue::Error("#NUM!".to_string()));
576    }
577    let s = if n >= 0 {
578        format!("{n:X}")
579    } else {
580        let bits = (n as u64) & 0xFF_FFFF_FFFF;
581        format!("{bits:010X}")
582    };
583    if let EngineeringPlaces::Width(width) = places {
584        if n >= 0 && s.len() > width {
585            return Ok(CellValue::Error("#NUM!".to_string()));
586        }
587        if n >= 0 {
588            ctx.check_output_bytes(u64::try_from(width).unwrap_or(u64::MAX))?;
589            return Ok(CellValue::String(format!("{s:0>width$}")));
590        }
591    }
592    ctx.check_output_bytes(u64::try_from(s.len()).unwrap_or(u64::MAX))?;
593    Ok(CellValue::String(s))
594}
595
596fn format_oct(n: i64, args: &[Expr], ctx: &mut Evaluator, places_idx: usize) -> Result<CellValue> {
597    let places = engineering_places(args, ctx, places_idx)?;
598    if matches!(places, EngineeringPlaces::Invalid) {
599        return Ok(CellValue::Error("#NUM!".to_string()));
600    }
601    let s = if n >= 0 {
602        format!("{n:o}")
603    } else {
604        // 10 octal digits = 30 bits
605        let bits = (n as u64) & 0x3FFFFFFF;
606        format!("{bits:010o}")
607    };
608    if let EngineeringPlaces::Width(width) = places {
609        if n >= 0 && s.len() > width {
610            return Ok(CellValue::Error("#NUM!".to_string()));
611        }
612        if n >= 0 {
613            ctx.check_output_bytes(u64::try_from(width).unwrap_or(u64::MAX))?;
614            return Ok(CellValue::String(format!("{s:0>width$}")));
615        }
616    }
617    ctx.check_output_bytes(u64::try_from(s.len()).unwrap_or(u64::MAX))?;
618    Ok(CellValue::String(s))
619}
620
621fn erf_approx(x: f64) -> f64 {
622    let sign = if x < 0.0 { -1.0 } else { 1.0 };
623    let x = x.abs();
624    let t = 1.0 / (1.0 + 0.3275911 * x);
625    let poly = t
626        * (0.254829592
627            + t * (-0.284496736 + t * (1.421413741 + t * (-1.453152027 + t * 1.061405429))));
628    sign * (1.0 - poly * (-x * x).exp())
629}
630
631fn parse_complex(s: &str) -> Option<(f64, f64)> {
632    let s = s.trim();
633    if s.is_empty() {
634        return None;
635    }
636    if let Ok(n) = s.parse::<f64>() {
637        return Some((n, 0.0));
638    }
639    if s == "i" || s == "j" {
640        return Some((0.0, 1.0));
641    }
642    if s == "-i" || s == "-j" {
643        return Some((0.0, -1.0));
644    }
645    if s == "+i" || s == "+j" {
646        return Some((0.0, 1.0));
647    }
648    let suffix = if s.ends_with('i') || s.ends_with('j') {
649        s.len() - 1
650    } else {
651        return None;
652    };
653    let body = &s[..suffix];
654    let sign_pos = body.rfind('+').or_else(|| {
655        let rp = body.rfind('-')?;
656        if rp == 0 {
657            None
658        } else {
659            Some(rp)
660        }
661    });
662    match sign_pos {
663        Some(pos) => {
664            let real_str = &body[..pos];
665            let imag_str = &body[pos..];
666            let real = if real_str.is_empty() {
667                0.0
668            } else {
669                real_str.parse::<f64>().ok()?
670            };
671            let imag = if imag_str == "+" || imag_str.is_empty() {
672                1.0
673            } else if imag_str == "-" {
674                -1.0
675            } else {
676                imag_str.parse::<f64>().ok()?
677            };
678            Some((real, imag))
679        }
680        None => {
681            let imag = if body == "+" || body.is_empty() {
682                1.0
683            } else if body == "-" {
684                -1.0
685            } else {
686                body.parse::<f64>().ok()?
687            };
688            Some((0.0, imag))
689        }
690    }
691}
692
693fn format_complex(real: f64, imag: f64, suffix: &str) -> String {
694    let real = clean_float(real);
695    let imag = clean_float(imag);
696    if imag == 0.0 {
697        return format_number(real);
698    }
699    if real == 0.0 {
700        if imag == 1.0 {
701            return suffix.to_string();
702        }
703        if imag == -1.0 {
704            return format!("-{suffix}");
705        }
706        return format!("{}{suffix}", format_number(imag));
707    }
708    let imag_str = if imag == 1.0 {
709        format!("+{suffix}")
710    } else if imag == -1.0 {
711        format!("-{suffix}")
712    } else if imag > 0.0 {
713        format!("+{}{suffix}", format_number(imag))
714    } else {
715        format!("{}{suffix}", format_number(imag))
716    };
717    format!("{}{imag_str}", format_number(real))
718}
719
720fn clean_float(v: f64) -> f64 {
721    if v.abs() < 1e-15 {
722        0.0
723    } else {
724        v
725    }
726}
727
728fn format_number(n: f64) -> String {
729    if n.fract() == 0.0 && n.is_finite() && n.abs() < 1e15 {
730        format!("{}", n as i64)
731    } else {
732        format!("{n}")
733    }
734}
735
736fn convert_units(value: f64, from: &str, to: &str) -> Option<f64> {
737    let from_base = unit_to_base_factor(from)?;
738    let to_base = unit_to_base_factor(to)?;
739    if from_base.1 != to_base.1 {
740        if from_base.1 == "C" && to_base.1 == "C" {
741            return None;
742        }
743        return None;
744    }
745    if from_base.1 == "C" {
746        let celsius = temp_to_celsius(value, from)?;
747        return celsius_to_temp(celsius, to);
748    }
749    Some(value * from_base.0 / to_base.0)
750}
751
752fn temp_to_celsius(value: f64, unit: &str) -> Option<f64> {
753    match unit {
754        "C" | "cel" => Some(value),
755        "F" | "fah" => Some((value - 32.0) * 5.0 / 9.0),
756        "K" | "kel" => Some(value - 273.15),
757        "Rank" => Some((value - 491.67) * 5.0 / 9.0),
758        "Reau" => Some(value * 5.0 / 4.0),
759        _ => None,
760    }
761}
762
763fn celsius_to_temp(celsius: f64, unit: &str) -> Option<f64> {
764    match unit {
765        "C" | "cel" => Some(celsius),
766        "F" | "fah" => Some(celsius * 9.0 / 5.0 + 32.0),
767        "K" | "kel" => Some(celsius + 273.15),
768        "Rank" => Some((celsius + 273.15) * 9.0 / 5.0),
769        "Reau" => Some(celsius * 4.0 / 5.0),
770        _ => None,
771    }
772}
773
774fn unit_to_base_factor(unit: &str) -> Option<(f64, &'static str)> {
775    match unit {
776        // Weight/Mass (base: kg)
777        "g" => Some((0.001, "mass")),
778        "kg" => Some((1.0, "mass")),
779        "mg" => Some((1e-6, "mass")),
780        "lbm" => Some((0.45359237, "mass")),
781        "ozm" => Some((0.028349523125, "mass")),
782        "stone" => Some((6.35029318, "mass")),
783        "ton" => Some((907.18474, "mass")),
784        "sg" => Some((14.593903, "mass")),
785        "u" => Some((1.66053906660e-27, "mass")),
786        "grain" => Some((6.479891e-5, "mass")),
787        "cwt" | "shweight" => Some((45.359237, "mass")),
788        "uk_cwt" | "lcwt" | "hweight" => Some((50.80234544, "mass")),
789        "LTON" | "brton" => Some((1016.0469088, "mass")),
790
791        // Distance (base: m)
792        "m" => Some((1.0, "dist")),
793        "km" => Some((1000.0, "dist")),
794        "cm" => Some((0.01, "dist")),
795        "mm" => Some((0.001, "dist")),
796        "mi" => Some((1609.344, "dist")),
797        "Nmi" => Some((1852.0, "dist")),
798        "in" => Some((0.0254, "dist")),
799        "ft" => Some((0.3048, "dist")),
800        "yd" => Some((0.9144, "dist")),
801        "ang" => Some((1e-10, "dist")),
802        "ell" => Some((1.143, "dist")),
803        "ly" => Some((9.46073047258e15, "dist")),
804        "parsec" | "pc" => Some((3.08567758149e16, "dist")),
805        "Pica" | "Picapt" => Some((0.00035277778, "dist")),
806        "pica" => Some((0.00423333333, "dist")),
807        "survey_mi" => Some((1609.3472, "dist")),
808
809        // Time (base: s)
810        "sec" | "s" => Some((1.0, "time")),
811        "min" | "mn" => Some((60.0, "time")),
812        "hr" => Some((3600.0, "time")),
813        "day" | "d" => Some((86400.0, "time")),
814        "yr" => Some((365.25 * 86400.0, "time")),
815
816        // Speed (base: m/s)
817        "m/s" | "m/sec" => Some((1.0, "speed")),
818        "m/h" | "m/hr" => Some((1.0 / 3600.0, "speed")),
819        "mph" => Some((0.44704, "speed")),
820        "kn" | "admkn" => Some((0.514444444, "speed")),
821
822        // Area (base: m^2)
823        "ar" => Some((100.0, "area")),
824        "ha" => Some((10000.0, "area")),
825        "uk_acre" => Some((4046.8564224, "area")),
826        "us_acre" => Some((4046.8726, "area")),
827
828        // Volume (base: l)
829        "l" | "L" | "lt" => Some((1.0, "vol")),
830        "ml" => Some((0.001, "vol")),
831        "gal" => Some((3.78541178, "vol")),
832        "qt" => Some((0.946352946, "vol")),
833        "pt" | "us_pt" => Some((0.473176473, "vol")),
834        "cup" => Some((0.236588236, "vol")),
835        "oz" | "fl_oz" | "us_oz" => Some((0.0295735296, "vol")),
836        "tbs" => Some((0.0147867648, "vol")),
837        "tsp" => Some((0.00492892159, "vol")),
838        "uk_gal" => Some((4.54609, "vol")),
839        "uk_qt" => Some((1.1365225, "vol")),
840        "uk_pt" => Some((0.56826125, "vol")),
841
842        // Energy (base: J)
843        "J" | "j" => Some((1.0, "energy")),
844        "e" => Some((1e-7, "energy")),
845        "cal" => Some((4.1868, "energy")),
846        "eV" | "ev" => Some((1.602176634e-19, "energy")),
847        "HPh" | "hh" => Some((2684519.5, "energy")),
848        "Wh" | "wh" => Some((3600.0, "energy")),
849        "flb" => Some((1.3558179483, "energy")),
850        "BTU" | "btu" => Some((1055.05585262, "energy")),
851
852        // Power (base: W)
853        "W" | "w" => Some((1.0, "power")),
854        "kW" | "kw" => Some((1000.0, "power")),
855        "HP" | "h" => Some((745.69987158, "power")),
856        "PS" => Some((735.49875, "power")),
857
858        // Force (base: N)
859        "N" => Some((1.0, "force")),
860        "dyn" | "dy" => Some((1e-5, "force")),
861        "lbf" => Some((4.4482216152605, "force")),
862        "pond" => Some((9.80665e-3, "force")),
863
864        // Pressure (base: Pa)
865        "Pa" | "p" => Some((1.0, "press")),
866        "atm" | "at" => Some((101325.0, "press")),
867        "mmHg" => Some((133.322, "press")),
868        "psi" => Some((6894.757, "press")),
869        "Torr" => Some((133.3224, "press")),
870
871        // Temperature (special handling)
872        "C" | "cel" | "F" | "fah" | "K" | "kel" | "Rank" | "Reau" => Some((1.0, "C")),
873
874        // Information (base: bit)
875        "bit" => Some((1.0, "info")),
876        "byte" => Some((8.0, "info")),
877
878        _ => None,
879    }
880}
881
882fn bessel_y(x: f64, n: i32) -> f64 {
883    if x > 15.0 {
884        let y0 = bessel_jy_asymptotic(x, 0).1;
885        if n == 0 {
886            return y0;
887        }
888        let mut previous = y0;
889        let mut current = bessel_jy_asymptotic(x, 1).1;
890        for order in 1..n {
891            (previous, current) = (current, 2.0 * order as f64 / x * current - previous);
892        }
893        return current;
894    }
895    // For integer orders, the generic formula divides by sin(n*pi) = 0.
896    // Use the limiting form via numerical differentiation instead.
897    let nf = n as f64;
898    let eps = 1e-8;
899    let y_plus = {
900        let v = nf + eps;
901        let pi = std::f64::consts::PI;
902        ((v * pi).cos() * bessel_j(x, v) - bessel_j(x, -v)) / (v * pi).sin()
903    };
904    let y_minus = {
905        let v = nf - eps;
906        let pi = std::f64::consts::PI;
907        ((v * pi).cos() * bessel_j(x, v) - bessel_j(x, -v)) / (v * pi).sin()
908    };
909    (y_plus + y_minus) / 2.0
910}
911
912/// Evaluate J_v(x) for real (non-integer) order v using the power series.
913fn bessel_j(x: f64, v: f64) -> f64 {
914    if x.abs() > 15.0 && v.fract() == 0.0 && v * v <= 2.0 * x.abs() {
915        let n = v as i32;
916        let value = bessel_jy_asymptotic(x.abs(), n).0;
917        return if x < 0.0 && n % 2 != 0 { -value } else { value };
918    }
919    let mut sum = 0.0;
920    for m in 0_i32..50 {
921        let sign = if m % 2 == 0 { 1.0 } else { -1.0 };
922        let numer = (x / 2.0).powf(2.0 * m as f64 + v);
923        let denom = gamma(m as f64 + 1.0) * gamma(m as f64 + v + 1.0);
924        if denom == 0.0 || !numer.is_finite() {
925            break;
926        }
927        sum += sign * numer / denom;
928    }
929    sum
930}
931
932fn bessel_k(x: f64, n: i32) -> f64 {
933    if x > 15.0 {
934        let k0 = bessel_ik_asymptotic(x, 0).1;
935        if n == 0 {
936            return k0;
937        }
938        let mut previous = k0;
939        let mut current = bessel_ik_asymptotic(x, 1).1;
940        for order in 1..n {
941            (previous, current) = (current, previous + 2.0 * order as f64 / x * current);
942        }
943        return current;
944    }
945    // For integer orders, the generic formula divides by sin(n*pi) = 0.
946    // Use the limiting form via numerical differentiation.
947    let nf = n as f64;
948    let eps = 1e-8;
949    let pi = std::f64::consts::PI;
950    let k_plus = {
951        let v = nf + eps;
952        pi / 2.0 * (bessel_i(x, -v) - bessel_i(x, v)) / (v * pi).sin()
953    };
954    let k_minus = {
955        let v = nf - eps;
956        pi / 2.0 * (bessel_i(x, -v) - bessel_i(x, v)) / (v * pi).sin()
957    };
958    (k_plus + k_minus) / 2.0
959}
960
961/// Evaluate I_v(x) for real (non-integer) order v using the power series.
962fn bessel_i(x: f64, v: f64) -> f64 {
963    if x.abs() > 15.0 && v.fract() == 0.0 && v * v <= 2.0 * x.abs() {
964        let n = v as i32;
965        let value = bessel_ik_asymptotic(x.abs(), n).0;
966        return if x < 0.0 && n % 2 != 0 { -value } else { value };
967    }
968    let mut sum = 0.0;
969    for m in 0_i32..50 {
970        let numer = (x / 2.0).powf(2.0 * m as f64 + v);
971        let denom = gamma(m as f64 + 1.0) * gamma(m as f64 + v + 1.0);
972        if denom == 0.0 || !numer.is_finite() {
973            break;
974        }
975        sum += numer / denom;
976    }
977    sum
978}
979
980fn bessel_jy_asymptotic(x: f64, n: i32) -> (f64, f64) {
981    let mu = 4.0 * (n as f64).powi(2);
982    let mut term = 1.0;
983    let mut p = 1.0;
984    let mut q = 0.0;
985    let mut previous = f64::INFINITY;
986    for k in 1..=40 {
987        let odd = (2 * k - 1) as f64;
988        term *= (mu - odd * odd) / (k as f64 * 8.0 * x);
989        if term.abs() > previous {
990            break;
991        }
992        previous = term.abs();
993        if k % 2 == 0 {
994            p += if k % 4 == 0 { term } else { -term };
995        } else {
996            q += if k % 4 == 1 { term } else { -term };
997        }
998    }
999    let phase = x - n as f64 * std::f64::consts::FRAC_PI_2 - std::f64::consts::FRAC_PI_4;
1000    let scale = (2.0 / (std::f64::consts::PI * x)).sqrt();
1001    let (sin, cos) = phase.sin_cos();
1002    (scale * (cos * p - sin * q), scale * (sin * p + cos * q))
1003}
1004
1005fn bessel_ik_asymptotic(x: f64, n: i32) -> (f64, f64) {
1006    let mu = 4.0 * (n as f64).powi(2);
1007    let mut term = 1.0;
1008    let mut i_sum = 1.0;
1009    let mut k_sum = 1.0;
1010    let mut previous = f64::INFINITY;
1011    for k in 1..=40 {
1012        let odd = (2 * k - 1) as f64;
1013        term *= (mu - odd * odd) / (k as f64 * 8.0 * x);
1014        if term.abs() > previous {
1015            break;
1016        }
1017        previous = term.abs();
1018        k_sum += term;
1019        i_sum += if k % 2 == 0 { term } else { -term };
1020    }
1021    (
1022        x.exp() / (2.0 * std::f64::consts::PI * x).sqrt() * i_sum,
1023        (std::f64::consts::PI / (2.0 * x)).sqrt() * (-x).exp() * k_sum,
1024    )
1025}
1026
1027/// Lanczos approximation of the Gamma function for real arguments.
1028fn gamma(z: f64) -> f64 {
1029    if z < 0.5 {
1030        let pi = std::f64::consts::PI;
1031        return pi / ((pi * z).sin() * gamma(1.0 - z));
1032    }
1033    let g = 7.0;
1034    #[allow(clippy::excessive_precision)]
1035    let c = [
1036        0.99999999999980993,
1037        676.5203681218851,
1038        -1259.1392167224028,
1039        771.32342877765313,
1040        -176.61502916214059,
1041        12.507343278686905,
1042        -0.13857109526572012,
1043        9.9843695780195716e-6,
1044        1.5056327351493116e-7,
1045    ];
1046    let z = z - 1.0;
1047    let mut x = c[0];
1048    for (i, &coeff) in c.iter().enumerate().skip(1) {
1049        x += coeff / (z + i as f64);
1050    }
1051    let t = z + g + 0.5;
1052    (2.0 * std::f64::consts::PI).sqrt() * t.powf(z + 0.5) * (-t).exp() * x
1053}
1054
1055#[cfg(test)]
1056mod tests {
1057    use crate::cell::CellValue;
1058    use crate::error::Result;
1059    use crate::formula::ast::Expr;
1060    use crate::formula::eval::{evaluate, CellSnapshot};
1061    use crate::formula::parser::parse_formula;
1062
1063    fn eval(formula: &str) -> CellValue {
1064        let snap = CellSnapshot::new("Sheet1".to_string());
1065        let expr = parse_formula(formula).unwrap();
1066        evaluate(&expr, &snap).unwrap()
1067    }
1068
1069    fn eval_expr(expr: &Expr) -> Result<CellValue> {
1070        let snap = CellSnapshot::new("Sheet1".to_string());
1071        evaluate(expr, &snap)
1072    }
1073
1074    fn conversion(function: &str, number: Expr, places: f64) -> Expr {
1075        Expr::Function {
1076            name: function.to_string(),
1077            args: vec![number, Expr::Number(places)],
1078        }
1079    }
1080
1081    fn assert_approx(result: CellValue, expected: f64, tol: f64) {
1082        match result {
1083            CellValue::Number(n) => {
1084                assert!((n - expected).abs() < tol, "expected ~{expected}, got {n}");
1085            }
1086            other => panic!("expected number ~{expected}, got {other:?}"),
1087        }
1088    }
1089
1090    #[test]
1091    fn bin2dec_positive() {
1092        assert_approx(eval("BIN2DEC(\"1100100\")"), 100.0, 0.01);
1093    }
1094
1095    #[test]
1096    fn bin2dec_negative() {
1097        assert_approx(eval("BIN2DEC(\"1111111111\")"), -1.0, 0.01);
1098    }
1099
1100    #[test]
1101    fn bin2hex_basic() {
1102        assert_eq!(
1103            eval("BIN2HEX(\"11111011\",4)"),
1104            CellValue::String("00FB".to_string())
1105        );
1106    }
1107
1108    #[test]
1109    fn bin2oct_basic() {
1110        assert_eq!(
1111            eval("BIN2OCT(\"1001\",4)"),
1112            CellValue::String("0011".to_string())
1113        );
1114    }
1115
1116    #[test]
1117    fn dec2bin_basic() {
1118        assert_eq!(eval("DEC2BIN(9)"), CellValue::String("1001".to_string()));
1119    }
1120
1121    #[test]
1122    fn dec2bin_negative() {
1123        assert_eq!(
1124            eval("DEC2BIN(-100)"),
1125            CellValue::String("1110011100".to_string())
1126        );
1127    }
1128
1129    #[test]
1130    fn dec2bin_with_places() {
1131        assert_eq!(
1132            eval("DEC2BIN(9,8)"),
1133            CellValue::String("00001001".to_string())
1134        );
1135    }
1136
1137    #[test]
1138    fn engineering_places_enforce_excel_width_before_formatting() {
1139        let cases = [
1140            ("BIN2HEX", Expr::String("1".to_string())),
1141            ("BIN2OCT", Expr::String("1".to_string())),
1142            ("DEC2BIN", Expr::Number(1.0)),
1143            ("DEC2OCT", Expr::Number(1.0)),
1144            ("OCT2BIN", Expr::String("1".to_string())),
1145            ("OCT2HEX", Expr::String("1".to_string())),
1146        ];
1147
1148        for (function, number) in cases {
1149            assert_eq!(
1150                eval_expr(&conversion(function, number.clone(), 10.0)).unwrap(),
1151                CellValue::String("0000000001".to_string()),
1152                "{function} must accept the exact width ceiling"
1153            );
1154            for invalid_places in [
1155                11.0,
1156                1e20,
1157                f64::NAN,
1158                f64::INFINITY,
1159                f64::NEG_INFINITY,
1160                0.0,
1161                0.9,
1162                -1.0,
1163                -1.9,
1164            ] {
1165                assert_eq!(
1166                    eval_expr(&conversion(function, number.clone(), invalid_places)).unwrap(),
1167                    CellValue::Error("#NUM!".to_string()),
1168                    "{function} must reject places={invalid_places:?}"
1169                );
1170            }
1171            assert_eq!(
1172                eval_expr(&conversion(function, number, 4.9)).unwrap(),
1173                CellValue::String("0001".to_string()),
1174                "{function} must truncate fractional places"
1175            );
1176        }
1177    }
1178
1179    #[test]
1180    fn engineering_negative_values_keep_ten_digits_with_valid_places() {
1181        let cases = [
1182            (
1183                "BIN2HEX",
1184                Expr::String("1111111111".to_string()),
1185                "FFFFFFFFFF",
1186            ),
1187            (
1188                "BIN2OCT",
1189                Expr::String("1111111111".to_string()),
1190                "7777777777",
1191            ),
1192            ("DEC2BIN", Expr::Number(-1.0), "1111111111"),
1193            ("DEC2OCT", Expr::Number(-1.0), "7777777777"),
1194            (
1195                "OCT2BIN",
1196                Expr::String("7777777777".to_string()),
1197                "1111111111",
1198            ),
1199            (
1200                "OCT2HEX",
1201                Expr::String("7777777777".to_string()),
1202                "FFFFFFFFFF",
1203            ),
1204        ];
1205
1206        for (function, number, expected) in cases {
1207            assert_eq!(
1208                eval_expr(&conversion(function, number.clone(), 1.0)).unwrap(),
1209                CellValue::String(expected.to_string()),
1210                "{function} must ignore a valid places width for negative values"
1211            );
1212            assert_eq!(
1213                eval_expr(&conversion(function, number, 11.0)).unwrap(),
1214                CellValue::Error("#NUM!".to_string()),
1215                "{function} must enforce the non-overridable width ceiling"
1216            );
1217        }
1218    }
1219
1220    #[test]
1221    fn decimal_engineering_numbers_use_checked_truncation() {
1222        for function in ["DEC2BIN", "DEC2HEX", "DEC2OCT"] {
1223            for invalid_number in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, 1e20] {
1224                assert_eq!(
1225                    eval_expr(&conversion(function, Expr::Number(invalid_number), 10.0)).unwrap(),
1226                    CellValue::Error("#NUM!".to_string()),
1227                    "{function} must reject number={invalid_number:?}"
1228                );
1229            }
1230        }
1231
1232        assert_eq!(eval("DEC2BIN(9.9)"), CellValue::String("1001".to_string()));
1233        assert_eq!(
1234            eval("DEC2BIN(-1.9)"),
1235            CellValue::String("1111111111".to_string())
1236        );
1237        assert_eq!(eval("DEC2OCT(9.9)"), CellValue::String("11".to_string()));
1238        assert_eq!(
1239            eval("DEC2OCT(-1.9)"),
1240            CellValue::String("7777777777".to_string())
1241        );
1242    }
1243
1244    #[test]
1245    fn dec2hex_basic() {
1246        assert_eq!(eval("DEC2HEX(100)"), CellValue::String("64".to_string()));
1247    }
1248
1249    #[test]
1250    fn dec2hex_negative() {
1251        let result = eval("DEC2HEX(-54)");
1252        assert_eq!(result, CellValue::String("FFFFFFFFCA".to_string()));
1253    }
1254
1255    #[test]
1256    fn dec2oct_basic() {
1257        assert_eq!(eval("DEC2OCT(58)"), CellValue::String("72".to_string()));
1258    }
1259
1260    #[test]
1261    fn dec2oct_negative() {
1262        // DEC2OCT(-1) should produce 7777777777 (10-digit, 30-bit two's complement)
1263        assert_eq!(
1264            eval("DEC2OCT(-1)"),
1265            CellValue::String("7777777777".to_string())
1266        );
1267        // DEC2OCT(-536870912) is the minimum value
1268        assert_eq!(
1269            eval("DEC2OCT(-536870912)"),
1270            CellValue::String("4000000000".to_string())
1271        );
1272    }
1273
1274    #[test]
1275    fn hex2bin_basic() {
1276        assert_eq!(
1277            eval("HEX2BIN(\"F\",8)"),
1278            CellValue::String("00001111".to_string())
1279        );
1280    }
1281
1282    #[test]
1283    fn hex2dec_basic() {
1284        assert_approx(eval("HEX2DEC(\"A5\")"), 165.0, 0.01);
1285    }
1286
1287    #[test]
1288    fn hex2dec_negative() {
1289        assert_approx(eval("HEX2DEC(\"FFFFFFFFFF\")"), -1.0, 0.01);
1290    }
1291
1292    #[test]
1293    fn hex2oct_basic() {
1294        assert_eq!(
1295            eval("HEX2OCT(\"F\",3)"),
1296            CellValue::String("017".to_string())
1297        );
1298    }
1299
1300    #[test]
1301    fn oct2bin_basic() {
1302        assert_eq!(
1303            eval("OCT2BIN(\"3\",4)"),
1304            CellValue::String("0011".to_string())
1305        );
1306    }
1307
1308    #[test]
1309    fn oct2bin_negative() {
1310        // 7777777000 octal = -512 decimal -> 10-bit binary 1000000000
1311        assert_eq!(
1312            eval("OCT2BIN(\"7777777000\")"),
1313            CellValue::String("1000000000".to_string())
1314        );
1315        // 7777777776 octal = -2 decimal -> 1111111110
1316        assert_eq!(
1317            eval("OCT2BIN(\"7777777776\")"),
1318            CellValue::String("1111111110".to_string())
1319        );
1320        // 7777777777 octal = -1 decimal -> 1111111111
1321        assert_eq!(
1322            eval("OCT2BIN(\"7777777777\")"),
1323            CellValue::String("1111111111".to_string())
1324        );
1325    }
1326
1327    #[test]
1328    fn oct2dec_basic() {
1329        assert_approx(eval("OCT2DEC(\"54\")"), 44.0, 0.01);
1330    }
1331
1332    #[test]
1333    fn oct2dec_negative() {
1334        // 7777777777 octal = -1 decimal (30-bit two's complement)
1335        assert_approx(eval("OCT2DEC(\"7777777777\")"), -1.0, 0.01);
1336        // 4000000000 octal = -536870912 decimal
1337        assert_approx(eval("OCT2DEC(\"4000000000\")"), -536_870_912.0, 0.01);
1338        // 7777777000 octal = -512 decimal
1339        assert_approx(eval("OCT2DEC(\"7777777000\")"), -512.0, 0.01);
1340    }
1341
1342    #[test]
1343    fn oct2dec_positive_boundary() {
1344        // 3777777777 octal = 536870911 (max positive in 30-bit two's complement)
1345        assert_approx(eval("OCT2DEC(\"3777777777\")"), 536_870_911.0, 0.01);
1346    }
1347
1348    #[test]
1349    fn oct2hex_basic() {
1350        assert_eq!(
1351            eval("OCT2HEX(\"100\",4)"),
1352            CellValue::String("0040".to_string())
1353        );
1354    }
1355
1356    #[test]
1357    fn oct2hex_negative() {
1358        // 7777777777 octal = -1 decimal -> FFFFFFFFFF hex
1359        assert_eq!(
1360            eval("OCT2HEX(\"7777777777\")"),
1361            CellValue::String("FFFFFFFFFF".to_string())
1362        );
1363        // 4000000000 octal = -536870912 decimal -> FFE0000000 hex
1364        assert_eq!(
1365            eval("OCT2HEX(\"4000000000\")"),
1366            CellValue::String("FFE0000000".to_string())
1367        );
1368    }
1369
1370    #[test]
1371    fn delta_equal() {
1372        assert_approx(eval("DELTA(5,5)"), 1.0, 0.01);
1373    }
1374
1375    #[test]
1376    fn delta_not_equal() {
1377        assert_approx(eval("DELTA(5,4)"), 0.0, 0.01);
1378    }
1379
1380    #[test]
1381    fn delta_default() {
1382        assert_approx(eval("DELTA(0)"), 1.0, 0.01);
1383    }
1384
1385    #[test]
1386    fn delta_distinct_close_values() {
1387        // Values that differ by more than f64::EPSILON but are distinct
1388        // should NOT be considered equal (old code used epsilon comparison).
1389        // 1.0 and 1.0 + 1e-15 are distinct f64 values.
1390        let a = 1.0_f64;
1391        let b = 1.0_f64 + 1e-15;
1392        assert_ne!(a, b);
1393        assert_approx(eval("DELTA(1, 1.000000000000001)"), 0.0, 0.01);
1394    }
1395
1396    #[test]
1397    fn gestep_above() {
1398        assert_approx(eval("GESTEP(5,4)"), 1.0, 0.01);
1399    }
1400
1401    #[test]
1402    fn gestep_below() {
1403        assert_approx(eval("GESTEP(3,4)"), 0.0, 0.01);
1404    }
1405
1406    #[test]
1407    fn gestep_equal() {
1408        assert_approx(eval("GESTEP(4,4)"), 1.0, 0.01);
1409    }
1410
1411    #[test]
1412    fn erf_basic() {
1413        assert_approx(eval("ERF(1)"), 0.8427, 0.001);
1414    }
1415
1416    #[test]
1417    fn erf_range() {
1418        assert_approx(eval("ERF(0,1)"), 0.8427, 0.001);
1419    }
1420
1421    #[test]
1422    fn erfc_basic() {
1423        assert_approx(eval("ERFC(1)"), 0.1573, 0.001);
1424    }
1425
1426    #[test]
1427    fn complex_basic() {
1428        assert_eq!(eval("COMPLEX(3,4)"), CellValue::String("3+4i".to_string()));
1429    }
1430
1431    #[test]
1432    fn complex_real_only() {
1433        assert_eq!(eval("COMPLEX(3,0)"), CellValue::String("3".to_string()));
1434    }
1435
1436    #[test]
1437    fn complex_imag_only() {
1438        assert_eq!(eval("COMPLEX(0,4)"), CellValue::String("4i".to_string()));
1439    }
1440
1441    #[test]
1442    fn complex_negative_imag() {
1443        assert_eq!(eval("COMPLEX(3,-4)"), CellValue::String("3-4i".to_string()));
1444    }
1445
1446    #[test]
1447    fn imreal_basic() {
1448        assert_approx(eval("IMREAL(\"3+4i\")"), 3.0, 0.01);
1449    }
1450
1451    #[test]
1452    fn imaginary_basic() {
1453        assert_approx(eval("IMAGINARY(\"3+4i\")"), 4.0, 0.01);
1454    }
1455
1456    #[test]
1457    fn imabs_basic() {
1458        assert_approx(eval("IMABS(\"3+4i\")"), 5.0, 0.01);
1459    }
1460
1461    #[test]
1462    fn imargument_basic() {
1463        assert_approx(eval("IMARGUMENT(\"3+4i\")"), (4.0_f64).atan2(3.0), 0.001);
1464    }
1465
1466    #[test]
1467    fn imconjugate_basic() {
1468        assert_eq!(
1469            eval("IMCONJUGATE(\"3+4i\")"),
1470            CellValue::String("3-4i".to_string())
1471        );
1472    }
1473
1474    #[test]
1475    fn imsum_basic() {
1476        assert_eq!(
1477            eval("IMSUM(\"3+4i\",\"1-2i\")"),
1478            CellValue::String("4+2i".to_string())
1479        );
1480    }
1481
1482    #[test]
1483    fn imsub_basic() {
1484        assert_eq!(
1485            eval("IMSUB(\"3+4i\",\"1+2i\")"),
1486            CellValue::String("2+2i".to_string())
1487        );
1488    }
1489
1490    #[test]
1491    fn improduct_basic() {
1492        assert_eq!(
1493            eval("IMPRODUCT(\"1+2i\",\"3+4i\")"),
1494            CellValue::String("-5+10i".to_string())
1495        );
1496    }
1497
1498    #[test]
1499    fn imdiv_basic() {
1500        let result = eval("IMDIV(\"2+4i\",\"1+1i\")");
1501        assert_eq!(result, CellValue::String("3+i".to_string()));
1502    }
1503
1504    #[test]
1505    fn impower_basic() {
1506        let result = eval("IMPOWER(\"2+3i\",2)");
1507        if let CellValue::String(s) = &result {
1508            let parsed = super::parse_complex(s).unwrap();
1509            assert!((parsed.0 - (-5.0)).abs() < 0.01);
1510            assert!((parsed.1 - 12.0).abs() < 0.01);
1511        } else {
1512            panic!("expected string, got {result:?}");
1513        }
1514    }
1515
1516    #[test]
1517    fn imsqrt_basic() {
1518        let result = eval("IMSQRT(\"4\")");
1519        if let CellValue::String(s) = &result {
1520            let parsed = super::parse_complex(s).unwrap();
1521            assert!((parsed.0 - 2.0).abs() < 0.01);
1522            assert!(parsed.1.abs() < 0.01);
1523        } else {
1524            panic!("expected string, got {result:?}");
1525        }
1526    }
1527
1528    #[test]
1529    fn convert_length() {
1530        assert_approx(eval("CONVERT(1,\"in\",\"cm\")"), 2.54, 0.001);
1531    }
1532
1533    #[test]
1534    fn convert_weight() {
1535        assert_approx(eval("CONVERT(1,\"lbm\",\"kg\")"), 0.453592, 0.001);
1536    }
1537
1538    #[test]
1539    fn convert_temperature() {
1540        assert_approx(eval("CONVERT(100,\"C\",\"F\")"), 212.0, 0.1);
1541    }
1542
1543    #[test]
1544    fn convert_temperature_k() {
1545        assert_approx(eval("CONVERT(0,\"C\",\"K\")"), 273.15, 0.01);
1546    }
1547
1548    #[test]
1549    fn convert_incompatible() {
1550        assert_eq!(
1551            eval("CONVERT(1,\"in\",\"kg\")"),
1552            CellValue::Error("#N/A".to_string())
1553        );
1554    }
1555
1556    #[test]
1557    fn besselj_basic() {
1558        assert_approx(eval("BESSELJ(1.9,2)"), 0.3295, 0.01);
1559    }
1560
1561    #[test]
1562    fn besseli_basic() {
1563        assert_approx(eval("BESSELI(1.5,1)"), 0.9817, 0.01);
1564    }
1565
1566    #[test]
1567    fn besselj_order_zero() {
1568        // BESSELJ(0, 0) = 1.0
1569        assert_approx(eval("BESSELJ(0,0)"), 1.0, 0.01);
1570    }
1571
1572    #[test]
1573    fn besselk_zero_x() {
1574        assert_eq!(eval("BESSELK(0,1)"), CellValue::Error("#NUM!".to_string()));
1575    }
1576
1577    #[test]
1578    fn besselk_integer_order() {
1579        // BESSELK(1.5, 1) should be finite (~0.2774)
1580        let result = eval("BESSELK(1.5,1)");
1581        if let CellValue::Number(v) = result {
1582            assert!(v.is_finite(), "BESSELK(1.5,1) should be finite, got {v}");
1583            assert!((v - 0.2774).abs() < 0.05);
1584        } else {
1585            panic!("expected number, got {result:?}");
1586        }
1587    }
1588
1589    #[test]
1590    fn bessely_zero_x() {
1591        assert_eq!(eval("BESSELY(0,1)"), CellValue::Error("#NUM!".to_string()));
1592    }
1593
1594    #[test]
1595    fn bessely_integer_order() {
1596        // BESSELY(2.5, 1) should be finite (~0.1459)
1597        let result = eval("BESSELY(2.5,1)");
1598        if let CellValue::Number(v) = result {
1599            assert!(v.is_finite(), "BESSELY(2.5,1) should be finite, got {v}");
1600            assert!((v - 0.1459).abs() < 0.05);
1601        } else {
1602            panic!("expected number, got {result:?}");
1603        }
1604    }
1605
1606    #[test]
1607    fn bessely_order_zero() {
1608        // BESSELY(1, 0) should be finite (~0.0883)
1609        let result = eval("BESSELY(1,0)");
1610        if let CellValue::Number(v) = result {
1611            assert!(v.is_finite(), "BESSELY(1,0) should be finite, got {v}");
1612            assert!((v - 0.0883).abs() < 0.05);
1613        } else {
1614            panic!("expected number, got {result:?}");
1615        }
1616    }
1617
1618    #[test]
1619    fn bessel_large_x_reference_vectors() {
1620        // High-precision reference values computed from the DLMF definitions.
1621        assert_approx(eval("BESSELJ(20,0)"), 0.167_024_664_340_583_16, 1e-12);
1622        assert_approx(eval("BESSELJ(20,3)"), -0.098_901_394_560_449_58, 1e-12);
1623        assert_approx(eval("BESSELY(20,0)"), 0.062_640_596_809_383_83, 1e-12);
1624        assert_approx(eval("BESSELY(20,3)"), 0.149_673_262_713_394_08, 1e-12);
1625        assert_approx(eval("BESSELI(20,0)"), 43_558_282.559_553_534, 1e-6);
1626        assert_approx(eval("BESSELI(20,3)"), 34_592_416.340_919_62, 1e-6);
1627        assert_approx(eval("BESSELK(20,0)"), 5.741_237_815_336_524e-10, 1e-20);
1628        assert_approx(eval("BESSELK(20,3)"), 7.148_966_692_015_484e-10, 1e-20);
1629        assert_approx(eval("BESSELJ(20,10)"), 0.186_482_558_023_945_1, 1e-9);
1630        assert_approx(eval("BESSELY(20,10)"), -0.043_894_653_515_658_4, 1e-12);
1631        assert_approx(eval("BESSELI(20,10)"), 3_540_200.209_019_521, 1e-6);
1632        assert_approx(eval("BESSELK(20,10)"), 6.316_214_528_321_58e-9, 1e-19);
1633    }
1634
1635    #[test]
1636    fn bessel_large_x_boundary_regression() {
1637        assert_approx(eval("BESSELJ(15,2)"), 0.041_571_677_975_250_48, 1e-9);
1638        assert_approx(eval("BESSELJ(16,2)"), 0.186_198_720_941_292_8, 1e-10);
1639    }
1640
1641    #[test]
1642    fn bessel_validates_domains_and_non_finite_results() {
1643        assert_eq!(eval("BESSELJ(1,-1)"), CellValue::Error("#NUM!".to_string()));
1644        assert_eq!(eval("BESSELY(-1,0)"), CellValue::Error("#NUM!".to_string()));
1645        assert_eq!(
1646            eval("BESSELI(1000,0)"),
1647            CellValue::Error("#NUM!".to_string())
1648        );
1649    }
1650}