#![allow(
clippy::must_use_candidate,
reason = "a `#[must_use]` on each of hundreds of table entries says nothing"
)]
pub mod data;
pub mod database;
pub mod date;
pub mod distributions;
pub mod engineering;
pub mod ets;
pub mod financial;
pub mod group;
pub mod info;
pub mod json;
pub mod lambda;
pub mod lists;
pub mod logical;
pub mod lookup;
pub mod math;
pub mod pattern;
pub mod pivot;
pub mod regression;
pub mod securities;
pub mod stats;
pub mod text;
pub mod web;
use crate::error::CellError;
use crate::formula::eval::{Engine, Origin};
use crate::formula::parser::{BinaryOp, Expr};
use crate::formula::value::Value;
use crate::shared::date::Epoch;
type Eager = fn(&[Arg]) -> Value;
type Dated = fn(Epoch, &[Arg]) -> Value;
type Lazy = fn(&mut Engine<'_>, Origin, &[Expr]) -> Value;
#[derive(Debug, Clone)]
pub struct Arg {
pub value: Value,
pub reference: bool,
}
impl Arg {
pub fn number(&self) -> Result<f64, CellError> {
self.value.number()
}
pub fn text(&self) -> Result<String, CellError> {
self.value.text()
}
pub fn serial(&self, epoch: Epoch) -> Result<f64, CellError> {
let serial = match self.value.scalar() {
Value::Text(text) => match self.value.scalar().number() {
Ok(n) => n,
Err(_) => crate::shared::date_parse::parse(text)
.and_then(|parsed| parsed.serial(epoch))
.ok_or(CellError::Value)?,
},
other => other.number()?,
};
if (0.0..=date::last_serial(epoch)).contains(&serial) {
Ok(serial)
} else {
Err(CellError::Num)
}
}
#[must_use]
pub const fn missing(&self) -> bool {
matches!(self.value, Value::Blank) && !self.reference
}
}
pub fn call(engine: &mut Engine<'_>, origin: Origin, name: &str, args: &[Expr]) -> Value {
let signature = crate::shared::biff_functions::by_name(name);
let class = |i: usize| signature.map(|s| s.arg_class(i));
if let Some(f) = lazy(name) {
let narrowed: Vec<_> = args
.iter()
.enumerate()
.map(|(i, e)| match class(i) {
Some(b'V') => engine.narrowed(origin, e),
_ => None,
})
.collect();
if narrowed.iter().all(Option::is_none) {
return f(engine, origin, args);
}
let args: Vec<Expr> = args
.iter()
.zip(narrowed)
.map(|(e, n)| match n {
Some(Ok(cell)) => cell,
Some(Err(err)) => Expr::Error(err),
None => e.clone(),
})
.collect();
return f(engine, origin, &args);
}
let eager = eager(name);
let dated = dated(name);
let custom = if eager.is_none() && dated.is_none() {
match engine.custom().and_then(|set| set.get(name)) {
Some(f) => Some(f),
None => return engine.call_defined(origin, name, args),
}
} else {
None
};
let epoch = engine.book().epoch;
let args: Vec<Arg> = args
.iter()
.enumerate()
.map(|(i, e)| Arg {
value: match class(i) {
Some(b'V') => engine.eval_value(origin, e),
Some(b'A') => engine.in_array(|engine| engine.eval_expr(origin, e)),
_ => engine.eval_expr(origin, e),
},
reference: is_reference(e),
})
.collect();
if let Some(f) = custom {
let values: Vec<Value> = args.into_iter().map(|a| a.value).collect();
return f(&values);
}
let run = |args: &[Arg]| {
if let Some(e) = passed_error(name, signature, args) {
return Value::Error(e);
}
match (eager, dated) {
(Some(f), _) => f(args),
(_, Some(f)) => f(epoch, args),
_ => Value::Error(CellError::Name),
}
};
match lifted(name, &args) {
Some(positions) => lift(&args, &positions, run),
None => run(&args),
}
}
fn passed_error(
name: &str,
signature: Option<&crate::shared::biff_functions::Function>,
args: &[Arg],
) -> Option<CellError> {
const INSPECTING: [&str; 11] = [
"ISERROR",
"ISERR",
"ISNA",
"ISBLANK",
"ISTEXT",
"ISNONTEXT",
"ISNUMBER",
"ISLOGICAL",
"ISREF",
"ERROR.TYPE",
"TYPE",
];
const COUNTING: [&str; 4] = ["COUNT", "COUNTA", "COUNTBLANK", "AGGREGATE"];
if INSPECTING.contains(&name) {
return None;
}
let class = |i: usize| signature.map_or(b'V', |s| s.arg_class(i));
args.iter()
.enumerate()
.find_map(|(i, arg)| match arg.value {
Value::Error(e) if class(i) == b'V' || !COUNTING.contains(&name) => Some(e),
_ => None,
})
}
fn lifted(name: &str, args: &[Arg]) -> Option<Vec<usize>> {
if name == "TYPE" || !args.iter().any(|a| matches!(a.value, Value::Array(_))) {
return None;
}
let signature = crate::shared::biff_functions::by_name(name)?;
let positions: Vec<usize> = args
.iter()
.enumerate()
.filter(|(i, a)| matches!(a.value, Value::Array(_)) && signature.arg_class(*i) == b'V')
.map(|(i, _)| i)
.collect();
(!positions.is_empty()).then_some(positions)
}
fn lift(args: &[Arg], positions: &[usize], run: impl Fn(&[Arg]) -> Value) -> Value {
let (rows, cols) = positions
.iter()
.map(|&i| crate::formula::eval::shape(&args[i].value))
.fold((0, 0), |(r, c), (ar, ac)| (r.max(ar), c.max(ac)));
if rows.saturating_mul(cols) > crate::formula::eval::MAX_RANGE_CELLS {
return Value::Error(CellError::Num);
}
let mut call = args.to_vec();
let out = (0..rows)
.map(|r| {
(0..cols)
.map(|c| {
for &i in positions {
call[i] = Arg {
value: crate::formula::eval::at(&args[i].value, r, c),
reference: false,
};
}
run(&call).scalar().clone()
})
.collect()
})
.collect();
Value::array(out)
}
fn is_reference(e: &Expr) -> bool {
match e {
Expr::Range { .. } => true,
Expr::Call { name, args } => match name.as_str() {
"INDIRECT" | "OFFSET" => true,
"INDEX" => args.first().is_some_and(is_reference),
_ => false,
},
Expr::Binary(BinaryOp::Span | BinaryOp::Intersect | BinaryOp::Union, a, b) => {
is_reference(a) && is_reference(b)
}
_ => false,
}
}
#[must_use]
pub fn is_known(name: &str) -> bool {
lazy(name).is_some() || eager(name).is_some() || dated(name).is_some()
}
fn lazy(name: &str) -> Option<Lazy> {
Some(match name {
"BYCOL" => lambda::bycol,
"BYROW" => lambda::byrow,
"IF" => logical::if_,
"LAMBDA" => lambda::lambda,
"LET" => lambda::let_,
"MAKEARRAY" => lambda::makearray,
"MAP" => lambda::map,
"REDUCE" => lambda::reduce,
"SCAN" => lambda::scan,
"IFERROR" => logical::iferror,
"IFNA" => logical::ifna,
"IFS" => logical::ifs,
"SWITCH" => logical::switch,
"SUBTOTAL" => math::subtotal,
"AGGREGATE" => math::aggregate,
"AREAS" => lookup::areas,
"ISREF" => info::isref,
"ISOMITTED" => info::isomitted,
"ISFORMULA" => info::isformula,
"FORMULATEXT" => info::formulatext,
"SHEET" => info::sheet,
"SHEETS" => info::sheets,
"CELL" => info::cell_info,
"GETPIVOTDATA" => pivot::getpivotdata,
"INFO" => info::info,
"GROUPBY" => group::groupby,
"PIVOTBY" => group::pivotby,
"ROLLING" => group::rolling,
"ANCHORARRAY" => lookup::anchorarray,
"INDIRECT" => lookup::indirect,
"SINGLE" => lookup::single,
"OFFSET" => lookup::offset,
"ROW" => lookup::row,
"COLUMN" => lookup::column,
"ROWS" => lookup::rows,
"COLUMNS" => lookup::columns,
"TEXT" => text::text_format,
"VALUE" => text::value,
_ => return None,
})
}
fn dated(name: &str) -> Option<Dated> {
Some(match name {
"AMORDEGRC" => financial::amordegrc,
"COUPDAYBS" => securities::coupdaybs,
"COUPDAYS" => securities::coupdays,
"COUPDAYSNC" => securities::coupdaysnc,
"COUPNCD" => securities::coupncd,
"COUPNUM" => securities::coupnum,
"COUPPCD" => securities::couppcd,
"ACCRINT" => securities::accrint,
"ACCRINTM" => securities::accrintm,
"DISC" => securities::disc,
"INTRATE" => securities::intrate,
"ODDFPRICE" => securities::oddfprice,
"ODDFYIELD" => securities::oddfyield,
"ODDLPRICE" => securities::oddlprice,
"ODDLYIELD" => securities::oddlyield,
"PRICE" => securities::price,
"PRICEDISC" => securities::pricedisc,
"PRICEMAT" => securities::pricemat,
"RECEIVED" => securities::received,
"TBILLEQ" => securities::tbilleq,
"TBILLPRICE" => securities::tbillprice,
"TBILLYIELD" => securities::tbillyield,
"DURATION" => securities::duration,
"MDURATION" => securities::mduration,
"YIELD" => securities::yield_,
"YIELDDISC" => securities::yielddisc,
"YIELDMAT" => securities::yieldmat,
"AMORLINC" => financial::amorlinc,
"DATE" => date::date,
"DATEVALUE" => date::datevalue,
"TIMEVALUE" => date::timevalue,
"DATEDIF" => date::datedif,
"DAY" => date::day,
"DAYS" => date::days,
"DAYS360" => date::days360,
"EDATE" => date::edate,
"EOMONTH" => date::eomonth,
"HOUR" => date::hour,
"ISOWEEKNUM" => date::isoweeknum,
"MINUTE" => date::minute,
"MONTH" => date::month,
"NETWORKDAYS" => date::networkdays,
"NETWORKDAYS.INTL" => date::networkdays_intl,
"NOW" => date::now,
"SECOND" => date::second,
"TIME" => date::time,
"TODAY" => date::today,
"WEEKDAY" => date::weekday,
"WEEKNUM" => date::weeknum,
"WORKDAY" => date::workday,
"WORKDAY.INTL" => date::workday_intl,
"YEAR" => date::year,
"YEARFRAC" => date::yearfrac,
_ => return None,
})
}
fn eager(name: &str) -> Option<Eager> {
const TABLES: [fn(&str) -> Option<Eager>; 7] = [
eager_math,
eager_finance,
eager_stats,
eager_engineering,
eager_distributions,
eager_logic_text,
eager_lookup,
];
TABLES.iter().find_map(|table| table(name))
}
fn eager_math(name: &str) -> Option<Eager> {
Some(match name {
"ABS" => math::abs,
"CEILING" | "CEILING.ODS" => math::ceiling,
"EXP" => math::exp,
"FLOOR" | "FLOOR.ODS" => math::floor,
"INT" => math::int,
"LN" => math::ln,
"LOG" => math::log,
"LOG10" => math::log10,
"MOD" => math::mod_,
"PI" => math::pi,
"POWER" => math::power,
"PRODUCT" => math::product,
"ROUND" => math::round,
"ROUNDDOWN" => math::rounddown,
"ROUNDUP" => math::roundup,
"SIGN" => math::sign,
"SQRT" => math::sqrt,
"SUM" => math::sum,
"SUMIF" => stats::sumif,
"SUMIFS" => stats::sumifs,
"SUMPRODUCT" => math::sumproduct,
"TRUNC" => math::trunc,
"SIN" => math::sin,
"COS" => math::cos,
"TAN" => math::tan,
"COT" => math::cot,
"SEC" => math::sec,
"CSC" => math::csc,
"ASIN" => math::asin,
"ACOS" => math::acos,
"ATAN" => math::atan,
"ACOT" => math::acot,
"ATAN2" => math::atan2,
"SINH" => math::sinh,
"COSH" => math::cosh,
"TANH" => math::tanh,
"COTH" => math::coth,
"SECH" => math::sech,
"CSCH" => math::csch,
"ASINH" => math::asinh,
"ACOSH" => math::acosh,
"ATANH" => math::atanh,
"ACOTH" => math::acoth,
"DEGREES" => math::degrees,
"RADIANS" => math::radians,
"EVEN" => math::even,
"ODD" => math::odd,
"MROUND" => math::mround,
"QUOTIENT" => math::quotient,
"GCD" => math::gcd,
"LCM" => math::lcm,
"FACT" => math::fact,
"FACTDOUBLE" => math::factdouble,
"COMBIN" => math::combin,
"COMBINA" => math::combina,
"PERMUT" => math::permut,
"MULTINOMIAL" => math::multinomial,
"SUMSQ" => math::sumsq,
"SUMX2MY2" => math::sumx2my2,
"SUMX2PY2" => math::sumx2py2,
"SUMXMY2" => math::sumxmy2,
"SERIESSUM" => math::seriessum,
"SQRTPI" => math::sqrtpi,
"MUNIT" => math::munit,
"MMULT" => math::mmult,
"MDETERM" => math::mdeterm,
"MINVERSE" => math::minverse,
"SEQUENCE" => math::sequence,
"RAND" => math::rand,
"RANDBETWEEN" => math::randbetween,
"RANDARRAY" => math::randarray,
"WRAPROWS" => lookup::wraprows,
"WRAPCOLS" => lookup::wrapcols,
"EXPAND" => lookup::expand,
"ROMAN" => math::roman,
"ARABIC" => math::arabic,
"BASE" => math::base,
"DECIMAL" => math::decimal,
"CEILING.MATH" | "CEILING.XCL" => math::ceiling_math,
"FLOOR.MATH" | "FLOOR.XCL" => math::floor_math,
"CEILING.PRECISE" | "ISO.CEILING" | "ECMA.CEILING" => math::ceiling_precise,
"FLOOR.PRECISE" => math::floor_precise,
_ => return None,
})
}
fn eager_finance(name: &str) -> Option<Eager> {
Some(match name {
"FV" => financial::fv,
"PV" => financial::pv,
"PMT" => financial::pmt,
"NPER" => financial::nper,
"RATE" => financial::rate,
"IPMT" => financial::ipmt,
"PPMT" => financial::ppmt,
"CUMIPMT" => financial::cumipmt,
"CUMPRINC" => financial::cumprinc,
"ISPMT" => financial::ispmt,
"NPV" => financial::npv,
"IRR" => financial::irr,
"MIRR" => financial::mirr,
"XNPV" => financial::xnpv,
"XIRR" => financial::xirr,
"FVSCHEDULE" => financial::fvschedule,
"SLN" => financial::sln,
"SYD" => financial::syd,
"DB" => financial::db,
"DDB" => financial::ddb,
"VDB" => financial::vdb,
"EFFECT" => financial::effect,
"NOMINAL" => financial::nominal,
"RRI" => financial::rri,
"PDURATION" => financial::pduration,
"DOLLARDE" => financial::dollarde,
"DOLLARFR" => financial::dollarfr,
"EUROCONVERT" => financial::euroconvert,
_ => return None,
})
}
fn eager_stats(name: &str) -> Option<Eager> {
Some(match name {
"AVERAGE" => stats::average,
"AVERAGEIF" => stats::averageif,
"AVERAGEIFS" => stats::averageifs,
"COUNT" => stats::count,
"COUNTA" => stats::counta,
"COUNTIF" => stats::countif,
"COUNTIFS" => stats::countifs,
"COUNTBLANK" => stats::countblank,
"MAX" => stats::max,
"LARGE" => stats::large,
"MEDIAN" => stats::median,
"MEDIANIF" => stats::medianif,
"RANK" | "RANK.EQ" => stats::rank,
"SMALL" => stats::small,
"STDEV" | "STDEV.S" => stats::stdev,
"STDEVP" | "STDEV.P" => stats::stdevp,
"VAR" | "VAR.S" => stats::var,
"VARP" | "VAR.P" => stats::varp,
"AVEDEV" => stats::avedev,
"DEVSQ" => stats::devsq,
"GEOMEAN" => stats::geomean,
"HARMEAN" => stats::harmean,
"SKEW" => stats::skew,
"SKEW.P" => stats::skewp,
"KURT" => stats::kurt,
"MODE" | "MODE.SNGL" => stats::mode,
"TRIMMEAN" => stats::trimmean,
"STANDARDIZE" => stats::standardize,
"PERMUTATIONA" => stats::permutationa,
"PERCENTILE" | "PERCENTILE.INC" => stats::percentile,
"PERCENTILE.EXC" => stats::percentile_exc,
"QUARTILE" | "QUARTILE.INC" => stats::quartile,
"QUARTILE.EXC" => stats::quartile_exc,
"PERCENTRANK" | "PERCENTRANK.INC" => stats::percentrank,
"PERCENTRANK.EXC" => stats::percentrank_exc,
"CORREL" | "PEARSON" => stats::correl,
"RSQ" => stats::rsq,
"COVAR" | "COVARIANCE.P" => stats::covar,
"COVARIANCE.S" => stats::covariance_s,
"SLOPE" => stats::slope,
"INTERCEPT" => stats::intercept,
"STEYX" => stats::steyx,
"FORECAST" | "FORECAST.LINEAR" => stats::forecast,
"FORECAST.ETS" => ets::forecast_ets,
"FORECAST.ETS.CONFINT" => ets::forecast_ets_confint,
"FORECAST.ETS.SEASONALITY" => ets::forecast_ets_seasonality,
"FORECAST.ETS.STAT" => ets::forecast_ets_stat,
"FISHER" => stats::fisher,
"FISHERINV" => stats::fisherinv,
"PHI" => stats::phi,
"AVERAGEA" => stats::averagea,
"MAXA" => stats::maxa,
"MINA" => stats::mina,
"STDEVA" => stats::stdeva,
"STDEVPA" => stats::stdevpa,
"VARA" => stats::vara,
"VARPA" => stats::varpa,
"MAXIFS" => stats::maxifs,
"MINIFS" => stats::minifs,
"RANK.AVG" => stats::rank_avg,
"MODE.MULT" => stats::mode_mult,
"FREQUENCY" => stats::frequency,
"PROB" => stats::prob,
_ => return None,
})
}
fn eager_engineering(name: &str) -> Option<Eager> {
Some(match name {
"DSUM" => database::dsum,
"DPRODUCT" => database::dproduct,
"DAVERAGE" => database::daverage,
"DMAX" => database::dmax,
"DMIN" => database::dmin,
"DCOUNT" => database::dcount,
"DCOUNTA" => database::dcounta,
"DSTDEV" => database::dstdev,
"DSTDEVP" => database::dstdevp,
"DVAR" => database::dvar,
"DVARP" => database::dvarp,
"DGET" => database::dget,
"BIN2DEC" => engineering::bin2dec,
"OCT2DEC" => engineering::oct2dec,
"HEX2DEC" => engineering::hex2dec,
"DEC2BIN" => engineering::dec2bin,
"DEC2OCT" => engineering::dec2oct,
"DEC2HEX" => engineering::dec2hex,
"BIN2OCT" => engineering::bin2oct,
"BIN2HEX" => engineering::bin2hex,
"OCT2BIN" => engineering::oct2bin,
"OCT2HEX" => engineering::oct2hex,
"HEX2BIN" => engineering::hex2bin,
"HEX2OCT" => engineering::hex2oct,
"BITAND" => engineering::bitand,
"BITOR" => engineering::bitor,
"BITXOR" => engineering::bitxor,
"BITLSHIFT" => engineering::bitlshift,
"BITRSHIFT" => engineering::bitrshift,
"DELTA" => engineering::delta,
"GESTEP" => engineering::gestep,
"BESSELJ" => engineering::besselj,
"BESSELI" => engineering::besseli,
"BESSELK" => engineering::besselk,
"BESSELY" => engineering::bessely,
"CONVERT" => engineering::convert,
"ERF" | "ERF.PRECISE" => engineering::erf_fn,
"ERFC" | "ERFC.PRECISE" => engineering::erfc_fn,
"COMPLEX" => engineering::complex,
"IMREAL" => engineering::imreal,
"IMAGINARY" => engineering::imaginary,
"IMABS" => engineering::imabs,
"IMARGUMENT" => engineering::imargument,
"IMCONJUGATE" => engineering::imconjugate,
"IMSUM" => engineering::imsum,
"IMSUB" => engineering::imsub,
"IMPRODUCT" => engineering::improduct,
"IMDIV" => engineering::imdiv,
"IMEXP" => engineering::imexp,
"IMLN" => engineering::imln,
"IMLOG10" => engineering::imlog10,
"IMLOG2" => engineering::imlog2,
"IMPOWER" => engineering::impower,
"IMSQRT" => engineering::imsqrt,
"IMSIN" => engineering::imsin,
"IMCOS" => engineering::imcos,
"IMSINH" => engineering::imsinh,
"IMCOSH" => engineering::imcosh,
"IMTAN" => engineering::imtan,
"IMCOT" => engineering::imcot,
"IMSEC" => engineering::imsec,
"IMCSC" => engineering::imcsc,
"IMSECH" => engineering::imsech,
"IMCSCH" => engineering::imcsch,
_ => return None,
})
}
fn eager_distributions(name: &str) -> Option<Eager> {
Some(match name {
"LINEST" => regression::linest,
"LOGEST" => regression::logest,
"TREND" => regression::trend,
"GROWTH" => regression::growth,
"CHISQ.TEST" | "CHITEST" => distributions::chisq_test,
"F.TEST" | "FTEST" => distributions::f_test,
"T.TEST" | "TTEST" => distributions::t_test,
"Z.TEST" | "ZTEST" => distributions::z_test,
"NORM.DIST" | "NORMDIST" => distributions::norm_dist,
"NORM.S.DIST" | "NORMSDIST" => distributions::norm_s_dist,
"NORM.INV" | "NORMINV" => distributions::norm_inv,
"NORM.S.INV" | "NORMSINV" => distributions::norm_s_inv,
"GAUSS" => distributions::gauss,
"CONFIDENCE" | "CONFIDENCE.NORM" => distributions::confidence,
"CONFIDENCE.T" => distributions::confidence_t,
"BINOM.DIST.RANGE" => distributions::binom_dist_range,
"LOGNORM.DIST" | "LOGNORMDIST" => distributions::lognorm_dist,
"LOGNORM.INV" | "LOGINV" => distributions::lognorm_inv,
"GAMMA" => distributions::gamma_fn,
"GAMMALN" | "GAMMALN.PRECISE" => distributions::gammaln,
"GAMMA.DIST" | "GAMMADIST" => distributions::gamma_dist,
"GAMMA.INV" | "GAMMAINV" => distributions::gamma_inv,
"CHISQ.DIST" => distributions::chisq_dist,
"CHISQ.DIST.RT" | "CHIDIST" => distributions::chisq_dist_rt,
"CHISQ.INV" => distributions::chisq_inv,
"CHISQ.INV.RT" | "CHIINV" => distributions::chisq_inv_rt,
"T.DIST" => distributions::t_dist,
"T.DIST.RT" => distributions::t_dist_rt,
"T.DIST.2T" => distributions::t_dist_2t,
"TDIST" => distributions::tdist,
"T.INV" => distributions::t_inv,
"T.INV.2T" | "TINV" => distributions::t_inv_2t,
"F.DIST" => distributions::f_dist,
"F.DIST.RT" | "FDIST" => distributions::f_dist_rt,
"F.INV" => distributions::f_inv,
"F.INV.RT" | "FINV" => distributions::f_inv_rt,
"BETA.DIST" => distributions::beta_dist,
"BETADIST" => distributions::betadist,
"BETA.INV" | "BETAINV" => distributions::beta_inv,
"EXPON.DIST" | "EXPONDIST" => distributions::expon_dist,
"WEIBULL.DIST" | "WEIBULL" => distributions::weibull_dist,
"POISSON.DIST" | "POISSON" => distributions::poisson_dist,
"BINOM.DIST" | "BINOMDIST" => distributions::binom_dist,
"NEGBINOM.DIST" | "NEGBINOMDIST" => distributions::negbinom_dist,
"HYPGEOM.DIST" | "HYPGEOMDIST" => distributions::hypgeom_dist,
"BINOM.INV" | "CRITBINOM" => distributions::binom_inv,
"MIN" => stats::min,
_ => return None,
})
}
fn eager_logic_text(name: &str) -> Option<Eager> {
Some(match name {
"AND" => logical::and,
"FALSE" => logical::false_,
"NOT" => logical::not,
"OR" => logical::or,
"TRUE" => logical::true_,
"XOR" => logical::xor,
"CONCAT" | "CONCATENATE" => text::concatenate,
"EXACT" => text::exact,
"ASC" => text::asc,
"BAHTTEXT" => text::bahttext,
"ISTHAIDIGIT" => text::isthaidigit,
"THAIDIGIT" => text::thaidigit,
"ROUNDBAHTUP" => text::roundbahtup,
"ROUNDBAHTDOWN" => text::roundbahtdown,
"DBCS" | "JIS" => text::dbcs,
"FIND" | "FINDB" => text::find,
"LEFT" | "LEFTB" => text::left,
"LEN" | "LENB" => text::len,
"LOWER" => text::lower,
"MID" | "MIDB" => text::mid,
"REPT" => text::rept,
"RIGHT" | "RIGHTB" => text::right,
"SEARCH" | "SEARCHB" => text::search,
"SUBSTITUTE" => text::substitute,
"TRIM" => text::trim,
"UPPER" => text::upper,
"DOLLAR" => text::dollar,
"TEXTSPLIT" => text::textsplit,
"ARRAYTOTEXT" => text::arraytotext,
"VALUETOTEXT" => text::valuetotext,
"ENCODEURL" => web::encodeurl,
"PROPER" => text::proper,
"CLEAN" => text::clean,
"T" => text::t,
"CHAR" => text::char_,
"UNICHAR" => text::unichar,
"CODE" => text::code,
"UNICODE" => text::unicode,
"REPLACE" | "REPLACEB" => text::replace,
"TEXTJOIN" => text::textjoin,
"TEXTBEFORE" => text::textbefore,
"TEXTAFTER" => text::textafter,
"NUMBERVALUE" => text::numbervalue,
"FIXED" => text::fixed,
"ISBLANK" => info::isblank,
"ISERR" => info::iserr,
"ISERROR" => info::iserror,
"ISLOGICAL" => info::islogical,
"ISNA" => info::isna,
"ISNONTEXT" => info::isnontext,
"ISNUMBER" => info::isnumber,
"ISTEXT" => info::istext,
"N" => info::n,
"NA" => info::na,
"TYPE" => info::type_,
_ => return None,
})
}
fn eager_lookup(name: &str) -> Option<Eager> {
Some(match name {
"CHOOSE" => lookup::choose,
"TRANSPOSE" => lookup::transpose,
"ADDRESS" => lookup::address,
"SORT" => lookup::sort,
"SORTBY" => lookup::sortby,
"UNIQUE" => lookup::unique,
"FILTER" => lookup::filter,
"TAKE" => lookup::take,
"DROP" => lookup::drop,
"CHOOSEROWS" => lookup::chooserows,
"CHOOSECOLS" => lookup::choosecols,
"VSTACK" => lookup::vstack,
"HSTACK" => lookup::hstack,
"TOROW" => lookup::torow,
"TOCOL" => lookup::tocol,
"HYPERLINK" => lookup::hyperlink,
"TRIMRANGE" => group::trimrange,
"PERCENTOF" => group::percentof,
"FLATTEN" => lists::flatten,
"HAS" => lists::has,
"HASANY" => lists::hasany,
"HASALL" => lists::hasall,
"FILLDOWN" => lists::filldown,
"PARSEJSON" => json::parsejson,
"BINS" => data::bins,
"TABLEJOIN" => data::tablejoin,
"FUZZYLOOKUP" => data::fuzzylookup,
"PHONETIC" => text::phonetic,
"REGEXTEST" => pattern::regextest,
"REGEXEXTRACT" => pattern::regexextract,
"REGEXREPLACE" => pattern::regexreplace,
"XLOOKUP" => lookup::xlookup,
"XMATCH" => lookup::xmatch,
"LOOKUP" => lookup::lookup_vector,
"ISEVEN" => info::iseven,
"ISODD" => info::isodd,
"ERROR.TYPE" => info::error_type,
"HLOOKUP" => lookup::hlookup,
"INDEX" => lookup::index,
"MATCH" => lookup::match_,
"VLOOKUP" => lookup::vlookup,
_ => return None,
})
}
pub(crate) fn first_error(args: &[Arg]) -> Option<CellError> {
let mut flat = Vec::new();
for a in args {
a.value.flatten(&mut flat);
}
flat.iter().find_map(|v| v.error())
}
pub(crate) fn aggregate_numbers(args: &[Arg]) -> Result<Vec<f64>, CellError> {
let mut out = Vec::new();
for arg in args {
let mut flat = Vec::new();
arg.value.flatten(&mut flat);
let skips = arg.reference || matches!(arg.value, Value::Array(_));
for v in flat {
match v {
Value::Error(e) => return Err(*e),
Value::Number(n) => out.push(*n),
Value::Blank => {}
Value::Bool(_) | Value::Text(_) if skips => {}
other => out.push(other.number()?),
}
}
}
Ok(out)
}
pub(crate) struct Criterion {
order: [bool; 3],
against: Value,
pattern: Option<String>,
}
impl Criterion {
pub(crate) fn parse(value: &Value) -> Self {
let text = match value.scalar() {
Value::Text(t) => t.clone(),
other => {
return Self {
order: [false, true, false],
against: other.clone(),
pattern: None,
};
}
};
let (order, rest) = if let Some(rest) = text.strip_prefix("<>") {
([true, false, true], rest)
} else if let Some(rest) = text.strip_prefix(">=") {
([false, true, true], rest)
} else if let Some(rest) = text.strip_prefix("<=") {
([true, true, false], rest)
} else if let Some(rest) = text.strip_prefix('>') {
([false, false, true], rest)
} else if let Some(rest) = text.strip_prefix('<') {
([true, false, false], rest)
} else if let Some(rest) = text.strip_prefix('=') {
([false, true, false], rest)
} else {
([false, true, false], text.as_str())
};
let against = match rest.trim().parse::<f64>() {
Ok(n) if !rest.trim().is_empty() => Value::Number(n),
_ => Value::Text(rest.to_owned()),
};
let pattern = matches!(against, Value::Text(_))
.then(|| rest.to_owned())
.filter(|p| {
p.contains(['*', '?'])
&& (order == [false, true, false] || order == [true, false, true])
});
Self {
order,
against,
pattern,
}
}
pub(crate) fn matches(&self, value: &Value) -> bool {
if let Some(pattern) = &self.pattern {
let hit = match value.scalar() {
Value::Text(text) => wildcard_match(&pattern.to_uppercase(), &text.to_uppercase()),
_ => false,
};
return hit == self.order[1];
}
if matches!(value, Value::Blank) {
return matches!(&self.against, Value::Text(t) if t.is_empty()) && self.order[1];
}
let comparable = match (value.scalar(), &self.against) {
(Value::Number(_) | Value::Bool(_), Value::Number(_) | Value::Bool(_))
| (Value::Text(_), Value::Text(_)) => true,
(_, Value::Text(t)) if t.is_empty() => return self.order[0] && self.order[2],
_ => false,
};
if !comparable {
return false;
}
let ord = crate::formula::value::compare(value.scalar(), &self.against);
self.order[match ord {
std::cmp::Ordering::Less => 0,
std::cmp::Ordering::Equal => 1,
std::cmp::Ordering::Greater => 2,
}]
}
}
pub(crate) use crate::shared::wildcard_match;
pub(crate) fn wildcard_position(pattern: &str, text: &str, from: usize) -> Option<usize> {
let chars: Vec<char> = text.chars().collect();
let anchored = format!("{pattern}*");
for start in from..=chars.len() {
let tail: String = chars[start..].iter().collect();
if wildcard_match(&anchored, &tail) {
return Some(start + 1);
}
}
None
}
pub(crate) fn cells(arg: &Arg) -> Vec<&Value> {
let mut out = Vec::new();
arg.value.flatten(&mut out);
out
}
pub(crate) fn selected(pairs: &[&Arg], len: usize) -> Result<Vec<bool>, CellError> {
let mut keep = vec![true; len];
for [range, criterion] in pairs.as_chunks::<2>().0 {
let values = cells(range);
if values.len() != len {
return Err(CellError::Value);
}
let test = Criterion::parse(&criterion.value);
for (slot, value) in keep.iter_mut().zip(values) {
*slot = *slot && test.matches(value);
}
}
Ok(keep)
}
pub(crate) fn read_error<T: Copy>(reads: &[Result<T, CellError>]) -> Value {
Value::Error(
reads
.iter()
.find_map(|r| r.err())
.unwrap_or(CellError::Value),
)
}
pub(crate) fn one(args: &[Arg], f: impl Fn(f64) -> Value) -> Value {
match args {
[a] => match a.number() {
Ok(n) => f(n),
Err(e) => Value::Error(e),
},
_ => Value::Error(CellError::Value),
}
}