632 lines
23 KiB
Rust
632 lines
23 KiB
Rust
use crate::cast::NumberOrArray;
|
|
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
|
use crate::expressions::parser::ArrayNode;
|
|
use crate::expressions::types::CellReferenceIndex;
|
|
use crate::number_format::to_precision;
|
|
use crate::single_number_fn;
|
|
use crate::{
|
|
calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
|
|
};
|
|
use std::f64::consts::PI;
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
pub fn random() -> f64 {
|
|
rand::random()
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
pub fn random() -> f64 {
|
|
use js_sys::Math;
|
|
Math::random()
|
|
}
|
|
|
|
impl Model {
|
|
pub(crate) fn fn_min(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
let mut result = f64::NAN;
|
|
for arg in args {
|
|
match self.evaluate_node_in_context(arg, cell) {
|
|
CalcResult::Number(value) => result = value.min(result),
|
|
CalcResult::Range { left, right } => {
|
|
if left.sheet != right.sheet {
|
|
return CalcResult::new_error(
|
|
Error::VALUE,
|
|
cell,
|
|
"Ranges are in different sheets".to_string(),
|
|
);
|
|
}
|
|
for row in left.row..(right.row + 1) {
|
|
for column in left.column..(right.column + 1) {
|
|
match self.evaluate_cell(CellReferenceIndex {
|
|
sheet: left.sheet,
|
|
row,
|
|
column,
|
|
}) {
|
|
CalcResult::Number(value) => {
|
|
result = value.min(result);
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
};
|
|
}
|
|
if result.is_nan() || result.is_infinite() {
|
|
return CalcResult::Number(0.0);
|
|
}
|
|
CalcResult::Number(result)
|
|
}
|
|
|
|
pub(crate) fn fn_max(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
let mut result = f64::NAN;
|
|
for arg in args {
|
|
match self.evaluate_node_in_context(arg, cell) {
|
|
CalcResult::Number(value) => result = value.max(result),
|
|
CalcResult::Range { left, right } => {
|
|
if left.sheet != right.sheet {
|
|
return CalcResult::new_error(
|
|
Error::VALUE,
|
|
cell,
|
|
"Ranges are in different sheets".to_string(),
|
|
);
|
|
}
|
|
for row in left.row..(right.row + 1) {
|
|
for column in left.column..(right.column + 1) {
|
|
match self.evaluate_cell(CellReferenceIndex {
|
|
sheet: left.sheet,
|
|
row,
|
|
column,
|
|
}) {
|
|
CalcResult::Number(value) => {
|
|
result = value.max(result);
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
};
|
|
}
|
|
if result.is_nan() || result.is_infinite() {
|
|
return CalcResult::Number(0.0);
|
|
}
|
|
CalcResult::Number(result)
|
|
}
|
|
|
|
pub(crate) fn fn_sum(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.is_empty() {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
|
|
let mut result = 0.0;
|
|
for arg in args {
|
|
match self.evaluate_node_in_context(arg, cell) {
|
|
CalcResult::Number(value) => result += value,
|
|
CalcResult::Range { left, right } => {
|
|
if left.sheet != right.sheet {
|
|
return CalcResult::new_error(
|
|
Error::VALUE,
|
|
cell,
|
|
"Ranges are in different sheets".to_string(),
|
|
);
|
|
}
|
|
// TODO: We should do this for all functions that run through ranges
|
|
// Running cargo test for the ironcalc takes around .8 seconds with this speedup
|
|
// and ~ 3.5 seconds without it. Note that once properly in place sheet.dimension should be almost a noop
|
|
let row1 = left.row;
|
|
let mut row2 = right.row;
|
|
let column1 = left.column;
|
|
let mut column2 = right.column;
|
|
if row1 == 1 && row2 == LAST_ROW {
|
|
row2 = match self.workbook.worksheet(left.sheet) {
|
|
Ok(s) => s.dimension().max_row,
|
|
Err(_) => {
|
|
return CalcResult::new_error(
|
|
Error::ERROR,
|
|
cell,
|
|
format!("Invalid worksheet index: '{}'", left.sheet),
|
|
);
|
|
}
|
|
};
|
|
}
|
|
if column1 == 1 && column2 == LAST_COLUMN {
|
|
column2 = match self.workbook.worksheet(left.sheet) {
|
|
Ok(s) => s.dimension().max_column,
|
|
Err(_) => {
|
|
return CalcResult::new_error(
|
|
Error::ERROR,
|
|
cell,
|
|
format!("Invalid worksheet index: '{}'", left.sheet),
|
|
);
|
|
}
|
|
};
|
|
}
|
|
for row in row1..row2 + 1 {
|
|
for column in column1..(column2 + 1) {
|
|
match self.evaluate_cell(CellReferenceIndex {
|
|
sheet: left.sheet,
|
|
row,
|
|
column,
|
|
}) {
|
|
CalcResult::Number(value) => {
|
|
result += value;
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
CalcResult::Array(array) => {
|
|
for row in array {
|
|
for value in row {
|
|
match value {
|
|
ArrayNode::Number(value) => {
|
|
result += value;
|
|
}
|
|
ArrayNode::Error(error) => {
|
|
return CalcResult::Error {
|
|
error,
|
|
origin: cell,
|
|
message: "Error in array".to_string(),
|
|
}
|
|
}
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
};
|
|
}
|
|
CalcResult::Number(result)
|
|
}
|
|
|
|
pub(crate) fn fn_product(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.is_empty() {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let mut result = 1.0;
|
|
let mut seen_value = false;
|
|
for arg in args {
|
|
match self.evaluate_node_in_context(arg, cell) {
|
|
CalcResult::Number(value) => {
|
|
seen_value = true;
|
|
result *= value;
|
|
}
|
|
CalcResult::Range { left, right } => {
|
|
if left.sheet != right.sheet {
|
|
return CalcResult::new_error(
|
|
Error::VALUE,
|
|
cell,
|
|
"Ranges are in different sheets".to_string(),
|
|
);
|
|
}
|
|
let row1 = left.row;
|
|
let mut row2 = right.row;
|
|
let column1 = left.column;
|
|
let mut column2 = right.column;
|
|
if row1 == 1 && row2 == LAST_ROW {
|
|
row2 = match self.workbook.worksheet(left.sheet) {
|
|
Ok(s) => s.dimension().max_row,
|
|
Err(_) => {
|
|
return CalcResult::new_error(
|
|
Error::ERROR,
|
|
cell,
|
|
format!("Invalid worksheet index: '{}'", left.sheet),
|
|
);
|
|
}
|
|
};
|
|
}
|
|
if column1 == 1 && column2 == LAST_COLUMN {
|
|
column2 = match self.workbook.worksheet(left.sheet) {
|
|
Ok(s) => s.dimension().max_column,
|
|
Err(_) => {
|
|
return CalcResult::new_error(
|
|
Error::ERROR,
|
|
cell,
|
|
format!("Invalid worksheet index: '{}'", left.sheet),
|
|
);
|
|
}
|
|
};
|
|
}
|
|
for row in row1..row2 + 1 {
|
|
for column in column1..(column2 + 1) {
|
|
match self.evaluate_cell(CellReferenceIndex {
|
|
sheet: left.sheet,
|
|
row,
|
|
column,
|
|
}) {
|
|
CalcResult::Number(value) => {
|
|
seen_value = true;
|
|
result *= value;
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
error @ CalcResult::Error { .. } => return error,
|
|
_ => {
|
|
// We ignore booleans and strings
|
|
}
|
|
};
|
|
}
|
|
if !seen_value {
|
|
return CalcResult::Number(0.0);
|
|
}
|
|
CalcResult::Number(result)
|
|
}
|
|
|
|
/// SUMIF(criteria_range, criteria, [sum_range])
|
|
/// if sum_rage is missing then criteria_range will be used
|
|
pub(crate) fn fn_sumif(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.len() == 2 {
|
|
let arguments = vec![args[0].clone(), args[0].clone(), args[1].clone()];
|
|
self.fn_sumifs(&arguments, cell)
|
|
} else if args.len() == 3 {
|
|
let arguments = vec![args[2].clone(), args[0].clone(), args[1].clone()];
|
|
self.fn_sumifs(&arguments, cell)
|
|
} else {
|
|
CalcResult::new_args_number_error(cell)
|
|
}
|
|
}
|
|
|
|
/// SUMIFS(sum_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)
|
|
pub(crate) fn fn_sumifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
let mut total = 0.0;
|
|
let sum = |value| total += value;
|
|
if let Err(e) = self.apply_ifs(args, cell, sum) {
|
|
return e;
|
|
}
|
|
CalcResult::Number(total)
|
|
}
|
|
|
|
pub(crate) fn fn_round(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.len() != 2 {
|
|
// Incorrect number of arguments
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let value = match self.get_number(&args[0], cell) {
|
|
Ok(f) => to_precision(f, 15),
|
|
Err(s) => return s,
|
|
};
|
|
let number_of_digits = match self.get_number(&args[1], cell) {
|
|
Ok(f) => {
|
|
if f > 0.0 {
|
|
f.floor()
|
|
} else {
|
|
f.ceil()
|
|
}
|
|
}
|
|
Err(s) => return s,
|
|
};
|
|
let scale = 10.0_f64.powf(number_of_digits);
|
|
CalcResult::Number((value * scale).round() / scale)
|
|
}
|
|
|
|
pub(crate) fn fn_roundup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.len() != 2 {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let value = match self.get_number(&args[0], cell) {
|
|
Ok(f) => to_precision(f, 15),
|
|
Err(s) => return s,
|
|
};
|
|
let number_of_digits = match self.get_number(&args[1], cell) {
|
|
Ok(f) => {
|
|
if f > 0.0 {
|
|
f.floor()
|
|
} else {
|
|
f.ceil()
|
|
}
|
|
}
|
|
Err(s) => return s,
|
|
};
|
|
let scale = 10.0_f64.powf(number_of_digits);
|
|
if value > 0.0 {
|
|
CalcResult::Number((value * scale).ceil() / scale)
|
|
} else {
|
|
CalcResult::Number((value * scale).floor() / scale)
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fn_rounddown(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.len() != 2 {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let value = match self.get_number(&args[0], cell) {
|
|
Ok(f) => to_precision(f, 15),
|
|
Err(s) => return s,
|
|
};
|
|
let number_of_digits = match self.get_number(&args[1], cell) {
|
|
Ok(f) => {
|
|
if f > 0.0 {
|
|
f.floor()
|
|
} else {
|
|
f.ceil()
|
|
}
|
|
}
|
|
Err(s) => return s,
|
|
};
|
|
let scale = 10.0_f64.powf(number_of_digits);
|
|
if value > 0.0 {
|
|
CalcResult::Number((value * scale).floor() / scale)
|
|
} else {
|
|
CalcResult::Number((value * scale).ceil() / scale)
|
|
}
|
|
}
|
|
|
|
single_number_fn!(fn_log10, |f| if f <= 0.0 {
|
|
Err(Error::NUM)
|
|
} else {
|
|
Ok(f64::log10(f))
|
|
});
|
|
single_number_fn!(fn_ln, |f| if f <= 0.0 {
|
|
Err(Error::NUM)
|
|
} else {
|
|
Ok(f64::ln(f))
|
|
});
|
|
single_number_fn!(fn_sin, |f| Ok(f64::sin(f)));
|
|
single_number_fn!(fn_cos, |f| Ok(f64::cos(f)));
|
|
single_number_fn!(fn_tan, |f| Ok(f64::tan(f)));
|
|
single_number_fn!(fn_sinh, |f| Ok(f64::sinh(f)));
|
|
single_number_fn!(fn_cosh, |f| Ok(f64::cosh(f)));
|
|
single_number_fn!(fn_tanh, |f| Ok(f64::tanh(f)));
|
|
single_number_fn!(fn_asin, |f| Ok(f64::asin(f)));
|
|
single_number_fn!(fn_acos, |f| Ok(f64::acos(f)));
|
|
single_number_fn!(fn_atan, |f| Ok(f64::atan(f)));
|
|
single_number_fn!(fn_asinh, |f| Ok(f64::asinh(f)));
|
|
single_number_fn!(fn_acosh, |f| Ok(f64::acosh(f)));
|
|
single_number_fn!(fn_atanh, |f| Ok(f64::atanh(f)));
|
|
single_number_fn!(fn_abs, |f| Ok(f64::abs(f)));
|
|
single_number_fn!(fn_sqrt, |f| if f < 0.0 {
|
|
Err(Error::NUM)
|
|
} else {
|
|
Ok(f64::sqrt(f))
|
|
});
|
|
single_number_fn!(fn_sqrtpi, |f: f64| if f < 0.0 {
|
|
Err(Error::NUM)
|
|
} else {
|
|
Ok((f * PI).sqrt())
|
|
});
|
|
single_number_fn!(fn_acot, |f| if f == 0.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(f64::atan(1.0 / f))
|
|
});
|
|
single_number_fn!(fn_acoth, |f: f64| if f.abs() == 1.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(0.5 * (f64::ln((f + 1.0) / (f - 1.0))))
|
|
});
|
|
single_number_fn!(fn_cot, |f| if f == 0.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(f64::cos(f) / f64::sin(f))
|
|
});
|
|
single_number_fn!(fn_coth, |f| if f == 0.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(f64::cosh(f) / f64::sinh(f))
|
|
});
|
|
single_number_fn!(fn_csc, |f| if f == 0.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(1.0 / f64::sin(f))
|
|
});
|
|
single_number_fn!(fn_csch, |f| if f == 0.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(1.0 / f64::sinh(f))
|
|
});
|
|
single_number_fn!(fn_sec, |f| if f == 0.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(1.0 / f64::cos(f))
|
|
});
|
|
single_number_fn!(fn_sech, |f| if f == 0.0 {
|
|
Err(Error::DIV)
|
|
} else {
|
|
Ok(1.0 / f64::cosh(f))
|
|
});
|
|
single_number_fn!(fn_exp, |f: f64| Ok(f64::exp(f)));
|
|
single_number_fn!(fn_fact, |x: f64| {
|
|
let x = x.floor();
|
|
if x < 0.0 {
|
|
return Err(Error::NUM);
|
|
}
|
|
let mut acc = 1.0;
|
|
let mut k = 2.0;
|
|
while k <= x {
|
|
acc *= k;
|
|
k += 1.0;
|
|
}
|
|
Ok(acc)
|
|
});
|
|
single_number_fn!(fn_factdouble, |x: f64| {
|
|
let x = x.floor();
|
|
if x < -1.0 {
|
|
return Err(Error::NUM);
|
|
}
|
|
if x < 0.0 {
|
|
return Ok(1.0);
|
|
}
|
|
let mut acc = 1.0;
|
|
let mut k = if x % 2.0 == 0.0 { 2.0 } else { 1.0 };
|
|
while k <= x {
|
|
acc *= k;
|
|
k += 2.0;
|
|
}
|
|
Ok(acc)
|
|
});
|
|
single_number_fn!(fn_sign, |f| Ok(f64::signum(f)));
|
|
single_number_fn!(fn_degrees, |f| Ok(f * (180.0 / PI)));
|
|
single_number_fn!(fn_radians, |f| Ok(f * (PI / 180.0)));
|
|
|
|
pub(crate) fn fn_pi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if !args.is_empty() {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
CalcResult::Number(PI)
|
|
}
|
|
|
|
pub(crate) fn fn_atan2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.len() != 2 {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let x = match self.get_number(&args[0], cell) {
|
|
Ok(f) => f,
|
|
Err(s) => return s,
|
|
};
|
|
let y = match self.get_number(&args[1], cell) {
|
|
Ok(f) => f,
|
|
Err(s) => return s,
|
|
};
|
|
if x == 0.0 && y == 0.0 {
|
|
return CalcResult::Error {
|
|
error: Error::DIV,
|
|
origin: cell,
|
|
message: "Arguments can't be both zero".to_string(),
|
|
};
|
|
}
|
|
CalcResult::Number(f64::atan2(y, x))
|
|
}
|
|
|
|
pub(crate) fn fn_log(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
let n_args = args.len();
|
|
if !(1..=2).contains(&n_args) {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let x = match self.get_number(&args[0], cell) {
|
|
Ok(f) => f,
|
|
Err(s) => return s,
|
|
};
|
|
let y = if n_args == 1 {
|
|
10.0
|
|
} else {
|
|
match self.get_number(&args[1], cell) {
|
|
Ok(f) => f,
|
|
Err(s) => return s,
|
|
}
|
|
};
|
|
if x <= 0.0 {
|
|
return CalcResult::Error {
|
|
error: Error::NUM,
|
|
origin: cell,
|
|
message: "Number must be positive".to_string(),
|
|
};
|
|
}
|
|
if y == 1.0 {
|
|
return CalcResult::Error {
|
|
error: Error::DIV,
|
|
origin: cell,
|
|
message: "Logarithm base cannot be 1".to_string(),
|
|
};
|
|
}
|
|
if y <= 0.0 {
|
|
return CalcResult::Error {
|
|
error: Error::NUM,
|
|
origin: cell,
|
|
message: "Logarithm base must be positive".to_string(),
|
|
};
|
|
}
|
|
CalcResult::Number(f64::log(x, y))
|
|
}
|
|
|
|
pub(crate) fn fn_power(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.len() != 2 {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let x = match self.get_number(&args[0], cell) {
|
|
Ok(f) => f,
|
|
Err(s) => return s,
|
|
};
|
|
let y = match self.get_number(&args[1], cell) {
|
|
Ok(f) => f,
|
|
Err(s) => return s,
|
|
};
|
|
if x == 0.0 && y == 0.0 {
|
|
return CalcResult::Error {
|
|
error: Error::NUM,
|
|
origin: cell,
|
|
message: "Arguments can't be both zero".to_string(),
|
|
};
|
|
}
|
|
if y == 0.0 {
|
|
return CalcResult::Number(1.0);
|
|
}
|
|
let result = x.powf(y);
|
|
if result.is_infinite() {
|
|
return CalcResult::Error {
|
|
error: Error::DIV,
|
|
origin: cell,
|
|
message: "POWER returned infinity".to_string(),
|
|
};
|
|
}
|
|
if result.is_nan() {
|
|
// This might happen for some combinations of negative base and exponent
|
|
return CalcResult::Error {
|
|
error: Error::NUM,
|
|
origin: cell,
|
|
message: "Invalid arguments for POWER".to_string(),
|
|
};
|
|
}
|
|
CalcResult::Number(result)
|
|
}
|
|
|
|
pub(crate) fn fn_rand(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if !args.is_empty() {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
CalcResult::Number(random())
|
|
}
|
|
|
|
// TODO: Add tests for RANDBETWEEN
|
|
pub(crate) fn fn_randbetween(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
|
if args.len() != 2 {
|
|
return CalcResult::new_args_number_error(cell);
|
|
}
|
|
let x = match self.get_number(&args[0], cell) {
|
|
Ok(f) => f.floor(),
|
|
Err(s) => return s,
|
|
};
|
|
let y = match self.get_number(&args[1], cell) {
|
|
Ok(f) => f.ceil() + 1.0,
|
|
Err(s) => return s,
|
|
};
|
|
if x > y {
|
|
return CalcResult::Error {
|
|
error: Error::NUM,
|
|
origin: cell,
|
|
message: format!("{x}>{y}"),
|
|
};
|
|
}
|
|
CalcResult::Number((x + random() * (y - x)).floor())
|
|
}
|
|
}
|