Skip to main content

ironcalc_base/functions/
mod.rs

1use std::array::IntoIter;
2
3use crate::{
4    calc_result::CalcResult,
5    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
6    language::{get_default_language, Functions, Language},
7    model::Model,
8};
9
10pub(crate) mod binary_search;
11mod database;
12pub(crate) mod date_and_time;
13mod engineering;
14mod financial;
15mod information;
16mod logical;
17mod lookup_and_reference;
18mod macros;
19mod math_and_trigonometry;
20mod spill_functions;
21mod statistical;
22mod subtotal;
23mod text;
24pub(crate) mod util;
25mod xlookup;
26
27/// List of all implemented functions
28#[derive(PartialEq, Clone, Debug)]
29pub enum Function {
30    // Logical
31    And,
32    False,
33    If,
34    Iferror,
35    Ifna,
36    Ifs,
37    Lambda,
38    Let,
39    Not,
40    Or,
41    Switch,
42    True,
43    Xor,
44    Bycol,
45    Byrow,
46    Map,
47    Reduce,
48    Scan,
49    Makearray,
50
51    // Mathematical and trigonometry
52    Abs,
53    Acos,
54    Acosh,
55    Asin,
56    Asinh,
57    Atan,
58    Atan2,
59    Atanh,
60    Choose,
61    Column,
62    Columns,
63    Cos,
64    Cosh,
65    Log,
66    Log10,
67    Ln,
68    Max,
69    Min,
70    Pi,
71    Power,
72    Product,
73    Rand,
74    Randbetween,
75    Round,
76    Rounddown,
77    Roundup,
78    Sin,
79    Sinh,
80    Sqrt,
81    Sqrtpi,
82    Sum,
83    Sumif,
84    Sumifs,
85    Sumx2my2,
86    Sumx2py2,
87    Sumxmy2,
88    Tan,
89    Tanh,
90    Acot,
91    Acoth,
92    Cot,
93    Coth,
94    Csc,
95    Csch,
96    Sec,
97    Sech,
98    Exp,
99    Fact,
100    Factdouble,
101    Sign,
102    Radians,
103    Degrees,
104    Int,
105    Even,
106    Odd,
107    Ceiling,
108    CeilingMath,
109    CeilingPrecise,
110    Floor,
111    FloorMath,
112    FloorPrecise,
113    IsoCeiling,
114    Mod,
115    Quotient,
116    Mround,
117    Trunc,
118    Gcd,
119    Lcm,
120    Base,
121    Decimal,
122    Roman,
123    Arabic,
124    Combin,
125    Combina,
126    Sumsq,
127    Mdeterm,
128    Minverse,
129    Munit,
130    Multinomial,
131    Seriessum,
132    Sumproduct,
133    Percentof,
134
135    // Information
136    ErrorType,
137    Formulatext,
138    Isblank,
139    Iserr,
140    Iserror,
141    Iseven,
142    Isformula,
143    Islogical,
144    Isna,
145    Isnontext,
146    Isnumber,
147    Isodd,
148    Isomitted,
149    Isref,
150    Istext,
151    Na,
152    Sheet,
153    Type,
154
155    Sheets,
156    N,
157    Cell,
158    Info,
159
160    // Lookup and reference
161    Address,
162    Areas,
163    Choosecols,
164    Chooserows,
165    Expand,
166    Filter,
167    Hlookup,
168    Hstack,
169    Index,
170    Indirect,
171    Lookup,
172    Match,
173    Offset,
174    Row,
175    Rows,
176    Sort,
177    Sortby,
178    Unique,
179    Vlookup,
180    Vstack,
181    Wrapcols,
182    Wraprows,
183    Xlookup,
184    Xmatch,
185    Trimrange,
186    Take,
187    Drop,
188    Tocol,
189    Torow,
190    Transpose,
191    Mmult,
192
193    // Dynamic array
194    Sequence,
195    Randarray,
196
197    // Text
198    Concat,
199    Textsplit,
200    Concatenate,
201    Exact,
202    Find,
203    Left,
204    Len,
205    Lower,
206    Mid,
207    Rept,
208    Right,
209    Search,
210    Substitute,
211    Regexextract,
212    Regexreplace,
213    Regextest,
214    T,
215    Text,
216    Textafter,
217    Textbefore,
218    Textjoin,
219    Trim,
220    Unicode,
221    Unichar,
222    Char,
223    Clean,
224    Code,
225    Asc,
226    Arraytotext,
227    Dollar,
228    Findb,
229    Fixed,
230    Leftb,
231    Lenb,
232    Midb,
233    Numbervalue,
234    Proper,
235    Replace,
236    Replaceb,
237    Rightb,
238    Searchb,
239    Upper,
240    Value,
241    Valuetotext,
242
243    // Statistical
244    Average,
245    Averagea,
246    Averageif,
247    Averageifs,
248    Count,
249    Counta,
250    Countblank,
251    Countif,
252    Countifs,
253    Maxifs,
254    Minifs,
255    Geomean,
256
257    Frequency,
258    Growth,
259
260    Avedev,
261    BetaDist,
262    BetaInv,
263    BinomDist,
264    BinomDistRange,
265    BinomInv,
266    ChisqDist,
267    ChisqDistRT,
268    ChisqInv,
269    ChisqInvRT,
270    ChisqTest,
271    ConfidenceNorm,
272    ConfidenceT,
273    CovarianceP,
274    CovarianceS,
275    Devsq,
276    ExponDist,
277    FDist,
278    FDistRT,
279    FInv,
280    FInvRT,
281    FTest,
282    Fisher,
283    FisherInv,
284    Forecast,
285    ForecastLinear,
286    ForecastEts,
287    ForecastEtsConfint,
288    ForecastEtsSeasonality,
289    ForecastEtsStat,
290    Gamma,
291    GammaDist,
292    GammaInv,
293    GammaLn,
294    GammaLnPrecise,
295    Gauss,
296    Harmean,
297    HypGeomDist,
298    Kurt,
299    Large,
300    Linest,
301    Logest,
302    LogNormDist,
303    LogNormInv,
304    MaxA,
305    Median,
306    MinA,
307    ModeMult,
308    ModeSingl,
309    NegbinomDist,
310    NormDist,
311    NormInv,
312    NormSdist,
313    NormSInv,
314    Pearson,
315    PercentileExc,
316    PercentileInc,
317    PercentrankExc,
318    PercentrankInc,
319    Permut,
320    Permutationa,
321    Phi,
322    PoissonDist,
323    Prob,
324    QuartileExc,
325    QuartileInc,
326    RankAvg,
327    RankEq,
328    Skew,
329    SkewP,
330    Small,
331    Standardize,
332    Stdev,
333    StDevP,
334    StDevS,
335    Stdeva,
336    Stdevpa,
337    TDist,
338    TDist2T,
339    TDistRT,
340    TInv,
341    TInv2T,
342    TTest,
343    Trend,
344    Trimmean,
345    VarP,
346    VarS,
347    VarpA,
348    VarA,
349    WeibullDist,
350    ZTest,
351
352    // Compatibility — wrappers
353    BetaDistCompat,
354    HypGeomDistCompat,
355    LogNormDistCompat,
356    NegbinomDistCompat,
357    NormSDistCompat,
358    TDistCompat,
359    // Compatibility — aliases
360    BetaInvCompat,
361    BinomDistCompat,
362    ChiDistCompat,
363    ChiInvCompat,
364    ChiTestCompat,
365    ConfidenceCompat,
366    CovarCompat,
367    CritbinomCompat,
368    ExponDistCompat,
369    FDistCompat,
370    FInvCompat,
371    FTestCompat,
372    GammaDistCompat,
373    GammaInvCompat,
374    LoginvCompat,
375    ModeCompat,
376    NormDistCompat,
377    NormInvCompat,
378    NormSInvCompat,
379    PercentileCompat,
380    PercentrankCompat,
381    PoissonCompat,
382    QuartileCompat,
383    RankCompat,
384    StDevPCompat,
385    TInvCompat,
386    TTestCompat,
387    VarCompat,
388    VarPCompat,
389    WeibullCompat,
390    ZTestCompat,
391
392    // Date and time
393    Date,
394    Datedif,
395    Datevalue,
396    Day,
397    Edate,
398    Eomonth,
399    Month,
400    Time,
401    Timevalue,
402    Hour,
403    Minute,
404    Second,
405    Now,
406    Today,
407    Year,
408    Networkdays,
409    NetworkdaysIntl,
410    Days,
411    Days360,
412    Weekday,
413    Weeknum,
414    Workday,
415    WorkdayIntl,
416    Yearfrac,
417    Isoweeknum,
418
419    // Financial
420    Accrint,
421    Accrintm,
422    Disc,
423    Fvschedule,
424    Intrate,
425    Pricedisc,
426    Pricemat,
427    Received,
428    Yielddisc,
429    Yieldmat,
430    Cumipmt,
431    Cumprinc,
432    Db,
433    Ddb,
434    Dollarde,
435    Dollarfr,
436    Effect,
437    Fv,
438    Ipmt,
439    Irr,
440    Ispmt,
441    Mirr,
442    Nominal,
443    Nper,
444    Npv,
445    Pduration,
446    Pmt,
447    Ppmt,
448    Pv,
449    Rate,
450    Rri,
451    Sln,
452    Syd,
453    Tbilleq,
454    Tbillprice,
455    Tbillyield,
456    Xirr,
457    Xnpv,
458    Duration,
459    Mduration,
460    Price,
461    Yield,
462    Oddfprice,
463    Oddfyield,
464    Oddlprice,
465    Oddlyield,
466    Coupdaybs,
467    Coupdays,
468    Coupdaysnc,
469    Coupncd,
470    Coupnum,
471    Couppcd,
472    Amordegrc,
473    Amorlinc,
474    Vdb,
475
476    // Engineering: Bessel and transcendental functions
477    Besseli,
478    Besselj,
479    Besselk,
480    Bessely,
481    Erf,
482    Erfc,
483    ErfcPrecise,
484    ErfPrecise,
485
486    // Engineering: Number systems
487    Bin2dec,
488    Bin2hex,
489    Bin2oct,
490    Dec2Bin,
491    Dec2hex,
492    Dec2oct,
493    Hex2bin,
494    Hex2dec,
495    Hex2oct,
496    Oct2bin,
497    Oct2dec,
498    Oct2hex,
499
500    // Engineering: Bit functions
501    Bitand,
502    Bitlshift,
503    Bitor,
504    Bitrshift,
505    Bitxor,
506
507    // Engineering: Complex functions
508    Complex,
509    Imabs,
510    Imaginary,
511    Imargument,
512    Imconjugate,
513    Imcos,
514    Imcosh,
515    Imcot,
516    Imcsc,
517    Imcsch,
518    Imdiv,
519    Imexp,
520    Imln,
521    Imlog10,
522    Imlog2,
523    Impower,
524    Improduct,
525    Imreal,
526    Imsec,
527    Imsech,
528    Imsin,
529    Imsinh,
530    Imsqrt,
531    Imsub,
532    Imsum,
533    Imtan,
534
535    // Engineering: Misc function
536    Convert,
537    Delta,
538    Gestep,
539    Subtotal,
540
541    // Database
542    Daverage,
543    Dcount,
544    Dget,
545    Dmax,
546    Dmin,
547    Dsum,
548    Dcounta,
549    Dproduct,
550    Dstdev,
551    Dvar,
552    Dvarp,
553    Dstdevp,
554
555    Correl,
556    Rsq,
557    Intercept,
558    Slope,
559    Steyx,
560}
561
562macro_rules! impl_function_lookup {
563    ($($field:ident => $variant:ident),+ $(,)?) => {
564        impl Functions {
565            pub fn lookup(&self, name: &str) -> Option<Function> {
566                let key = name.to_uppercase();
567                $(
568                    if self.$field == key {
569                        return Some(Function::$variant);
570                    }
571                )*
572                None
573            }
574        }
575    }
576}
577
578impl_function_lookup! {
579    // Logical
580    and         => And,
581    r#false     => False,
582    r#if        => If,
583    iferror     => Iferror,
584    ifna        => Ifna,
585    ifs         => Ifs,
586    lambda      => Lambda,
587    r#let       => Let,
588    not         => Not,
589    or          => Or,
590    switch      => Switch,
591    r#true      => True,
592    xor         => Xor,
593    bycol       => Bycol,
594    byrow       => Byrow,
595    map         => Map,
596    reduce      => Reduce,
597    scan        => Scan,
598    makearray   => Makearray,
599
600    // Mathematical and trigonometry
601    abs             => Abs,
602    acos            => Acos,
603    acosh           => Acosh,
604    asin            => Asin,
605    asinh           => Asinh,
606    atan            => Atan,
607    atan2           => Atan2,
608    atanh           => Atanh,
609    choose          => Choose,
610    column          => Column,
611    columns         => Columns,
612    cos             => Cos,
613    cosh            => Cosh,
614    log             => Log,
615    log10           => Log10,
616    ln              => Ln,
617    max             => Max,
618    min             => Min,
619    pi              => Pi,
620    power           => Power,
621    product         => Product,
622    rand            => Rand,
623    randbetween     => Randbetween,
624    round           => Round,
625    rounddown       => Rounddown,
626    roundup         => Roundup,
627    sin             => Sin,
628    sinh            => Sinh,
629    sqrt            => Sqrt,
630    sqrtpi          => Sqrtpi,
631    sum             => Sum,
632    sumif           => Sumif,
633    sumifs          => Sumifs,
634    sumx2my2        => Sumx2my2,
635    sumx2py2        => Sumx2py2,
636    sumxmy2         => Sumxmy2,
637    tan             => Tan,
638    tanh            => Tanh,
639    acot            => Acot,
640    acoth           => Acoth,
641    cot             => Cot,
642    coth            => Coth,
643    csc             => Csc,
644    csch            => Csch,
645    sec             => Sec,
646    sech            => Sech,
647    exp             => Exp,
648    fact            => Fact,
649    factdouble      => Factdouble,
650    sign            => Sign,
651    radians         => Radians,
652    degrees         => Degrees,
653    int             => Int,
654    even            => Even,
655    odd             => Odd,
656    ceiling         => Ceiling,
657    ceilingmath     => CeilingMath,
658    ceilingprecise  => CeilingPrecise,
659    floor           => Floor,
660    floormath       => FloorMath,
661    floorprecise    => FloorPrecise,
662    isoceiling      => IsoCeiling,
663    r#mod           => Mod,
664    quotient        => Quotient,
665    mround          => Mround,
666    trunc           => Trunc,
667    gcd             => Gcd,
668    lcm             => Lcm,
669    base            => Base,
670    decimal         => Decimal,
671    roman           => Roman,
672    arabic          => Arabic,
673    combin          => Combin,
674    combina         => Combina,
675    sumsq           => Sumsq,
676    mdeterm         => Mdeterm,
677    minverse        => Minverse,
678    munit           => Munit,
679    multinomial     => Multinomial,
680    seriessum       => Seriessum,
681    sumproduct      => Sumproduct,
682    percentof       => Percentof,
683
684    // Information
685    errortype   => ErrorType,
686    formulatext => Formulatext,
687    isblank     => Isblank,
688    iserr       => Iserr,
689    iserror     => Iserror,
690    iseven      => Iseven,
691    isformula   => Isformula,
692    islogical   => Islogical,
693    isna        => Isna,
694    isnontext   => Isnontext,
695    isnumber    => Isnumber,
696    isodd       => Isodd,
697    isomitted   => Isomitted,
698    isref       => Isref,
699    istext      => Istext,
700    na          => Na,
701    sheet       => Sheet,
702    r#type      => Type,
703
704    sheets      => Sheets,
705    n           => N,
706    cell        => Cell,
707    info        => Info,
708
709    // Lookup and reference
710    address   => Address,
711    areas     => Areas,
712    choosecols => Choosecols,
713    chooserows => Chooserows,
714    expand    => Expand,
715    filter    => Filter,
716    hlookup   => Hlookup,
717    hstack    => Hstack,
718    index     => Index,
719    indirect  => Indirect,
720    lookup    => Lookup,
721    r#match   => Match,
722    offset    => Offset,
723    row       => Row,
724    rows      => Rows,
725    sort      => Sort,
726    sortby    => Sortby,
727    unique    => Unique,
728    vlookup   => Vlookup,
729    vstack    => Vstack,
730    wrapcols  => Wrapcols,
731    wraprows  => Wraprows,
732    xlookup   => Xlookup,
733    xmatch    => Xmatch,
734    trimrange => Trimrange,
735    take      => Take,
736    drop      => Drop,
737    tocol     => Tocol,
738    torow     => Torow,
739    transpose => Transpose,
740    mmult     => Mmult,
741
742    // Dynamic array
743    sequence  => Sequence,
744    randarray => Randarray,
745
746    // Text
747    concat      => Concat,
748    textsplit   => Textsplit,
749    concatenate => Concatenate,
750    exact       => Exact,
751    find        => Find,
752    left        => Left,
753    len         => Len,
754    lower       => Lower,
755    mid         => Mid,
756    rept        => Rept,
757    right       => Right,
758    search      => Search,
759    substitute    => Substitute,
760    regexextract  => Regexextract,
761    regexreplace  => Regexreplace,
762    regextest     => Regextest,
763    t             => T,
764    text        => Text,
765    textafter   => Textafter,
766    textbefore  => Textbefore,
767    textjoin    => Textjoin,
768    trim        => Trim,
769    unicode     => Unicode,
770    unichar     => Unichar,
771    char        => Char,
772    clean       => Clean,
773    code        => Code,
774    asc         => Asc,
775    arraytotext => Arraytotext,
776    dollar      => Dollar,
777    findb       => Findb,
778    fixed       => Fixed,
779    leftb       => Leftb,
780    lenb        => Lenb,
781    midb        => Midb,
782    numbervalue => Numbervalue,
783    proper      => Proper,
784    replace     => Replace,
785    replaceb    => Replaceb,
786    rightb      => Rightb,
787    searchb     => Searchb,
788    upper       => Upper,
789    value       => Value,
790    valuetotext => Valuetotext,
791
792    // Statistical
793    average        => Average,
794    averagea       => Averagea,
795    averageif      => Averageif,
796    averageifs     => Averageifs,
797    count          => Count,
798    counta         => Counta,
799    countblank     => Countblank,
800    countif        => Countif,
801    countifs       => Countifs,
802    maxifs         => Maxifs,
803    minifs         => Minifs,
804    geomean        => Geomean,
805    avedev         => Avedev,
806    betadist       => BetaDist,
807    betainv        => BetaInv,
808    binomdist      => BinomDist,
809    binomdistrange => BinomDistRange,
810    binominv       => BinomInv,
811    chisqdist      => ChisqDist,
812    chisqdistrt    => ChisqDistRT,
813    chisqinv       => ChisqInv,
814    chisqinvrt     => ChisqInvRT,
815    chisqtest      => ChisqTest,
816    confidencenorm => ConfidenceNorm,
817    confidencet    => ConfidenceT,
818    covariancep    => CovarianceP,
819    covariances    => CovarianceS,
820    devsq          => Devsq,
821    expondist      => ExponDist,
822    fdist          => FDist,
823    fdistrt        => FDistRT,
824    finv           => FInv,
825    finvrt         => FInvRT,
826    ftest          => FTest,
827    fisher         => Fisher,
828    fisherinv      => FisherInv,
829    gamma          => Gamma,
830    gammadist      => GammaDist,
831    gammainv       => GammaInv,
832    gammaln        => GammaLn,
833    gammalnprecise => GammaLnPrecise,
834    gauss          => Gauss,
835    harmean        => Harmean,
836    hypgeomdist    => HypGeomDist,
837    kurt           => Kurt,
838    large          => Large,
839    lognormdist    => LogNormDist,
840    lognorminv     => LogNormInv,
841    maxa           => MaxA,
842    median         => Median,
843    mina           => MinA,
844    negbinomdist   => NegbinomDist,
845    normdist       => NormDist,
846    norminv        => NormInv,
847    normsdist      => NormSdist,
848    normsinv       => NormSInv,
849    pearson        => Pearson,
850    phi            => Phi,
851    poissondist    => PoissonDist,
852    rankavg        => RankAvg,
853    rankeq         => RankEq,
854    skew           => Skew,
855    skewp          => SkewP,
856    small          => Small,
857    standardize    => Standardize,
858    stdev          => Stdev,
859    stdevp         => StDevP,
860    stdevs         => StDevS,
861    stdeva         => Stdeva,
862    stdevpa        => Stdevpa,
863    tdist          => TDist,
864    tdist2t        => TDist2T,
865    tdistrt        => TDistRT,
866    tinv           => TInv,
867    tinv2t         => TInv2T,
868    ttest          => TTest,
869    varp           => VarP,
870    vars           => VarS,
871    varpa          => VarpA,
872    vara           => VarA,
873    weibulldist    => WeibullDist,
874    ztest          => ZTest,
875
876    // Compatibility — wrappers
877    betadistcompat     => BetaDistCompat,
878    hypgeomdistcompat  => HypGeomDistCompat,
879    lognormdistcompat  => LogNormDistCompat,
880    negbinomdistcompat => NegbinomDistCompat,
881    normsdistcompat    => NormSDistCompat,
882    tdistcompat        => TDistCompat,
883    // Compatibility — aliases (own variant for round-trip serialization)
884    chidist            => ChiDistCompat,
885    chiinv             => ChiInvCompat,
886    chitest            => ChiTestCompat,
887    confidence         => ConfidenceCompat,
888    covar              => CovarCompat,
889    critbinom          => CritbinomCompat,
890    loginv             => LoginvCompat,
891    betainvcompat      => BetaInvCompat,
892    binomdistcompat    => BinomDistCompat,
893    expondistcompat    => ExponDistCompat,
894    fdistcompat        => FDistCompat,
895    finvcompat         => FInvCompat,
896    ftestcompat        => FTestCompat,
897    gammadistcompat    => GammaDistCompat,
898    gammainvcompat     => GammaInvCompat,
899    modecompat         => ModeCompat,
900    normdistcompat     => NormDistCompat,
901    norminvcompat      => NormInvCompat,
902    normsinvcompat     => NormSInvCompat,
903    percentilecompat   => PercentileCompat,
904    percentrankcompat  => PercentrankCompat,
905    poissoncompat      => PoissonCompat,
906    quartilecompat     => QuartileCompat,
907    rankcompat         => RankCompat,
908    stdevpcompat       => StDevPCompat,
909    tinvcompat         => TInvCompat,
910    ttestcompat        => TTestCompat,
911    varcompat          => VarCompat,
912    varpcompat         => VarPCompat,
913    weibullcompat      => WeibullCompat,
914    ztestcompat        => ZTestCompat,
915
916    // Date and time
917    date            => Date,
918    datedif         => Datedif,
919    datevalue       => Datevalue,
920    day             => Day,
921    edate           => Edate,
922    eomonth         => Eomonth,
923    month           => Month,
924    time            => Time,
925    timevalue       => Timevalue,
926    hour            => Hour,
927    minute          => Minute,
928    second          => Second,
929    now             => Now,
930    today           => Today,
931    year            => Year,
932    networkdays     => Networkdays,
933    networkdaysintl => NetworkdaysIntl,
934    days            => Days,
935    days360         => Days360,
936    weekday         => Weekday,
937    weeknum         => Weeknum,
938    workday         => Workday,
939    workdayintl     => WorkdayIntl,
940    yearfrac        => Yearfrac,
941    isoweeknum      => Isoweeknum,
942
943    // Financial
944    accrint    => Accrint,
945    accrintm   => Accrintm,
946    disc       => Disc,
947    fvschedule => Fvschedule,
948    intrate    => Intrate,
949    pricedisc  => Pricedisc,
950    pricemat   => Pricemat,
951    received   => Received,
952    yielddisc  => Yielddisc,
953    yieldmat   => Yieldmat,
954    cumipmt    => Cumipmt,
955    cumprinc   => Cumprinc,
956    db         => Db,
957    ddb        => Ddb,
958    dollarde   => Dollarde,
959    dollarfr   => Dollarfr,
960    effect     => Effect,
961    fv         => Fv,
962    ipmt       => Ipmt,
963    irr        => Irr,
964    ispmt      => Ispmt,
965    mirr       => Mirr,
966    nominal    => Nominal,
967    nper       => Nper,
968    npv        => Npv,
969    pduration  => Pduration,
970    pmt        => Pmt,
971    ppmt       => Ppmt,
972    pv         => Pv,
973    rate       => Rate,
974    rri        => Rri,
975    sln        => Sln,
976    syd        => Syd,
977    tbilleq    => Tbilleq,
978    tbillprice => Tbillprice,
979    tbillyield => Tbillyield,
980    xirr       => Xirr,
981    xnpv       => Xnpv,
982    duration   => Duration,
983    mduration  => Mduration,
984    price      => Price,
985    r#yield    => Yield,
986    oddfprice  => Oddfprice,
987    oddfyield  => Oddfyield,
988    oddlprice  => Oddlprice,
989    oddlyield  => Oddlyield,
990    coupdaybs  => Coupdaybs,
991    coupdays   => Coupdays,
992    coupdaysnc => Coupdaysnc,
993    coupncd    => Coupncd,
994    coupnum    => Coupnum,
995    couppcd    => Couppcd,
996    amordegrc  => Amordegrc,
997    amorlinc   => Amorlinc,
998    vdb        => Vdb,
999
1000    // Engineering: Bessel and transcendental functions
1001    besseli       => Besseli,
1002    besselj       => Besselj,
1003    besselk       => Besselk,
1004    bessely       => Bessely,
1005    erf           => Erf,
1006    erfc          => Erfc,
1007    erfcprecise   => ErfcPrecise,
1008    erfprecise    => ErfPrecise,
1009
1010    // Engineering: Number systems
1011    bin2dec  => Bin2dec,
1012    bin2hex  => Bin2hex,
1013    bin2oct  => Bin2oct,
1014    dec2bin  => Dec2Bin,
1015    dec2hex  => Dec2hex,
1016    dec2oct  => Dec2oct,
1017    hex2bin  => Hex2bin,
1018    hex2dec  => Hex2dec,
1019    hex2oct  => Hex2oct,
1020    oct2bin  => Oct2bin,
1021    oct2dec  => Oct2dec,
1022    oct2hex  => Oct2hex,
1023
1024    // Engineering: Bit functions
1025    bitand    => Bitand,
1026    bitlshift => Bitlshift,
1027    bitor     => Bitor,
1028    bitrshift => Bitrshift,
1029    bitxor    => Bitxor,
1030
1031    // Engineering: Complex functions
1032    complex     => Complex,
1033    imabs       => Imabs,
1034    imaginary   => Imaginary,
1035    imargument  => Imargument,
1036    imconjugate => Imconjugate,
1037    imcos       => Imcos,
1038    imcosh      => Imcosh,
1039    imcot       => Imcot,
1040    imcsc       => Imcsc,
1041    imcsch      => Imcsch,
1042    imdiv       => Imdiv,
1043    imexp       => Imexp,
1044    imln        => Imln,
1045    imlog10     => Imlog10,
1046    imlog2      => Imlog2,
1047    impower     => Impower,
1048    improduct   => Improduct,
1049    imreal      => Imreal,
1050    imsec       => Imsec,
1051    imsech      => Imsech,
1052    imsin       => Imsin,
1053    imsinh      => Imsinh,
1054    imsqrt      => Imsqrt,
1055    imsub       => Imsub,
1056    imsum       => Imsum,
1057    imtan       => Imtan,
1058
1059    // Engineering: Misc function
1060    convert  => Convert,
1061    delta    => Delta,
1062    gestep   => Gestep,
1063    subtotal => Subtotal,
1064
1065    // Database
1066    daverage => Daverage,
1067    dcount   => Dcount,
1068    dget     => Dget,
1069    dmax     => Dmax,
1070    dmin     => Dmin,
1071    dsum     => Dsum,
1072    dcounta  => Dcounta,
1073    dproduct => Dproduct,
1074    dstdev   => Dstdev,
1075    dvar     => Dvar,
1076    dvarp    => Dvarp,
1077    dstdevp  => Dstdevp,
1078
1079    // More statistical
1080    correl          => Correl,
1081    rsq             => Rsq,
1082    intercept       => Intercept,
1083    slope           => Slope,
1084    steyx           => Steyx,
1085    forecast        => Forecast,
1086    forecastlinear  => ForecastLinear,
1087    forecastets            => ForecastEts,
1088    forecastetsconfint     => ForecastEtsConfint,
1089    forecastetsseasonality => ForecastEtsSeasonality,
1090    forecastetsstat        => ForecastEtsStat,
1091    frequency       => Frequency,
1092    growth          => Growth,
1093    linest          => Linest,
1094    logest          => Logest,
1095    modemult        => ModeMult,
1096    modesngl        => ModeSingl,
1097    percentileexc   => PercentileExc,
1098    percentileinc   => PercentileInc,
1099    percentrankexc  => PercentrankExc,
1100    percentrankinc  => PercentrankInc,
1101    permut          => Permut,
1102    permutationa    => Permutationa,
1103    prob            => Prob,
1104    quartileexc     => QuartileExc,
1105    quartileinc     => QuartileInc,
1106    trend           => Trend,
1107    trimmean        => Trimmean,
1108}
1109
1110impl Function {
1111    pub fn to_localized_name(&self, language: &Language) -> String {
1112        let functions = &language.functions;
1113        match self {
1114            Function::And => functions.and.clone(),
1115            Function::False => functions.r#false.clone(),
1116            Function::If => functions.r#if.clone(),
1117            Function::Iferror => functions.iferror.clone(),
1118            Function::Ifna => functions.ifna.clone(),
1119            Function::Ifs => functions.ifs.clone(),
1120            Function::Lambda => functions.lambda.clone(),
1121            Function::Let => functions.r#let.clone(),
1122            Function::Not => functions.not.clone(),
1123            Function::Or => functions.or.clone(),
1124            Function::Switch => functions.switch.clone(),
1125            Function::True => functions.r#true.clone(),
1126            Function::Xor => functions.xor.clone(),
1127            Function::Bycol => functions.bycol.clone(),
1128            Function::Byrow => functions.byrow.clone(),
1129            Function::Map => functions.map.clone(),
1130            Function::Reduce => functions.reduce.clone(),
1131            Function::Scan => functions.scan.clone(),
1132            Function::Makearray => functions.makearray.clone(),
1133            Function::Abs => functions.abs.clone(),
1134            Function::Acos => functions.acos.clone(),
1135            Function::Acosh => functions.acosh.clone(),
1136            Function::Asin => functions.asin.clone(),
1137            Function::Asinh => functions.asinh.clone(),
1138            Function::Atan => functions.atan.clone(),
1139            Function::Atan2 => functions.atan2.clone(),
1140            Function::Atanh => functions.atanh.clone(),
1141            Function::Choose => functions.choose.clone(),
1142            Function::Column => functions.column.clone(),
1143            Function::Columns => functions.columns.clone(),
1144            Function::Cos => functions.cos.clone(),
1145            Function::Cosh => functions.cosh.clone(),
1146            Function::Log => functions.log.clone(),
1147            Function::Log10 => functions.log10.clone(),
1148            Function::Ln => functions.ln.clone(),
1149            Function::Max => functions.max.clone(),
1150            Function::Min => functions.min.clone(),
1151            Function::Pi => functions.pi.clone(),
1152            Function::Power => functions.power.clone(),
1153            Function::Product => functions.product.clone(),
1154            Function::Rand => functions.rand.clone(),
1155            Function::Randbetween => functions.randbetween.clone(),
1156            Function::Round => functions.round.clone(),
1157            Function::Rounddown => functions.rounddown.clone(),
1158            Function::Roundup => functions.roundup.clone(),
1159            Function::Sin => functions.sin.clone(),
1160            Function::Sinh => functions.sinh.clone(),
1161            Function::Sqrt => functions.sqrt.clone(),
1162            Function::Sqrtpi => functions.sqrtpi.clone(),
1163            Function::Sum => functions.sum.clone(),
1164            Function::Sumif => functions.sumif.clone(),
1165            Function::Sumifs => functions.sumifs.clone(),
1166            Function::Sumx2my2 => functions.sumx2my2.clone(),
1167            Function::Sumx2py2 => functions.sumx2py2.clone(),
1168            Function::Sumxmy2 => functions.sumxmy2.clone(),
1169            Function::Tan => functions.tan.clone(),
1170            Function::Tanh => functions.tanh.clone(),
1171            Function::Acot => functions.acot.clone(),
1172            Function::Acoth => functions.acoth.clone(),
1173            Function::Cot => functions.cot.clone(),
1174            Function::Coth => functions.coth.clone(),
1175            Function::Csc => functions.csc.clone(),
1176            Function::Csch => functions.csch.clone(),
1177            Function::Sec => functions.sec.clone(),
1178            Function::Sech => functions.sech.clone(),
1179            Function::Exp => functions.exp.clone(),
1180            Function::Fact => functions.fact.clone(),
1181            Function::Factdouble => functions.factdouble.clone(),
1182            Function::Sign => functions.sign.clone(),
1183            Function::Radians => functions.radians.clone(),
1184            Function::Degrees => functions.degrees.clone(),
1185            Function::Int => functions.int.clone(),
1186            Function::Even => functions.even.clone(),
1187            Function::Odd => functions.odd.clone(),
1188            Function::Ceiling => functions.ceiling.clone(),
1189            Function::CeilingMath => functions.ceilingmath.clone(),
1190            Function::CeilingPrecise => functions.ceilingprecise.clone(),
1191            Function::Floor => functions.floor.clone(),
1192            Function::FloorMath => functions.floormath.clone(),
1193            Function::FloorPrecise => functions.floorprecise.clone(),
1194            Function::IsoCeiling => functions.isoceiling.clone(),
1195            Function::Mod => functions.r#mod.clone(),
1196            Function::Quotient => functions.quotient.clone(),
1197            Function::Mround => functions.mround.clone(),
1198            Function::Trunc => functions.trunc.clone(),
1199            Function::Gcd => functions.gcd.clone(),
1200            Function::Lcm => functions.lcm.clone(),
1201            Function::Base => functions.base.clone(),
1202            Function::Decimal => functions.decimal.clone(),
1203            Function::Roman => functions.roman.clone(),
1204            Function::Arabic => functions.arabic.clone(),
1205            Function::Combin => functions.combin.clone(),
1206            Function::Combina => functions.combina.clone(),
1207            Function::Sumsq => functions.sumsq.clone(),
1208            Function::Mdeterm => functions.mdeterm.clone(),
1209            Function::Minverse => functions.minverse.clone(),
1210            Function::Munit => functions.munit.clone(),
1211            Function::Multinomial => functions.multinomial.clone(),
1212            Function::Seriessum => functions.seriessum.clone(),
1213            Function::Sumproduct => functions.sumproduct.clone(),
1214            Function::Percentof => functions.percentof.clone(),
1215            Function::ErrorType => functions.errortype.clone(),
1216            Function::Formulatext => functions.formulatext.clone(),
1217            Function::Isblank => functions.isblank.clone(),
1218            Function::Iserr => functions.iserr.clone(),
1219            Function::Iserror => functions.iserror.clone(),
1220            Function::Iseven => functions.iseven.clone(),
1221            Function::Isformula => functions.isformula.clone(),
1222            Function::Islogical => functions.islogical.clone(),
1223            Function::Isna => functions.isna.clone(),
1224            Function::Isnontext => functions.isnontext.clone(),
1225            Function::Isnumber => functions.isnumber.clone(),
1226            Function::Isodd => functions.isodd.clone(),
1227            Function::Isomitted => functions.isomitted.clone(),
1228            Function::Isref => functions.isref.clone(),
1229            Function::Istext => functions.istext.clone(),
1230            Function::Na => functions.na.clone(),
1231            Function::Sheet => functions.sheet.clone(),
1232            Function::Type => functions.r#type.clone(),
1233            Function::Sheets => functions.sheets.clone(),
1234            Function::N => functions.n.clone(),
1235            Function::Cell => functions.cell.clone(),
1236            Function::Info => functions.info.clone(),
1237            Function::Address => functions.address.clone(),
1238            Function::Areas => functions.areas.clone(),
1239            Function::Choosecols => functions.choosecols.clone(),
1240            Function::Chooserows => functions.chooserows.clone(),
1241            Function::Expand => functions.expand.clone(),
1242            Function::Filter => functions.filter.clone(),
1243            Function::Hlookup => functions.hlookup.clone(),
1244            Function::Hstack => functions.hstack.clone(),
1245            Function::Index => functions.index.clone(),
1246            Function::Indirect => functions.indirect.clone(),
1247            Function::Lookup => functions.lookup.clone(),
1248            Function::Match => functions.r#match.clone(),
1249            Function::Offset => functions.offset.clone(),
1250            Function::Row => functions.row.clone(),
1251            Function::Rows => functions.rows.clone(),
1252            Function::Sort => functions.sort.clone(),
1253            Function::Sortby => functions.sortby.clone(),
1254            Function::Unique => functions.unique.clone(),
1255            Function::Vlookup => functions.vlookup.clone(),
1256            Function::Vstack => functions.vstack.clone(),
1257            Function::Wrapcols => functions.wrapcols.clone(),
1258            Function::Wraprows => functions.wraprows.clone(),
1259            Function::Xlookup => functions.xlookup.clone(),
1260            Function::Xmatch => functions.xmatch.clone(),
1261            Function::Trimrange => functions.trimrange.clone(),
1262            Function::Take => functions.take.clone(),
1263            Function::Drop => functions.drop.clone(),
1264            Function::Tocol => functions.tocol.clone(),
1265            Function::Torow => functions.torow.clone(),
1266            Function::Transpose => functions.transpose.clone(),
1267            Function::Mmult => functions.mmult.clone(),
1268            Function::Sequence => functions.sequence.clone(),
1269            Function::Randarray => functions.randarray.clone(),
1270            Function::Concat => functions.concat.clone(),
1271            Function::Textsplit => functions.textsplit.clone(),
1272            Function::Concatenate => functions.concatenate.clone(),
1273            Function::Exact => functions.exact.clone(),
1274            Function::Find => functions.find.clone(),
1275            Function::Left => functions.left.clone(),
1276            Function::Len => functions.len.clone(),
1277            Function::Lower => functions.lower.clone(),
1278            Function::Mid => functions.mid.clone(),
1279            Function::Rept => functions.rept.clone(),
1280            Function::Right => functions.right.clone(),
1281            Function::Search => functions.search.clone(),
1282            Function::Substitute => functions.substitute.clone(),
1283            Function::Regexextract => functions.regexextract.clone(),
1284            Function::Regexreplace => functions.regexreplace.clone(),
1285            Function::Regextest => functions.regextest.clone(),
1286            Function::T => functions.t.clone(),
1287            Function::Text => functions.text.clone(),
1288            Function::Textafter => functions.textafter.clone(),
1289            Function::Textbefore => functions.textbefore.clone(),
1290            Function::Textjoin => functions.textjoin.clone(),
1291            Function::Trim => functions.trim.clone(),
1292            Function::Unicode => functions.unicode.clone(),
1293            Function::Unichar => functions.unichar.clone(),
1294            Function::Char => functions.r#char.clone(),
1295            Function::Clean => functions.clean.clone(),
1296            Function::Code => functions.code.clone(),
1297            Function::Asc => functions.asc.clone(),
1298            Function::Arraytotext => functions.arraytotext.clone(),
1299            Function::Dollar => functions.dollar.clone(),
1300            Function::Findb => functions.findb.clone(),
1301            Function::Fixed => functions.fixed.clone(),
1302            Function::Leftb => functions.leftb.clone(),
1303            Function::Lenb => functions.lenb.clone(),
1304            Function::Midb => functions.midb.clone(),
1305            Function::Numbervalue => functions.numbervalue.clone(),
1306            Function::Proper => functions.proper.clone(),
1307            Function::Replace => functions.replace.clone(),
1308            Function::Replaceb => functions.replaceb.clone(),
1309            Function::Rightb => functions.rightb.clone(),
1310            Function::Searchb => functions.searchb.clone(),
1311            Function::Upper => functions.upper.clone(),
1312            Function::Value => functions.value.clone(),
1313            Function::Valuetotext => functions.valuetotext.clone(),
1314            Function::Average => functions.average.clone(),
1315            Function::Averagea => functions.averagea.clone(),
1316            Function::Averageif => functions.averageif.clone(),
1317            Function::Averageifs => functions.averageifs.clone(),
1318            Function::Count => functions.count.clone(),
1319            Function::Counta => functions.counta.clone(),
1320            Function::Countblank => functions.countblank.clone(),
1321            Function::Countif => functions.countif.clone(),
1322            Function::Countifs => functions.countifs.clone(),
1323            Function::Maxifs => functions.maxifs.clone(),
1324            Function::Minifs => functions.minifs.clone(),
1325            Function::Geomean => functions.geomean.clone(),
1326            Function::Avedev => functions.avedev.clone(),
1327            Function::BetaDist => functions.betadist.clone(),
1328            Function::BetaInv => functions.betainv.clone(),
1329            Function::BinomDist => functions.binomdist.clone(),
1330            Function::BinomDistRange => functions.binomdistrange.clone(),
1331            Function::BinomInv => functions.binominv.clone(),
1332            Function::ChisqDist => functions.chisqdist.clone(),
1333            Function::ChisqDistRT => functions.chisqdistrt.clone(),
1334            Function::ChisqInv => functions.chisqinv.clone(),
1335            Function::ChisqInvRT => functions.chisqinvrt.clone(),
1336            Function::ChisqTest => functions.chisqtest.clone(),
1337            Function::ConfidenceNorm => functions.confidencenorm.clone(),
1338            Function::ConfidenceT => functions.confidencet.clone(),
1339            Function::CovarianceP => functions.covariancep.clone(),
1340            Function::CovarianceS => functions.covariances.clone(),
1341            Function::Devsq => functions.devsq.clone(),
1342            Function::ExponDist => functions.expondist.clone(),
1343            Function::FDist => functions.fdist.clone(),
1344            Function::FDistRT => functions.fdistrt.clone(),
1345            Function::FInv => functions.finv.clone(),
1346            Function::FInvRT => functions.finvrt.clone(),
1347            Function::FTest => functions.ftest.clone(),
1348            Function::Fisher => functions.fisher.clone(),
1349            Function::FisherInv => functions.fisherinv.clone(),
1350            Function::Gamma => functions.gamma.clone(),
1351            Function::GammaDist => functions.gammadist.clone(),
1352            Function::GammaInv => functions.gammainv.clone(),
1353            Function::GammaLn => functions.gammaln.clone(),
1354            Function::GammaLnPrecise => functions.gammalnprecise.clone(),
1355            Function::Gauss => functions.gauss.clone(),
1356            Function::Harmean => functions.harmean.clone(),
1357            Function::HypGeomDist => functions.hypgeomdist.clone(),
1358            Function::Kurt => functions.kurt.clone(),
1359            Function::Large => functions.large.clone(),
1360            Function::LogNormDist => functions.lognormdist.clone(),
1361            Function::LogNormInv => functions.lognorminv.clone(),
1362            Function::MaxA => functions.maxa.clone(),
1363            Function::Median => functions.median.clone(),
1364            Function::MinA => functions.mina.clone(),
1365            Function::NegbinomDist => functions.negbinomdist.clone(),
1366            Function::NormDist => functions.normdist.clone(),
1367            Function::NormInv => functions.norminv.clone(),
1368            Function::NormSdist => functions.normsdist.clone(),
1369            Function::NormSInv => functions.normsinv.clone(),
1370            Function::Pearson => functions.pearson.clone(),
1371            Function::Phi => functions.phi.clone(),
1372            Function::PoissonDist => functions.poissondist.clone(),
1373            Function::RankAvg => functions.rankavg.clone(),
1374            Function::RankEq => functions.rankeq.clone(),
1375            Function::Skew => functions.skew.clone(),
1376            Function::SkewP => functions.skewp.clone(),
1377            Function::Small => functions.small.clone(),
1378            Function::Standardize => functions.standardize.clone(),
1379            Function::Stdev => functions.stdev.clone(),
1380            Function::StDevP => functions.stdevp.clone(),
1381            Function::StDevS => functions.stdevs.clone(),
1382            Function::Stdeva => functions.stdeva.clone(),
1383            Function::Stdevpa => functions.stdevpa.clone(),
1384            Function::TDist => functions.tdist.clone(),
1385            Function::TDist2T => functions.tdist2t.clone(),
1386            Function::TDistRT => functions.tdistrt.clone(),
1387            Function::TInv => functions.tinv.clone(),
1388            Function::TInv2T => functions.tinv2t.clone(),
1389            Function::TTest => functions.ttest.clone(),
1390            Function::VarP => functions.varp.clone(),
1391            Function::VarS => functions.vars.clone(),
1392            Function::VarpA => functions.varpa.clone(),
1393            Function::VarA => functions.vara.clone(),
1394            Function::WeibullDist => functions.weibulldist.clone(),
1395            Function::ZTest => functions.ztest.clone(),
1396            Function::BetaDistCompat => functions.betadistcompat.clone(),
1397            Function::HypGeomDistCompat => functions.hypgeomdistcompat.clone(),
1398            Function::LogNormDistCompat => functions.lognormdistcompat.clone(),
1399            Function::NegbinomDistCompat => functions.negbinomdistcompat.clone(),
1400            Function::NormSDistCompat => functions.normsdistcompat.clone(),
1401            Function::TDistCompat => functions.tdistcompat.clone(),
1402            Function::BetaInvCompat => functions.betainvcompat.clone(),
1403            Function::BinomDistCompat => functions.binomdistcompat.clone(),
1404            Function::ChiDistCompat => functions.chidist.clone(),
1405            Function::ChiInvCompat => functions.chiinv.clone(),
1406            Function::ChiTestCompat => functions.chitest.clone(),
1407            Function::ConfidenceCompat => functions.confidence.clone(),
1408            Function::CovarCompat => functions.covar.clone(),
1409            Function::CritbinomCompat => functions.critbinom.clone(),
1410            Function::ExponDistCompat => functions.expondistcompat.clone(),
1411            Function::FDistCompat => functions.fdistcompat.clone(),
1412            Function::FInvCompat => functions.finvcompat.clone(),
1413            Function::FTestCompat => functions.ftestcompat.clone(),
1414            Function::GammaDistCompat => functions.gammadistcompat.clone(),
1415            Function::GammaInvCompat => functions.gammainvcompat.clone(),
1416            Function::LoginvCompat => functions.loginv.clone(),
1417            Function::ModeCompat => functions.modecompat.clone(),
1418            Function::NormDistCompat => functions.normdistcompat.clone(),
1419            Function::NormInvCompat => functions.norminvcompat.clone(),
1420            Function::NormSInvCompat => functions.normsinvcompat.clone(),
1421            Function::PercentileCompat => functions.percentilecompat.clone(),
1422            Function::PercentrankCompat => functions.percentrankcompat.clone(),
1423            Function::PoissonCompat => functions.poissoncompat.clone(),
1424            Function::QuartileCompat => functions.quartilecompat.clone(),
1425            Function::RankCompat => functions.rankcompat.clone(),
1426            Function::StDevPCompat => functions.stdevpcompat.clone(),
1427            Function::TInvCompat => functions.tinvcompat.clone(),
1428            Function::TTestCompat => functions.ttestcompat.clone(),
1429            Function::VarCompat => functions.varcompat.clone(),
1430            Function::VarPCompat => functions.varpcompat.clone(),
1431            Function::WeibullCompat => functions.weibullcompat.clone(),
1432            Function::ZTestCompat => functions.ztestcompat.clone(),
1433            Function::Date => functions.date.clone(),
1434            Function::Datedif => functions.datedif.clone(),
1435            Function::Datevalue => functions.datevalue.clone(),
1436            Function::Day => functions.day.clone(),
1437            Function::Edate => functions.edate.clone(),
1438            Function::Eomonth => functions.eomonth.clone(),
1439            Function::Month => functions.month.clone(),
1440            Function::Time => functions.time.clone(),
1441            Function::Timevalue => functions.timevalue.clone(),
1442            Function::Hour => functions.hour.clone(),
1443            Function::Minute => functions.minute.clone(),
1444            Function::Second => functions.second.clone(),
1445            Function::Now => functions.now.clone(),
1446            Function::Today => functions.today.clone(),
1447            Function::Year => functions.year.clone(),
1448            Function::Networkdays => functions.networkdays.clone(),
1449            Function::NetworkdaysIntl => functions.networkdaysintl.clone(),
1450            Function::Days => functions.days.clone(),
1451            Function::Days360 => functions.days360.clone(),
1452            Function::Weekday => functions.weekday.clone(),
1453            Function::Weeknum => functions.weeknum.clone(),
1454            Function::Workday => functions.workday.clone(),
1455            Function::WorkdayIntl => functions.workdayintl.clone(),
1456            Function::Yearfrac => functions.yearfrac.clone(),
1457            Function::Isoweeknum => functions.isoweeknum.clone(),
1458            Function::Accrint => functions.accrint.clone(),
1459            Function::Accrintm => functions.accrintm.clone(),
1460            Function::Disc => functions.disc.clone(),
1461            Function::Fvschedule => functions.fvschedule.clone(),
1462            Function::Intrate => functions.intrate.clone(),
1463            Function::Pricedisc => functions.pricedisc.clone(),
1464            Function::Pricemat => functions.pricemat.clone(),
1465            Function::Received => functions.received.clone(),
1466            Function::Yielddisc => functions.yielddisc.clone(),
1467            Function::Yieldmat => functions.yieldmat.clone(),
1468            Function::Cumipmt => functions.cumipmt.clone(),
1469            Function::Cumprinc => functions.cumprinc.clone(),
1470            Function::Db => functions.db.clone(),
1471            Function::Ddb => functions.ddb.clone(),
1472            Function::Dollarde => functions.dollarde.clone(),
1473            Function::Dollarfr => functions.dollarfr.clone(),
1474            Function::Effect => functions.effect.clone(),
1475            Function::Fv => functions.fv.clone(),
1476            Function::Ipmt => functions.ipmt.clone(),
1477            Function::Irr => functions.irr.clone(),
1478            Function::Ispmt => functions.ispmt.clone(),
1479            Function::Mirr => functions.mirr.clone(),
1480            Function::Nominal => functions.nominal.clone(),
1481            Function::Nper => functions.nper.clone(),
1482            Function::Npv => functions.npv.clone(),
1483            Function::Pduration => functions.pduration.clone(),
1484            Function::Pmt => functions.pmt.clone(),
1485            Function::Ppmt => functions.ppmt.clone(),
1486            Function::Pv => functions.pv.clone(),
1487            Function::Rate => functions.rate.clone(),
1488            Function::Rri => functions.rri.clone(),
1489            Function::Sln => functions.sln.clone(),
1490            Function::Syd => functions.syd.clone(),
1491            Function::Tbilleq => functions.tbilleq.clone(),
1492            Function::Tbillprice => functions.tbillprice.clone(),
1493            Function::Tbillyield => functions.tbillyield.clone(),
1494            Function::Xirr => functions.xirr.clone(),
1495            Function::Xnpv => functions.xnpv.clone(),
1496            Function::Duration => functions.duration.clone(),
1497            Function::Mduration => functions.mduration.clone(),
1498            Function::Price => functions.price.clone(),
1499            Function::Yield => functions.r#yield.clone(),
1500            Function::Oddfprice => functions.oddfprice.clone(),
1501            Function::Oddfyield => functions.oddfyield.clone(),
1502            Function::Oddlprice => functions.oddlprice.clone(),
1503            Function::Oddlyield => functions.oddlyield.clone(),
1504            Function::Coupdaybs => functions.coupdaybs.clone(),
1505            Function::Coupdays => functions.coupdays.clone(),
1506            Function::Coupdaysnc => functions.coupdaysnc.clone(),
1507            Function::Coupncd => functions.coupncd.clone(),
1508            Function::Coupnum => functions.coupnum.clone(),
1509            Function::Couppcd => functions.couppcd.clone(),
1510            Function::Amordegrc => functions.amordegrc.clone(),
1511            Function::Amorlinc => functions.amorlinc.clone(),
1512            Function::Vdb => functions.vdb.clone(),
1513            Function::Besseli => functions.besseli.clone(),
1514            Function::Besselj => functions.besselj.clone(),
1515            Function::Besselk => functions.besselk.clone(),
1516            Function::Bessely => functions.bessely.clone(),
1517            Function::Erf => functions.erf.clone(),
1518            Function::Erfc => functions.erfc.clone(),
1519            Function::ErfcPrecise => functions.erfcprecise.clone(),
1520            Function::ErfPrecise => functions.erfprecise.clone(),
1521            Function::Bin2dec => functions.bin2dec.clone(),
1522            Function::Bin2hex => functions.bin2hex.clone(),
1523            Function::Bin2oct => functions.bin2oct.clone(),
1524            Function::Dec2Bin => functions.dec2bin.clone(),
1525            Function::Dec2hex => functions.dec2hex.clone(),
1526            Function::Dec2oct => functions.dec2oct.clone(),
1527            Function::Hex2bin => functions.hex2bin.clone(),
1528            Function::Hex2dec => functions.hex2dec.clone(),
1529            Function::Hex2oct => functions.hex2oct.clone(),
1530            Function::Oct2bin => functions.oct2bin.clone(),
1531            Function::Oct2dec => functions.oct2dec.clone(),
1532            Function::Oct2hex => functions.oct2hex.clone(),
1533            Function::Bitand => functions.bitand.clone(),
1534            Function::Bitlshift => functions.bitlshift.clone(),
1535            Function::Bitor => functions.bitor.clone(),
1536            Function::Bitrshift => functions.bitrshift.clone(),
1537            Function::Bitxor => functions.bitxor.clone(),
1538            Function::Complex => functions.complex.clone(),
1539            Function::Imabs => functions.imabs.clone(),
1540            Function::Imaginary => functions.imaginary.clone(),
1541            Function::Imargument => functions.imargument.clone(),
1542            Function::Imconjugate => functions.imconjugate.clone(),
1543            Function::Imcos => functions.imcos.clone(),
1544            Function::Imcosh => functions.imcosh.clone(),
1545            Function::Imcot => functions.imcot.clone(),
1546            Function::Imcsc => functions.imcsc.clone(),
1547            Function::Imcsch => functions.imcsch.clone(),
1548            Function::Imdiv => functions.imdiv.clone(),
1549            Function::Imexp => functions.imexp.clone(),
1550            Function::Imln => functions.imln.clone(),
1551            Function::Imlog10 => functions.imlog10.clone(),
1552            Function::Imlog2 => functions.imlog2.clone(),
1553            Function::Impower => functions.impower.clone(),
1554            Function::Improduct => functions.improduct.clone(),
1555            Function::Imreal => functions.imreal.clone(),
1556            Function::Imsec => functions.imsec.clone(),
1557            Function::Imsech => functions.imsech.clone(),
1558            Function::Imsin => functions.imsin.clone(),
1559            Function::Imsinh => functions.imsinh.clone(),
1560            Function::Imsqrt => functions.imsqrt.clone(),
1561            Function::Imsub => functions.imsub.clone(),
1562            Function::Imsum => functions.imsum.clone(),
1563            Function::Imtan => functions.imtan.clone(),
1564            Function::Convert => functions.convert.clone(),
1565            Function::Delta => functions.delta.clone(),
1566            Function::Gestep => functions.gestep.clone(),
1567            Function::Subtotal => functions.subtotal.clone(),
1568            Function::Daverage => functions.daverage.clone(),
1569            Function::Dcount => functions.dcount.clone(),
1570            Function::Dget => functions.dget.clone(),
1571            Function::Dmax => functions.dmax.clone(),
1572            Function::Dmin => functions.dmin.clone(),
1573            Function::Dsum => functions.dsum.clone(),
1574            Function::Dcounta => functions.dcounta.clone(),
1575            Function::Dproduct => functions.dproduct.clone(),
1576            Function::Dstdev => functions.dstdev.clone(),
1577            Function::Dvar => functions.dvar.clone(),
1578            Function::Dvarp => functions.dvarp.clone(),
1579            Function::Dstdevp => functions.dstdevp.clone(),
1580            Function::Correl => functions.correl.clone(),
1581            Function::Rsq => functions.rsq.clone(),
1582            Function::Intercept => functions.intercept.clone(),
1583            Function::Slope => functions.slope.clone(),
1584            Function::Steyx => functions.steyx.clone(),
1585            Function::Forecast => functions.forecast.clone(),
1586            Function::ForecastLinear => functions.forecastlinear.clone(),
1587            Function::ForecastEts => functions.forecastets.clone(),
1588            Function::ForecastEtsConfint => functions.forecastetsconfint.clone(),
1589            Function::ForecastEtsSeasonality => functions.forecastetsseasonality.clone(),
1590            Function::ForecastEtsStat => functions.forecastetsstat.clone(),
1591            Function::Frequency => functions.frequency.clone(),
1592            Function::Growth => functions.growth.clone(),
1593            Function::Linest => functions.linest.clone(),
1594            Function::Logest => functions.logest.clone(),
1595            Function::ModeMult => functions.modemult.clone(),
1596            Function::ModeSingl => functions.modesngl.clone(),
1597            Function::PercentileExc => functions.percentileexc.clone(),
1598            Function::PercentileInc => functions.percentileinc.clone(),
1599            Function::PercentrankExc => functions.percentrankexc.clone(),
1600            Function::PercentrankInc => functions.percentrankinc.clone(),
1601            Function::Permut => functions.permut.clone(),
1602            Function::Permutationa => functions.permutationa.clone(),
1603            Function::Prob => functions.prob.clone(),
1604            Function::QuartileExc => functions.quartileexc.clone(),
1605            Function::QuartileInc => functions.quartileinc.clone(),
1606            Function::Trend => functions.trend.clone(),
1607            Function::Trimmean => functions.trimmean.clone(),
1608        }
1609    }
1610
1611    pub fn into_iter() -> IntoIter<Function, 494> {
1612        [
1613            Function::And,
1614            Function::False,
1615            Function::If,
1616            Function::Iferror,
1617            Function::Ifna,
1618            Function::Ifs,
1619            Function::Lambda,
1620            Function::Let,
1621            Function::Not,
1622            Function::Or,
1623            Function::Switch,
1624            Function::True,
1625            Function::Xor,
1626            Function::Bycol,
1627            Function::Byrow,
1628            Function::Map,
1629            Function::Reduce,
1630            Function::Scan,
1631            Function::Makearray,
1632            Function::Sin,
1633            Function::Cos,
1634            Function::Tan,
1635            Function::Asin,
1636            Function::Acos,
1637            Function::Atan,
1638            Function::Sinh,
1639            Function::Cosh,
1640            Function::Tanh,
1641            Function::Asinh,
1642            Function::Acosh,
1643            Function::Atanh,
1644            Function::Abs,
1645            Function::Pi,
1646            Function::Ln,
1647            Function::Log,
1648            Function::Log10,
1649            Function::Sqrt,
1650            Function::Sqrtpi,
1651            Function::Atan2,
1652            Function::Acot,
1653            Function::Acoth,
1654            Function::Cot,
1655            Function::Coth,
1656            Function::Csc,
1657            Function::Csch,
1658            Function::Sec,
1659            Function::Sech,
1660            Function::Power,
1661            Function::Exp,
1662            Function::Fact,
1663            Function::Factdouble,
1664            Function::Sign,
1665            Function::Int,
1666            Function::Even,
1667            Function::Odd,
1668            Function::Ceiling,
1669            Function::CeilingMath,
1670            Function::CeilingPrecise,
1671            Function::Floor,
1672            Function::FloorMath,
1673            Function::FloorPrecise,
1674            Function::IsoCeiling,
1675            Function::Mod,
1676            Function::Quotient,
1677            Function::Mround,
1678            Function::Trunc,
1679            Function::Gcd,
1680            Function::Lcm,
1681            Function::Base,
1682            Function::Decimal,
1683            Function::Max,
1684            Function::Min,
1685            Function::Product,
1686            Function::Rand,
1687            Function::Randbetween,
1688            Function::Radians,
1689            Function::Degrees,
1690            Function::Round,
1691            Function::Rounddown,
1692            Function::Roundup,
1693            Function::Sum,
1694            Function::Sumif,
1695            Function::Sumifs,
1696            Function::Sumx2my2,
1697            Function::Sumx2py2,
1698            Function::Sumxmy2,
1699            Function::Address,
1700            Function::Areas,
1701            Function::Choose,
1702            Function::Choosecols,
1703            Function::Chooserows,
1704            Function::Column,
1705            Function::Columns,
1706            Function::Expand,
1707            Function::Index,
1708            Function::Indirect,
1709            Function::Hlookup,
1710            Function::Hstack,
1711            Function::Filter,
1712            Function::Lookup,
1713            Function::Match,
1714            Function::Offset,
1715            Function::Row,
1716            Function::Rows,
1717            Function::Sort,
1718            Function::Sortby,
1719            Function::Unique,
1720            Function::Vlookup,
1721            Function::Vstack,
1722            Function::Wrapcols,
1723            Function::Wraprows,
1724            Function::Xlookup,
1725            Function::Xmatch,
1726            Function::Trimrange,
1727            Function::Take,
1728            Function::Drop,
1729            Function::Tocol,
1730            Function::Torow,
1731            Function::Transpose,
1732            Function::Mmult,
1733            Function::Sequence,
1734            Function::Randarray,
1735            Function::Concatenate,
1736            Function::Exact,
1737            Function::Value,
1738            Function::T,
1739            Function::Valuetotext,
1740            Function::Concat,
1741            Function::Find,
1742            Function::Left,
1743            Function::Len,
1744            Function::Lower,
1745            Function::Mid,
1746            Function::Right,
1747            Function::Search,
1748            Function::Text,
1749            Function::Trim,
1750            Function::Unicode,
1751            Function::Unichar,
1752            Function::Char,
1753            Function::Clean,
1754            Function::Code,
1755            Function::Asc,
1756            Function::Arraytotext,
1757            Function::Dollar,
1758            Function::Findb,
1759            Function::Fixed,
1760            Function::Leftb,
1761            Function::Lenb,
1762            Function::Midb,
1763            Function::Numbervalue,
1764            Function::Proper,
1765            Function::Replace,
1766            Function::Replaceb,
1767            Function::Rightb,
1768            Function::Searchb,
1769            Function::Upper,
1770            Function::Isnumber,
1771            Function::Isnontext,
1772            Function::Istext,
1773            Function::Islogical,
1774            Function::Isblank,
1775            Function::Iserr,
1776            Function::Iserror,
1777            Function::Isna,
1778            Function::Na,
1779            Function::Isref,
1780            Function::Isodd,
1781            Function::Iseven,
1782            Function::ErrorType,
1783            Function::Formulatext,
1784            Function::Isformula,
1785            Function::Isomitted,
1786            Function::Type,
1787            Function::Sheet,
1788            Function::Average,
1789            Function::Avedev,
1790            Function::Averagea,
1791            Function::Averageif,
1792            Function::Averageifs,
1793            Function::Count,
1794            Function::Counta,
1795            Function::Countblank,
1796            Function::Countif,
1797            Function::Countifs,
1798            Function::Maxifs,
1799            Function::Minifs,
1800            Function::Geomean,
1801            Function::Year,
1802            Function::Day,
1803            Function::Month,
1804            Function::Eomonth,
1805            Function::Date,
1806            Function::Datedif,
1807            Function::Datevalue,
1808            Function::Edate,
1809            Function::Networkdays,
1810            Function::NetworkdaysIntl,
1811            Function::Time,
1812            Function::Timevalue,
1813            Function::Hour,
1814            Function::Minute,
1815            Function::Second,
1816            Function::Today,
1817            Function::Now,
1818            Function::Days,
1819            Function::Days360,
1820            Function::Weekday,
1821            Function::Weeknum,
1822            Function::Workday,
1823            Function::WorkdayIntl,
1824            Function::Yearfrac,
1825            Function::Isoweeknum,
1826            Function::Pmt,
1827            Function::Pv,
1828            Function::Rate,
1829            Function::Nper,
1830            Function::Fv,
1831            Function::Ppmt,
1832            Function::Ipmt,
1833            Function::Npv,
1834            Function::Mirr,
1835            Function::Irr,
1836            Function::Xirr,
1837            Function::Xnpv,
1838            Function::Rept,
1839            Function::Textafter,
1840            Function::Textbefore,
1841            Function::Textsplit,
1842            Function::Textjoin,
1843            Function::Substitute,
1844            Function::Regexextract,
1845            Function::Regexreplace,
1846            Function::Regextest,
1847            Function::Ispmt,
1848            Function::Rri,
1849            Function::Sln,
1850            Function::Syd,
1851            Function::Nominal,
1852            Function::Effect,
1853            Function::Pduration,
1854            Function::Tbillyield,
1855            Function::Tbillprice,
1856            Function::Tbilleq,
1857            Function::Dollarde,
1858            Function::Dollarfr,
1859            Function::Ddb,
1860            Function::Db,
1861            Function::Cumprinc,
1862            Function::Cumipmt,
1863            Function::Accrint,
1864            Function::Accrintm,
1865            Function::Disc,
1866            Function::Fvschedule,
1867            Function::Intrate,
1868            Function::Pricedisc,
1869            Function::Pricemat,
1870            Function::Received,
1871            Function::Yielddisc,
1872            Function::Yieldmat,
1873            Function::Duration,
1874            Function::Mduration,
1875            Function::Price,
1876            Function::Yield,
1877            Function::Oddfprice,
1878            Function::Oddfyield,
1879            Function::Oddlprice,
1880            Function::Oddlyield,
1881            Function::Coupdaybs,
1882            Function::Coupdays,
1883            Function::Coupdaysnc,
1884            Function::Coupncd,
1885            Function::Coupnum,
1886            Function::Couppcd,
1887            Function::Amordegrc,
1888            Function::Amorlinc,
1889            Function::Vdb,
1890            Function::Besseli,
1891            Function::Besselj,
1892            Function::Besselk,
1893            Function::Bessely,
1894            Function::Erf,
1895            Function::ErfPrecise,
1896            Function::Erfc,
1897            Function::ErfcPrecise,
1898            Function::Bin2dec,
1899            Function::Bin2hex,
1900            Function::Bin2oct,
1901            Function::Dec2Bin,
1902            Function::Dec2hex,
1903            Function::Dec2oct,
1904            Function::Hex2bin,
1905            Function::Hex2dec,
1906            Function::Hex2oct,
1907            Function::Oct2bin,
1908            Function::Oct2dec,
1909            Function::Oct2hex,
1910            Function::Bitand,
1911            Function::Bitlshift,
1912            Function::Bitor,
1913            Function::Bitrshift,
1914            Function::Bitxor,
1915            Function::Complex,
1916            Function::Imabs,
1917            Function::Imaginary,
1918            Function::Imargument,
1919            Function::Imconjugate,
1920            Function::Imcos,
1921            Function::Imcosh,
1922            Function::Imcot,
1923            Function::Imcsc,
1924            Function::Imcsch,
1925            Function::Imdiv,
1926            Function::Imexp,
1927            Function::Imln,
1928            Function::Imlog10,
1929            Function::Imlog2,
1930            Function::Impower,
1931            Function::Improduct,
1932            Function::Imreal,
1933            Function::Imsec,
1934            Function::Imsech,
1935            Function::Imsin,
1936            Function::Imsinh,
1937            Function::Imsqrt,
1938            Function::Imsub,
1939            Function::Imsum,
1940            Function::Imtan,
1941            Function::Convert,
1942            Function::Delta,
1943            Function::Gestep,
1944            Function::Subtotal,
1945            Function::Roman,
1946            Function::Arabic,
1947            Function::Combin,
1948            Function::Combina,
1949            Function::Sumsq,
1950            Function::Mdeterm,
1951            Function::Minverse,
1952            Function::Munit,
1953            Function::Multinomial,
1954            Function::Seriessum,
1955            Function::Sumproduct,
1956            Function::Percentof,
1957            Function::N,
1958            Function::Cell,
1959            Function::Info,
1960            Function::Sheets,
1961            Function::Daverage,
1962            Function::Dcount,
1963            Function::Dget,
1964            Function::Dmax,
1965            Function::Dmin,
1966            Function::Dsum,
1967            Function::Dcounta,
1968            Function::Dproduct,
1969            Function::Dstdev,
1970            Function::Dvar,
1971            Function::Dvarp,
1972            Function::Dstdevp,
1973            Function::BetaDist,
1974            Function::BetaInv,
1975            Function::BinomDist,
1976            Function::BinomDistRange,
1977            Function::BinomInv,
1978            Function::ChisqDist,
1979            Function::ChisqDistRT,
1980            Function::ChisqInv,
1981            Function::ChisqInvRT,
1982            Function::ChisqTest,
1983            Function::ConfidenceNorm,
1984            Function::ConfidenceT,
1985            Function::CovarianceP,
1986            Function::CovarianceS,
1987            Function::Devsq,
1988            Function::ExponDist,
1989            Function::FDist,
1990            Function::FDistRT,
1991            Function::FInv,
1992            Function::FInvRT,
1993            Function::FTest,
1994            Function::Fisher,
1995            Function::FisherInv,
1996            Function::Gamma,
1997            Function::GammaDist,
1998            Function::GammaInv,
1999            Function::GammaLn,
2000            Function::GammaLnPrecise,
2001            Function::HypGeomDist,
2002            Function::LogNormDist,
2003            Function::LogNormInv,
2004            Function::NegbinomDist,
2005            Function::NormDist,
2006            Function::NormInv,
2007            Function::NormSdist,
2008            Function::NormSInv,
2009            Function::Pearson,
2010            Function::Phi,
2011            Function::PoissonDist,
2012            Function::Standardize,
2013            Function::Stdev,
2014            Function::StDevP,
2015            Function::StDevS,
2016            Function::Stdeva,
2017            Function::Stdevpa,
2018            Function::TDist,
2019            Function::TDist2T,
2020            Function::TDistRT,
2021            Function::TInv,
2022            Function::TInv2T,
2023            Function::TTest,
2024            Function::VarP,
2025            Function::VarS,
2026            Function::VarpA,
2027            Function::VarA,
2028            Function::WeibullDist,
2029            Function::ZTest,
2030            Function::BetaDistCompat,
2031            Function::HypGeomDistCompat,
2032            Function::LogNormDistCompat,
2033            Function::NegbinomDistCompat,
2034            Function::NormSDistCompat,
2035            Function::TDistCompat,
2036            Function::BetaInvCompat,
2037            Function::BinomDistCompat,
2038            Function::ChiDistCompat,
2039            Function::ChiInvCompat,
2040            Function::ChiTestCompat,
2041            Function::ConfidenceCompat,
2042            Function::CovarCompat,
2043            Function::CritbinomCompat,
2044            Function::ExponDistCompat,
2045            Function::FDistCompat,
2046            Function::FInvCompat,
2047            Function::FTestCompat,
2048            Function::GammaDistCompat,
2049            Function::GammaInvCompat,
2050            Function::LoginvCompat,
2051            Function::ModeCompat,
2052            Function::NormDistCompat,
2053            Function::NormInvCompat,
2054            Function::NormSInvCompat,
2055            Function::PercentileCompat,
2056            Function::PercentrankCompat,
2057            Function::PoissonCompat,
2058            Function::QuartileCompat,
2059            Function::RankCompat,
2060            Function::StDevPCompat,
2061            Function::TInvCompat,
2062            Function::TTestCompat,
2063            Function::VarCompat,
2064            Function::VarPCompat,
2065            Function::WeibullCompat,
2066            Function::ZTestCompat,
2067            Function::Correl,
2068            Function::Rsq,
2069            Function::Intercept,
2070            Function::Slope,
2071            Function::Steyx,
2072            Function::Forecast,
2073            Function::ForecastLinear,
2074            Function::ForecastEts,
2075            Function::ForecastEtsConfint,
2076            Function::ForecastEtsSeasonality,
2077            Function::ForecastEtsStat,
2078            Function::Frequency,
2079            Function::Growth,
2080            Function::Linest,
2081            Function::Logest,
2082            Function::ModeMult,
2083            Function::ModeSingl,
2084            Function::PercentileExc,
2085            Function::PercentileInc,
2086            Function::PercentrankExc,
2087            Function::PercentrankInc,
2088            Function::Permut,
2089            Function::Permutationa,
2090            Function::Prob,
2091            Function::QuartileExc,
2092            Function::QuartileInc,
2093            Function::Trend,
2094            Function::Trimmean,
2095            Function::Large,
2096            Function::Median,
2097            Function::Small,
2098            Function::RankAvg,
2099            Function::RankEq,
2100            Function::Skew,
2101            Function::SkewP,
2102            Function::Harmean,
2103            Function::Gauss,
2104            Function::Kurt,
2105            Function::MaxA,
2106            Function::MinA,
2107        ]
2108        .into_iter()
2109    }
2110}
2111
2112impl Function {
2113    /// Some functions in Excel like CONCAT are stringified as `_xlfn.CONCAT`. (known as "future functions")
2114    /// FILTER and SORT are stringified as `_xlfn._xlws.FILTER`. (known as "worksheet only functions")
2115    /// See <https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/3d025add-118d-4413-9856-ab65712ec1b0>
2116    pub fn to_xlsx_string(&self) -> String {
2117        match self {
2118            Function::Concat => "_xlfn.CONCAT".to_string(),
2119            Function::Ifna => "_xlfn.IFNA".to_string(),
2120            Function::Ifs => "_xlfn.IFS".to_string(),
2121            Function::Lambda => "_xlfn.LAMBDA".to_string(),
2122            Function::Let => "_xlfn.LET".to_string(),
2123            Function::Maxifs => "_xlfn.MAXIFS".to_string(),
2124            Function::Minifs => "_xlfn.MINIFS".to_string(),
2125            Function::Switch => "_xlfn.SWITCH".to_string(),
2126            Function::Filter => "_xlfn._xlws.FILTER".to_string(),
2127            Function::Sort => "_xlfn._xlws.SORT".to_string(),
2128            Function::Sortby => "_xlfn.SORTBY".to_string(),
2129            Function::Unique => "_xlfn.UNIQUE".to_string(),
2130            Function::Xlookup => "_xlfn.XLOOKUP".to_string(),
2131            Function::Xmatch => "_xlfn.XMATCH".to_string(),
2132            Function::Trimrange => "_xlfn.TRIMRANGE".to_string(),
2133            Function::Take => "_xlfn.TAKE".to_string(),
2134            Function::Drop => "_xlfn.DROP".to_string(),
2135            Function::Tocol => "_xlfn.TOCOL".to_string(),
2136            Function::Torow => "_xlfn.TOROW".to_string(),
2137            Function::Choosecols => "_xlfn.CHOOSECOLS".to_string(),
2138            Function::Chooserows => "_xlfn.CHOOSEROWS".to_string(),
2139            Function::Expand => "_xlfn.EXPAND".to_string(),
2140            Function::Hstack => "_xlfn.HSTACK".to_string(),
2141            Function::Vstack => "_xlfn.VSTACK".to_string(),
2142            Function::Wrapcols => "_xlfn.WRAPCOLS".to_string(),
2143            Function::Wraprows => "_xlfn.WRAPROWS".to_string(),
2144            Function::Bycol => "_xlfn.BYCOL".to_string(),
2145            Function::Byrow => "_xlfn.BYROW".to_string(),
2146            Function::Map => "_xlfn.MAP".to_string(),
2147            Function::Reduce => "_xlfn.REDUCE".to_string(),
2148            Function::Scan => "_xlfn.SCAN".to_string(),
2149            Function::Makearray => "_xlfn.MAKEARRAY".to_string(),
2150            Function::Xor => "_xlfn.XOR".to_string(),
2151            Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
2152            Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
2153            Function::Textsplit => "_xlfn.TEXTSPLIT".to_string(),
2154            Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
2155            Function::Sequence => "_xlfn.SEQUENCE".to_string(),
2156            Function::Randarray => "_xlfn.RANDARRAY".to_string(),
2157            Function::Unicode => "_xlfn.UNICODE".to_string(),
2158            Function::Unichar => "_xlfn.UNICHAR".to_string(),
2159            Function::Numbervalue => "_xlfn.NUMBERVALUE".to_string(),
2160            Function::Arraytotext => "_xlfn.ARRAYTOTEXT".to_string(),
2161            Function::Rri => "_xlfn.RRI".to_string(),
2162            Function::Pduration => "_xlfn.PDURATION".to_string(),
2163            Function::Bitand => "_xlfn.BITAND".to_string(),
2164            Function::Bitor => "_xlfn.BITOR".to_string(),
2165            Function::Bitxor => "_xlfn.BITXOR".to_string(),
2166            Function::Bitlshift => "_xlfn.BITLSHIFT".to_string(),
2167            Function::Bitrshift => "_xlfn.BITRSHIFT".to_string(),
2168            Function::Imtan => "_xlfn.IMTAN".to_string(),
2169            Function::Imsinh => "_xlfn.IMSINH".to_string(),
2170            Function::Imcosh => "_xlfn.IMCOSH".to_string(),
2171            Function::Imcot => "_xlfn.IMCOT".to_string(),
2172            Function::Imcsc => "_xlfn.IMCSC".to_string(),
2173            Function::Imcsch => "_xlfn.IMCSCH".to_string(),
2174            Function::Imsec => "_xlfn.IMSEC".to_string(),
2175            Function::ErfcPrecise => "_xlfn.ERFC.PRECISE".to_string(),
2176            Function::ErfPrecise => "_xlfn.ERF.PRECISE".to_string(),
2177            Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
2178            Function::Regexextract => "_xlfn.REGEXEXTRACT".to_string(),
2179            Function::Regexreplace => "_xlfn.REGEXREPLACE".to_string(),
2180            Function::Regextest => "_xlfn.REGEXTEST".to_string(),
2181            Function::Isformula => "_xlfn.ISFORMULA".to_string(),
2182            Function::Isomitted => "_xlfn.ISOMITTED".to_string(),
2183            Function::Sheet => "_xlfn.SHEET".to_string(),
2184            Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
2185            Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
2186            Function::Ceiling => "_xlfn.CEILING".to_string(),
2187            Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
2188            Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
2189            Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
2190            Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
2191            Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
2192            Function::Base => "_xlfn.BASE".to_string(),
2193            Function::Decimal => "_xlfn.DECIMAL".to_string(),
2194            Function::Arabic => "_xlfn.ARABIC".to_string(),
2195            Function::Combina => "_xlfn.COMBINA".to_string(),
2196            Function::Sheets => "_xlfn.SHEETS".to_string(),
2197            Function::Acoth => "_xlfn.ACOTH".to_string(),
2198            Function::Cot => "_xlfn.COT".to_string(),
2199            Function::Coth => "_xlfn.COTH".to_string(),
2200            Function::Csc => "_xlfn.CSC".to_string(),
2201            Function::Csch => "_xlfn.CSCH".to_string(),
2202            Function::Sec => "_xlfn.SEC".to_string(),
2203            Function::Sech => "_xlfn.SECH".to_string(),
2204            Function::Acot => "_xlfn.ACOT".to_string(),
2205            Function::GammaLnPrecise => "_xlfn.GAMMALN.PRECISE".to_string(),
2206            Function::Gamma => "_xlfn.GAMMA".to_string(),
2207            Function::GammaInv => "_xlfn.GAMMA.INV".to_string(),
2208            Function::GammaLn => "_xlfn.GAMMALN".to_string(),
2209            Function::BetaDist => "_xlfn.BETA.DIST".to_string(),
2210            Function::BetaInv => "_xlfn.BETA.INV".to_string(),
2211
2212            Function::BinomDist => "_xlfn.BINOM.DIST".to_string(),
2213            Function::BinomDistRange => "_xlfn.BINOM.DIST.RANGE".to_string(),
2214            Function::BinomInv => "_xlfn.BINOM.INV".to_string(),
2215            Function::NegbinomDist => "_xlfn.NEGBINOM.DIST".to_string(),
2216
2217            Function::ChisqDist => "_xlfn.CHISQ.DIST".to_string(),
2218            Function::ChisqDistRT => "_xlfn.CHISQ.DIST.RT".to_string(),
2219            Function::ChisqInv => "_xlfn.CHISQ.INV".to_string(),
2220            Function::ChisqInvRT => "_xlfn.CHISQ.INV.RT".to_string(),
2221            Function::ChisqTest => "_xlfn.CHISQ.TEST".to_string(),
2222
2223            Function::ConfidenceNorm => "_xlfn.CONFIDENCE.NORM".to_string(),
2224            Function::ConfidenceT => "_xlfn.CONFIDENCE.T".to_string(),
2225
2226            Function::CovarianceP => "_xlfn.COVARIANCE.P".to_string(),
2227            Function::CovarianceS => "_xlfn.COVARIANCE.S".to_string(),
2228
2229            Function::ExponDist => "_xlfn.EXPON.DIST".to_string(),
2230
2231            Function::FDist => "_xlfn.F.DIST".to_string(),
2232            Function::FDistRT => "_xlfn.F.DIST.RT".to_string(),
2233            Function::FInv => "_xlfn.F.INV".to_string(),
2234            Function::FInvRT => "_xlfn.F.INV.RT".to_string(),
2235            Function::FTest => "_xlfn.F.TEST".to_string(),
2236
2237            Function::HypGeomDist => "_xlfn.HYPGEOM.DIST".to_string(),
2238
2239            Function::LogNormDist => "_xlfn.LOGNORM.DIST".to_string(),
2240            Function::LogNormInv => "_xlfn.LOGNORM.INV".to_string(),
2241
2242            Function::NormDist => "_xlfn.NORM.DIST".to_string(),
2243            Function::NormInv => "_xlfn.NORM.INV".to_string(),
2244            Function::NormSdist => "_xlfn.NORM.S.DIST".to_string(),
2245            Function::NormSInv => "_xlfn.NORM.S.INV".to_string(),
2246
2247            Function::Phi => "_xlfn.PHI".to_string(),
2248
2249            Function::PoissonDist => "_xlfn.POISSON.DIST".to_string(),
2250
2251            Function::StDevP => "_xlfn.STDEV.P".to_string(),
2252            Function::StDevS => "_xlfn.STDEV.S".to_string(),
2253
2254            Function::TDist => "_xlfn.T.DIST".to_string(),
2255            Function::TDist2T => "_xlfn.T.DIST.2T".to_string(),
2256            Function::TDistRT => "_xlfn.T.DIST.RT".to_string(),
2257            Function::TInv => "_xlfn.T.INV".to_string(),
2258            Function::TInv2T => "_xlfn.T.INV.2T".to_string(),
2259            Function::TTest => "_xlfn.T.TEST".to_string(),
2260
2261            Function::VarP => "_xlfn.VAR.P".to_string(),
2262            Function::VarS => "_xlfn.VAR.S".to_string(),
2263
2264            Function::WeibullDist => "_xlfn.WEIBULL.DIST".to_string(),
2265            Function::ZTest => "_xlfn.Z.TEST".to_string(),
2266            Function::SkewP => "_xlfn.SKEW.P".to_string(),
2267            Function::RankAvg => "_xlfn.RANK.AVG".to_string(),
2268            Function::RankEq => "_xlfn.RANK.EQ".to_string(),
2269            Function::Munit => "_xlfn.MUNIT".to_string(),
2270
2271            Function::ModeMult => "_xlfn.MODE.MULT".to_string(),
2272            Function::ModeSingl => "_xlfn.MODE.SNGL".to_string(),
2273            Function::PercentileExc => "_xlfn.PERCENTILE.EXC".to_string(),
2274            Function::PercentileInc => "_xlfn.PERCENTILE.INC".to_string(),
2275            Function::PercentrankExc => "_xlfn.PERCENTRANK.EXC".to_string(),
2276            Function::PercentrankInc => "_xlfn.PERCENTRANK.INC".to_string(),
2277            Function::Permutationa => "_xlfn.PERMUTATIONA".to_string(),
2278            Function::QuartileExc => "_xlfn.QUARTILE.EXC".to_string(),
2279            Function::QuartileInc => "_xlfn.QUARTILE.INC".to_string(),
2280
2281            Function::ForecastEts => "_xlfn.FORECAST.ETS".to_string(),
2282            Function::ForecastEtsConfint => "_xlfn.FORECAST.ETS.CONFINT".to_string(),
2283            Function::ForecastEtsSeasonality => "_xlfn.FORECAST.ETS.SEASONALITY".to_string(),
2284            Function::ForecastEtsStat => "_xlfn.FORECAST.ETS.STAT".to_string(),
2285
2286            _ => {
2287                let language = get_default_language();
2288                self.to_localized_name(language)
2289            }
2290        }
2291    }
2292
2293    pub(crate) fn returns_reference(&self) -> bool {
2294        matches!(self, Function::Indirect | Function::Offset)
2295    }
2296}
2297
2298impl<'a> Model<'a> {
2299    pub(crate) fn evaluate_function(
2300        &mut self,
2301        kind: &Function,
2302        args: &[Node],
2303        cell: CellReferenceIndex,
2304    ) -> CalcResult {
2305        match kind {
2306            Function::And => self.fn_and(args, cell),
2307            Function::False => self.fn_false(args, cell),
2308            Function::If => self.fn_if(args, cell),
2309            Function::Iferror => self.fn_iferror(args, cell),
2310            Function::Ifna => self.fn_ifna(args, cell),
2311            Function::Ifs => self.fn_ifs(args, cell),
2312            Function::Lambda => self.fn_lambda(args, cell),
2313            Function::Let => self.fn_let(args, cell),
2314            Function::Not => self.fn_not(args, cell),
2315            Function::Or => self.fn_or(args, cell),
2316            Function::Switch => self.fn_switch(args, cell),
2317            Function::True => self.fn_true(args, cell),
2318            Function::Xor => self.fn_xor(args, cell),
2319            Function::Bycol => self.fn_bycol(args, cell),
2320            Function::Byrow => self.fn_byrow(args, cell),
2321            Function::Map => self.fn_map(args, cell),
2322            Function::Reduce => self.fn_reduce(args, cell),
2323            Function::Scan => self.fn_scan(args, cell),
2324            Function::Makearray => self.fn_makearray(args, cell),
2325            Function::Log => self.fn_log(args, cell),
2326            Function::Log10 => self.fn_log10(args, cell),
2327            Function::Ln => self.fn_ln(args, cell),
2328            Function::Sin => self.fn_sin(args, cell),
2329            Function::Cos => self.fn_cos(args, cell),
2330            Function::Tan => self.fn_tan(args, cell),
2331            Function::Asin => self.fn_asin(args, cell),
2332            Function::Acos => self.fn_acos(args, cell),
2333            Function::Atan => self.fn_atan(args, cell),
2334            Function::Sinh => self.fn_sinh(args, cell),
2335            Function::Cosh => self.fn_cosh(args, cell),
2336            Function::Tanh => self.fn_tanh(args, cell),
2337            Function::Asinh => self.fn_asinh(args, cell),
2338            Function::Acosh => self.fn_acosh(args, cell),
2339            Function::Atanh => self.fn_atanh(args, cell),
2340            Function::Pi => self.fn_pi(args, cell),
2341            Function::Abs => self.fn_abs(args, cell),
2342            Function::Sqrt => self.fn_sqrt(args, cell),
2343            Function::Sqrtpi => self.fn_sqrtpi(args, cell),
2344            Function::Atan2 => self.fn_atan2(args, cell),
2345            Function::Power => self.fn_power(args, cell),
2346            Function::Max => self.fn_max(args, cell),
2347            Function::Min => self.fn_min(args, cell),
2348            Function::Product => self.fn_product(args, cell),
2349            Function::Rand => self.fn_rand(args, cell),
2350            Function::Randbetween => self.fn_randbetween(args, cell),
2351            Function::Round => self.fn_round(args, cell),
2352            Function::Rounddown => self.fn_rounddown(args, cell),
2353            Function::Roundup => self.fn_roundup(args, cell),
2354            Function::Sum => self.fn_sum(args, cell),
2355            Function::Sumif => self.fn_sumif(args, cell),
2356            Function::Sumifs => self.fn_sumifs(args, cell),
2357            Function::Choose => self.fn_choose(args, cell),
2358            Function::Column => self.fn_column(args, cell),
2359            Function::Address => self.fn_address(args, cell),
2360            Function::Areas => self.fn_areas(args, cell),
2361            Function::Columns => self.fn_columns(args, cell),
2362            Function::Choosecols => self.fn_choosecols(args, cell),
2363            Function::Chooserows => self.fn_chooserows(args, cell),
2364            Function::Expand => self.fn_expand(args, cell),
2365            Function::Index => self.fn_index(args, cell),
2366            Function::Indirect => self.fn_indirect(args, cell),
2367            Function::Hlookup => self.fn_hlookup(args, cell),
2368            Function::Hstack => self.fn_hstack(args, cell),
2369            Function::Lookup => self.fn_lookup(args, cell),
2370            Function::Match => self.fn_match(args, cell),
2371            Function::Offset => self.fn_offset(args, cell),
2372            Function::Row => self.fn_row(args, cell),
2373            Function::Rows => self.fn_rows(args, cell),
2374            Function::Filter => self.fn_filter(args, cell),
2375            Function::Sort => self.fn_sort(args, cell),
2376            Function::Sortby => self.fn_sortby(args, cell),
2377            Function::Unique => self.fn_unique(args, cell),
2378            Function::Vlookup => self.fn_vlookup(args, cell),
2379            Function::Vstack => self.fn_vstack(args, cell),
2380            Function::Wrapcols => self.fn_wrapcols(args, cell),
2381            Function::Wraprows => self.fn_wraprows(args, cell),
2382            Function::Xlookup => self.fn_xlookup(args, cell),
2383            Function::Xmatch => self.fn_xmatch(args, cell),
2384            Function::Trimrange => self.fn_trimrange(args, cell),
2385            Function::Take => self.fn_take(args, cell),
2386            Function::Drop => self.fn_drop(args, cell),
2387            Function::Tocol => self.fn_tocol(args, cell),
2388            Function::Torow => self.fn_torow(args, cell),
2389            Function::Transpose => self.fn_transpose(args, cell),
2390            Function::Mmult => self.fn_mmult(args, cell),
2391            Function::Sequence => self.fn_sequence(args, cell),
2392            Function::Randarray => self.fn_randarray(args, cell),
2393            Function::Concatenate => self.fn_concatenate(args, cell),
2394            Function::Exact => self.fn_exact(args, cell),
2395            Function::Value => self.fn_value(args, cell),
2396            Function::T => self.fn_t(args, cell),
2397            Function::Valuetotext => self.fn_valuetotext(args, cell),
2398            Function::Concat => self.fn_concat(args, cell),
2399            Function::Find => self.fn_find(args, cell),
2400            Function::Left => self.fn_left(args, cell),
2401            Function::Len => self.fn_len(args, cell),
2402            Function::Lower => self.fn_lower(args, cell),
2403            Function::Mid => self.fn_mid(args, cell),
2404            Function::Right => self.fn_right(args, cell),
2405            Function::Search => self.fn_search(args, cell),
2406            Function::Text => self.fn_text(args, cell),
2407            Function::Trim => self.fn_trim(args, cell),
2408            Function::Unicode => self.fn_unicode(args, cell),
2409            Function::Unichar => self.fn_unichar(args, cell),
2410            Function::Char => self.fn_char(args, cell),
2411            Function::Clean => self.fn_clean(args, cell),
2412            Function::Code => self.fn_code(args, cell),
2413            Function::Asc => self.fn_asc(args, cell),
2414            Function::Arraytotext => self.fn_arraytotext(args, cell),
2415            Function::Dollar => self.fn_dollar(args, cell),
2416            Function::Findb => self.fn_findb(args, cell),
2417            Function::Fixed => self.fn_fixed(args, cell),
2418            Function::Leftb => self.fn_leftb(args, cell),
2419            Function::Lenb => self.fn_lenb(args, cell),
2420            Function::Midb => self.fn_midb(args, cell),
2421            Function::Numbervalue => self.fn_numbervalue(args, cell),
2422            Function::Proper => self.fn_proper(args, cell),
2423            Function::Replace => self.fn_replace(args, cell),
2424            Function::Replaceb => self.fn_replaceb(args, cell),
2425            Function::Rightb => self.fn_rightb(args, cell),
2426            Function::Searchb => self.fn_searchb(args, cell),
2427            Function::Upper => self.fn_upper(args, cell),
2428            Function::Isnumber => self.fn_isnumber(args, cell),
2429            Function::Isnontext => self.fn_isnontext(args, cell),
2430            Function::Istext => self.fn_istext(args, cell),
2431            Function::Islogical => self.fn_islogical(args, cell),
2432            Function::Isblank => self.fn_isblank(args, cell),
2433            Function::Iserr => self.fn_iserr(args, cell),
2434            Function::Iserror => self.fn_iserror(args, cell),
2435            Function::Isna => self.fn_isna(args, cell),
2436            Function::Na => CalcResult::new_error(Error::NA, cell, "".to_string()),
2437            Function::Isref => self.fn_isref(args, cell),
2438            Function::Isodd => self.fn_isodd(args, cell),
2439            Function::Isomitted => self.fn_isomitted(args, cell),
2440            Function::Iseven => self.fn_iseven(args, cell),
2441            Function::ErrorType => self.fn_errortype(args, cell),
2442            Function::Formulatext => self.fn_formulatext(args, cell),
2443            Function::Isformula => self.fn_isformula(args, cell),
2444            Function::Type => self.fn_type(args, cell),
2445            Function::Sheet => self.fn_sheet(args, cell),
2446            Function::Average => self.fn_average(args, cell),
2447            Function::Averagea => self.fn_averagea(args, cell),
2448            Function::Avedev => self.fn_avedev(args, cell),
2449            Function::Averageif => self.fn_averageif(args, cell),
2450            Function::Averageifs => self.fn_averageifs(args, cell),
2451            Function::Count => self.fn_count(args, cell),
2452            Function::Counta => self.fn_counta(args, cell),
2453            Function::Countblank => self.fn_countblank(args, cell),
2454            Function::Countif => self.fn_countif(args, cell),
2455            Function::Countifs => self.fn_countifs(args, cell),
2456            Function::Maxifs => self.fn_maxifs(args, cell),
2457            Function::Minifs => self.fn_minifs(args, cell),
2458            Function::Geomean => self.fn_geomean(args, cell),
2459            Function::Year => self.fn_year(args, cell),
2460            Function::Day => self.fn_day(args, cell),
2461            Function::Eomonth => self.fn_eomonth(args, cell),
2462            Function::Month => self.fn_month(args, cell),
2463            Function::Date => self.fn_date(args, cell),
2464            Function::Datedif => self.fn_datedif(args, cell),
2465            Function::Datevalue => self.fn_datevalue(args, cell),
2466            Function::Edate => self.fn_edate(args, cell),
2467            Function::Networkdays => self.fn_networkdays(args, cell),
2468            Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
2469            Function::Time => self.fn_time(args, cell),
2470            Function::Timevalue => self.fn_timevalue(args, cell),
2471            Function::Hour => self.fn_hour(args, cell),
2472            Function::Minute => self.fn_minute(args, cell),
2473            Function::Second => self.fn_second(args, cell),
2474            Function::Today => self.fn_today(args, cell),
2475            Function::Now => self.fn_now(args, cell),
2476            Function::Days => self.fn_days(args, cell),
2477            Function::Days360 => self.fn_days360(args, cell),
2478            Function::Weekday => self.fn_weekday(args, cell),
2479            Function::Weeknum => self.fn_weeknum(args, cell),
2480            Function::Workday => self.fn_workday(args, cell),
2481            Function::WorkdayIntl => self.fn_workday_intl(args, cell),
2482            Function::Yearfrac => self.fn_yearfrac(args, cell),
2483            Function::Isoweeknum => self.fn_isoweeknum(args, cell),
2484            Function::Pmt => self.fn_pmt(args, cell),
2485            Function::Pv => self.fn_pv(args, cell),
2486            Function::Rate => self.fn_rate(args, cell),
2487            Function::Nper => self.fn_nper(args, cell),
2488            Function::Fv => self.fn_fv(args, cell),
2489            Function::Ppmt => self.fn_ppmt(args, cell),
2490            Function::Ipmt => self.fn_ipmt(args, cell),
2491            Function::Npv => self.fn_npv(args, cell),
2492            Function::Mirr => self.fn_mirr(args, cell),
2493            Function::Irr => self.fn_irr(args, cell),
2494            Function::Xirr => self.fn_xirr(args, cell),
2495            Function::Xnpv => self.fn_xnpv(args, cell),
2496            Function::Rept => self.fn_rept(args, cell),
2497            Function::Textafter => self.fn_textafter(args, cell),
2498            Function::Textbefore => self.fn_textbefore(args, cell),
2499            Function::Textsplit => self.fn_textsplit(args, cell),
2500            Function::Textjoin => self.fn_textjoin(args, cell),
2501            Function::Substitute => self.fn_substitute(args, cell),
2502            Function::Regexextract => self.fn_regexextract(args, cell),
2503            Function::Regexreplace => self.fn_regexreplace(args, cell),
2504            Function::Regextest => self.fn_regextest(args, cell),
2505            Function::Ispmt => self.fn_ispmt(args, cell),
2506            Function::Rri => self.fn_rri(args, cell),
2507            Function::Sln => self.fn_sln(args, cell),
2508            Function::Syd => self.fn_syd(args, cell),
2509            Function::Nominal => self.fn_nominal(args, cell),
2510            Function::Effect => self.fn_effect(args, cell),
2511            Function::Pduration => self.fn_pduration(args, cell),
2512            Function::Tbillyield => self.fn_tbillyield(args, cell),
2513            Function::Tbillprice => self.fn_tbillprice(args, cell),
2514            Function::Tbilleq => self.fn_tbilleq(args, cell),
2515            Function::Dollarde => self.fn_dollarde(args, cell),
2516            Function::Dollarfr => self.fn_dollarfr(args, cell),
2517            Function::Ddb => self.fn_ddb(args, cell),
2518            Function::Db => self.fn_db(args, cell),
2519            Function::Cumprinc => self.fn_cumprinc(args, cell),
2520            Function::Cumipmt => self.fn_cumipmt(args, cell),
2521            Function::Accrint => self.fn_accrint(args, cell),
2522            Function::Accrintm => self.fn_accrintm(args, cell),
2523            Function::Disc => self.fn_disc(args, cell),
2524            Function::Fvschedule => self.fn_fvschedule(args, cell),
2525            Function::Intrate => self.fn_intrate(args, cell),
2526            Function::Pricedisc => self.fn_pricedisc(args, cell),
2527            Function::Pricemat => self.fn_pricemat(args, cell),
2528            Function::Received => self.fn_received(args, cell),
2529            Function::Yielddisc => self.fn_yielddisc(args, cell),
2530            Function::Yieldmat => self.fn_yieldmat(args, cell),
2531            Function::Duration => self.fn_duration(args, cell),
2532            Function::Mduration => self.fn_mduration(args, cell),
2533            Function::Price => self.fn_price(args, cell),
2534            Function::Yield => self.fn_yield(args, cell),
2535            Function::Oddfprice => self.fn_oddfprice(args, cell),
2536            Function::Oddfyield => self.fn_oddfyield(args, cell),
2537            Function::Oddlprice => self.fn_oddlprice(args, cell),
2538            Function::Oddlyield => self.fn_oddlyield(args, cell),
2539            Function::Coupdaybs => self.fn_coupdaybs(args, cell),
2540            Function::Coupdays => self.fn_coupdays(args, cell),
2541            Function::Coupdaysnc => self.fn_coupdaysnc(args, cell),
2542            Function::Coupncd => self.fn_coupncd(args, cell),
2543            Function::Coupnum => self.fn_coupnum(args, cell),
2544            Function::Couppcd => self.fn_couppcd(args, cell),
2545            Function::Amordegrc => self.fn_amordegrc(args, cell),
2546            Function::Amorlinc => self.fn_amorlinc(args, cell),
2547            Function::Vdb => self.fn_vdb(args, cell),
2548            Function::Besseli => self.fn_besseli(args, cell),
2549            Function::Besselj => self.fn_besselj(args, cell),
2550            Function::Besselk => self.fn_besselk(args, cell),
2551            Function::Bessely => self.fn_bessely(args, cell),
2552            Function::Erf => self.fn_erf(args, cell),
2553            Function::ErfPrecise => self.fn_erfprecise(args, cell),
2554            Function::Erfc => self.fn_erfc(args, cell),
2555            Function::ErfcPrecise => self.fn_erfcprecise(args, cell),
2556            Function::Bin2dec => self.fn_bin2dec(args, cell),
2557            Function::Bin2hex => self.fn_bin2hex(args, cell),
2558            Function::Bin2oct => self.fn_bin2oct(args, cell),
2559            Function::Dec2Bin => self.fn_dec2bin(args, cell),
2560            Function::Dec2hex => self.fn_dec2hex(args, cell),
2561            Function::Dec2oct => self.fn_dec2oct(args, cell),
2562            Function::Hex2bin => self.fn_hex2bin(args, cell),
2563            Function::Hex2dec => self.fn_hex2dec(args, cell),
2564            Function::Hex2oct => self.fn_hex2oct(args, cell),
2565            Function::Oct2bin => self.fn_oct2bin(args, cell),
2566            Function::Oct2dec => self.fn_oct2dec(args, cell),
2567            Function::Oct2hex => self.fn_oct2hex(args, cell),
2568            Function::Bitand => self.fn_bitand(args, cell),
2569            Function::Bitlshift => self.fn_bitlshift(args, cell),
2570            Function::Bitor => self.fn_bitor(args, cell),
2571            Function::Bitrshift => self.fn_bitrshift(args, cell),
2572            Function::Bitxor => self.fn_bitxor(args, cell),
2573            Function::Complex => self.fn_complex(args, cell),
2574            Function::Imabs => self.fn_imabs(args, cell),
2575            Function::Imaginary => self.fn_imaginary(args, cell),
2576            Function::Imargument => self.fn_imargument(args, cell),
2577            Function::Imconjugate => self.fn_imconjugate(args, cell),
2578            Function::Imcos => self.fn_imcos(args, cell),
2579            Function::Imcosh => self.fn_imcosh(args, cell),
2580            Function::Imcot => self.fn_imcot(args, cell),
2581            Function::Imcsc => self.fn_imcsc(args, cell),
2582            Function::Imcsch => self.fn_imcsch(args, cell),
2583            Function::Imdiv => self.fn_imdiv(args, cell),
2584            Function::Imexp => self.fn_imexp(args, cell),
2585            Function::Imln => self.fn_imln(args, cell),
2586            Function::Imlog10 => self.fn_imlog10(args, cell),
2587            Function::Imlog2 => self.fn_imlog2(args, cell),
2588            Function::Impower => self.fn_impower(args, cell),
2589            Function::Improduct => self.fn_improduct(args, cell),
2590            Function::Imreal => self.fn_imreal(args, cell),
2591            Function::Imsec => self.fn_imsec(args, cell),
2592            Function::Imsech => self.fn_imsech(args, cell),
2593            Function::Imsin => self.fn_imsin(args, cell),
2594            Function::Imsinh => self.fn_imsinh(args, cell),
2595            Function::Imsqrt => self.fn_imsqrt(args, cell),
2596            Function::Imsub => self.fn_imsub(args, cell),
2597            Function::Imsum => self.fn_imsum(args, cell),
2598            Function::Imtan => self.fn_imtan(args, cell),
2599            Function::Convert => self.fn_convert(args, cell),
2600            Function::Delta => self.fn_delta(args, cell),
2601            Function::Gestep => self.fn_gestep(args, cell),
2602            Function::Subtotal => self.fn_subtotal(args, cell),
2603            Function::Acot => self.fn_acot(args, cell),
2604            Function::Acoth => self.fn_acoth(args, cell),
2605            Function::Cot => self.fn_cot(args, cell),
2606            Function::Coth => self.fn_coth(args, cell),
2607            Function::Csc => self.fn_csc(args, cell),
2608            Function::Csch => self.fn_csch(args, cell),
2609            Function::Sec => self.fn_sec(args, cell),
2610            Function::Sech => self.fn_sech(args, cell),
2611            Function::Exp => self.fn_exp(args, cell),
2612            Function::Fact => self.fn_fact(args, cell),
2613            Function::Factdouble => self.fn_factdouble(args, cell),
2614            Function::Sign => self.fn_sign(args, cell),
2615            Function::Radians => self.fn_radians(args, cell),
2616            Function::Degrees => self.fn_degrees(args, cell),
2617            Function::Int => self.fn_int(args, cell),
2618            Function::Even => self.fn_even(args, cell),
2619            Function::Odd => self.fn_odd(args, cell),
2620            Function::Ceiling => self.fn_ceiling(args, cell),
2621            Function::CeilingMath => self.fn_ceiling_math(args, cell),
2622            Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
2623            Function::Floor => self.fn_floor(args, cell),
2624            Function::FloorMath => self.fn_floor_math(args, cell),
2625            Function::FloorPrecise => self.fn_floor_precise(args, cell),
2626            Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
2627            Function::Mod => self.fn_mod(args, cell),
2628            Function::Quotient => self.fn_quotient(args, cell),
2629            Function::Mround => self.fn_mround(args, cell),
2630            Function::Trunc => self.fn_trunc(args, cell),
2631            Function::Gcd => self.fn_gcd(args, cell),
2632            Function::Lcm => self.fn_lcm(args, cell),
2633            Function::Base => self.fn_base(args, cell),
2634            Function::Decimal => self.fn_decimal(args, cell),
2635            Function::Roman => self.fn_roman(args, cell),
2636            Function::Arabic => self.fn_arabic(args, cell),
2637            Function::Combin => self.fn_combin(args, cell),
2638            Function::Combina => self.fn_combina(args, cell),
2639            Function::Sumsq => self.fn_sumsq(args, cell),
2640            Function::Mdeterm => self.fn_mdeterm(args, cell),
2641            Function::Minverse => self.fn_minverse(args, cell),
2642            Function::Munit => self.fn_munit(args, cell),
2643            Function::Multinomial => self.fn_multinomial(args, cell),
2644            Function::Seriessum => self.fn_seriessum(args, cell),
2645            Function::Sumproduct => self.fn_sumproduct(args, cell),
2646            Function::Percentof => self.fn_percentof(args, cell),
2647            Function::N => self.fn_n(args, cell),
2648            Function::Cell => self.fn_cell(args, cell),
2649            Function::Info => self.fn_info(args, cell),
2650            Function::Sheets => self.fn_sheets(args, cell),
2651            Function::Daverage => self.fn_daverage(args, cell),
2652            Function::Dcount => self.fn_dcount(args, cell),
2653            Function::Dget => self.fn_dget(args, cell),
2654            Function::Dmax => self.fn_dmax(args, cell),
2655            Function::Dmin => self.fn_dmin(args, cell),
2656            Function::Dsum => self.fn_dsum(args, cell),
2657            Function::Dcounta => self.fn_dcounta(args, cell),
2658            Function::Dproduct => self.fn_dproduct(args, cell),
2659            Function::Dstdev => self.fn_dstdev(args, cell),
2660            Function::Dvar => self.fn_dvar(args, cell),
2661            Function::Dvarp => self.fn_dvarp(args, cell),
2662            Function::Dstdevp => self.fn_dstdevp(args, cell),
2663            Function::BetaDist => self.fn_beta_dist(args, cell),
2664            Function::BetaInv => self.fn_beta_inv(args, cell),
2665            Function::BinomDist => self.fn_binom_dist(args, cell),
2666            Function::BinomDistRange => self.fn_binom_dist_range(args, cell),
2667            Function::BinomInv => self.fn_binom_inv(args, cell),
2668            Function::ChisqDist => self.fn_chisq_dist(args, cell),
2669            Function::ChisqDistRT => self.fn_chisq_dist_rt(args, cell),
2670            Function::ChisqInv => self.fn_chisq_inv(args, cell),
2671            Function::ChisqInvRT => self.fn_chisq_inv_rt(args, cell),
2672            Function::ChisqTest => self.fn_chisq_test(args, cell),
2673            Function::ConfidenceNorm => self.fn_confidence_norm(args, cell),
2674            Function::ConfidenceT => self.fn_confidence_t(args, cell),
2675            Function::CovarianceP => self.fn_covariance_p(args, cell),
2676            Function::CovarianceS => self.fn_covariance_s(args, cell),
2677            Function::Devsq => self.fn_devsq(args, cell),
2678            Function::ExponDist => self.fn_expon_dist(args, cell),
2679            Function::FDist => self.fn_f_dist(args, cell),
2680            Function::FDistRT => self.fn_f_dist_rt(args, cell),
2681            Function::FInv => self.fn_f_inv(args, cell),
2682            Function::FInvRT => self.fn_f_inv_rt(args, cell),
2683            Function::Fisher => self.fn_fisher(args, cell),
2684            Function::FisherInv => self.fn_fisher_inv(args, cell),
2685            Function::FTest => self.fn_f_test(args, cell),
2686            Function::Gamma => self.fn_gamma(args, cell),
2687            Function::GammaDist => self.fn_gamma_dist(args, cell),
2688            Function::GammaInv => self.fn_gamma_inv(args, cell),
2689            Function::GammaLn => self.fn_gamma_ln(args, cell),
2690            Function::GammaLnPrecise => self.fn_gamma_ln_precise(args, cell),
2691            Function::HypGeomDist => self.fn_hyp_geom_dist(args, cell),
2692            Function::LogNormDist => self.fn_log_norm_dist(args, cell),
2693            Function::LogNormInv => self.fn_log_norm_inv(args, cell),
2694            Function::NegbinomDist => self.fn_negbinom_dist(args, cell),
2695            Function::NormDist => self.fn_norm_dist(args, cell),
2696            Function::NormInv => self.fn_norm_inv(args, cell),
2697            Function::NormSdist => self.fn_norm_s_dist(args, cell),
2698            Function::NormSInv => self.fn_norm_s_inv(args, cell),
2699            Function::Pearson => self.fn_pearson(args, cell),
2700            Function::Phi => self.fn_phi(args, cell),
2701            Function::PoissonDist => self.fn_poisson_dist(args, cell),
2702            Function::Standardize => self.fn_standardize(args, cell),
2703            Function::Stdev => self.fn_stdev_s(args, cell),
2704            Function::StDevP => self.fn_stdev_p(args, cell),
2705            Function::StDevS => self.fn_stdev_s(args, cell),
2706            Function::Stdeva => self.fn_stdeva(args, cell),
2707            Function::Stdevpa => self.fn_stdevpa(args, cell),
2708            Function::TDist => self.fn_t_dist(args, cell),
2709            Function::TDist2T => self.fn_t_dist_2t(args, cell),
2710            Function::TDistRT => self.fn_t_dist_rt(args, cell),
2711            Function::TInv => self.fn_t_inv(args, cell),
2712            Function::TInv2T => self.fn_t_inv_2t(args, cell),
2713            Function::TTest => self.fn_t_test(args, cell),
2714            Function::VarP => self.fn_var_p(args, cell),
2715            Function::VarS => self.fn_var_s(args, cell),
2716            Function::VarpA => self.fn_varpa(args, cell),
2717            Function::VarA => self.fn_vara(args, cell),
2718            Function::WeibullDist => self.fn_weibull_dist(args, cell),
2719            Function::ZTest => self.fn_z_test(args, cell),
2720            Function::BetaDistCompat => self.fn_betadist_compat(args, cell),
2721            Function::HypGeomDistCompat => self.fn_hypgeomdist_compat(args, cell),
2722            Function::LogNormDistCompat => self.fn_lognormdist_compat(args, cell),
2723            Function::NegbinomDistCompat => self.fn_negbinomdist_compat(args, cell),
2724            Function::NormSDistCompat => self.fn_normsdist_compat(args, cell),
2725            Function::TDistCompat => self.fn_tdist_compat(args, cell),
2726            Function::BetaInvCompat => self.fn_beta_inv(args, cell),
2727            Function::BinomDistCompat => self.fn_binom_dist(args, cell),
2728            Function::ChiDistCompat => self.fn_chisq_dist_rt(args, cell),
2729            Function::ChiInvCompat => self.fn_chisq_inv_rt(args, cell),
2730            Function::ChiTestCompat => self.fn_chisq_test(args, cell),
2731            Function::ConfidenceCompat => self.fn_confidence_norm(args, cell),
2732            Function::CovarCompat => self.fn_covariance_p(args, cell),
2733            Function::CritbinomCompat => self.fn_binom_inv(args, cell),
2734            Function::ExponDistCompat => self.fn_expon_dist(args, cell),
2735            Function::FDistCompat => self.fn_f_dist_rt(args, cell),
2736            Function::FInvCompat => self.fn_f_inv_rt(args, cell),
2737            Function::FTestCompat => self.fn_f_test(args, cell),
2738            Function::GammaDistCompat => self.fn_gamma_dist(args, cell),
2739            Function::GammaInvCompat => self.fn_gamma_inv(args, cell),
2740            Function::LoginvCompat => self.fn_log_norm_inv(args, cell),
2741            Function::ModeCompat => self.fn_mode_sngl(args, cell),
2742            Function::NormDistCompat => self.fn_norm_dist(args, cell),
2743            Function::NormInvCompat => self.fn_norm_inv(args, cell),
2744            Function::NormSInvCompat => self.fn_norm_s_inv(args, cell),
2745            Function::PercentileCompat => self.fn_percentile_inc(args, cell),
2746            Function::PercentrankCompat => self.fn_percentrank_inc(args, cell),
2747            Function::PoissonCompat => self.fn_poisson_dist(args, cell),
2748            Function::QuartileCompat => self.fn_quartile_inc(args, cell),
2749            Function::RankCompat => self.fn_rank_eq(args, cell),
2750            Function::StDevPCompat => self.fn_stdev_p(args, cell),
2751            Function::TInvCompat => self.fn_t_inv_2t(args, cell),
2752            Function::TTestCompat => self.fn_t_test(args, cell),
2753            Function::VarCompat => self.fn_var_s(args, cell),
2754            Function::VarPCompat => self.fn_var_p(args, cell),
2755            Function::WeibullCompat => self.fn_weibull_dist(args, cell),
2756            Function::ZTestCompat => self.fn_z_test(args, cell),
2757            Function::Sumx2my2 => self.fn_sumx2my2(args, cell),
2758            Function::Sumx2py2 => self.fn_sumx2py2(args, cell),
2759            Function::Sumxmy2 => self.fn_sumxmy2(args, cell),
2760            Function::Correl => self.fn_correl(args, cell),
2761            Function::Rsq => self.fn_rsq(args, cell),
2762            Function::Intercept => self.fn_intercept(args, cell),
2763            Function::Slope => self.fn_slope(args, cell),
2764            Function::Steyx => self.fn_steyx(args, cell),
2765            Function::Forecast => self.fn_forecast(args, cell),
2766            Function::ForecastLinear => self.fn_forecast_linear(args, cell),
2767            Function::ForecastEts => self.fn_forecast_ets(args, cell),
2768            Function::ForecastEtsConfint => self.fn_forecast_ets_confint(args, cell),
2769            Function::ForecastEtsSeasonality => self.fn_forecast_ets_seasonality(args, cell),
2770            Function::ForecastEtsStat => self.fn_forecast_ets_stat(args, cell),
2771            Function::Frequency => self.fn_frequency(args, cell),
2772            Function::Growth => self.fn_growth(args, cell),
2773            Function::Linest => self.fn_linest(args, cell),
2774            Function::Logest => self.fn_logest(args, cell),
2775            Function::ModeMult => self.fn_mode_mult(args, cell),
2776            Function::ModeSingl => self.fn_mode_sngl(args, cell),
2777            Function::PercentileExc => self.fn_percentile_exc(args, cell),
2778            Function::PercentileInc => self.fn_percentile_inc(args, cell),
2779            Function::PercentrankExc => self.fn_percentrank_exc(args, cell),
2780            Function::PercentrankInc => self.fn_percentrank_inc(args, cell),
2781            Function::Permut => self.fn_permut(args, cell),
2782            Function::Permutationa => self.fn_permutationa(args, cell),
2783            Function::Prob => self.fn_prob(args, cell),
2784            Function::QuartileExc => self.fn_quartile_exc(args, cell),
2785            Function::QuartileInc => self.fn_quartile_inc(args, cell),
2786            Function::Trend => self.fn_trend(args, cell),
2787            Function::Trimmean => self.fn_trimmean(args, cell),
2788            Function::Gauss => self.fn_gauss(args, cell),
2789            Function::Harmean => self.fn_harmean(args, cell),
2790            Function::Kurt => self.fn_kurt(args, cell),
2791            Function::Large => self.fn_large(args, cell),
2792            Function::MaxA => self.fn_maxa(args, cell),
2793            Function::Median => self.fn_median(args, cell),
2794            Function::MinA => self.fn_mina(args, cell),
2795            Function::RankAvg => self.fn_rank_avg(args, cell),
2796            Function::RankEq => self.fn_rank_eq(args, cell),
2797            Function::Skew => self.fn_skew(args, cell),
2798            Function::SkewP => self.fn_skew_p(args, cell),
2799            Function::Small => self.fn_small(args, cell),
2800        }
2801    }
2802}
2803
2804#[cfg(test)]
2805mod tests {
2806    #![allow(clippy::unwrap_used)]
2807    use std::{
2808        fs::File,
2809        io::{BufRead, BufReader},
2810    };
2811
2812    #[test]
2813    fn function_iterator() {
2814        // This checks that the number of functions in the enum is the same
2815        // as the number of functions in the Iterator.
2816
2817        // This is tricky. In Rust we cannot loop over all the members of an enum.
2818        // There are alternatives like using an external crate like strum.
2819        // But I am not in the mood for that.
2820
2821        // What we do here is read this file , extract the functions in the enum
2822        // and check they are the same as in the iterator
2823        let file = File::open("src/functions/mod.rs").unwrap();
2824        let reader = BufReader::new(file);
2825        let mut start = false;
2826        let mut list = Vec::new();
2827
2828        for line in reader.lines() {
2829            let text = line.unwrap();
2830            let text = text.trim().trim_end_matches(',');
2831            if text == "pub enum Function {" {
2832                start = true;
2833                continue;
2834            }
2835            if start {
2836                if text == "}" {
2837                    break;
2838                }
2839                if text.starts_with("//") {
2840                    // skip comments
2841                    continue;
2842                }
2843                if text.is_empty() {
2844                    // skip empty lines
2845                    continue;
2846                }
2847                list.push(text.to_owned());
2848            }
2849        }
2850        // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
2851        // let iter_list = Function::into_iter()
2852        //     .map(|f| format!("{f}").replace('.', ""))
2853        //     .collect::<Vec<_>>();
2854
2855        // let len = iter_list.len();
2856
2857        // assert_eq!(list.len(), len);
2858        // // We still need to check there are no duplicates. This will fail if a function in iter_list
2859        // // is included twice and one is missing
2860        // for function in list {
2861        //     assert!(iter_list.contains(&function.to_uppercase()));
2862        // }
2863    }
2864}