Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use std::array::IntoIter;
use crate::{
calc_result::CalcResult,
expressions::{parser::Node, token::Error, types::CellReferenceIndex},
language::{get_default_language, Functions, Language},
model::Model,
};
mod aggregate; // MACRO
pub(crate) mod binary_search;
mod database;
pub(crate) mod date_and_time;
mod engineering;
mod financial;
mod getpivotdata; // MACRO
pub use getpivotdata::{PivotField, PivotItem, PivotLayout, PivotLine}; // MACRO
mod information;
mod lift; // MACRO
mod logical;
mod lookup_and_reference;
mod macros;
mod math_and_trigonometry;
// MACRO
#[cfg(target_arch = "wasm32")]
pub use math_and_trigonometry::set_random_seed;
mod spill_functions;
mod statistical;
mod subtotal;
pub use subtotal::FilteredRange; // MACRO
mod text;
pub(crate) mod util;
mod xlookup;
/// List of all implemented functions
#[derive(PartialEq, Clone, Debug)]
pub enum Function {
// Logical
And,
False,
If,
Iferror,
Ifna,
Ifs,
Lambda,
Let,
Not,
Or,
Switch,
True,
Xor,
Bycol,
Byrow,
Map,
Reduce,
Scan,
Makearray,
// Mathematical and trigonometry
Abs,
Acos,
Acosh,
Asin,
Asinh,
Atan,
Atan2,
Atanh,
Choose,
Column,
Columns,
Cos,
Cosh,
Log,
Log10,
Ln,
Max,
Min,
Pi,
Power,
Product,
Rand,
Randbetween,
Round,
Rounddown,
Roundup,
Sin,
Sinh,
Sqrt,
Sqrtpi,
Sum,
Sumif,
Sumifs,
Sumx2my2,
Sumx2py2,
Sumxmy2,
Tan,
Tanh,
Acot,
Acoth,
Cot,
Coth,
Csc,
Csch,
Sec,
Sech,
Exp,
Fact,
Factdouble,
Sign,
Radians,
Degrees,
Int,
Even,
Odd,
Ceiling,
CeilingMath,
CeilingPrecise,
Floor,
FloorMath,
FloorPrecise,
IsoCeiling,
Mod,
Quotient,
Mround,
Trunc,
Gcd,
Lcm,
Base,
Decimal,
Roman,
Arabic,
Combin,
Combina,
Sumsq,
Mdeterm,
Minverse,
Munit,
Multinomial,
Seriessum,
Sumproduct,
Percentof,
// Information
ErrorType,
Formulatext,
Isblank,
Iserr,
Iserror,
Iseven,
Isformula,
Islogical,
Isna,
Isnontext,
Isnumber,
Isodd,
Isomitted,
Isref,
Istext,
Na,
Sheet,
Type,
Sheets,
N,
Cell,
Info,
// Lookup and reference
Address,
Areas,
Choosecols,
Chooserows,
Expand,
Filter,
Hlookup,
Hstack,
Hyperlink,
Index,
Indirect,
Lookup,
Match,
Offset,
Row,
Rows,
Sort,
Sortby,
Unique,
Vlookup,
Vstack,
Wrapcols,
Wraprows,
Xlookup,
Xmatch,
Trimrange,
Take,
Drop,
Tocol,
Torow,
Transpose,
Mmult,
// Dynamic array
Sequence,
Randarray,
// Text
Concat,
Textsplit,
Concatenate,
Exact,
Find,
Left,
Len,
Lower,
Mid,
Rept,
Right,
Search,
Substitute,
Regexextract,
Regexreplace,
Regextest,
T,
Text,
Textafter,
Textbefore,
Textjoin,
Trim,
Unicode,
Unichar,
Char,
Clean,
Code,
Asc,
Arraytotext,
Dollar,
Encodeurl,
Findb,
Fixed,
Leftb,
Lenb,
Midb,
Numbervalue,
Proper,
Replace,
Replaceb,
Rightb,
Searchb,
Upper,
Value,
Valuetotext,
// Statistical
Average,
Averagea,
Averageif,
Averageifs,
Count,
Counta,
Countblank,
Countif,
Countifs,
Maxifs,
Minifs,
Geomean,
Frequency,
Growth,
Avedev,
BetaDist,
BetaInv,
BinomDist,
BinomDistRange,
BinomInv,
ChisqDist,
ChisqDistRT,
ChisqInv,
ChisqInvRT,
ChisqTest,
ConfidenceNorm,
ConfidenceT,
CovarianceP,
CovarianceS,
Devsq,
ExponDist,
FDist,
FDistRT,
FInv,
FInvRT,
FTest,
Fisher,
FisherInv,
Forecast,
ForecastLinear,
ForecastEts,
ForecastEtsConfint,
ForecastEtsSeasonality,
ForecastEtsStat,
Gamma,
GammaDist,
GammaInv,
GammaLn,
GammaLnPrecise,
Gauss,
Harmean,
HypGeomDist,
Kurt,
Large,
Linest,
Logest,
LogNormDist,
LogNormInv,
MaxA,
Median,
MinA,
ModeMult,
ModeSingl,
NegbinomDist,
NormDist,
NormInv,
NormSdist,
NormSInv,
Pearson,
PercentileExc,
PercentileInc,
PercentrankExc,
PercentrankInc,
Permut,
Permutationa,
Phi,
PoissonDist,
Prob,
QuartileExc,
QuartileInc,
RankAvg,
RankEq,
Skew,
SkewP,
Small,
Standardize,
Stdev,
StDevP,
StDevS,
Stdeva,
Stdevpa,
TDist,
TDist2T,
TDistRT,
TInv,
TInv2T,
TTest,
Trend,
Trimmean,
VarP,
VarS,
VarpA,
VarA,
WeibullDist,
ZTest,
// Compatibility — wrappers
BetaDistCompat,
HypGeomDistCompat,
LogNormDistCompat,
NegbinomDistCompat,
NormSDistCompat,
TDistCompat,
// Compatibility — aliases
BetaInvCompat,
BinomDistCompat,
ChiDistCompat,
ChiInvCompat,
ChiTestCompat,
ConfidenceCompat,
CovarCompat,
CritbinomCompat,
ExponDistCompat,
FDistCompat,
FInvCompat,
FTestCompat,
GammaDistCompat,
GammaInvCompat,
LoginvCompat,
ModeCompat,
NormDistCompat,
NormInvCompat,
NormSInvCompat,
PercentileCompat,
PercentrankCompat,
PoissonCompat,
QuartileCompat,
RankCompat,
StDevPCompat,
TInvCompat,
TTestCompat,
VarCompat,
VarPCompat,
WeibullCompat,
ZTestCompat,
// Date and time
Date,
Datedif,
Datevalue,
Day,
Edate,
Eomonth,
Month,
Time,
Timevalue,
Hour,
Minute,
Second,
Now,
Today,
Year,
Networkdays,
NetworkdaysIntl,
Days,
Days360,
Weekday,
Weeknum,
Workday,
WorkdayIntl,
Yearfrac,
Isoweeknum,
// Financial
Accrint,
Accrintm,
Disc,
Fvschedule,
Intrate,
Pricedisc,
Pricemat,
Received,
Yielddisc,
Yieldmat,
Cumipmt,
Cumprinc,
Db,
Ddb,
Dollarde,
Dollarfr,
Effect,
Fv,
Ipmt,
Irr,
Ispmt,
Mirr,
Nominal,
Nper,
Npv,
Pduration,
Pmt,
Ppmt,
Pv,
Rate,
Rri,
Sln,
Syd,
Tbilleq,
Tbillprice,
Tbillyield,
Xirr,
Xnpv,
Duration,
Mduration,
Price,
Yield,
Oddfprice,
Oddfyield,
Oddlprice,
Oddlyield,
Coupdaybs,
Coupdays,
Coupdaysnc,
Coupncd,
Coupnum,
Couppcd,
Amordegrc,
Amorlinc,
Vdb,
// Engineering: Bessel and transcendental functions
Besseli,
Besselj,
Besselk,
Bessely,
Erf,
Erfc,
ErfcPrecise,
ErfPrecise,
// Engineering: Number systems
Bin2dec,
Bin2hex,
Bin2oct,
Dec2Bin,
Dec2hex,
Dec2oct,
Hex2bin,
Hex2dec,
Hex2oct,
Oct2bin,
Oct2dec,
Oct2hex,
// Engineering: Bit functions
Bitand,
Bitlshift,
Bitor,
Bitrshift,
Bitxor,
// Engineering: Complex functions
Complex,
Imabs,
Imaginary,
Imargument,
Imconjugate,
Imcos,
Imcosh,
Imcot,
Imcsc,
Imcsch,
Imdiv,
Imexp,
Imln,
Imlog10,
Imlog2,
Impower,
Improduct,
Imreal,
Imsec,
Imsech,
Imsin,
Imsinh,
Imsqrt,
Imsub,
Imsum,
Imtan,
// Engineering: Misc function
Convert,
Delta,
Gestep,
Subtotal,
// MACRO: not in upstream yet
Aggregate,
Getpivotdata,
// Database
Daverage,
Dcount,
Dget,
Dmax,
Dmin,
Dsum,
Dcounta,
Dproduct,
Dstdev,
Dvar,
Dvarp,
Dstdevp,
Correl,
Rsq,
Intercept,
Slope,
Steyx,
}
macro_rules! impl_function_lookup {
($($field:ident => $variant:ident),+ $(,)?) => {
impl Functions {
pub fn lookup(&self, name: &str) -> Option<Function> {
let key = name.to_uppercase();
$(
if self.$field == key {
return Some(Function::$variant);
}
)*
// MACRO: functions the language data does not name yet.
match key.as_str() {
"AGGREGATE" => Some(Function::Aggregate),
"GETPIVOTDATA" => Some(Function::Getpivotdata),
_ => None,
}
}
}
}
}
impl_function_lookup! {
// Logical
and => And,
r#false => False,
r#if => If,
iferror => Iferror,
ifna => Ifna,
ifs => Ifs,
lambda => Lambda,
r#let => Let,
not => Not,
or => Or,
switch => Switch,
r#true => True,
xor => Xor,
bycol => Bycol,
byrow => Byrow,
map => Map,
reduce => Reduce,
scan => Scan,
makearray => Makearray,
// Mathematical and trigonometry
abs => Abs,
acos => Acos,
acosh => Acosh,
asin => Asin,
asinh => Asinh,
atan => Atan,
atan2 => Atan2,
atanh => Atanh,
choose => Choose,
column => Column,
columns => Columns,
cos => Cos,
cosh => Cosh,
log => Log,
log10 => Log10,
ln => Ln,
max => Max,
min => Min,
pi => Pi,
power => Power,
product => Product,
rand => Rand,
randbetween => Randbetween,
round => Round,
rounddown => Rounddown,
roundup => Roundup,
sin => Sin,
sinh => Sinh,
sqrt => Sqrt,
sqrtpi => Sqrtpi,
sum => Sum,
sumif => Sumif,
sumifs => Sumifs,
sumx2my2 => Sumx2my2,
sumx2py2 => Sumx2py2,
sumxmy2 => Sumxmy2,
tan => Tan,
tanh => Tanh,
acot => Acot,
acoth => Acoth,
cot => Cot,
coth => Coth,
csc => Csc,
csch => Csch,
sec => Sec,
sech => Sech,
exp => Exp,
fact => Fact,
factdouble => Factdouble,
sign => Sign,
radians => Radians,
degrees => Degrees,
int => Int,
even => Even,
odd => Odd,
ceiling => Ceiling,
ceilingmath => CeilingMath,
ceilingprecise => CeilingPrecise,
floor => Floor,
floormath => FloorMath,
floorprecise => FloorPrecise,
isoceiling => IsoCeiling,
r#mod => Mod,
quotient => Quotient,
mround => Mround,
trunc => Trunc,
gcd => Gcd,
lcm => Lcm,
base => Base,
decimal => Decimal,
roman => Roman,
arabic => Arabic,
combin => Combin,
combina => Combina,
sumsq => Sumsq,
mdeterm => Mdeterm,
minverse => Minverse,
munit => Munit,
multinomial => Multinomial,
seriessum => Seriessum,
sumproduct => Sumproduct,
percentof => Percentof,
// Information
errortype => ErrorType,
formulatext => Formulatext,
isblank => Isblank,
iserr => Iserr,
iserror => Iserror,
iseven => Iseven,
isformula => Isformula,
islogical => Islogical,
isna => Isna,
isnontext => Isnontext,
isnumber => Isnumber,
isodd => Isodd,
isomitted => Isomitted,
isref => Isref,
istext => Istext,
na => Na,
sheet => Sheet,
r#type => Type,
sheets => Sheets,
n => N,
cell => Cell,
info => Info,
// Lookup and reference
address => Address,
areas => Areas,
choosecols => Choosecols,
chooserows => Chooserows,
expand => Expand,
filter => Filter,
hlookup => Hlookup,
hstack => Hstack,
hyperlink => Hyperlink,
index => Index,
indirect => Indirect,
lookup => Lookup,
r#match => Match,
offset => Offset,
row => Row,
rows => Rows,
sort => Sort,
sortby => Sortby,
unique => Unique,
vlookup => Vlookup,
vstack => Vstack,
wrapcols => Wrapcols,
wraprows => Wraprows,
xlookup => Xlookup,
xmatch => Xmatch,
trimrange => Trimrange,
take => Take,
drop => Drop,
tocol => Tocol,
torow => Torow,
transpose => Transpose,
mmult => Mmult,
// Dynamic array
sequence => Sequence,
randarray => Randarray,
// Text
concat => Concat,
textsplit => Textsplit,
concatenate => Concatenate,
exact => Exact,
find => Find,
left => Left,
len => Len,
lower => Lower,
mid => Mid,
rept => Rept,
right => Right,
search => Search,
substitute => Substitute,
regexextract => Regexextract,
regexreplace => Regexreplace,
regextest => Regextest,
t => T,
text => Text,
textafter => Textafter,
textbefore => Textbefore,
textjoin => Textjoin,
trim => Trim,
unicode => Unicode,
unichar => Unichar,
char => Char,
clean => Clean,
code => Code,
asc => Asc,
arraytotext => Arraytotext,
dollar => Dollar,
encodeurl => Encodeurl,
findb => Findb,
fixed => Fixed,
leftb => Leftb,
lenb => Lenb,
midb => Midb,
numbervalue => Numbervalue,
proper => Proper,
replace => Replace,
replaceb => Replaceb,
rightb => Rightb,
searchb => Searchb,
upper => Upper,
value => Value,
valuetotext => Valuetotext,
// Statistical
average => Average,
averagea => Averagea,
averageif => Averageif,
averageifs => Averageifs,
count => Count,
counta => Counta,
countblank => Countblank,
countif => Countif,
countifs => Countifs,
maxifs => Maxifs,
minifs => Minifs,
geomean => Geomean,
avedev => Avedev,
betadist => BetaDist,
betainv => BetaInv,
binomdist => BinomDist,
binomdistrange => BinomDistRange,
binominv => BinomInv,
chisqdist => ChisqDist,
chisqdistrt => ChisqDistRT,
chisqinv => ChisqInv,
chisqinvrt => ChisqInvRT,
chisqtest => ChisqTest,
confidencenorm => ConfidenceNorm,
confidencet => ConfidenceT,
covariancep => CovarianceP,
covariances => CovarianceS,
devsq => Devsq,
expondist => ExponDist,
fdist => FDist,
fdistrt => FDistRT,
finv => FInv,
finvrt => FInvRT,
ftest => FTest,
fisher => Fisher,
fisherinv => FisherInv,
gamma => Gamma,
gammadist => GammaDist,
gammainv => GammaInv,
gammaln => GammaLn,
gammalnprecise => GammaLnPrecise,
gauss => Gauss,
harmean => Harmean,
hypgeomdist => HypGeomDist,
kurt => Kurt,
large => Large,
lognormdist => LogNormDist,
lognorminv => LogNormInv,
maxa => MaxA,
median => Median,
mina => MinA,
negbinomdist => NegbinomDist,
normdist => NormDist,
norminv => NormInv,
normsdist => NormSdist,
normsinv => NormSInv,
pearson => Pearson,
phi => Phi,
poissondist => PoissonDist,
rankavg => RankAvg,
rankeq => RankEq,
skew => Skew,
skewp => SkewP,
small => Small,
standardize => Standardize,
stdev => Stdev,
stdevp => StDevP,
stdevs => StDevS,
stdeva => Stdeva,
stdevpa => Stdevpa,
tdist => TDist,
tdist2t => TDist2T,
tdistrt => TDistRT,
tinv => TInv,
tinv2t => TInv2T,
ttest => TTest,
varp => VarP,
vars => VarS,
varpa => VarpA,
vara => VarA,
weibulldist => WeibullDist,
ztest => ZTest,
// Compatibility — wrappers
betadistcompat => BetaDistCompat,
hypgeomdistcompat => HypGeomDistCompat,
lognormdistcompat => LogNormDistCompat,
negbinomdistcompat => NegbinomDistCompat,
normsdistcompat => NormSDistCompat,
tdistcompat => TDistCompat,
// Compatibility — aliases (own variant for round-trip serialization)
chidist => ChiDistCompat,
chiinv => ChiInvCompat,
chitest => ChiTestCompat,
confidence => ConfidenceCompat,
covar => CovarCompat,
critbinom => CritbinomCompat,
loginv => LoginvCompat,
betainvcompat => BetaInvCompat,
binomdistcompat => BinomDistCompat,
expondistcompat => ExponDistCompat,
fdistcompat => FDistCompat,
finvcompat => FInvCompat,
ftestcompat => FTestCompat,
gammadistcompat => GammaDistCompat,
gammainvcompat => GammaInvCompat,
modecompat => ModeCompat,
normdistcompat => NormDistCompat,
norminvcompat => NormInvCompat,
normsinvcompat => NormSInvCompat,
percentilecompat => PercentileCompat,
percentrankcompat => PercentrankCompat,
poissoncompat => PoissonCompat,
quartilecompat => QuartileCompat,
rankcompat => RankCompat,
stdevpcompat => StDevPCompat,
tinvcompat => TInvCompat,
ttestcompat => TTestCompat,
varcompat => VarCompat,
varpcompat => VarPCompat,
weibullcompat => WeibullCompat,
ztestcompat => ZTestCompat,
// Date and time
date => Date,
datedif => Datedif,
datevalue => Datevalue,
day => Day,
edate => Edate,
eomonth => Eomonth,
month => Month,
time => Time,
timevalue => Timevalue,
hour => Hour,
minute => Minute,
second => Second,
now => Now,
today => Today,
year => Year,
networkdays => Networkdays,
networkdaysintl => NetworkdaysIntl,
days => Days,
days360 => Days360,
weekday => Weekday,
weeknum => Weeknum,
workday => Workday,
workdayintl => WorkdayIntl,
yearfrac => Yearfrac,
isoweeknum => Isoweeknum,
// Financial
accrint => Accrint,
accrintm => Accrintm,
disc => Disc,
fvschedule => Fvschedule,
intrate => Intrate,
pricedisc => Pricedisc,
pricemat => Pricemat,
received => Received,
yielddisc => Yielddisc,
yieldmat => Yieldmat,
cumipmt => Cumipmt,
cumprinc => Cumprinc,
db => Db,
ddb => Ddb,
dollarde => Dollarde,
dollarfr => Dollarfr,
effect => Effect,
fv => Fv,
ipmt => Ipmt,
irr => Irr,
ispmt => Ispmt,
mirr => Mirr,
nominal => Nominal,
nper => Nper,
npv => Npv,
pduration => Pduration,
pmt => Pmt,
ppmt => Ppmt,
pv => Pv,
rate => Rate,
rri => Rri,
sln => Sln,
syd => Syd,
tbilleq => Tbilleq,
tbillprice => Tbillprice,
tbillyield => Tbillyield,
xirr => Xirr,
xnpv => Xnpv,
duration => Duration,
mduration => Mduration,
price => Price,
r#yield => Yield,
oddfprice => Oddfprice,
oddfyield => Oddfyield,
oddlprice => Oddlprice,
oddlyield => Oddlyield,
coupdaybs => Coupdaybs,
coupdays => Coupdays,
coupdaysnc => Coupdaysnc,
coupncd => Coupncd,
coupnum => Coupnum,
couppcd => Couppcd,
amordegrc => Amordegrc,
amorlinc => Amorlinc,
vdb => Vdb,
// Engineering: Bessel and transcendental functions
besseli => Besseli,
besselj => Besselj,
besselk => Besselk,
bessely => Bessely,
erf => Erf,
erfc => Erfc,
erfcprecise => ErfcPrecise,
erfprecise => ErfPrecise,
// Engineering: Number systems
bin2dec => Bin2dec,
bin2hex => Bin2hex,
bin2oct => Bin2oct,
dec2bin => Dec2Bin,
dec2hex => Dec2hex,
dec2oct => Dec2oct,
hex2bin => Hex2bin,
hex2dec => Hex2dec,
hex2oct => Hex2oct,
oct2bin => Oct2bin,
oct2dec => Oct2dec,
oct2hex => Oct2hex,
// Engineering: Bit functions
bitand => Bitand,
bitlshift => Bitlshift,
bitor => Bitor,
bitrshift => Bitrshift,
bitxor => Bitxor,
// Engineering: Complex functions
complex => Complex,
imabs => Imabs,
imaginary => Imaginary,
imargument => Imargument,
imconjugate => Imconjugate,
imcos => Imcos,
imcosh => Imcosh,
imcot => Imcot,
imcsc => Imcsc,
imcsch => Imcsch,
imdiv => Imdiv,
imexp => Imexp,
imln => Imln,
imlog10 => Imlog10,
imlog2 => Imlog2,
impower => Impower,
improduct => Improduct,
imreal => Imreal,
imsec => Imsec,
imsech => Imsech,
imsin => Imsin,
imsinh => Imsinh,
imsqrt => Imsqrt,
imsub => Imsub,
imsum => Imsum,
imtan => Imtan,
// Engineering: Misc function
convert => Convert,
delta => Delta,
gestep => Gestep,
subtotal => Subtotal,
// Database
daverage => Daverage,
dcount => Dcount,
dget => Dget,
dmax => Dmax,
dmin => Dmin,
dsum => Dsum,
dcounta => Dcounta,
dproduct => Dproduct,
dstdev => Dstdev,
dvar => Dvar,
dvarp => Dvarp,
dstdevp => Dstdevp,
// More statistical
correl => Correl,
rsq => Rsq,
intercept => Intercept,
slope => Slope,
steyx => Steyx,
forecast => Forecast,
forecastlinear => ForecastLinear,
forecastets => ForecastEts,
forecastetsconfint => ForecastEtsConfint,
forecastetsseasonality => ForecastEtsSeasonality,
forecastetsstat => ForecastEtsStat,
frequency => Frequency,
growth => Growth,
linest => Linest,
logest => Logest,
modemult => ModeMult,
modesngl => ModeSingl,
percentileexc => PercentileExc,
percentileinc => PercentileInc,
percentrankexc => PercentrankExc,
percentrankinc => PercentrankInc,
permut => Permut,
permutationa => Permutationa,
prob => Prob,
quartileexc => QuartileExc,
quartileinc => QuartileInc,
trend => Trend,
trimmean => Trimmean,
}
impl Function {
pub fn to_localized_name(&self, language: &Language) -> String {
let functions = &language.functions;
match self {
Function::And => functions.and.clone(),
Function::False => functions.r#false.clone(),
Function::If => functions.r#if.clone(),
Function::Iferror => functions.iferror.clone(),
Function::Ifna => functions.ifna.clone(),
Function::Ifs => functions.ifs.clone(),
Function::Lambda => functions.lambda.clone(),
Function::Let => functions.r#let.clone(),
Function::Not => functions.not.clone(),
Function::Or => functions.or.clone(),
Function::Switch => functions.switch.clone(),
Function::True => functions.r#true.clone(),
Function::Xor => functions.xor.clone(),
Function::Bycol => functions.bycol.clone(),
Function::Byrow => functions.byrow.clone(),
Function::Map => functions.map.clone(),
Function::Reduce => functions.reduce.clone(),
Function::Scan => functions.scan.clone(),
Function::Makearray => functions.makearray.clone(),
Function::Abs => functions.abs.clone(),
Function::Acos => functions.acos.clone(),
Function::Acosh => functions.acosh.clone(),
Function::Asin => functions.asin.clone(),
Function::Asinh => functions.asinh.clone(),
Function::Atan => functions.atan.clone(),
Function::Atan2 => functions.atan2.clone(),
Function::Atanh => functions.atanh.clone(),
Function::Choose => functions.choose.clone(),
Function::Column => functions.column.clone(),
Function::Columns => functions.columns.clone(),
Function::Cos => functions.cos.clone(),
Function::Cosh => functions.cosh.clone(),
Function::Log => functions.log.clone(),
Function::Log10 => functions.log10.clone(),
Function::Ln => functions.ln.clone(),
Function::Max => functions.max.clone(),
Function::Min => functions.min.clone(),
Function::Pi => functions.pi.clone(),
Function::Power => functions.power.clone(),
Function::Product => functions.product.clone(),
Function::Rand => functions.rand.clone(),
Function::Randbetween => functions.randbetween.clone(),
Function::Round => functions.round.clone(),
Function::Rounddown => functions.rounddown.clone(),
Function::Roundup => functions.roundup.clone(),
Function::Sin => functions.sin.clone(),
Function::Sinh => functions.sinh.clone(),
Function::Sqrt => functions.sqrt.clone(),
Function::Sqrtpi => functions.sqrtpi.clone(),
Function::Sum => functions.sum.clone(),
Function::Sumif => functions.sumif.clone(),
Function::Sumifs => functions.sumifs.clone(),
Function::Sumx2my2 => functions.sumx2my2.clone(),
Function::Sumx2py2 => functions.sumx2py2.clone(),
Function::Sumxmy2 => functions.sumxmy2.clone(),
Function::Tan => functions.tan.clone(),
Function::Tanh => functions.tanh.clone(),
Function::Acot => functions.acot.clone(),
Function::Acoth => functions.acoth.clone(),
Function::Cot => functions.cot.clone(),
Function::Coth => functions.coth.clone(),
Function::Csc => functions.csc.clone(),
Function::Csch => functions.csch.clone(),
Function::Sec => functions.sec.clone(),
Function::Sech => functions.sech.clone(),
Function::Exp => functions.exp.clone(),
Function::Fact => functions.fact.clone(),
Function::Factdouble => functions.factdouble.clone(),
Function::Sign => functions.sign.clone(),
Function::Radians => functions.radians.clone(),
Function::Degrees => functions.degrees.clone(),
Function::Int => functions.int.clone(),
Function::Even => functions.even.clone(),
Function::Odd => functions.odd.clone(),
Function::Ceiling => functions.ceiling.clone(),
Function::CeilingMath => functions.ceilingmath.clone(),
Function::CeilingPrecise => functions.ceilingprecise.clone(),
Function::Floor => functions.floor.clone(),
Function::FloorMath => functions.floormath.clone(),
Function::FloorPrecise => functions.floorprecise.clone(),
Function::IsoCeiling => functions.isoceiling.clone(),
Function::Mod => functions.r#mod.clone(),
Function::Quotient => functions.quotient.clone(),
Function::Mround => functions.mround.clone(),
Function::Trunc => functions.trunc.clone(),
Function::Gcd => functions.gcd.clone(),
Function::Lcm => functions.lcm.clone(),
Function::Base => functions.base.clone(),
Function::Decimal => functions.decimal.clone(),
Function::Roman => functions.roman.clone(),
Function::Arabic => functions.arabic.clone(),
Function::Combin => functions.combin.clone(),
Function::Combina => functions.combina.clone(),
Function::Sumsq => functions.sumsq.clone(),
Function::Mdeterm => functions.mdeterm.clone(),
Function::Minverse => functions.minverse.clone(),
Function::Munit => functions.munit.clone(),
Function::Multinomial => functions.multinomial.clone(),
Function::Seriessum => functions.seriessum.clone(),
Function::Sumproduct => functions.sumproduct.clone(),
Function::Percentof => functions.percentof.clone(),
Function::ErrorType => functions.errortype.clone(),
Function::Formulatext => functions.formulatext.clone(),
Function::Isblank => functions.isblank.clone(),
Function::Iserr => functions.iserr.clone(),
Function::Iserror => functions.iserror.clone(),
Function::Iseven => functions.iseven.clone(),
Function::Isformula => functions.isformula.clone(),
Function::Islogical => functions.islogical.clone(),
Function::Isna => functions.isna.clone(),
Function::Isnontext => functions.isnontext.clone(),
Function::Isnumber => functions.isnumber.clone(),
Function::Isodd => functions.isodd.clone(),
Function::Isomitted => functions.isomitted.clone(),
Function::Isref => functions.isref.clone(),
Function::Istext => functions.istext.clone(),
Function::Na => functions.na.clone(),
Function::Sheet => functions.sheet.clone(),
Function::Type => functions.r#type.clone(),
Function::Sheets => functions.sheets.clone(),
Function::N => functions.n.clone(),
Function::Cell => functions.cell.clone(),
Function::Info => functions.info.clone(),
Function::Address => functions.address.clone(),
Function::Areas => functions.areas.clone(),
Function::Choosecols => functions.choosecols.clone(),
Function::Chooserows => functions.chooserows.clone(),
Function::Expand => functions.expand.clone(),
Function::Filter => functions.filter.clone(),
Function::Hlookup => functions.hlookup.clone(),
Function::Hstack => functions.hstack.clone(),
Function::Hyperlink => functions.hyperlink.clone(),
Function::Index => functions.index.clone(),
Function::Indirect => functions.indirect.clone(),
Function::Lookup => functions.lookup.clone(),
Function::Match => functions.r#match.clone(),
Function::Offset => functions.offset.clone(),
Function::Row => functions.row.clone(),
Function::Rows => functions.rows.clone(),
Function::Sort => functions.sort.clone(),
Function::Sortby => functions.sortby.clone(),
Function::Unique => functions.unique.clone(),
Function::Vlookup => functions.vlookup.clone(),
Function::Vstack => functions.vstack.clone(),
Function::Wrapcols => functions.wrapcols.clone(),
Function::Wraprows => functions.wraprows.clone(),
Function::Xlookup => functions.xlookup.clone(),
Function::Xmatch => functions.xmatch.clone(),
Function::Trimrange => functions.trimrange.clone(),
Function::Take => functions.take.clone(),
Function::Drop => functions.drop.clone(),
Function::Tocol => functions.tocol.clone(),
Function::Torow => functions.torow.clone(),
Function::Transpose => functions.transpose.clone(),
Function::Mmult => functions.mmult.clone(),
Function::Sequence => functions.sequence.clone(),
Function::Randarray => functions.randarray.clone(),
Function::Concat => functions.concat.clone(),
Function::Textsplit => functions.textsplit.clone(),
Function::Concatenate => functions.concatenate.clone(),
Function::Exact => functions.exact.clone(),
Function::Find => functions.find.clone(),
Function::Left => functions.left.clone(),
Function::Len => functions.len.clone(),
Function::Lower => functions.lower.clone(),
Function::Mid => functions.mid.clone(),
Function::Rept => functions.rept.clone(),
Function::Right => functions.right.clone(),
Function::Search => functions.search.clone(),
Function::Substitute => functions.substitute.clone(),
Function::Regexextract => functions.regexextract.clone(),
Function::Regexreplace => functions.regexreplace.clone(),
Function::Regextest => functions.regextest.clone(),
Function::T => functions.t.clone(),
Function::Text => functions.text.clone(),
Function::Textafter => functions.textafter.clone(),
Function::Textbefore => functions.textbefore.clone(),
Function::Textjoin => functions.textjoin.clone(),
Function::Trim => functions.trim.clone(),
Function::Unicode => functions.unicode.clone(),
Function::Unichar => functions.unichar.clone(),
Function::Char => functions.r#char.clone(),
Function::Clean => functions.clean.clone(),
Function::Code => functions.code.clone(),
Function::Asc => functions.asc.clone(),
Function::Arraytotext => functions.arraytotext.clone(),
Function::Dollar => functions.dollar.clone(),
Function::Encodeurl => functions.encodeurl.clone(),
Function::Findb => functions.findb.clone(),
Function::Fixed => functions.fixed.clone(),
Function::Leftb => functions.leftb.clone(),
Function::Lenb => functions.lenb.clone(),
Function::Midb => functions.midb.clone(),
Function::Numbervalue => functions.numbervalue.clone(),
Function::Proper => functions.proper.clone(),
Function::Replace => functions.replace.clone(),
Function::Replaceb => functions.replaceb.clone(),
Function::Rightb => functions.rightb.clone(),
Function::Searchb => functions.searchb.clone(),
Function::Upper => functions.upper.clone(),
Function::Value => functions.value.clone(),
Function::Valuetotext => functions.valuetotext.clone(),
Function::Average => functions.average.clone(),
Function::Averagea => functions.averagea.clone(),
Function::Averageif => functions.averageif.clone(),
Function::Averageifs => functions.averageifs.clone(),
Function::Count => functions.count.clone(),
Function::Counta => functions.counta.clone(),
Function::Countblank => functions.countblank.clone(),
Function::Countif => functions.countif.clone(),
Function::Countifs => functions.countifs.clone(),
Function::Maxifs => functions.maxifs.clone(),
Function::Minifs => functions.minifs.clone(),
Function::Geomean => functions.geomean.clone(),
Function::Avedev => functions.avedev.clone(),
Function::BetaDist => functions.betadist.clone(),
Function::BetaInv => functions.betainv.clone(),
Function::BinomDist => functions.binomdist.clone(),
Function::BinomDistRange => functions.binomdistrange.clone(),
Function::BinomInv => functions.binominv.clone(),
Function::ChisqDist => functions.chisqdist.clone(),
Function::ChisqDistRT => functions.chisqdistrt.clone(),
Function::ChisqInv => functions.chisqinv.clone(),
Function::ChisqInvRT => functions.chisqinvrt.clone(),
Function::ChisqTest => functions.chisqtest.clone(),
Function::ConfidenceNorm => functions.confidencenorm.clone(),
Function::ConfidenceT => functions.confidencet.clone(),
Function::CovarianceP => functions.covariancep.clone(),
Function::CovarianceS => functions.covariances.clone(),
Function::Devsq => functions.devsq.clone(),
Function::ExponDist => functions.expondist.clone(),
Function::FDist => functions.fdist.clone(),
Function::FDistRT => functions.fdistrt.clone(),
Function::FInv => functions.finv.clone(),
Function::FInvRT => functions.finvrt.clone(),
Function::FTest => functions.ftest.clone(),
Function::Fisher => functions.fisher.clone(),
Function::FisherInv => functions.fisherinv.clone(),
Function::Gamma => functions.gamma.clone(),
Function::GammaDist => functions.gammadist.clone(),
Function::GammaInv => functions.gammainv.clone(),
Function::GammaLn => functions.gammaln.clone(),
Function::GammaLnPrecise => functions.gammalnprecise.clone(),
Function::Gauss => functions.gauss.clone(),
Function::Harmean => functions.harmean.clone(),
Function::HypGeomDist => functions.hypgeomdist.clone(),
Function::Kurt => functions.kurt.clone(),
Function::Large => functions.large.clone(),
Function::LogNormDist => functions.lognormdist.clone(),
Function::LogNormInv => functions.lognorminv.clone(),
Function::MaxA => functions.maxa.clone(),
Function::Median => functions.median.clone(),
Function::MinA => functions.mina.clone(),
Function::NegbinomDist => functions.negbinomdist.clone(),
Function::NormDist => functions.normdist.clone(),
Function::NormInv => functions.norminv.clone(),
Function::NormSdist => functions.normsdist.clone(),
Function::NormSInv => functions.normsinv.clone(),
Function::Pearson => functions.pearson.clone(),
Function::Phi => functions.phi.clone(),
Function::PoissonDist => functions.poissondist.clone(),
Function::RankAvg => functions.rankavg.clone(),
Function::RankEq => functions.rankeq.clone(),
Function::Skew => functions.skew.clone(),
Function::SkewP => functions.skewp.clone(),
Function::Small => functions.small.clone(),
Function::Standardize => functions.standardize.clone(),
Function::Stdev => functions.stdev.clone(),
Function::StDevP => functions.stdevp.clone(),
Function::StDevS => functions.stdevs.clone(),
Function::Stdeva => functions.stdeva.clone(),
Function::Stdevpa => functions.stdevpa.clone(),
Function::TDist => functions.tdist.clone(),
Function::TDist2T => functions.tdist2t.clone(),
Function::TDistRT => functions.tdistrt.clone(),
Function::TInv => functions.tinv.clone(),
Function::TInv2T => functions.tinv2t.clone(),
Function::TTest => functions.ttest.clone(),
Function::VarP => functions.varp.clone(),
Function::VarS => functions.vars.clone(),
Function::VarpA => functions.varpa.clone(),
Function::VarA => functions.vara.clone(),
Function::WeibullDist => functions.weibulldist.clone(),
Function::ZTest => functions.ztest.clone(),
Function::BetaDistCompat => functions.betadistcompat.clone(),
Function::HypGeomDistCompat => functions.hypgeomdistcompat.clone(),
Function::LogNormDistCompat => functions.lognormdistcompat.clone(),
Function::NegbinomDistCompat => functions.negbinomdistcompat.clone(),
Function::NormSDistCompat => functions.normsdistcompat.clone(),
Function::TDistCompat => functions.tdistcompat.clone(),
Function::BetaInvCompat => functions.betainvcompat.clone(),
Function::BinomDistCompat => functions.binomdistcompat.clone(),
Function::ChiDistCompat => functions.chidist.clone(),
Function::ChiInvCompat => functions.chiinv.clone(),
Function::ChiTestCompat => functions.chitest.clone(),
Function::ConfidenceCompat => functions.confidence.clone(),
Function::CovarCompat => functions.covar.clone(),
Function::CritbinomCompat => functions.critbinom.clone(),
Function::ExponDistCompat => functions.expondistcompat.clone(),
Function::FDistCompat => functions.fdistcompat.clone(),
Function::FInvCompat => functions.finvcompat.clone(),
Function::FTestCompat => functions.ftestcompat.clone(),
Function::GammaDistCompat => functions.gammadistcompat.clone(),
Function::GammaInvCompat => functions.gammainvcompat.clone(),
Function::LoginvCompat => functions.loginv.clone(),
Function::ModeCompat => functions.modecompat.clone(),
Function::NormDistCompat => functions.normdistcompat.clone(),
Function::NormInvCompat => functions.norminvcompat.clone(),
Function::NormSInvCompat => functions.normsinvcompat.clone(),
Function::PercentileCompat => functions.percentilecompat.clone(),
Function::PercentrankCompat => functions.percentrankcompat.clone(),
Function::PoissonCompat => functions.poissoncompat.clone(),
Function::QuartileCompat => functions.quartilecompat.clone(),
Function::RankCompat => functions.rankcompat.clone(),
Function::StDevPCompat => functions.stdevpcompat.clone(),
Function::TInvCompat => functions.tinvcompat.clone(),
Function::TTestCompat => functions.ttestcompat.clone(),
Function::VarCompat => functions.varcompat.clone(),
Function::VarPCompat => functions.varpcompat.clone(),
Function::WeibullCompat => functions.weibullcompat.clone(),
Function::ZTestCompat => functions.ztestcompat.clone(),
Function::Date => functions.date.clone(),
Function::Datedif => functions.datedif.clone(),
Function::Datevalue => functions.datevalue.clone(),
Function::Day => functions.day.clone(),
Function::Edate => functions.edate.clone(),
Function::Eomonth => functions.eomonth.clone(),
Function::Month => functions.month.clone(),
Function::Time => functions.time.clone(),
Function::Timevalue => functions.timevalue.clone(),
Function::Hour => functions.hour.clone(),
Function::Minute => functions.minute.clone(),
Function::Second => functions.second.clone(),
Function::Now => functions.now.clone(),
Function::Today => functions.today.clone(),
Function::Year => functions.year.clone(),
Function::Networkdays => functions.networkdays.clone(),
Function::NetworkdaysIntl => functions.networkdaysintl.clone(),
Function::Days => functions.days.clone(),
Function::Days360 => functions.days360.clone(),
Function::Weekday => functions.weekday.clone(),
Function::Weeknum => functions.weeknum.clone(),
Function::Workday => functions.workday.clone(),
Function::WorkdayIntl => functions.workdayintl.clone(),
Function::Yearfrac => functions.yearfrac.clone(),
Function::Isoweeknum => functions.isoweeknum.clone(),
Function::Accrint => functions.accrint.clone(),
Function::Accrintm => functions.accrintm.clone(),
Function::Disc => functions.disc.clone(),
Function::Fvschedule => functions.fvschedule.clone(),
Function::Intrate => functions.intrate.clone(),
Function::Pricedisc => functions.pricedisc.clone(),
Function::Pricemat => functions.pricemat.clone(),
Function::Received => functions.received.clone(),
Function::Yielddisc => functions.yielddisc.clone(),
Function::Yieldmat => functions.yieldmat.clone(),
Function::Cumipmt => functions.cumipmt.clone(),
Function::Cumprinc => functions.cumprinc.clone(),
Function::Db => functions.db.clone(),
Function::Ddb => functions.ddb.clone(),
Function::Dollarde => functions.dollarde.clone(),
Function::Dollarfr => functions.dollarfr.clone(),
Function::Effect => functions.effect.clone(),
Function::Fv => functions.fv.clone(),
Function::Ipmt => functions.ipmt.clone(),
Function::Irr => functions.irr.clone(),
Function::Ispmt => functions.ispmt.clone(),
Function::Mirr => functions.mirr.clone(),
Function::Nominal => functions.nominal.clone(),
Function::Nper => functions.nper.clone(),
Function::Npv => functions.npv.clone(),
Function::Pduration => functions.pduration.clone(),
Function::Pmt => functions.pmt.clone(),
Function::Ppmt => functions.ppmt.clone(),
Function::Pv => functions.pv.clone(),
Function::Rate => functions.rate.clone(),
Function::Rri => functions.rri.clone(),
Function::Sln => functions.sln.clone(),
Function::Syd => functions.syd.clone(),
Function::Tbilleq => functions.tbilleq.clone(),
Function::Tbillprice => functions.tbillprice.clone(),
Function::Tbillyield => functions.tbillyield.clone(),
Function::Xirr => functions.xirr.clone(),
Function::Xnpv => functions.xnpv.clone(),
Function::Duration => functions.duration.clone(),
Function::Mduration => functions.mduration.clone(),
Function::Price => functions.price.clone(),
Function::Yield => functions.r#yield.clone(),
Function::Oddfprice => functions.oddfprice.clone(),
Function::Oddfyield => functions.oddfyield.clone(),
Function::Oddlprice => functions.oddlprice.clone(),
Function::Oddlyield => functions.oddlyield.clone(),
Function::Coupdaybs => functions.coupdaybs.clone(),
Function::Coupdays => functions.coupdays.clone(),
Function::Coupdaysnc => functions.coupdaysnc.clone(),
Function::Coupncd => functions.coupncd.clone(),
Function::Coupnum => functions.coupnum.clone(),
Function::Couppcd => functions.couppcd.clone(),
Function::Amordegrc => functions.amordegrc.clone(),
Function::Amorlinc => functions.amorlinc.clone(),
Function::Vdb => functions.vdb.clone(),
Function::Besseli => functions.besseli.clone(),
Function::Besselj => functions.besselj.clone(),
Function::Besselk => functions.besselk.clone(),
Function::Bessely => functions.bessely.clone(),
Function::Erf => functions.erf.clone(),
Function::Erfc => functions.erfc.clone(),
Function::ErfcPrecise => functions.erfcprecise.clone(),
Function::ErfPrecise => functions.erfprecise.clone(),
Function::Bin2dec => functions.bin2dec.clone(),
Function::Bin2hex => functions.bin2hex.clone(),
Function::Bin2oct => functions.bin2oct.clone(),
Function::Dec2Bin => functions.dec2bin.clone(),
Function::Dec2hex => functions.dec2hex.clone(),
Function::Dec2oct => functions.dec2oct.clone(),
Function::Hex2bin => functions.hex2bin.clone(),
Function::Hex2dec => functions.hex2dec.clone(),
Function::Hex2oct => functions.hex2oct.clone(),
Function::Oct2bin => functions.oct2bin.clone(),
Function::Oct2dec => functions.oct2dec.clone(),
Function::Oct2hex => functions.oct2hex.clone(),
Function::Bitand => functions.bitand.clone(),
Function::Bitlshift => functions.bitlshift.clone(),
Function::Bitor => functions.bitor.clone(),
Function::Bitrshift => functions.bitrshift.clone(),
Function::Bitxor => functions.bitxor.clone(),
Function::Complex => functions.complex.clone(),
Function::Imabs => functions.imabs.clone(),
Function::Imaginary => functions.imaginary.clone(),
Function::Imargument => functions.imargument.clone(),
Function::Imconjugate => functions.imconjugate.clone(),
Function::Imcos => functions.imcos.clone(),
Function::Imcosh => functions.imcosh.clone(),
Function::Imcot => functions.imcot.clone(),
Function::Imcsc => functions.imcsc.clone(),
Function::Imcsch => functions.imcsch.clone(),
Function::Imdiv => functions.imdiv.clone(),
Function::Imexp => functions.imexp.clone(),
Function::Imln => functions.imln.clone(),
Function::Imlog10 => functions.imlog10.clone(),
Function::Imlog2 => functions.imlog2.clone(),
Function::Impower => functions.impower.clone(),
Function::Improduct => functions.improduct.clone(),
Function::Imreal => functions.imreal.clone(),
Function::Imsec => functions.imsec.clone(),
Function::Imsech => functions.imsech.clone(),
Function::Imsin => functions.imsin.clone(),
Function::Imsinh => functions.imsinh.clone(),
Function::Imsqrt => functions.imsqrt.clone(),
Function::Imsub => functions.imsub.clone(),
Function::Imsum => functions.imsum.clone(),
Function::Imtan => functions.imtan.clone(),
Function::Convert => functions.convert.clone(),
Function::Delta => functions.delta.clone(),
Function::Gestep => functions.gestep.clone(),
Function::Subtotal => functions.subtotal.clone(),
Function::Aggregate => "AGGREGATE".to_string(), // MACRO
Function::Getpivotdata => "GETPIVOTDATA".to_string(), // MACRO
Function::Daverage => functions.daverage.clone(),
Function::Dcount => functions.dcount.clone(),
Function::Dget => functions.dget.clone(),
Function::Dmax => functions.dmax.clone(),
Function::Dmin => functions.dmin.clone(),
Function::Dsum => functions.dsum.clone(),
Function::Dcounta => functions.dcounta.clone(),
Function::Dproduct => functions.dproduct.clone(),
Function::Dstdev => functions.dstdev.clone(),
Function::Dvar => functions.dvar.clone(),
Function::Dvarp => functions.dvarp.clone(),
Function::Dstdevp => functions.dstdevp.clone(),
Function::Correl => functions.correl.clone(),
Function::Rsq => functions.rsq.clone(),
Function::Intercept => functions.intercept.clone(),
Function::Slope => functions.slope.clone(),
Function::Steyx => functions.steyx.clone(),
Function::Forecast => functions.forecast.clone(),
Function::ForecastLinear => functions.forecastlinear.clone(),
Function::ForecastEts => functions.forecastets.clone(),
Function::ForecastEtsConfint => functions.forecastetsconfint.clone(),
Function::ForecastEtsSeasonality => functions.forecastetsseasonality.clone(),
Function::ForecastEtsStat => functions.forecastetsstat.clone(),
Function::Frequency => functions.frequency.clone(),
Function::Growth => functions.growth.clone(),
Function::Linest => functions.linest.clone(),
Function::Logest => functions.logest.clone(),
Function::ModeMult => functions.modemult.clone(),
Function::ModeSingl => functions.modesngl.clone(),
Function::PercentileExc => functions.percentileexc.clone(),
Function::PercentileInc => functions.percentileinc.clone(),
Function::PercentrankExc => functions.percentrankexc.clone(),
Function::PercentrankInc => functions.percentrankinc.clone(),
Function::Permut => functions.permut.clone(),
Function::Permutationa => functions.permutationa.clone(),
Function::Prob => functions.prob.clone(),
Function::QuartileExc => functions.quartileexc.clone(),
Function::QuartileInc => functions.quartileinc.clone(),
Function::Trend => functions.trend.clone(),
Function::Trimmean => functions.trimmean.clone(),
}
}
pub fn into_iter() -> IntoIter<Function, 498> {
// MACRO: AGGREGATE and GETPIVOTDATA
[
Function::And,
Function::False,
Function::If,
Function::Iferror,
Function::Ifna,
Function::Ifs,
Function::Lambda,
Function::Let,
Function::Not,
Function::Or,
Function::Switch,
Function::True,
Function::Xor,
Function::Bycol,
Function::Byrow,
Function::Map,
Function::Reduce,
Function::Scan,
Function::Makearray,
Function::Sin,
Function::Cos,
Function::Tan,
Function::Asin,
Function::Acos,
Function::Atan,
Function::Sinh,
Function::Cosh,
Function::Tanh,
Function::Asinh,
Function::Acosh,
Function::Atanh,
Function::Abs,
Function::Pi,
Function::Ln,
Function::Log,
Function::Log10,
Function::Sqrt,
Function::Sqrtpi,
Function::Atan2,
Function::Acot,
Function::Acoth,
Function::Cot,
Function::Coth,
Function::Csc,
Function::Csch,
Function::Sec,
Function::Sech,
Function::Power,
Function::Exp,
Function::Fact,
Function::Factdouble,
Function::Sign,
Function::Int,
Function::Even,
Function::Odd,
Function::Ceiling,
Function::CeilingMath,
Function::CeilingPrecise,
Function::Floor,
Function::FloorMath,
Function::FloorPrecise,
Function::IsoCeiling,
Function::Mod,
Function::Quotient,
Function::Mround,
Function::Trunc,
Function::Gcd,
Function::Lcm,
Function::Base,
Function::Decimal,
Function::Max,
Function::Min,
Function::Product,
Function::Rand,
Function::Randbetween,
Function::Radians,
Function::Degrees,
Function::Round,
Function::Rounddown,
Function::Roundup,
Function::Sum,
Function::Sumif,
Function::Sumifs,
Function::Sumx2my2,
Function::Sumx2py2,
Function::Sumxmy2,
Function::Address,
Function::Areas,
Function::Choose,
Function::Choosecols,
Function::Chooserows,
Function::Column,
Function::Columns,
Function::Expand,
Function::Index,
Function::Indirect,
Function::Hlookup,
Function::Hstack,
Function::Hyperlink,
Function::Filter,
Function::Lookup,
Function::Match,
Function::Offset,
Function::Row,
Function::Rows,
Function::Sort,
Function::Sortby,
Function::Unique,
Function::Vlookup,
Function::Vstack,
Function::Wrapcols,
Function::Wraprows,
Function::Xlookup,
Function::Xmatch,
Function::Trimrange,
Function::Take,
Function::Drop,
Function::Tocol,
Function::Torow,
Function::Transpose,
Function::Mmult,
Function::Sequence,
Function::Randarray,
Function::Concatenate,
Function::Exact,
Function::Value,
Function::T,
Function::Valuetotext,
Function::Concat,
Function::Find,
Function::Left,
Function::Len,
Function::Lower,
Function::Mid,
Function::Right,
Function::Search,
Function::Text,
Function::Trim,
Function::Unicode,
Function::Unichar,
Function::Char,
Function::Clean,
Function::Code,
Function::Asc,
Function::Arraytotext,
Function::Dollar,
Function::Encodeurl,
Function::Findb,
Function::Fixed,
Function::Leftb,
Function::Lenb,
Function::Midb,
Function::Numbervalue,
Function::Proper,
Function::Replace,
Function::Replaceb,
Function::Rightb,
Function::Searchb,
Function::Upper,
Function::Isnumber,
Function::Isnontext,
Function::Istext,
Function::Islogical,
Function::Isblank,
Function::Iserr,
Function::Iserror,
Function::Isna,
Function::Na,
Function::Isref,
Function::Isodd,
Function::Iseven,
Function::ErrorType,
Function::Formulatext,
Function::Isformula,
Function::Isomitted,
Function::Type,
Function::Sheet,
Function::Average,
Function::Avedev,
Function::Averagea,
Function::Averageif,
Function::Averageifs,
Function::Count,
Function::Counta,
Function::Countblank,
Function::Countif,
Function::Countifs,
Function::Maxifs,
Function::Minifs,
Function::Geomean,
Function::Year,
Function::Day,
Function::Month,
Function::Eomonth,
Function::Date,
Function::Datedif,
Function::Datevalue,
Function::Edate,
Function::Networkdays,
Function::NetworkdaysIntl,
Function::Time,
Function::Timevalue,
Function::Hour,
Function::Minute,
Function::Second,
Function::Today,
Function::Now,
Function::Days,
Function::Days360,
Function::Weekday,
Function::Weeknum,
Function::Workday,
Function::WorkdayIntl,
Function::Yearfrac,
Function::Isoweeknum,
Function::Pmt,
Function::Pv,
Function::Rate,
Function::Nper,
Function::Fv,
Function::Ppmt,
Function::Ipmt,
Function::Npv,
Function::Mirr,
Function::Irr,
Function::Xirr,
Function::Xnpv,
Function::Rept,
Function::Textafter,
Function::Textbefore,
Function::Textsplit,
Function::Textjoin,
Function::Substitute,
Function::Regexextract,
Function::Regexreplace,
Function::Regextest,
Function::Ispmt,
Function::Rri,
Function::Sln,
Function::Syd,
Function::Nominal,
Function::Effect,
Function::Pduration,
Function::Tbillyield,
Function::Tbillprice,
Function::Tbilleq,
Function::Dollarde,
Function::Dollarfr,
Function::Ddb,
Function::Db,
Function::Cumprinc,
Function::Cumipmt,
Function::Accrint,
Function::Accrintm,
Function::Disc,
Function::Fvschedule,
Function::Intrate,
Function::Pricedisc,
Function::Pricemat,
Function::Received,
Function::Yielddisc,
Function::Yieldmat,
Function::Duration,
Function::Mduration,
Function::Price,
Function::Yield,
Function::Oddfprice,
Function::Oddfyield,
Function::Oddlprice,
Function::Oddlyield,
Function::Coupdaybs,
Function::Coupdays,
Function::Coupdaysnc,
Function::Coupncd,
Function::Coupnum,
Function::Couppcd,
Function::Amordegrc,
Function::Amorlinc,
Function::Vdb,
Function::Besseli,
Function::Besselj,
Function::Besselk,
Function::Bessely,
Function::Erf,
Function::ErfPrecise,
Function::Erfc,
Function::ErfcPrecise,
Function::Bin2dec,
Function::Bin2hex,
Function::Bin2oct,
Function::Dec2Bin,
Function::Dec2hex,
Function::Dec2oct,
Function::Hex2bin,
Function::Hex2dec,
Function::Hex2oct,
Function::Oct2bin,
Function::Oct2dec,
Function::Oct2hex,
Function::Bitand,
Function::Bitlshift,
Function::Bitor,
Function::Bitrshift,
Function::Bitxor,
Function::Complex,
Function::Imabs,
Function::Imaginary,
Function::Imargument,
Function::Imconjugate,
Function::Imcos,
Function::Imcosh,
Function::Imcot,
Function::Imcsc,
Function::Imcsch,
Function::Imdiv,
Function::Imexp,
Function::Imln,
Function::Imlog10,
Function::Imlog2,
Function::Impower,
Function::Improduct,
Function::Imreal,
Function::Imsec,
Function::Imsech,
Function::Imsin,
Function::Imsinh,
Function::Imsqrt,
Function::Imsub,
Function::Imsum,
Function::Imtan,
Function::Convert,
Function::Delta,
Function::Gestep,
Function::Subtotal,
Function::Aggregate, // MACRO
Function::Getpivotdata, // MACRO
Function::Roman,
Function::Arabic,
Function::Combin,
Function::Combina,
Function::Sumsq,
Function::Mdeterm,
Function::Minverse,
Function::Munit,
Function::Multinomial,
Function::Seriessum,
Function::Sumproduct,
Function::Percentof,
Function::N,
Function::Cell,
Function::Info,
Function::Sheets,
Function::Daverage,
Function::Dcount,
Function::Dget,
Function::Dmax,
Function::Dmin,
Function::Dsum,
Function::Dcounta,
Function::Dproduct,
Function::Dstdev,
Function::Dvar,
Function::Dvarp,
Function::Dstdevp,
Function::BetaDist,
Function::BetaInv,
Function::BinomDist,
Function::BinomDistRange,
Function::BinomInv,
Function::ChisqDist,
Function::ChisqDistRT,
Function::ChisqInv,
Function::ChisqInvRT,
Function::ChisqTest,
Function::ConfidenceNorm,
Function::ConfidenceT,
Function::CovarianceP,
Function::CovarianceS,
Function::Devsq,
Function::ExponDist,
Function::FDist,
Function::FDistRT,
Function::FInv,
Function::FInvRT,
Function::FTest,
Function::Fisher,
Function::FisherInv,
Function::Gamma,
Function::GammaDist,
Function::GammaInv,
Function::GammaLn,
Function::GammaLnPrecise,
Function::HypGeomDist,
Function::LogNormDist,
Function::LogNormInv,
Function::NegbinomDist,
Function::NormDist,
Function::NormInv,
Function::NormSdist,
Function::NormSInv,
Function::Pearson,
Function::Phi,
Function::PoissonDist,
Function::Standardize,
Function::Stdev,
Function::StDevP,
Function::StDevS,
Function::Stdeva,
Function::Stdevpa,
Function::TDist,
Function::TDist2T,
Function::TDistRT,
Function::TInv,
Function::TInv2T,
Function::TTest,
Function::VarP,
Function::VarS,
Function::VarpA,
Function::VarA,
Function::WeibullDist,
Function::ZTest,
Function::BetaDistCompat,
Function::HypGeomDistCompat,
Function::LogNormDistCompat,
Function::NegbinomDistCompat,
Function::NormSDistCompat,
Function::TDistCompat,
Function::BetaInvCompat,
Function::BinomDistCompat,
Function::ChiDistCompat,
Function::ChiInvCompat,
Function::ChiTestCompat,
Function::ConfidenceCompat,
Function::CovarCompat,
Function::CritbinomCompat,
Function::ExponDistCompat,
Function::FDistCompat,
Function::FInvCompat,
Function::FTestCompat,
Function::GammaDistCompat,
Function::GammaInvCompat,
Function::LoginvCompat,
Function::ModeCompat,
Function::NormDistCompat,
Function::NormInvCompat,
Function::NormSInvCompat,
Function::PercentileCompat,
Function::PercentrankCompat,
Function::PoissonCompat,
Function::QuartileCompat,
Function::RankCompat,
Function::StDevPCompat,
Function::TInvCompat,
Function::TTestCompat,
Function::VarCompat,
Function::VarPCompat,
Function::WeibullCompat,
Function::ZTestCompat,
Function::Correl,
Function::Rsq,
Function::Intercept,
Function::Slope,
Function::Steyx,
Function::Forecast,
Function::ForecastLinear,
Function::ForecastEts,
Function::ForecastEtsConfint,
Function::ForecastEtsSeasonality,
Function::ForecastEtsStat,
Function::Frequency,
Function::Growth,
Function::Linest,
Function::Logest,
Function::ModeMult,
Function::ModeSingl,
Function::PercentileExc,
Function::PercentileInc,
Function::PercentrankExc,
Function::PercentrankInc,
Function::Permut,
Function::Permutationa,
Function::Prob,
Function::QuartileExc,
Function::QuartileInc,
Function::Trend,
Function::Trimmean,
Function::Large,
Function::Median,
Function::Small,
Function::RankAvg,
Function::RankEq,
Function::Skew,
Function::SkewP,
Function::Harmean,
Function::Gauss,
Function::Kurt,
Function::MaxA,
Function::MinA,
]
.into_iter()
}
}
impl Function {
/// Some functions in Excel like CONCAT are stringified as `_xlfn.CONCAT`. (known as "future functions")
/// FILTER and SORT are stringified as `_xlfn._xlws.FILTER`. (known as "worksheet only functions")
/// See <https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/3d025add-118d-4413-9856-ab65712ec1b0>
pub fn to_xlsx_string(&self) -> String {
match self {
Function::Concat => "_xlfn.CONCAT".to_string(),
Function::Ifna => "_xlfn.IFNA".to_string(),
Function::Ifs => "_xlfn.IFS".to_string(),
Function::Lambda => "_xlfn.LAMBDA".to_string(),
Function::Let => "_xlfn.LET".to_string(),
Function::Maxifs => "_xlfn.MAXIFS".to_string(),
Function::Minifs => "_xlfn.MINIFS".to_string(),
Function::Switch => "_xlfn.SWITCH".to_string(),
Function::Filter => "_xlfn._xlws.FILTER".to_string(),
Function::Sort => "_xlfn._xlws.SORT".to_string(),
Function::Sortby => "_xlfn.SORTBY".to_string(),
Function::Unique => "_xlfn.UNIQUE".to_string(),
Function::Xlookup => "_xlfn.XLOOKUP".to_string(),
Function::Xmatch => "_xlfn.XMATCH".to_string(),
Function::Trimrange => "_xlfn.TRIMRANGE".to_string(),
Function::Take => "_xlfn.TAKE".to_string(),
Function::Drop => "_xlfn.DROP".to_string(),
Function::Tocol => "_xlfn.TOCOL".to_string(),
Function::Torow => "_xlfn.TOROW".to_string(),
Function::Choosecols => "_xlfn.CHOOSECOLS".to_string(),
Function::Chooserows => "_xlfn.CHOOSEROWS".to_string(),
Function::Expand => "_xlfn.EXPAND".to_string(),
Function::Hstack => "_xlfn.HSTACK".to_string(),
Function::Vstack => "_xlfn.VSTACK".to_string(),
Function::Wrapcols => "_xlfn.WRAPCOLS".to_string(),
Function::Wraprows => "_xlfn.WRAPROWS".to_string(),
Function::Bycol => "_xlfn.BYCOL".to_string(),
Function::Byrow => "_xlfn.BYROW".to_string(),
Function::Map => "_xlfn.MAP".to_string(),
Function::Reduce => "_xlfn.REDUCE".to_string(),
Function::Scan => "_xlfn.SCAN".to_string(),
Function::Makearray => "_xlfn.MAKEARRAY".to_string(),
Function::Xor => "_xlfn.XOR".to_string(),
Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
Function::Textsplit => "_xlfn.TEXTSPLIT".to_string(),
Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
Function::Sequence => "_xlfn.SEQUENCE".to_string(),
Function::Randarray => "_xlfn.RANDARRAY".to_string(),
Function::Unicode => "_xlfn.UNICODE".to_string(),
Function::Unichar => "_xlfn.UNICHAR".to_string(),
Function::Numbervalue => "_xlfn.NUMBERVALUE".to_string(),
Function::Arraytotext => "_xlfn.ARRAYTOTEXT".to_string(),
Function::Encodeurl => "_xlfn.ENCODEURL".to_string(),
Function::Rri => "_xlfn.RRI".to_string(),
Function::Pduration => "_xlfn.PDURATION".to_string(),
Function::Bitand => "_xlfn.BITAND".to_string(),
Function::Bitor => "_xlfn.BITOR".to_string(),
Function::Bitxor => "_xlfn.BITXOR".to_string(),
Function::Bitlshift => "_xlfn.BITLSHIFT".to_string(),
Function::Bitrshift => "_xlfn.BITRSHIFT".to_string(),
Function::Imtan => "_xlfn.IMTAN".to_string(),
Function::Imsinh => "_xlfn.IMSINH".to_string(),
Function::Imcosh => "_xlfn.IMCOSH".to_string(),
Function::Imcot => "_xlfn.IMCOT".to_string(),
Function::Imcsc => "_xlfn.IMCSC".to_string(),
Function::Imcsch => "_xlfn.IMCSCH".to_string(),
Function::Imsec => "_xlfn.IMSEC".to_string(),
Function::ErfcPrecise => "_xlfn.ERFC.PRECISE".to_string(),
Function::ErfPrecise => "_xlfn.ERF.PRECISE".to_string(),
Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
Function::Regexextract => "_xlfn.REGEXEXTRACT".to_string(),
Function::Regexreplace => "_xlfn.REGEXREPLACE".to_string(),
Function::Regextest => "_xlfn.REGEXTEST".to_string(),
Function::Isformula => "_xlfn.ISFORMULA".to_string(),
Function::Isomitted => "_xlfn.ISOMITTED".to_string(),
Function::Sheet => "_xlfn.SHEET".to_string(),
Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
Function::Ceiling => "_xlfn.CEILING".to_string(),
Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
Function::Base => "_xlfn.BASE".to_string(),
Function::Decimal => "_xlfn.DECIMAL".to_string(),
Function::Arabic => "_xlfn.ARABIC".to_string(),
Function::Combina => "_xlfn.COMBINA".to_string(),
Function::Sheets => "_xlfn.SHEETS".to_string(),
Function::Acoth => "_xlfn.ACOTH".to_string(),
Function::Cot => "_xlfn.COT".to_string(),
Function::Coth => "_xlfn.COTH".to_string(),
Function::Csc => "_xlfn.CSC".to_string(),
Function::Csch => "_xlfn.CSCH".to_string(),
Function::Sec => "_xlfn.SEC".to_string(),
Function::Sech => "_xlfn.SECH".to_string(),
Function::Acot => "_xlfn.ACOT".to_string(),
Function::GammaLnPrecise => "_xlfn.GAMMALN.PRECISE".to_string(),
Function::Gamma => "_xlfn.GAMMA".to_string(),
Function::GammaInv => "_xlfn.GAMMA.INV".to_string(),
Function::GammaLn => "_xlfn.GAMMALN".to_string(),
Function::BetaDist => "_xlfn.BETA.DIST".to_string(),
Function::BetaInv => "_xlfn.BETA.INV".to_string(),
Function::BinomDist => "_xlfn.BINOM.DIST".to_string(),
Function::BinomDistRange => "_xlfn.BINOM.DIST.RANGE".to_string(),
Function::BinomInv => "_xlfn.BINOM.INV".to_string(),
Function::NegbinomDist => "_xlfn.NEGBINOM.DIST".to_string(),
Function::ChisqDist => "_xlfn.CHISQ.DIST".to_string(),
Function::ChisqDistRT => "_xlfn.CHISQ.DIST.RT".to_string(),
Function::ChisqInv => "_xlfn.CHISQ.INV".to_string(),
Function::ChisqInvRT => "_xlfn.CHISQ.INV.RT".to_string(),
Function::ChisqTest => "_xlfn.CHISQ.TEST".to_string(),
Function::ConfidenceNorm => "_xlfn.CONFIDENCE.NORM".to_string(),
Function::ConfidenceT => "_xlfn.CONFIDENCE.T".to_string(),
Function::CovarianceP => "_xlfn.COVARIANCE.P".to_string(),
Function::CovarianceS => "_xlfn.COVARIANCE.S".to_string(),
Function::ExponDist => "_xlfn.EXPON.DIST".to_string(),
Function::FDist => "_xlfn.F.DIST".to_string(),
Function::FDistRT => "_xlfn.F.DIST.RT".to_string(),
Function::FInv => "_xlfn.F.INV".to_string(),
Function::FInvRT => "_xlfn.F.INV.RT".to_string(),
Function::FTest => "_xlfn.F.TEST".to_string(),
Function::HypGeomDist => "_xlfn.HYPGEOM.DIST".to_string(),
Function::LogNormDist => "_xlfn.LOGNORM.DIST".to_string(),
Function::LogNormInv => "_xlfn.LOGNORM.INV".to_string(),
Function::NormDist => "_xlfn.NORM.DIST".to_string(),
Function::NormInv => "_xlfn.NORM.INV".to_string(),
Function::NormSdist => "_xlfn.NORM.S.DIST".to_string(),
Function::NormSInv => "_xlfn.NORM.S.INV".to_string(),
Function::Phi => "_xlfn.PHI".to_string(),
Function::PoissonDist => "_xlfn.POISSON.DIST".to_string(),
Function::StDevP => "_xlfn.STDEV.P".to_string(),
Function::StDevS => "_xlfn.STDEV.S".to_string(),
Function::TDist => "_xlfn.T.DIST".to_string(),
Function::TDist2T => "_xlfn.T.DIST.2T".to_string(),
Function::TDistRT => "_xlfn.T.DIST.RT".to_string(),
Function::TInv => "_xlfn.T.INV".to_string(),
Function::TInv2T => "_xlfn.T.INV.2T".to_string(),
Function::TTest => "_xlfn.T.TEST".to_string(),
Function::VarP => "_xlfn.VAR.P".to_string(),
Function::VarS => "_xlfn.VAR.S".to_string(),
Function::WeibullDist => "_xlfn.WEIBULL.DIST".to_string(),
Function::ZTest => "_xlfn.Z.TEST".to_string(),
Function::SkewP => "_xlfn.SKEW.P".to_string(),
Function::RankAvg => "_xlfn.RANK.AVG".to_string(),
Function::RankEq => "_xlfn.RANK.EQ".to_string(),
Function::Munit => "_xlfn.MUNIT".to_string(),
Function::ModeMult => "_xlfn.MODE.MULT".to_string(),
Function::ModeSingl => "_xlfn.MODE.SNGL".to_string(),
Function::PercentileExc => "_xlfn.PERCENTILE.EXC".to_string(),
Function::PercentileInc => "_xlfn.PERCENTILE.INC".to_string(),
Function::PercentrankExc => "_xlfn.PERCENTRANK.EXC".to_string(),
Function::PercentrankInc => "_xlfn.PERCENTRANK.INC".to_string(),
Function::Permutationa => "_xlfn.PERMUTATIONA".to_string(),
Function::QuartileExc => "_xlfn.QUARTILE.EXC".to_string(),
Function::QuartileInc => "_xlfn.QUARTILE.INC".to_string(),
Function::ForecastEts => "_xlfn.FORECAST.ETS".to_string(),
Function::ForecastEtsConfint => "_xlfn.FORECAST.ETS.CONFINT".to_string(),
Function::ForecastEtsSeasonality => "_xlfn.FORECAST.ETS.SEASONALITY".to_string(),
Function::ForecastEtsStat => "_xlfn.FORECAST.ETS.STAT".to_string(),
_ => {
let language = get_default_language();
self.to_localized_name(language)
}
}
}
pub(crate) fn returns_reference(&self) -> bool {
matches!(self, Function::Indirect | Function::Offset)
}
}
impl<'a> Model<'a> {
pub(crate) fn evaluate_function(
&mut self,
kind: &Function,
args: &[Node],
cell: CellReferenceIndex,
) -> CalcResult {
// MACRO: single-value parameters receiving ranges or arrays.
if let Some(result) = self.evaluate_lifted_function(kind, args, cell) {
return result;
}
self.dispatch_function(kind, args, cell)
}
pub(crate) fn dispatch_function(
&mut self,
kind: &Function,
args: &[Node],
cell: CellReferenceIndex,
) -> CalcResult {
match kind {
Function::And => self.fn_and(args, cell),
Function::False => self.fn_false(args, cell),
Function::If => self.fn_if(args, cell),
Function::Iferror => self.fn_iferror(args, cell),
Function::Ifna => self.fn_ifna(args, cell),
Function::Ifs => self.fn_ifs(args, cell),
Function::Lambda => self.fn_lambda(args, cell),
Function::Let => self.fn_let(args, cell),
Function::Not => self.fn_not(args, cell),
Function::Or => self.fn_or(args, cell),
Function::Switch => self.fn_switch(args, cell),
Function::True => self.fn_true(args, cell),
Function::Xor => self.fn_xor(args, cell),
Function::Bycol => self.fn_bycol(args, cell),
Function::Byrow => self.fn_byrow(args, cell),
Function::Map => self.fn_map(args, cell),
Function::Reduce => self.fn_reduce(args, cell),
Function::Scan => self.fn_scan(args, cell),
Function::Makearray => self.fn_makearray(args, cell),
Function::Log => self.fn_log(args, cell),
Function::Log10 => self.fn_log10(args, cell),
Function::Ln => self.fn_ln(args, cell),
Function::Sin => self.fn_sin(args, cell),
Function::Cos => self.fn_cos(args, cell),
Function::Tan => self.fn_tan(args, cell),
Function::Asin => self.fn_asin(args, cell),
Function::Acos => self.fn_acos(args, cell),
Function::Atan => self.fn_atan(args, cell),
Function::Sinh => self.fn_sinh(args, cell),
Function::Cosh => self.fn_cosh(args, cell),
Function::Tanh => self.fn_tanh(args, cell),
Function::Asinh => self.fn_asinh(args, cell),
Function::Acosh => self.fn_acosh(args, cell),
Function::Atanh => self.fn_atanh(args, cell),
Function::Pi => self.fn_pi(args, cell),
Function::Abs => self.fn_abs(args, cell),
Function::Sqrt => self.fn_sqrt(args, cell),
Function::Sqrtpi => self.fn_sqrtpi(args, cell),
Function::Atan2 => self.fn_atan2(args, cell),
Function::Power => self.fn_power(args, cell),
Function::Max => self.fn_max(args, cell),
Function::Min => self.fn_min(args, cell),
Function::Product => self.fn_product(args, cell),
Function::Rand => self.fn_rand(args, cell),
Function::Randbetween => self.fn_randbetween(args, cell),
Function::Round => self.fn_round(args, cell),
Function::Rounddown => self.fn_rounddown(args, cell),
Function::Roundup => self.fn_roundup(args, cell),
Function::Sum => self.fn_sum(args, cell),
Function::Sumif => self.fn_sumif(args, cell),
Function::Sumifs => self.fn_sumifs(args, cell),
Function::Choose => self.fn_choose(args, cell),
Function::Column => self.fn_column(args, cell),
Function::Address => self.fn_address(args, cell),
Function::Areas => self.fn_areas(args, cell),
Function::Columns => self.fn_columns(args, cell),
Function::Choosecols => self.fn_choosecols(args, cell),
Function::Chooserows => self.fn_chooserows(args, cell),
Function::Expand => self.fn_expand(args, cell),
Function::Index => self.fn_index(args, cell),
Function::Indirect => self.fn_indirect(args, cell),
Function::Hlookup => self.fn_hlookup(args, cell),
Function::Hstack => self.fn_hstack(args, cell),
Function::Hyperlink => self.fn_hyperlink(args, cell),
Function::Lookup => self.fn_lookup(args, cell),
Function::Match => self.fn_match(args, cell),
Function::Offset => self.fn_offset(args, cell),
Function::Row => self.fn_row(args, cell),
Function::Rows => self.fn_rows(args, cell),
Function::Filter => self.fn_filter(args, cell),
Function::Sort => self.fn_sort(args, cell),
Function::Sortby => self.fn_sortby(args, cell),
Function::Unique => self.fn_unique(args, cell),
Function::Vlookup => self.fn_vlookup(args, cell),
Function::Vstack => self.fn_vstack(args, cell),
Function::Wrapcols => self.fn_wrapcols(args, cell),
Function::Wraprows => self.fn_wraprows(args, cell),
Function::Xlookup => self.fn_xlookup(args, cell),
Function::Xmatch => self.fn_xmatch(args, cell),
Function::Trimrange => self.fn_trimrange(args, cell),
Function::Take => self.fn_take(args, cell),
Function::Drop => self.fn_drop(args, cell),
Function::Tocol => self.fn_tocol(args, cell),
Function::Torow => self.fn_torow(args, cell),
Function::Transpose => self.fn_transpose(args, cell),
Function::Mmult => self.fn_mmult(args, cell),
Function::Sequence => self.fn_sequence(args, cell),
Function::Randarray => self.fn_randarray(args, cell),
Function::Concatenate => self.fn_concatenate(args, cell),
Function::Exact => self.fn_exact(args, cell),
Function::Value => self.fn_value(args, cell),
Function::T => self.fn_t(args, cell),
Function::Valuetotext => self.fn_valuetotext(args, cell),
Function::Concat => self.fn_concat(args, cell),
Function::Find => self.fn_find(args, cell),
Function::Left => self.fn_left(args, cell),
Function::Len => self.fn_len(args, cell),
Function::Lower => self.fn_lower(args, cell),
Function::Mid => self.fn_mid(args, cell),
Function::Right => self.fn_right(args, cell),
Function::Search => self.fn_search(args, cell),
Function::Text => self.fn_text(args, cell),
Function::Trim => self.fn_trim(args, cell),
Function::Unicode => self.fn_unicode(args, cell),
Function::Unichar => self.fn_unichar(args, cell),
Function::Char => self.fn_char(args, cell),
Function::Clean => self.fn_clean(args, cell),
Function::Code => self.fn_code(args, cell),
Function::Asc => self.fn_asc(args, cell),
Function::Arraytotext => self.fn_arraytotext(args, cell),
Function::Dollar => self.fn_dollar(args, cell),
Function::Encodeurl => self.fn_encodeurl(args, cell),
Function::Findb => self.fn_findb(args, cell),
Function::Fixed => self.fn_fixed(args, cell),
Function::Leftb => self.fn_leftb(args, cell),
Function::Lenb => self.fn_lenb(args, cell),
Function::Midb => self.fn_midb(args, cell),
Function::Numbervalue => self.fn_numbervalue(args, cell),
Function::Proper => self.fn_proper(args, cell),
Function::Replace => self.fn_replace(args, cell),
Function::Replaceb => self.fn_replaceb(args, cell),
Function::Rightb => self.fn_rightb(args, cell),
Function::Searchb => self.fn_searchb(args, cell),
Function::Upper => self.fn_upper(args, cell),
Function::Isnumber => self.fn_isnumber(args, cell),
Function::Isnontext => self.fn_isnontext(args, cell),
Function::Istext => self.fn_istext(args, cell),
Function::Islogical => self.fn_islogical(args, cell),
Function::Isblank => self.fn_isblank(args, cell),
Function::Iserr => self.fn_iserr(args, cell),
Function::Iserror => self.fn_iserror(args, cell),
Function::Isna => self.fn_isna(args, cell),
Function::Na => CalcResult::new_error(Error::NA, cell, "".to_string()),
Function::Isref => self.fn_isref(args, cell),
Function::Isodd => self.fn_isodd(args, cell),
Function::Isomitted => self.fn_isomitted(args, cell),
Function::Iseven => self.fn_iseven(args, cell),
Function::ErrorType => self.fn_errortype(args, cell),
Function::Formulatext => self.fn_formulatext(args, cell),
Function::Isformula => self.fn_isformula(args, cell),
Function::Type => self.fn_type(args, cell),
Function::Sheet => self.fn_sheet(args, cell),
Function::Average => self.fn_average(args, cell),
Function::Averagea => self.fn_averagea(args, cell),
Function::Avedev => self.fn_avedev(args, cell),
Function::Averageif => self.fn_averageif(args, cell),
Function::Averageifs => self.fn_averageifs(args, cell),
Function::Count => self.fn_count(args, cell),
Function::Counta => self.fn_counta(args, cell),
Function::Countblank => self.fn_countblank(args, cell),
Function::Countif => self.fn_countif(args, cell),
Function::Countifs => self.fn_countifs(args, cell),
Function::Maxifs => self.fn_maxifs(args, cell),
Function::Minifs => self.fn_minifs(args, cell),
Function::Geomean => self.fn_geomean(args, cell),
Function::Year => self.fn_year(args, cell),
Function::Day => self.fn_day(args, cell),
Function::Eomonth => self.fn_eomonth(args, cell),
Function::Month => self.fn_month(args, cell),
Function::Date => self.fn_date(args, cell),
Function::Datedif => self.fn_datedif(args, cell),
Function::Datevalue => self.fn_datevalue(args, cell),
Function::Edate => self.fn_edate(args, cell),
Function::Networkdays => self.fn_networkdays(args, cell),
Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
Function::Time => self.fn_time(args, cell),
Function::Timevalue => self.fn_timevalue(args, cell),
Function::Hour => self.fn_hour(args, cell),
Function::Minute => self.fn_minute(args, cell),
Function::Second => self.fn_second(args, cell),
Function::Today => self.fn_today(args, cell),
Function::Now => self.fn_now(args, cell),
Function::Days => self.fn_days(args, cell),
Function::Days360 => self.fn_days360(args, cell),
Function::Weekday => self.fn_weekday(args, cell),
Function::Weeknum => self.fn_weeknum(args, cell),
Function::Workday => self.fn_workday(args, cell),
Function::WorkdayIntl => self.fn_workday_intl(args, cell),
Function::Yearfrac => self.fn_yearfrac(args, cell),
Function::Isoweeknum => self.fn_isoweeknum(args, cell),
Function::Pmt => self.fn_pmt(args, cell),
Function::Pv => self.fn_pv(args, cell),
Function::Rate => self.fn_rate(args, cell),
Function::Nper => self.fn_nper(args, cell),
Function::Fv => self.fn_fv(args, cell),
Function::Ppmt => self.fn_ppmt(args, cell),
Function::Ipmt => self.fn_ipmt(args, cell),
Function::Npv => self.fn_npv(args, cell),
Function::Mirr => self.fn_mirr(args, cell),
Function::Irr => self.fn_irr(args, cell),
Function::Xirr => self.fn_xirr(args, cell),
Function::Xnpv => self.fn_xnpv(args, cell),
Function::Rept => self.fn_rept(args, cell),
Function::Textafter => self.fn_textafter(args, cell),
Function::Textbefore => self.fn_textbefore(args, cell),
Function::Textsplit => self.fn_textsplit(args, cell),
Function::Textjoin => self.fn_textjoin(args, cell),
Function::Substitute => self.fn_substitute(args, cell),
Function::Regexextract => self.fn_regexextract(args, cell),
Function::Regexreplace => self.fn_regexreplace(args, cell),
Function::Regextest => self.fn_regextest(args, cell),
Function::Ispmt => self.fn_ispmt(args, cell),
Function::Rri => self.fn_rri(args, cell),
Function::Sln => self.fn_sln(args, cell),
Function::Syd => self.fn_syd(args, cell),
Function::Nominal => self.fn_nominal(args, cell),
Function::Effect => self.fn_effect(args, cell),
Function::Pduration => self.fn_pduration(args, cell),
Function::Tbillyield => self.fn_tbillyield(args, cell),
Function::Tbillprice => self.fn_tbillprice(args, cell),
Function::Tbilleq => self.fn_tbilleq(args, cell),
Function::Dollarde => self.fn_dollarde(args, cell),
Function::Dollarfr => self.fn_dollarfr(args, cell),
Function::Ddb => self.fn_ddb(args, cell),
Function::Db => self.fn_db(args, cell),
Function::Cumprinc => self.fn_cumprinc(args, cell),
Function::Cumipmt => self.fn_cumipmt(args, cell),
Function::Accrint => self.fn_accrint(args, cell),
Function::Accrintm => self.fn_accrintm(args, cell),
Function::Disc => self.fn_disc(args, cell),
Function::Fvschedule => self.fn_fvschedule(args, cell),
Function::Intrate => self.fn_intrate(args, cell),
Function::Pricedisc => self.fn_pricedisc(args, cell),
Function::Pricemat => self.fn_pricemat(args, cell),
Function::Received => self.fn_received(args, cell),
Function::Yielddisc => self.fn_yielddisc(args, cell),
Function::Yieldmat => self.fn_yieldmat(args, cell),
Function::Duration => self.fn_duration(args, cell),
Function::Mduration => self.fn_mduration(args, cell),
Function::Price => self.fn_price(args, cell),
Function::Yield => self.fn_yield(args, cell),
Function::Oddfprice => self.fn_oddfprice(args, cell),
Function::Oddfyield => self.fn_oddfyield(args, cell),
Function::Oddlprice => self.fn_oddlprice(args, cell),
Function::Oddlyield => self.fn_oddlyield(args, cell),
Function::Coupdaybs => self.fn_coupdaybs(args, cell),
Function::Coupdays => self.fn_coupdays(args, cell),
Function::Coupdaysnc => self.fn_coupdaysnc(args, cell),
Function::Coupncd => self.fn_coupncd(args, cell),
Function::Coupnum => self.fn_coupnum(args, cell),
Function::Couppcd => self.fn_couppcd(args, cell),
Function::Amordegrc => self.fn_amordegrc(args, cell),
Function::Amorlinc => self.fn_amorlinc(args, cell),
Function::Vdb => self.fn_vdb(args, cell),
Function::Besseli => self.fn_besseli(args, cell),
Function::Besselj => self.fn_besselj(args, cell),
Function::Besselk => self.fn_besselk(args, cell),
Function::Bessely => self.fn_bessely(args, cell),
Function::Erf => self.fn_erf(args, cell),
Function::ErfPrecise => self.fn_erfprecise(args, cell),
Function::Erfc => self.fn_erfc(args, cell),
Function::ErfcPrecise => self.fn_erfcprecise(args, cell),
Function::Bin2dec => self.fn_bin2dec(args, cell),
Function::Bin2hex => self.fn_bin2hex(args, cell),
Function::Bin2oct => self.fn_bin2oct(args, cell),
Function::Dec2Bin => self.fn_dec2bin(args, cell),
Function::Dec2hex => self.fn_dec2hex(args, cell),
Function::Dec2oct => self.fn_dec2oct(args, cell),
Function::Hex2bin => self.fn_hex2bin(args, cell),
Function::Hex2dec => self.fn_hex2dec(args, cell),
Function::Hex2oct => self.fn_hex2oct(args, cell),
Function::Oct2bin => self.fn_oct2bin(args, cell),
Function::Oct2dec => self.fn_oct2dec(args, cell),
Function::Oct2hex => self.fn_oct2hex(args, cell),
Function::Bitand => self.fn_bitand(args, cell),
Function::Bitlshift => self.fn_bitlshift(args, cell),
Function::Bitor => self.fn_bitor(args, cell),
Function::Bitrshift => self.fn_bitrshift(args, cell),
Function::Bitxor => self.fn_bitxor(args, cell),
Function::Complex => self.fn_complex(args, cell),
Function::Imabs => self.fn_imabs(args, cell),
Function::Imaginary => self.fn_imaginary(args, cell),
Function::Imargument => self.fn_imargument(args, cell),
Function::Imconjugate => self.fn_imconjugate(args, cell),
Function::Imcos => self.fn_imcos(args, cell),
Function::Imcosh => self.fn_imcosh(args, cell),
Function::Imcot => self.fn_imcot(args, cell),
Function::Imcsc => self.fn_imcsc(args, cell),
Function::Imcsch => self.fn_imcsch(args, cell),
Function::Imdiv => self.fn_imdiv(args, cell),
Function::Imexp => self.fn_imexp(args, cell),
Function::Imln => self.fn_imln(args, cell),
Function::Imlog10 => self.fn_imlog10(args, cell),
Function::Imlog2 => self.fn_imlog2(args, cell),
Function::Impower => self.fn_impower(args, cell),
Function::Improduct => self.fn_improduct(args, cell),
Function::Imreal => self.fn_imreal(args, cell),
Function::Imsec => self.fn_imsec(args, cell),
Function::Imsech => self.fn_imsech(args, cell),
Function::Imsin => self.fn_imsin(args, cell),
Function::Imsinh => self.fn_imsinh(args, cell),
Function::Imsqrt => self.fn_imsqrt(args, cell),
Function::Imsub => self.fn_imsub(args, cell),
Function::Imsum => self.fn_imsum(args, cell),
Function::Imtan => self.fn_imtan(args, cell),
Function::Convert => self.fn_convert(args, cell),
Function::Delta => self.fn_delta(args, cell),
Function::Gestep => self.fn_gestep(args, cell),
Function::Subtotal => self.fn_subtotal(args, cell),
Function::Aggregate => self.fn_aggregate(args, cell), // MACRO
Function::Getpivotdata => self.fn_getpivotdata(args, cell), // MACRO
Function::Acot => self.fn_acot(args, cell),
Function::Acoth => self.fn_acoth(args, cell),
Function::Cot => self.fn_cot(args, cell),
Function::Coth => self.fn_coth(args, cell),
Function::Csc => self.fn_csc(args, cell),
Function::Csch => self.fn_csch(args, cell),
Function::Sec => self.fn_sec(args, cell),
Function::Sech => self.fn_sech(args, cell),
Function::Exp => self.fn_exp(args, cell),
Function::Fact => self.fn_fact(args, cell),
Function::Factdouble => self.fn_factdouble(args, cell),
Function::Sign => self.fn_sign(args, cell),
Function::Radians => self.fn_radians(args, cell),
Function::Degrees => self.fn_degrees(args, cell),
Function::Int => self.fn_int(args, cell),
Function::Even => self.fn_even(args, cell),
Function::Odd => self.fn_odd(args, cell),
Function::Ceiling => self.fn_ceiling(args, cell),
Function::CeilingMath => self.fn_ceiling_math(args, cell),
Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
Function::Floor => self.fn_floor(args, cell),
Function::FloorMath => self.fn_floor_math(args, cell),
Function::FloorPrecise => self.fn_floor_precise(args, cell),
Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
Function::Mod => self.fn_mod(args, cell),
Function::Quotient => self.fn_quotient(args, cell),
Function::Mround => self.fn_mround(args, cell),
Function::Trunc => self.fn_trunc(args, cell),
Function::Gcd => self.fn_gcd(args, cell),
Function::Lcm => self.fn_lcm(args, cell),
Function::Base => self.fn_base(args, cell),
Function::Decimal => self.fn_decimal(args, cell),
Function::Roman => self.fn_roman(args, cell),
Function::Arabic => self.fn_arabic(args, cell),
Function::Combin => self.fn_combin(args, cell),
Function::Combina => self.fn_combina(args, cell),
Function::Sumsq => self.fn_sumsq(args, cell),
Function::Mdeterm => self.fn_mdeterm(args, cell),
Function::Minverse => self.fn_minverse(args, cell),
Function::Munit => self.fn_munit(args, cell),
Function::Multinomial => self.fn_multinomial(args, cell),
Function::Seriessum => self.fn_seriessum(args, cell),
Function::Sumproduct => self.fn_sumproduct(args, cell),
Function::Percentof => self.fn_percentof(args, cell),
Function::N => self.fn_n(args, cell),
Function::Cell => self.fn_cell(args, cell),
Function::Info => self.fn_info(args, cell),
Function::Sheets => self.fn_sheets(args, cell),
Function::Daverage => self.fn_daverage(args, cell),
Function::Dcount => self.fn_dcount(args, cell),
Function::Dget => self.fn_dget(args, cell),
Function::Dmax => self.fn_dmax(args, cell),
Function::Dmin => self.fn_dmin(args, cell),
Function::Dsum => self.fn_dsum(args, cell),
Function::Dcounta => self.fn_dcounta(args, cell),
Function::Dproduct => self.fn_dproduct(args, cell),
Function::Dstdev => self.fn_dstdev(args, cell),
Function::Dvar => self.fn_dvar(args, cell),
Function::Dvarp => self.fn_dvarp(args, cell),
Function::Dstdevp => self.fn_dstdevp(args, cell),
Function::BetaDist => self.fn_beta_dist(args, cell),
Function::BetaInv => self.fn_beta_inv(args, cell),
Function::BinomDist => self.fn_binom_dist(args, cell),
Function::BinomDistRange => self.fn_binom_dist_range(args, cell),
Function::BinomInv => self.fn_binom_inv(args, cell),
Function::ChisqDist => self.fn_chisq_dist(args, cell),
Function::ChisqDistRT => self.fn_chisq_dist_rt(args, cell),
Function::ChisqInv => self.fn_chisq_inv(args, cell),
Function::ChisqInvRT => self.fn_chisq_inv_rt(args, cell),
Function::ChisqTest => self.fn_chisq_test(args, cell),
Function::ConfidenceNorm => self.fn_confidence_norm(args, cell),
Function::ConfidenceT => self.fn_confidence_t(args, cell),
Function::CovarianceP => self.fn_covariance_p(args, cell),
Function::CovarianceS => self.fn_covariance_s(args, cell),
Function::Devsq => self.fn_devsq(args, cell),
Function::ExponDist => self.fn_expon_dist(args, cell),
Function::FDist => self.fn_f_dist(args, cell),
Function::FDistRT => self.fn_f_dist_rt(args, cell),
Function::FInv => self.fn_f_inv(args, cell),
Function::FInvRT => self.fn_f_inv_rt(args, cell),
Function::Fisher => self.fn_fisher(args, cell),
Function::FisherInv => self.fn_fisher_inv(args, cell),
Function::FTest => self.fn_f_test(args, cell),
Function::Gamma => self.fn_gamma(args, cell),
Function::GammaDist => self.fn_gamma_dist(args, cell),
Function::GammaInv => self.fn_gamma_inv(args, cell),
Function::GammaLn => self.fn_gamma_ln(args, cell),
Function::GammaLnPrecise => self.fn_gamma_ln_precise(args, cell),
Function::HypGeomDist => self.fn_hyp_geom_dist(args, cell),
Function::LogNormDist => self.fn_log_norm_dist(args, cell),
Function::LogNormInv => self.fn_log_norm_inv(args, cell),
Function::NegbinomDist => self.fn_negbinom_dist(args, cell),
Function::NormDist => self.fn_norm_dist(args, cell),
Function::NormInv => self.fn_norm_inv(args, cell),
Function::NormSdist => self.fn_norm_s_dist(args, cell),
Function::NormSInv => self.fn_norm_s_inv(args, cell),
Function::Pearson => self.fn_pearson(args, cell),
Function::Phi => self.fn_phi(args, cell),
Function::PoissonDist => self.fn_poisson_dist(args, cell),
Function::Standardize => self.fn_standardize(args, cell),
Function::Stdev => self.fn_stdev_s(args, cell),
Function::StDevP => self.fn_stdev_p(args, cell),
Function::StDevS => self.fn_stdev_s(args, cell),
Function::Stdeva => self.fn_stdeva(args, cell),
Function::Stdevpa => self.fn_stdevpa(args, cell),
Function::TDist => self.fn_t_dist(args, cell),
Function::TDist2T => self.fn_t_dist_2t(args, cell),
Function::TDistRT => self.fn_t_dist_rt(args, cell),
Function::TInv => self.fn_t_inv(args, cell),
Function::TInv2T => self.fn_t_inv_2t(args, cell),
Function::TTest => self.fn_t_test(args, cell),
Function::VarP => self.fn_var_p(args, cell),
Function::VarS => self.fn_var_s(args, cell),
Function::VarpA => self.fn_varpa(args, cell),
Function::VarA => self.fn_vara(args, cell),
Function::WeibullDist => self.fn_weibull_dist(args, cell),
Function::ZTest => self.fn_z_test(args, cell),
Function::BetaDistCompat => self.fn_betadist_compat(args, cell),
Function::HypGeomDistCompat => self.fn_hypgeomdist_compat(args, cell),
Function::LogNormDistCompat => self.fn_lognormdist_compat(args, cell),
Function::NegbinomDistCompat => self.fn_negbinomdist_compat(args, cell),
Function::NormSDistCompat => self.fn_normsdist_compat(args, cell),
Function::TDistCompat => self.fn_tdist_compat(args, cell),
Function::BetaInvCompat => self.fn_beta_inv(args, cell),
Function::BinomDistCompat => self.fn_binom_dist(args, cell),
Function::ChiDistCompat => self.fn_chisq_dist_rt(args, cell),
Function::ChiInvCompat => self.fn_chisq_inv_rt(args, cell),
Function::ChiTestCompat => self.fn_chisq_test(args, cell),
Function::ConfidenceCompat => self.fn_confidence_norm(args, cell),
Function::CovarCompat => self.fn_covariance_p(args, cell),
Function::CritbinomCompat => self.fn_binom_inv(args, cell),
Function::ExponDistCompat => self.fn_expon_dist(args, cell),
Function::FDistCompat => self.fn_f_dist_rt(args, cell),
Function::FInvCompat => self.fn_f_inv_rt(args, cell),
Function::FTestCompat => self.fn_f_test(args, cell),
Function::GammaDistCompat => self.fn_gamma_dist(args, cell),
Function::GammaInvCompat => self.fn_gamma_inv(args, cell),
Function::LoginvCompat => self.fn_log_norm_inv(args, cell),
Function::ModeCompat => self.fn_mode_sngl(args, cell),
Function::NormDistCompat => self.fn_norm_dist(args, cell),
Function::NormInvCompat => self.fn_norm_inv(args, cell),
Function::NormSInvCompat => self.fn_norm_s_inv(args, cell),
Function::PercentileCompat => self.fn_percentile_inc(args, cell),
Function::PercentrankCompat => self.fn_percentrank_inc(args, cell),
Function::PoissonCompat => self.fn_poisson_dist(args, cell),
Function::QuartileCompat => self.fn_quartile_inc(args, cell),
Function::RankCompat => self.fn_rank_eq(args, cell),
Function::StDevPCompat => self.fn_stdev_p(args, cell),
Function::TInvCompat => self.fn_t_inv_2t(args, cell),
Function::TTestCompat => self.fn_t_test(args, cell),
Function::VarCompat => self.fn_var_s(args, cell),
Function::VarPCompat => self.fn_var_p(args, cell),
Function::WeibullCompat => self.fn_weibull_dist(args, cell),
Function::ZTestCompat => self.fn_z_test(args, cell),
Function::Sumx2my2 => self.fn_sumx2my2(args, cell),
Function::Sumx2py2 => self.fn_sumx2py2(args, cell),
Function::Sumxmy2 => self.fn_sumxmy2(args, cell),
Function::Correl => self.fn_correl(args, cell),
Function::Rsq => self.fn_rsq(args, cell),
Function::Intercept => self.fn_intercept(args, cell),
Function::Slope => self.fn_slope(args, cell),
Function::Steyx => self.fn_steyx(args, cell),
Function::Forecast => self.fn_forecast(args, cell),
Function::ForecastLinear => self.fn_forecast_linear(args, cell),
Function::ForecastEts => self.fn_forecast_ets(args, cell),
Function::ForecastEtsConfint => self.fn_forecast_ets_confint(args, cell),
Function::ForecastEtsSeasonality => self.fn_forecast_ets_seasonality(args, cell),
Function::ForecastEtsStat => self.fn_forecast_ets_stat(args, cell),
Function::Frequency => self.fn_frequency(args, cell),
Function::Growth => self.fn_growth(args, cell),
Function::Linest => self.fn_linest(args, cell),
Function::Logest => self.fn_logest(args, cell),
Function::ModeMult => self.fn_mode_mult(args, cell),
Function::ModeSingl => self.fn_mode_sngl(args, cell),
Function::PercentileExc => self.fn_percentile_exc(args, cell),
Function::PercentileInc => self.fn_percentile_inc(args, cell),
Function::PercentrankExc => self.fn_percentrank_exc(args, cell),
Function::PercentrankInc => self.fn_percentrank_inc(args, cell),
Function::Permut => self.fn_permut(args, cell),
Function::Permutationa => self.fn_permutationa(args, cell),
Function::Prob => self.fn_prob(args, cell),
Function::QuartileExc => self.fn_quartile_exc(args, cell),
Function::QuartileInc => self.fn_quartile_inc(args, cell),
Function::Trend => self.fn_trend(args, cell),
Function::Trimmean => self.fn_trimmean(args, cell),
Function::Gauss => self.fn_gauss(args, cell),
Function::Harmean => self.fn_harmean(args, cell),
Function::Kurt => self.fn_kurt(args, cell),
Function::Large => self.fn_large(args, cell),
Function::MaxA => self.fn_maxa(args, cell),
Function::Median => self.fn_median(args, cell),
Function::MinA => self.fn_mina(args, cell),
Function::RankAvg => self.fn_rank_avg(args, cell),
Function::RankEq => self.fn_rank_eq(args, cell),
Function::Skew => self.fn_skew(args, cell),
Function::SkewP => self.fn_skew_p(args, cell),
Function::Small => self.fn_small(args, cell),
}
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
use std::{
fs::File,
io::{BufRead, BufReader},
};
#[test]
fn function_iterator() {
// This checks that the number of functions in the enum is the same
// as the number of functions in the Iterator.
// This is tricky. In Rust we cannot loop over all the members of an enum.
// There are alternatives like using an external crate like strum.
// But I am not in the mood for that.
// What we do here is read this file , extract the functions in the enum
// and check they are the same as in the iterator
let file = File::open("src/functions/mod.rs").unwrap();
let reader = BufReader::new(file);
let mut start = false;
let mut list = Vec::new();
for line in reader.lines() {
let text = line.unwrap();
let text = text.trim().trim_end_matches(',');
if text == "pub enum Function {" {
start = true;
continue;
}
if start {
if text == "}" {
break;
}
if text.starts_with("//") {
// skip comments
continue;
}
if text.is_empty() {
// skip empty lines
continue;
}
list.push(text.to_owned());
}
}
// We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
// let iter_list = Function::into_iter()
// .map(|f| format!("{f}").replace('.', ""))
// .collect::<Vec<_>>();
// let len = iter_list.len();
// assert_eq!(list.len(), len);
// // We still need to check there are no duplicates. This will fail if a function in iter_list
// // is included twice and one is missing
// for function in list {
// assert!(iter_list.contains(&function.to_uppercase()));
// }
}
}