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

ironcalc_base/functions/
mod.rs
