1use 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
12pub 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
29pub 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
46pub 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
63pub 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
73pub 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
83pub 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
93pub 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
113pub 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
130pub 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
150pub 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 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
171pub 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 let result = if val > 0x1FFFFFFF {
182 val - 0x40000000
183 } else {
184 val
185 };
186 Ok(CellValue::Number(result as f64))
187}
188
189pub 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 let result = if val > 0x1FFFFFFF {
200 val - 0x40000000
201 } else {
202 val
203 };
204 format_hex(result, args, ctx, 1)
205}
206
207pub 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 Ok(CellValue::Number(if n1 == n2 { 1.0 } else { 0.0 }))
218}
219
220pub 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
232pub 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
244pub 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
251pub 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
268pub 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
278pub 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
288pub 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
298pub 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
313pub 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
323pub 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
342pub 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
355pub 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
376pub 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
395pub 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
420pub 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
438pub 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
450pub 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
464pub 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
478pub 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
495pub 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 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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "C" | "cel" | "F" | "fah" | "K" | "kel" | "Rank" | "Reau" => Some((1.0, "C")),
873
874 "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 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
912fn 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 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
961fn 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
1027fn 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 assert_eq!(
1264 eval("DEC2OCT(-1)"),
1265 CellValue::String("7777777777".to_string())
1266 );
1267 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 assert_eq!(
1312 eval("OCT2BIN(\"7777777000\")"),
1313 CellValue::String("1000000000".to_string())
1314 );
1315 assert_eq!(
1317 eval("OCT2BIN(\"7777777776\")"),
1318 CellValue::String("1111111110".to_string())
1319 );
1320 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 assert_approx(eval("OCT2DEC(\"7777777777\")"), -1.0, 0.01);
1336 assert_approx(eval("OCT2DEC(\"4000000000\")"), -536_870_912.0, 0.01);
1338 assert_approx(eval("OCT2DEC(\"7777777000\")"), -512.0, 0.01);
1340 }
1341
1342 #[test]
1343 fn oct2dec_positive_boundary() {
1344 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 assert_eq!(
1360 eval("OCT2HEX(\"7777777777\")"),
1361 CellValue::String("FFFFFFFFFF".to_string())
1362 );
1363 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 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 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 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 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 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 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}