use super::{arg_count, arg_count_exact, collect_numbers, int_arg, num_arg, Ctx, R};
use crate::ast::Expr;
use crate::error::{ExcelError, FormulaError};
use crate::value::Value;
pub(crate) fn sum(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count(args, 1, usize::MAX)?;
let ns = collect_numbers(ctx, args)?;
Ok(Value::Number(ns.iter().sum()))
}
pub(crate) fn product(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count(args, 1, usize::MAX)?;
let ns = collect_numbers(ctx, args)?;
if ns.is_empty() {
return Ok(Value::Number(0.0));
}
Ok(Value::Number(ns.iter().product()))
}
pub(crate) fn abs(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 1)?;
Ok(Value::Number(num_arg(ctx, args, 0)?.abs()))
}
pub(crate) fn sign(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 1)?;
let n = num_arg(ctx, args, 0)?;
Ok(Value::Number(if n > 0.0 {
1.0
} else if n < 0.0 {
-1.0
} else {
0.0
}))
}
pub(crate) fn sqrt(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 1)?;
let n = num_arg(ctx, args, 0)?;
if n < 0.0 {
return Err(ExcelError::Num.into());
}
Ok(Value::Number(libm::sqrt(n)))
}
pub(crate) fn power(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 2)?;
let b = num_arg(ctx, args, 0)?;
let e = num_arg(ctx, args, 1)?;
if b == 0.0 && e == 0.0 {
return Err(ExcelError::Num.into());
}
if b == 0.0 && e < 0.0 {
return Err(ExcelError::DivZero.into());
}
let r = libm::pow(b, e);
if r.is_finite() {
Ok(Value::Number(r))
} else {
Err(ExcelError::Num.into())
}
}
pub(crate) fn exp(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 1)?;
let r = libm::exp(num_arg(ctx, args, 0)?);
if r.is_finite() {
Ok(Value::Number(r))
} else {
Err(ExcelError::Num.into())
}
}
pub(crate) fn ln(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 1)?;
let n = num_arg(ctx, args, 0)?;
if n <= 0.0 {
return Err(ExcelError::Num.into());
}
Ok(Value::Number(libm::log(n)))
}
pub(crate) fn log(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count(args, 1, 2)?;
let n = num_arg(ctx, args, 0)?;
let base = if args.len() > 1 {
num_arg(ctx, args, 1)?
} else {
10.0
};
checked_log(n, base)
}
pub(crate) fn log10(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 1)?;
let n = num_arg(ctx, args, 0)?;
checked_log(n, 10.0)
}
fn checked_log(n: f64, base: f64) -> R {
if n <= 0.0 || base <= 0.0 {
return Err(ExcelError::Num.into());
}
if base == 1.0 {
return Err(ExcelError::DivZero.into());
}
Ok(Value::Number(libm::log(n) / libm::log(base)))
}
pub(crate) fn mod_(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 2)?;
let n = num_arg(ctx, args, 0)?;
let d = num_arg(ctx, args, 1)?;
if d == 0.0 {
return Err(ExcelError::DivZero.into());
}
Ok(Value::Number(n - d * libm::floor(n / d)))
}
pub(crate) fn int(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 1)?;
Ok(Value::Number(libm::floor(num_arg(ctx, args, 0)?)))
}
pub(crate) fn trunc(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count(args, 1, 2)?;
let n = num_arg(ctx, args, 0)?;
let d = digits_arg(ctx, args, 1)?;
Ok(Value::Number(scale(n, d, libm::trunc)))
}
pub(crate) fn round(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count(args, 1, 2)?;
let n = num_arg(ctx, args, 0)?;
let d = digits_arg(ctx, args, 1)?;
Ok(Value::Number(scale(n, d, round_half_away)))
}
pub(crate) fn roundup(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count(args, 1, 2)?;
let n = num_arg(ctx, args, 0)?;
let d = digits_arg(ctx, args, 1)?;
Ok(Value::Number(scale(n, d, |t| {
if t >= 0.0 {
libm::ceil(t)
} else {
libm::floor(t)
}
})))
}
pub(crate) fn rounddown(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count(args, 1, 2)?;
let n = num_arg(ctx, args, 0)?;
let d = digits_arg(ctx, args, 1)?;
Ok(Value::Number(scale(n, d, libm::trunc)))
}
pub(crate) fn ceiling(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 2)?;
let n = num_arg(ctx, args, 0)?;
let s = num_arg(ctx, args, 1)?;
if s == 0.0 {
return Err(ExcelError::DivZero.into());
}
if n == 0.0 {
return Ok(Value::Number(0.0));
}
if s < 0.0 && n > 0.0 {
return Err(ExcelError::Num.into());
}
Ok(Value::Number(libm::ceil(n / s) * s))
}
pub(crate) fn floor(ctx: &mut Ctx<'_>, args: &[Expr]) -> R {
arg_count_exact(args, 2)?;
let n = num_arg(ctx, args, 0)?;
let s = num_arg(ctx, args, 1)?;
if s == 0.0 {
return Err(ExcelError::DivZero.into());
}
if n == 0.0 {
return Ok(Value::Number(0.0));
}
if n * s < 0.0 {
return Err(ExcelError::Num.into());
}
Ok(Value::Number(libm::floor(n / s) * s))
}
fn digits_arg(ctx: &mut Ctx<'_>, args: &[Expr], i: usize) -> Result<f64, FormulaError> {
match args.get(i) {
None => return Ok(0.0),
Some(e) if crate::ast::is_omitted_arg(e) => return Ok(0.0),
Some(_) => {}
}
let d = int_arg(ctx, args, i)?;
Ok(d.clamp(-15.0, 15.0))
}
fn scale(n: f64, digits: f64, f: impl Fn(f64) -> f64) -> f64 {
if digits == 0.0 {
return f(n);
}
let m = libm::pow(10.0, digits.abs());
let (m, un) = if digits > 0.0 {
(m, 1.0 / m)
} else {
(1.0 / m, m)
};
f(n * m) * un
}
pub(crate) fn round_half_away(t: f64) -> f64 {
if t >= 0.0 {
libm::floor(t + 0.5)
} else {
libm::ceil(t - 0.5)
}
}