#![allow(clippy::missing_docs_in_private_items)]
use rust_decimal::Decimal;
use rust_decimal::prelude::*;
use crate::ast::*;
use crate::types::*;
use super::super::core::Evaluator;
const MAX_POWER_EXPONENT: u64 = 10_000;
fn decimal_pow_int(mut base: Decimal, mut exp: u64) -> Option<Decimal> {
let mut acc = Decimal::ONE;
while exp > 0 {
if exp & 1 != 0 {
acc = acc.checked_mul(base)?;
}
exp >>= 1;
if exp > 0 {
base = base.checked_mul(base)?;
}
}
Some(acc)
}
impl<'a> Evaluator<'a> {
pub(in crate::evaluator) fn fn_num1(
&mut self,
args: &[Expr],
fn_name: &str,
f: fn(Decimal) -> Decimal,
) -> Value {
match self.eval_arg(args, 0) {
Value::Number(n) => Value::Number(f(n)),
Value::Null => Value::Null,
other => self.reject_expected_type(fn_name, "number", &other),
}
}
pub(in crate::evaluator) fn fn_round(&mut self, args: &[Expr]) -> Value {
let n = match self.eval_arg(args, 0) {
Value::Number(n) => n,
Value::Null => return Value::Null,
other => return self.reject_expected_type("round", "number", &other),
};
let precision = if args.len() > 1 {
match self.eval_arg(args, 1) {
Value::Number(p) => p.to_i32().unwrap_or(0),
Value::Null => return Value::Null,
other => return self.reject_expected_type("round", "number", &other),
}
} else {
0
};
let rounded = n.round_dp_with_strategy(
precision.max(0) as u32,
rust_decimal::RoundingStrategy::MidpointNearestEven,
);
Value::Number(rounded)
}
pub(in crate::evaluator) fn fn_power(&mut self, args: &[Expr]) -> Value {
let base = match self.eval_arg(args, 0) {
Value::Number(n) => n,
Value::Null => return Value::Null,
other => return self.reject_expected_type("power", "number", &other),
};
let exp = match self.eval_arg(args, 1) {
Value::Number(n) => n,
Value::Null => return Value::Null,
other => return self.reject_expected_type("power", "number", &other),
};
if let Some(exp_u64) = exp.to_u64() {
if exp_u64 > MAX_POWER_EXPONENT {
self.diag("power: exponent too large");
return Value::Null;
}
return match decimal_pow_int(base, exp_u64) {
Some(result) => Value::Number(result),
None => {
self.diag("power: overflow");
Value::Null
}
};
}
let Some(base_f) = base.to_f64() else {
self.diag("power: base is not representable as f64");
return Value::Null;
};
let Some(exp_f) = exp.to_f64() else {
self.diag("power: exponent is not representable as f64");
return Value::Null;
};
let result = base_f.powf(exp_f);
if result.is_finite() {
match Decimal::from_f64(result) {
Some(d) => Value::Number(d),
None => {
self.diag("power: overflow");
Value::Null
}
}
} else {
self.diag("power: overflow");
Value::Null
}
}
}