Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

111 KB
Raw Blame
use std::array::IntoIter;

use crate::{
    calc_result::CalcResult,
    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
    language::{get_default_language, Functions, Language},
    model::Model,
};

mod aggregate; // MACRO
pub(crate) mod binary_search;
mod database;
pub(crate) mod date_and_time;
mod engineering;
mod financial;
mod getpivotdata; // MACRO
pub use getpivotdata::{PivotField, PivotItem, PivotLayout, PivotLine}; // MACRO
mod information;
mod lift; // MACRO
mod logical;
mod lookup_and_reference;
mod macros;
mod math_and_trigonometry;
// MACRO
#[cfg(target_arch = "wasm32")]
pub use math_and_trigonometry::set_random_seed;
mod spill_functions;
mod statistical;
mod subtotal;
pub use subtotal::FilteredRange; // MACRO
mod text;
pub(crate) mod util;
mod xlookup;

/// List of all implemented functions
#[derive(PartialEq, Clone, Debug)]
pub enum Function {
    // Logical
    And,
    False,
    If,
    Iferror,
    Ifna,
    Ifs,
    Lambda,
    Let,
    Not,
    Or,
    Switch,
    True,
    Xor,
    Bycol,
    Byrow,
    Map,
    Reduce,
    Scan,
    Makearray,

    // Mathematical and trigonometry
    Abs,
    Acos,
    Acosh,
    Asin,
    Asinh,
    Atan,
    Atan2,
    Atanh,
    Choose,
    Column,
    Columns,
    Cos,
    Cosh,
    Log,
    Log10,
    Ln,
    Max,
    Min,
    Pi,
    Power,
    Product,
    Rand,
    Randbetween,
    Round,
    Rounddown,
    Roundup,
    Sin,
    Sinh,
    Sqrt,
    Sqrtpi,
    Sum,
    Sumif,
    Sumifs,
    Sumx2my2,
    Sumx2py2,
    Sumxmy2,
    Tan,
    Tanh,
    Acot,
    Acoth,
    Cot,
    Coth,
    Csc,
    Csch,
    Sec,
    Sech,
    Exp,
    Fact,
    Factdouble,
    Sign,
    Radians,
    Degrees,
    Int,
    Even,
    Odd,
    Ceiling,
    CeilingMath,
    CeilingPrecise,
    Floor,
    FloorMath,
    FloorPrecise,
    IsoCeiling,
    Mod,
    Quotient,
    Mround,
    Trunc,
    Gcd,
    Lcm,
    Base,
    Decimal,
    Roman,
    Arabic,
    Combin,
    Combina,
    Sumsq,
    Mdeterm,
    Minverse,
    Munit,
    Multinomial,
    Seriessum,
    Sumproduct,
    Percentof,

    // Information
    ErrorType,
    Formulatext,
    Isblank,
    Iserr,
    Iserror,
    Iseven,
    Isformula,
    Islogical,
    Isna,
    Isnontext,
    Isnumber,
    Isodd,
    Isomitted,
    Isref,
    Istext,
    Na,
    Sheet,
    Type,

    Sheets,
    N,
    Cell,
    Info,

    // Lookup and reference
    Address,
    Areas,
    Choosecols,
    Chooserows,
    Expand,
    Filter,
    Hlookup,
    Hstack,
    Hyperlink,
    Index,
    Indirect,
    Lookup,
    Match,
    Offset,
    Row,
    Rows,
    Sort,
    Sortby,
    Unique,
    Vlookup,
    Vstack,
    Wrapcols,
    Wraprows,
    Xlookup,
    Xmatch,
    Trimrange,
    Take,
    Drop,
    Tocol,
    Torow,
    Transpose,
    Mmult,

    // Dynamic array
    Sequence,
    Randarray,

    // Text
    Concat,
    Textsplit,
    Concatenate,
    Exact,
    Find,
    Left,
    Len,
    Lower,
    Mid,
    Rept,
    Right,
    Search,
    Substitute,
    Regexextract,
    Regexreplace,
    Regextest,
    T,
    Text,
    Textafter,
    Textbefore,
    Textjoin,
    Trim,
    Unicode,
    Unichar,
    Char,
    Clean,
    Code,
    Asc,
    Arraytotext,
    Dollar,
    Encodeurl,
    Findb,
    Fixed,
    Leftb,
    Lenb,
    Midb,
    Numbervalue,
    Proper,
    Replace,
    Replaceb,
    Rightb,
    Searchb,
    Upper,
    Value,
    Valuetotext,

    // Statistical
    Average,
    Averagea,
    Averageif,
    Averageifs,
    Count,
    Counta,
    Countblank,
    Countif,
    Countifs,
    Maxifs,
    Minifs,
    Geomean,

    Frequency,
    Growth,

    Avedev,
    BetaDist,
    BetaInv,
    BinomDist,
    BinomDistRange,
    BinomInv,
    ChisqDist,
    ChisqDistRT,
    ChisqInv,
    ChisqInvRT,
    ChisqTest,
    ConfidenceNorm,
    ConfidenceT,
    CovarianceP,
    CovarianceS,
    Devsq,
    ExponDist,
    FDist,
    FDistRT,
    FInv,
    FInvRT,
    FTest,
    Fisher,
    FisherInv,
    Forecast,
    ForecastLinear,
    ForecastEts,
    ForecastEtsConfint,
    ForecastEtsSeasonality,
    ForecastEtsStat,
    Gamma,
    GammaDist,
    GammaInv,
    GammaLn,
    GammaLnPrecise,
    Gauss,
    Harmean,
    HypGeomDist,
    Kurt,
    Large,
    Linest,
    Logest,
    LogNormDist,
    LogNormInv,
    MaxA,
    Median,
    MinA,
    ModeMult,
    ModeSingl,
    NegbinomDist,
    NormDist,
    NormInv,
    NormSdist,
    NormSInv,
    Pearson,
    PercentileExc,
    PercentileInc,
    PercentrankExc,
    PercentrankInc,
    Permut,
    Permutationa,
    Phi,
    PoissonDist,
    Prob,
    QuartileExc,
    QuartileInc,
    RankAvg,
    RankEq,
    Skew,
    SkewP,
    Small,
    Standardize,
    Stdev,
    StDevP,
    StDevS,
    Stdeva,
    Stdevpa,
    TDist,
    TDist2T,
    TDistRT,
    TInv,
    TInv2T,
    TTest,
    Trend,
    Trimmean,
    VarP,
    VarS,
    VarpA,
    VarA,
    WeibullDist,
    ZTest,

    // Compatibility — wrappers
    BetaDistCompat,
    HypGeomDistCompat,
    LogNormDistCompat,
    NegbinomDistCompat,
    NormSDistCompat,
    TDistCompat,
    // Compatibility — aliases
    BetaInvCompat,
    BinomDistCompat,
    ChiDistCompat,
    ChiInvCompat,
    ChiTestCompat,
    ConfidenceCompat,
    CovarCompat,
    CritbinomCompat,
    ExponDistCompat,
    FDistCompat,
    FInvCompat,
    FTestCompat,
    GammaDistCompat,
    GammaInvCompat,
    LoginvCompat,
    ModeCompat,
    NormDistCompat,
    NormInvCompat,
    NormSInvCompat,
    PercentileCompat,
    PercentrankCompat,
    PoissonCompat,
    QuartileCompat,
    RankCompat,
    StDevPCompat,
    TInvCompat,
    TTestCompat,
    VarCompat,
    VarPCompat,
    WeibullCompat,
    ZTestCompat,

    // Date and time
    Date,
    Datedif,
    Datevalue,
    Day,
    Edate,
    Eomonth,
    Month,
    Time,
    Timevalue,
    Hour,
    Minute,
    Second,
    Now,
    Today,
    Year,
    Networkdays,
    NetworkdaysIntl,
    Days,
    Days360,
    Weekday,
    Weeknum,
    Workday,
    WorkdayIntl,
    Yearfrac,
    Isoweeknum,

    // Financial
    Accrint,
    Accrintm,
    Disc,
    Fvschedule,
    Intrate,
    Pricedisc,
    Pricemat,
    Received,
    Yielddisc,
    Yieldmat,
    Cumipmt,
    Cumprinc,
    Db,
    Ddb,
    Dollarde,
    Dollarfr,
    Effect,
    Fv,
    Ipmt,
    Irr,
    Ispmt,
    Mirr,
    Nominal,
    Nper,
    Npv,
    Pduration,
    Pmt,
    Ppmt,
    Pv,
    Rate,
    Rri,
    Sln,
    Syd,
    Tbilleq,
    Tbillprice,
    Tbillyield,
    Xirr,
    Xnpv,
    Duration,
    Mduration,
    Price,
    Yield,
    Oddfprice,
    Oddfyield,
    Oddlprice,
    Oddlyield,
    Coupdaybs,
    Coupdays,
    Coupdaysnc,
    Coupncd,
    Coupnum,
    Couppcd,
    Amordegrc,
    Amorlinc,
    Vdb,

    // Engineering: Bessel and transcendental functions
    Besseli,
    Besselj,
    Besselk,
    Bessely,
    Erf,
    Erfc,
    ErfcPrecise,
    ErfPrecise,

    // Engineering: Number systems
    Bin2dec,
    Bin2hex,
    Bin2oct,
    Dec2Bin,
    Dec2hex,
    Dec2oct,
    Hex2bin,
    Hex2dec,
    Hex2oct,
    Oct2bin,
    Oct2dec,
    Oct2hex,

    // Engineering: Bit functions
    Bitand,
    Bitlshift,
    Bitor,
    Bitrshift,
    Bitxor,

    // Engineering: Complex functions
    Complex,
    Imabs,
    Imaginary,
    Imargument,
    Imconjugate,
    Imcos,
    Imcosh,
    Imcot,
    Imcsc,
    Imcsch,
    Imdiv,
    Imexp,
    Imln,
    Imlog10,
    Imlog2,
    Impower,
    Improduct,
    Imreal,
    Imsec,
    Imsech,
    Imsin,
    Imsinh,
    Imsqrt,
    Imsub,
    Imsum,
    Imtan,

    // Engineering: Misc function
    Convert,
    Delta,
    Gestep,
    Subtotal,
    // MACRO: not in upstream yet
    Aggregate,
    Getpivotdata,

    // Database
    Daverage,
    Dcount,
    Dget,
    Dmax,
    Dmin,
    Dsum,
    Dcounta,
    Dproduct,
    Dstdev,
    Dvar,
    Dvarp,
    Dstdevp,

    Correl,
    Rsq,
    Intercept,
    Slope,
    Steyx,
}

macro_rules! impl_function_lookup {
    ($($field:ident => $variant:ident),+ $(,)?) => {
        impl Functions {
            pub fn lookup(&self, name: &str) -> Option<Function> {
                let key = name.to_uppercase();
                $(
                    if self.$field == key {
                        return Some(Function::$variant);
                    }
                )*
                // MACRO: functions the language data does not name yet.
                match key.as_str() {
                    "AGGREGATE" => Some(Function::Aggregate),
                    "GETPIVOTDATA" => Some(Function::Getpivotdata),
                    _ => None,
                }
            }
        }
    }
}

impl_function_lookup! {
    // Logical
    and         => And,
    r#false     => False,
    r#if        => If,
    iferror     => Iferror,
    ifna        => Ifna,
    ifs         => Ifs,
    lambda      => Lambda,
    r#let       => Let,
    not         => Not,
    or          => Or,
    switch      => Switch,
    r#true      => True,
    xor         => Xor,
    bycol       => Bycol,
    byrow       => Byrow,
    map         => Map,
    reduce      => Reduce,
    scan        => Scan,
    makearray   => Makearray,

    // Mathematical and trigonometry
    abs             => Abs,
    acos            => Acos,
    acosh           => Acosh,
    asin            => Asin,
    asinh           => Asinh,
    atan            => Atan,
    atan2           => Atan2,
    atanh           => Atanh,
    choose          => Choose,
    column          => Column,
    columns         => Columns,
    cos             => Cos,
    cosh            => Cosh,
    log             => Log,
    log10           => Log10,
    ln              => Ln,
    max             => Max,
    min             => Min,
    pi              => Pi,
    power           => Power,
    product         => Product,
    rand            => Rand,
    randbetween     => Randbetween,
    round           => Round,
    rounddown       => Rounddown,
    roundup         => Roundup,
    sin             => Sin,
    sinh            => Sinh,
    sqrt            => Sqrt,
    sqrtpi          => Sqrtpi,
    sum             => Sum,
    sumif           => Sumif,
    sumifs          => Sumifs,
    sumx2my2        => Sumx2my2,
    sumx2py2        => Sumx2py2,
    sumxmy2         => Sumxmy2,
    tan             => Tan,
    tanh            => Tanh,
    acot            => Acot,
    acoth           => Acoth,
    cot             => Cot,
    coth            => Coth,
    csc             => Csc,
    csch            => Csch,
    sec             => Sec,
    sech            => Sech,
    exp             => Exp,
    fact            => Fact,
    factdouble      => Factdouble,
    sign            => Sign,
    radians         => Radians,
    degrees         => Degrees,
    int             => Int,
    even            => Even,
    odd             => Odd,
    ceiling         => Ceiling,
    ceilingmath     => CeilingMath,
    ceilingprecise  => CeilingPrecise,
    floor           => Floor,
    floormath       => FloorMath,
    floorprecise    => FloorPrecise,
    isoceiling      => IsoCeiling,
    r#mod           => Mod,
    quotient        => Quotient,
    mround          => Mround,
    trunc           => Trunc,
    gcd             => Gcd,
    lcm             => Lcm,
    base            => Base,
    decimal         => Decimal,
    roman           => Roman,
    arabic          => Arabic,
    combin          => Combin,
    combina         => Combina,
    sumsq           => Sumsq,
    mdeterm         => Mdeterm,
    minverse        => Minverse,
    munit           => Munit,
    multinomial     => Multinomial,
    seriessum       => Seriessum,
    sumproduct      => Sumproduct,
    percentof       => Percentof,

    // Information
    errortype   => ErrorType,
    formulatext => Formulatext,
    isblank     => Isblank,
    iserr       => Iserr,
    iserror     => Iserror,
    iseven      => Iseven,
    isformula   => Isformula,
    islogical   => Islogical,
    isna        => Isna,
    isnontext   => Isnontext,
    isnumber    => Isnumber,
    isodd       => Isodd,
    isomitted   => Isomitted,
    isref       => Isref,
    istext      => Istext,
    na          => Na,
    sheet       => Sheet,
    r#type      => Type,

    sheets      => Sheets,
    n           => N,
    cell        => Cell,
    info        => Info,

    // Lookup and reference
    address   => Address,
    areas     => Areas,
    choosecols => Choosecols,
    chooserows => Chooserows,
    expand    => Expand,
    filter    => Filter,
    hlookup   => Hlookup,
    hstack    => Hstack,
    hyperlink => Hyperlink,
    index     => Index,
    indirect  => Indirect,
    lookup    => Lookup,
    r#match   => Match,
    offset    => Offset,
    row       => Row,
    rows      => Rows,
    sort      => Sort,
    sortby    => Sortby,
    unique    => Unique,
    vlookup   => Vlookup,
    vstack    => Vstack,
    wrapcols  => Wrapcols,
    wraprows  => Wraprows,
    xlookup   => Xlookup,
    xmatch    => Xmatch,
    trimrange => Trimrange,
    take      => Take,
    drop      => Drop,
    tocol     => Tocol,
    torow     => Torow,
    transpose => Transpose,
    mmult     => Mmult,

    // Dynamic array
    sequence  => Sequence,
    randarray => Randarray,

    // Text
    concat      => Concat,
    textsplit   => Textsplit,
    concatenate => Concatenate,
    exact       => Exact,
    find        => Find,
    left        => Left,
    len         => Len,
    lower       => Lower,
    mid         => Mid,
    rept        => Rept,
    right       => Right,
    search      => Search,
    substitute    => Substitute,
    regexextract  => Regexextract,
    regexreplace  => Regexreplace,
    regextest     => Regextest,
    t             => T,
    text        => Text,
    textafter   => Textafter,
    textbefore  => Textbefore,
    textjoin    => Textjoin,
    trim        => Trim,
    unicode     => Unicode,
    unichar     => Unichar,
    char        => Char,
    clean       => Clean,
    code        => Code,
    asc         => Asc,
    arraytotext => Arraytotext,
    dollar      => Dollar,
    encodeurl   => Encodeurl,
    findb       => Findb,
    fixed       => Fixed,
    leftb       => Leftb,
    lenb        => Lenb,
    midb        => Midb,
    numbervalue => Numbervalue,
    proper      => Proper,
    replace     => Replace,
    replaceb    => Replaceb,
    rightb      => Rightb,
    searchb     => Searchb,
    upper       => Upper,
    value       => Value,
    valuetotext => Valuetotext,

    // Statistical
    average        => Average,
    averagea       => Averagea,
    averageif      => Averageif,
    averageifs     => Averageifs,
    count          => Count,
    counta         => Counta,
    countblank     => Countblank,
    countif        => Countif,
    countifs       => Countifs,
    maxifs         => Maxifs,
    minifs         => Minifs,
    geomean        => Geomean,
    avedev         => Avedev,
    betadist       => BetaDist,
    betainv        => BetaInv,
    binomdist      => BinomDist,
    binomdistrange => BinomDistRange,
    binominv       => BinomInv,
    chisqdist      => ChisqDist,
    chisqdistrt    => ChisqDistRT,
    chisqinv       => ChisqInv,
    chisqinvrt     => ChisqInvRT,
    chisqtest      => ChisqTest,
    confidencenorm => ConfidenceNorm,
    confidencet    => ConfidenceT,
    covariancep    => CovarianceP,
    covariances    => CovarianceS,
    devsq          => Devsq,
    expondist      => ExponDist,
    fdist          => FDist,
    fdistrt        => FDistRT,
    finv           => FInv,
    finvrt         => FInvRT,
    ftest          => FTest,
    fisher         => Fisher,
    fisherinv      => FisherInv,
    gamma          => Gamma,
    gammadist      => GammaDist,
    gammainv       => GammaInv,
    gammaln        => GammaLn,
    gammalnprecise => GammaLnPrecise,
    gauss          => Gauss,
    harmean        => Harmean,
    hypgeomdist    => HypGeomDist,
    kurt           => Kurt,
    large          => Large,
    lognormdist    => LogNormDist,
    lognorminv     => LogNormInv,
    maxa           => MaxA,
    median         => Median,
    mina           => MinA,
    negbinomdist   => NegbinomDist,
    normdist       => NormDist,
    norminv        => NormInv,
    normsdist      => NormSdist,
    normsinv       => NormSInv,
    pearson        => Pearson,
    phi            => Phi,
    poissondist    => PoissonDist,
    rankavg        => RankAvg,
    rankeq         => RankEq,
    skew           => Skew,
    skewp          => SkewP,
    small          => Small,
    standardize    => Standardize,
    stdev          => Stdev,
    stdevp         => StDevP,
    stdevs         => StDevS,
    stdeva         => Stdeva,
    stdevpa        => Stdevpa,
    tdist          => TDist,
    tdist2t        => TDist2T,
    tdistrt        => TDistRT,
    tinv           => TInv,
    tinv2t         => TInv2T,
    ttest          => TTest,
    varp           => VarP,
    vars           => VarS,
    varpa          => VarpA,
    vara           => VarA,
    weibulldist    => WeibullDist,
    ztest          => ZTest,

    // Compatibility — wrappers
    betadistcompat     => BetaDistCompat,
    hypgeomdistcompat  => HypGeomDistCompat,
    lognormdistcompat  => LogNormDistCompat,
    negbinomdistcompat => NegbinomDistCompat,
    normsdistcompat    => NormSDistCompat,
    tdistcompat        => TDistCompat,
    // Compatibility — aliases (own variant for round-trip serialization)
    chidist            => ChiDistCompat,
    chiinv             => ChiInvCompat,
    chitest            => ChiTestCompat,
    confidence         => ConfidenceCompat,
    covar              => CovarCompat,
    critbinom          => CritbinomCompat,
    loginv             => LoginvCompat,
    betainvcompat      => BetaInvCompat,
    binomdistcompat    => BinomDistCompat,
    expondistcompat    => ExponDistCompat,
    fdistcompat        => FDistCompat,
    finvcompat         => FInvCompat,
    ftestcompat        => FTestCompat,
    gammadistcompat    => GammaDistCompat,
    gammainvcompat     => GammaInvCompat,
    modecompat         => ModeCompat,
    normdistcompat     => NormDistCompat,
    norminvcompat      => NormInvCompat,
    normsinvcompat     => NormSInvCompat,
    percentilecompat   => PercentileCompat,
    percentrankcompat  => PercentrankCompat,
    poissoncompat      => PoissonCompat,
    quartilecompat     => QuartileCompat,
    rankcompat         => RankCompat,
    stdevpcompat       => StDevPCompat,
    tinvcompat         => TInvCompat,
    ttestcompat        => TTestCompat,
    varcompat          => VarCompat,
    varpcompat         => VarPCompat,
    weibullcompat      => WeibullCompat,
    ztestcompat        => ZTestCompat,

    // Date and time
    date            => Date,
    datedif         => Datedif,
    datevalue       => Datevalue,
    day             => Day,
    edate           => Edate,
    eomonth         => Eomonth,
    month           => Month,
    time            => Time,
    timevalue       => Timevalue,
    hour            => Hour,
    minute          => Minute,
    second          => Second,
    now             => Now,
    today           => Today,
    year            => Year,
    networkdays     => Networkdays,
    networkdaysintl => NetworkdaysIntl,
    days            => Days,
    days360         => Days360,
    weekday         => Weekday,
    weeknum         => Weeknum,
    workday         => Workday,
    workdayintl     => WorkdayIntl,
    yearfrac        => Yearfrac,
    isoweeknum      => Isoweeknum,

    // Financial
    accrint    => Accrint,
    accrintm   => Accrintm,
    disc       => Disc,
    fvschedule => Fvschedule,
    intrate    => Intrate,
    pricedisc  => Pricedisc,
    pricemat   => Pricemat,
    received   => Received,
    yielddisc  => Yielddisc,
    yieldmat   => Yieldmat,
    cumipmt    => Cumipmt,
    cumprinc   => Cumprinc,
    db         => Db,
    ddb        => Ddb,
    dollarde   => Dollarde,
    dollarfr   => Dollarfr,
    effect     => Effect,
    fv         => Fv,
    ipmt       => Ipmt,
    irr        => Irr,
    ispmt      => Ispmt,
    mirr       => Mirr,
    nominal    => Nominal,
    nper       => Nper,
    npv        => Npv,
    pduration  => Pduration,
    pmt        => Pmt,
    ppmt       => Ppmt,
    pv         => Pv,
    rate       => Rate,
    rri        => Rri,
    sln        => Sln,
    syd        => Syd,
    tbilleq    => Tbilleq,
    tbillprice => Tbillprice,
    tbillyield => Tbillyield,
    xirr       => Xirr,
    xnpv       => Xnpv,
    duration   => Duration,
    mduration  => Mduration,
    price      => Price,
    r#yield    => Yield,
    oddfprice  => Oddfprice,
    oddfyield  => Oddfyield,
    oddlprice  => Oddlprice,
    oddlyield  => Oddlyield,
    coupdaybs  => Coupdaybs,
    coupdays   => Coupdays,
    coupdaysnc => Coupdaysnc,
    coupncd    => Coupncd,
    coupnum    => Coupnum,
    couppcd    => Couppcd,
    amordegrc  => Amordegrc,
    amorlinc   => Amorlinc,
    vdb        => Vdb,

    // Engineering: Bessel and transcendental functions
    besseli       => Besseli,
    besselj       => Besselj,
    besselk       => Besselk,
    bessely       => Bessely,
    erf           => Erf,
    erfc          => Erfc,
    erfcprecise   => ErfcPrecise,
    erfprecise    => ErfPrecise,

    // Engineering: Number systems
    bin2dec  => Bin2dec,
    bin2hex  => Bin2hex,
    bin2oct  => Bin2oct,
    dec2bin  => Dec2Bin,
    dec2hex  => Dec2hex,
    dec2oct  => Dec2oct,
    hex2bin  => Hex2bin,
    hex2dec  => Hex2dec,
    hex2oct  => Hex2oct,
    oct2bin  => Oct2bin,
    oct2dec  => Oct2dec,
    oct2hex  => Oct2hex,

    // Engineering: Bit functions
    bitand    => Bitand,
    bitlshift => Bitlshift,
    bitor     => Bitor,
    bitrshift => Bitrshift,
    bitxor    => Bitxor,

    // Engineering: Complex functions
    complex     => Complex,
    imabs       => Imabs,
    imaginary   => Imaginary,
    imargument  => Imargument,
    imconjugate => Imconjugate,
    imcos       => Imcos,
    imcosh      => Imcosh,
    imcot       => Imcot,
    imcsc       => Imcsc,
    imcsch      => Imcsch,
    imdiv       => Imdiv,
    imexp       => Imexp,
    imln        => Imln,
    imlog10     => Imlog10,
    imlog2      => Imlog2,
    impower     => Impower,
    improduct   => Improduct,
    imreal      => Imreal,
    imsec       => Imsec,
    imsech      => Imsech,
    imsin       => Imsin,
    imsinh      => Imsinh,
    imsqrt      => Imsqrt,
    imsub       => Imsub,
    imsum       => Imsum,
    imtan       => Imtan,

    // Engineering: Misc function
    convert  => Convert,
    delta    => Delta,
    gestep   => Gestep,
    subtotal => Subtotal,

    // Database
    daverage => Daverage,
    dcount   => Dcount,
    dget     => Dget,
    dmax     => Dmax,
    dmin     => Dmin,
    dsum     => Dsum,
    dcounta  => Dcounta,
    dproduct => Dproduct,
    dstdev   => Dstdev,
    dvar     => Dvar,
    dvarp    => Dvarp,
    dstdevp  => Dstdevp,

    // More statistical
    correl          => Correl,
    rsq             => Rsq,
    intercept       => Intercept,
    slope           => Slope,
    steyx           => Steyx,
    forecast        => Forecast,
    forecastlinear  => ForecastLinear,
    forecastets            => ForecastEts,
    forecastetsconfint     => ForecastEtsConfint,
    forecastetsseasonality => ForecastEtsSeasonality,
    forecastetsstat        => ForecastEtsStat,
    frequency       => Frequency,
    growth          => Growth,
    linest          => Linest,
    logest          => Logest,
    modemult        => ModeMult,
    modesngl        => ModeSingl,
    percentileexc   => PercentileExc,
    percentileinc   => PercentileInc,
    percentrankexc  => PercentrankExc,
    percentrankinc  => PercentrankInc,
    permut          => Permut,
    permutationa    => Permutationa,
    prob            => Prob,
    quartileexc     => QuartileExc,
    quartileinc     => QuartileInc,
    trend           => Trend,
    trimmean        => Trimmean,
}

impl Function {
    pub fn to_localized_name(&self, language: &Language) -> String {
        let functions = &language.functions;
        match self {
            Function::And => functions.and.clone(),
            Function::False => functions.r#false.clone(),
            Function::If => functions.r#if.clone(),
            Function::Iferror => functions.iferror.clone(),
            Function::Ifna => functions.ifna.clone(),
            Function::Ifs => functions.ifs.clone(),
            Function::Lambda => functions.lambda.clone(),
            Function::Let => functions.r#let.clone(),
            Function::Not => functions.not.clone(),
            Function::Or => functions.or.clone(),
            Function::Switch => functions.switch.clone(),
            Function::True => functions.r#true.clone(),
            Function::Xor => functions.xor.clone(),
            Function::Bycol => functions.bycol.clone(),
            Function::Byrow => functions.byrow.clone(),
            Function::Map => functions.map.clone(),
            Function::Reduce => functions.reduce.clone(),
            Function::Scan => functions.scan.clone(),
            Function::Makearray => functions.makearray.clone(),
            Function::Abs => functions.abs.clone(),
            Function::Acos => functions.acos.clone(),
            Function::Acosh => functions.acosh.clone(),
            Function::Asin => functions.asin.clone(),
            Function::Asinh => functions.asinh.clone(),
            Function::Atan => functions.atan.clone(),
            Function::Atan2 => functions.atan2.clone(),
            Function::Atanh => functions.atanh.clone(),
            Function::Choose => functions.choose.clone(),
            Function::Column => functions.column.clone(),
            Function::Columns => functions.columns.clone(),
            Function::Cos => functions.cos.clone(),
            Function::Cosh => functions.cosh.clone(),
            Function::Log => functions.log.clone(),
            Function::Log10 => functions.log10.clone(),
            Function::Ln => functions.ln.clone(),
            Function::Max => functions.max.clone(),
            Function::Min => functions.min.clone(),
            Function::Pi => functions.pi.clone(),
            Function::Power => functions.power.clone(),
            Function::Product => functions.product.clone(),
            Function::Rand => functions.rand.clone(),
            Function::Randbetween => functions.randbetween.clone(),
            Function::Round => functions.round.clone(),
            Function::Rounddown => functions.rounddown.clone(),
            Function::Roundup => functions.roundup.clone(),
            Function::Sin => functions.sin.clone(),
            Function::Sinh => functions.sinh.clone(),
            Function::Sqrt => functions.sqrt.clone(),
            Function::Sqrtpi => functions.sqrtpi.clone(),
            Function::Sum => functions.sum.clone(),
            Function::Sumif => functions.sumif.clone(),
            Function::Sumifs => functions.sumifs.clone(),
            Function::Sumx2my2 => functions.sumx2my2.clone(),
            Function::Sumx2py2 => functions.sumx2py2.clone(),
            Function::Sumxmy2 => functions.sumxmy2.clone(),
            Function::Tan => functions.tan.clone(),
            Function::Tanh => functions.tanh.clone(),
            Function::Acot => functions.acot.clone(),
            Function::Acoth => functions.acoth.clone(),
            Function::Cot => functions.cot.clone(),
            Function::Coth => functions.coth.clone(),
            Function::Csc => functions.csc.clone(),
            Function::Csch => functions.csch.clone(),
            Function::Sec => functions.sec.clone(),
            Function::Sech => functions.sech.clone(),
            Function::Exp => functions.exp.clone(),
            Function::Fact => functions.fact.clone(),
            Function::Factdouble => functions.factdouble.clone(),
            Function::Sign => functions.sign.clone(),
            Function::Radians => functions.radians.clone(),
            Function::Degrees => functions.degrees.clone(),
            Function::Int => functions.int.clone(),
            Function::Even => functions.even.clone(),
            Function::Odd => functions.odd.clone(),
            Function::Ceiling => functions.ceiling.clone(),
            Function::CeilingMath => functions.ceilingmath.clone(),
            Function::CeilingPrecise => functions.ceilingprecise.clone(),
            Function::Floor => functions.floor.clone(),
            Function::FloorMath => functions.floormath.clone(),
            Function::FloorPrecise => functions.floorprecise.clone(),
            Function::IsoCeiling => functions.isoceiling.clone(),
            Function::Mod => functions.r#mod.clone(),
            Function::Quotient => functions.quotient.clone(),
            Function::Mround => functions.mround.clone(),
            Function::Trunc => functions.trunc.clone(),
            Function::Gcd => functions.gcd.clone(),
            Function::Lcm => functions.lcm.clone(),
            Function::Base => functions.base.clone(),
            Function::Decimal => functions.decimal.clone(),
            Function::Roman => functions.roman.clone(),
            Function::Arabic => functions.arabic.clone(),
            Function::Combin => functions.combin.clone(),
            Function::Combina => functions.combina.clone(),
            Function::Sumsq => functions.sumsq.clone(),
            Function::Mdeterm => functions.mdeterm.clone(),
            Function::Minverse => functions.minverse.clone(),
            Function::Munit => functions.munit.clone(),
            Function::Multinomial => functions.multinomial.clone(),
            Function::Seriessum => functions.seriessum.clone(),
            Function::Sumproduct => functions.sumproduct.clone(),
            Function::Percentof => functions.percentof.clone(),
            Function::ErrorType => functions.errortype.clone(),
            Function::Formulatext => functions.formulatext.clone(),
            Function::Isblank => functions.isblank.clone(),
            Function::Iserr => functions.iserr.clone(),
            Function::Iserror => functions.iserror.clone(),
            Function::Iseven => functions.iseven.clone(),
            Function::Isformula => functions.isformula.clone(),
            Function::Islogical => functions.islogical.clone(),
            Function::Isna => functions.isna.clone(),
            Function::Isnontext => functions.isnontext.clone(),
            Function::Isnumber => functions.isnumber.clone(),
            Function::Isodd => functions.isodd.clone(),
            Function::Isomitted => functions.isomitted.clone(),
            Function::Isref => functions.isref.clone(),
            Function::Istext => functions.istext.clone(),
            Function::Na => functions.na.clone(),
            Function::Sheet => functions.sheet.clone(),
            Function::Type => functions.r#type.clone(),
            Function::Sheets => functions.sheets.clone(),
            Function::N => functions.n.clone(),
            Function::Cell => functions.cell.clone(),
            Function::Info => functions.info.clone(),
            Function::Address => functions.address.clone(),
            Function::Areas => functions.areas.clone(),
            Function::Choosecols => functions.choosecols.clone(),
            Function::Chooserows => functions.chooserows.clone(),
            Function::Expand => functions.expand.clone(),
            Function::Filter => functions.filter.clone(),
            Function::Hlookup => functions.hlookup.clone(),
            Function::Hstack => functions.hstack.clone(),
            Function::Hyperlink => functions.hyperlink.clone(),
            Function::Index => functions.index.clone(),
            Function::Indirect => functions.indirect.clone(),
            Function::Lookup => functions.lookup.clone(),
            Function::Match => functions.r#match.clone(),
            Function::Offset => functions.offset.clone(),
            Function::Row => functions.row.clone(),
            Function::Rows => functions.rows.clone(),
            Function::Sort => functions.sort.clone(),
            Function::Sortby => functions.sortby.clone(),
            Function::Unique => functions.unique.clone(),
            Function::Vlookup => functions.vlookup.clone(),
            Function::Vstack => functions.vstack.clone(),
            Function::Wrapcols => functions.wrapcols.clone(),
            Function::Wraprows => functions.wraprows.clone(),
            Function::Xlookup => functions.xlookup.clone(),
            Function::Xmatch => functions.xmatch.clone(),
            Function::Trimrange => functions.trimrange.clone(),
            Function::Take => functions.take.clone(),
            Function::Drop => functions.drop.clone(),
            Function::Tocol => functions.tocol.clone(),
            Function::Torow => functions.torow.clone(),
            Function::Transpose => functions.transpose.clone(),
            Function::Mmult => functions.mmult.clone(),
            Function::Sequence => functions.sequence.clone(),
            Function::Randarray => functions.randarray.clone(),
            Function::Concat => functions.concat.clone(),
            Function::Textsplit => functions.textsplit.clone(),
            Function::Concatenate => functions.concatenate.clone(),
            Function::Exact => functions.exact.clone(),
            Function::Find => functions.find.clone(),
            Function::Left => functions.left.clone(),
            Function::Len => functions.len.clone(),
            Function::Lower => functions.lower.clone(),
            Function::Mid => functions.mid.clone(),
            Function::Rept => functions.rept.clone(),
            Function::Right => functions.right.clone(),
            Function::Search => functions.search.clone(),
            Function::Substitute => functions.substitute.clone(),
            Function::Regexextract => functions.regexextract.clone(),
            Function::Regexreplace => functions.regexreplace.clone(),
            Function::Regextest => functions.regextest.clone(),
            Function::T => functions.t.clone(),
            Function::Text => functions.text.clone(),
            Function::Textafter => functions.textafter.clone(),
            Function::Textbefore => functions.textbefore.clone(),
            Function::Textjoin => functions.textjoin.clone(),
            Function::Trim => functions.trim.clone(),
            Function::Unicode => functions.unicode.clone(),
            Function::Unichar => functions.unichar.clone(),
            Function::Char => functions.r#char.clone(),
            Function::Clean => functions.clean.clone(),
            Function::Code => functions.code.clone(),
            Function::Asc => functions.asc.clone(),
            Function::Arraytotext => functions.arraytotext.clone(),
            Function::Dollar => functions.dollar.clone(),
            Function::Encodeurl => functions.encodeurl.clone(),
            Function::Findb => functions.findb.clone(),
            Function::Fixed => functions.fixed.clone(),
            Function::Leftb => functions.leftb.clone(),
            Function::Lenb => functions.lenb.clone(),
            Function::Midb => functions.midb.clone(),
            Function::Numbervalue => functions.numbervalue.clone(),
            Function::Proper => functions.proper.clone(),
            Function::Replace => functions.replace.clone(),
            Function::Replaceb => functions.replaceb.clone(),
            Function::Rightb => functions.rightb.clone(),
            Function::Searchb => functions.searchb.clone(),
            Function::Upper => functions.upper.clone(),
            Function::Value => functions.value.clone(),
            Function::Valuetotext => functions.valuetotext.clone(),
            Function::Average => functions.average.clone(),
            Function::Averagea => functions.averagea.clone(),
            Function::Averageif => functions.averageif.clone(),
            Function::Averageifs => functions.averageifs.clone(),
            Function::Count => functions.count.clone(),
            Function::Counta => functions.counta.clone(),
            Function::Countblank => functions.countblank.clone(),
            Function::Countif => functions.countif.clone(),
            Function::Countifs => functions.countifs.clone(),
            Function::Maxifs => functions.maxifs.clone(),
            Function::Minifs => functions.minifs.clone(),
            Function::Geomean => functions.geomean.clone(),
            Function::Avedev => functions.avedev.clone(),
            Function::BetaDist => functions.betadist.clone(),
            Function::BetaInv => functions.betainv.clone(),
            Function::BinomDist => functions.binomdist.clone(),
            Function::BinomDistRange => functions.binomdistrange.clone(),
            Function::BinomInv => functions.binominv.clone(),
            Function::ChisqDist => functions.chisqdist.clone(),
            Function::ChisqDistRT => functions.chisqdistrt.clone(),
            Function::ChisqInv => functions.chisqinv.clone(),
            Function::ChisqInvRT => functions.chisqinvrt.clone(),
            Function::ChisqTest => functions.chisqtest.clone(),
            Function::ConfidenceNorm => functions.confidencenorm.clone(),
            Function::ConfidenceT => functions.confidencet.clone(),
            Function::CovarianceP => functions.covariancep.clone(),
            Function::CovarianceS => functions.covariances.clone(),
            Function::Devsq => functions.devsq.clone(),
            Function::ExponDist => functions.expondist.clone(),
            Function::FDist => functions.fdist.clone(),
            Function::FDistRT => functions.fdistrt.clone(),
            Function::FInv => functions.finv.clone(),
            Function::FInvRT => functions.finvrt.clone(),
            Function::FTest => functions.ftest.clone(),
            Function::Fisher => functions.fisher.clone(),
            Function::FisherInv => functions.fisherinv.clone(),
            Function::Gamma => functions.gamma.clone(),
            Function::GammaDist => functions.gammadist.clone(),
            Function::GammaInv => functions.gammainv.clone(),
            Function::GammaLn => functions.gammaln.clone(),
            Function::GammaLnPrecise => functions.gammalnprecise.clone(),
            Function::Gauss => functions.gauss.clone(),
            Function::Harmean => functions.harmean.clone(),
            Function::HypGeomDist => functions.hypgeomdist.clone(),
            Function::Kurt => functions.kurt.clone(),
            Function::Large => functions.large.clone(),
            Function::LogNormDist => functions.lognormdist.clone(),
            Function::LogNormInv => functions.lognorminv.clone(),
            Function::MaxA => functions.maxa.clone(),
            Function::Median => functions.median.clone(),
            Function::MinA => functions.mina.clone(),
            Function::NegbinomDist => functions.negbinomdist.clone(),
            Function::NormDist => functions.normdist.clone(),
            Function::NormInv => functions.norminv.clone(),
            Function::NormSdist => functions.normsdist.clone(),
            Function::NormSInv => functions.normsinv.clone(),
            Function::Pearson => functions.pearson.clone(),
            Function::Phi => functions.phi.clone(),
            Function::PoissonDist => functions.poissondist.clone(),
            Function::RankAvg => functions.rankavg.clone(),
            Function::RankEq => functions.rankeq.clone(),
            Function::Skew => functions.skew.clone(),
            Function::SkewP => functions.skewp.clone(),
            Function::Small => functions.small.clone(),
            Function::Standardize => functions.standardize.clone(),
            Function::Stdev => functions.stdev.clone(),
            Function::StDevP => functions.stdevp.clone(),
            Function::StDevS => functions.stdevs.clone(),
            Function::Stdeva => functions.stdeva.clone(),
            Function::Stdevpa => functions.stdevpa.clone(),
            Function::TDist => functions.tdist.clone(),
            Function::TDist2T => functions.tdist2t.clone(),
            Function::TDistRT => functions.tdistrt.clone(),
            Function::TInv => functions.tinv.clone(),
            Function::TInv2T => functions.tinv2t.clone(),
            Function::TTest => functions.ttest.clone(),
            Function::VarP => functions.varp.clone(),
            Function::VarS => functions.vars.clone(),
            Function::VarpA => functions.varpa.clone(),
            Function::VarA => functions.vara.clone(),
            Function::WeibullDist => functions.weibulldist.clone(),
            Function::ZTest => functions.ztest.clone(),
            Function::BetaDistCompat => functions.betadistcompat.clone(),
            Function::HypGeomDistCompat => functions.hypgeomdistcompat.clone(),
            Function::LogNormDistCompat => functions.lognormdistcompat.clone(),
            Function::NegbinomDistCompat => functions.negbinomdistcompat.clone(),
            Function::NormSDistCompat => functions.normsdistcompat.clone(),
            Function::TDistCompat => functions.tdistcompat.clone(),
            Function::BetaInvCompat => functions.betainvcompat.clone(),
            Function::BinomDistCompat => functions.binomdistcompat.clone(),
            Function::ChiDistCompat => functions.chidist.clone(),
            Function::ChiInvCompat => functions.chiinv.clone(),
            Function::ChiTestCompat => functions.chitest.clone(),
            Function::ConfidenceCompat => functions.confidence.clone(),
            Function::CovarCompat => functions.covar.clone(),
            Function::CritbinomCompat => functions.critbinom.clone(),
            Function::ExponDistCompat => functions.expondistcompat.clone(),
            Function::FDistCompat => functions.fdistcompat.clone(),
            Function::FInvCompat => functions.finvcompat.clone(),
            Function::FTestCompat => functions.ftestcompat.clone(),
            Function::GammaDistCompat => functions.gammadistcompat.clone(),
            Function::GammaInvCompat => functions.gammainvcompat.clone(),
            Function::LoginvCompat => functions.loginv.clone(),
            Function::ModeCompat => functions.modecompat.clone(),
            Function::NormDistCompat => functions.normdistcompat.clone(),
            Function::NormInvCompat => functions.norminvcompat.clone(),
            Function::NormSInvCompat => functions.normsinvcompat.clone(),
            Function::PercentileCompat => functions.percentilecompat.clone(),
            Function::PercentrankCompat => functions.percentrankcompat.clone(),
            Function::PoissonCompat => functions.poissoncompat.clone(),
            Function::QuartileCompat => functions.quartilecompat.clone(),
            Function::RankCompat => functions.rankcompat.clone(),
            Function::StDevPCompat => functions.stdevpcompat.clone(),
            Function::TInvCompat => functions.tinvcompat.clone(),
            Function::TTestCompat => functions.ttestcompat.clone(),
            Function::VarCompat => functions.varcompat.clone(),
            Function::VarPCompat => functions.varpcompat.clone(),
            Function::WeibullCompat => functions.weibullcompat.clone(),
            Function::ZTestCompat => functions.ztestcompat.clone(),
            Function::Date => functions.date.clone(),
            Function::Datedif => functions.datedif.clone(),
            Function::Datevalue => functions.datevalue.clone(),
            Function::Day => functions.day.clone(),
            Function::Edate => functions.edate.clone(),
            Function::Eomonth => functions.eomonth.clone(),
            Function::Month => functions.month.clone(),
            Function::Time => functions.time.clone(),
            Function::Timevalue => functions.timevalue.clone(),
            Function::Hour => functions.hour.clone(),
            Function::Minute => functions.minute.clone(),
            Function::Second => functions.second.clone(),
            Function::Now => functions.now.clone(),
            Function::Today => functions.today.clone(),
            Function::Year => functions.year.clone(),
            Function::Networkdays => functions.networkdays.clone(),
            Function::NetworkdaysIntl => functions.networkdaysintl.clone(),
            Function::Days => functions.days.clone(),
            Function::Days360 => functions.days360.clone(),
            Function::Weekday => functions.weekday.clone(),
            Function::Weeknum => functions.weeknum.clone(),
            Function::Workday => functions.workday.clone(),
            Function::WorkdayIntl => functions.workdayintl.clone(),
            Function::Yearfrac => functions.yearfrac.clone(),
            Function::Isoweeknum => functions.isoweeknum.clone(),
            Function::Accrint => functions.accrint.clone(),
            Function::Accrintm => functions.accrintm.clone(),
            Function::Disc => functions.disc.clone(),
            Function::Fvschedule => functions.fvschedule.clone(),
            Function::Intrate => functions.intrate.clone(),
            Function::Pricedisc => functions.pricedisc.clone(),
            Function::Pricemat => functions.pricemat.clone(),
            Function::Received => functions.received.clone(),
            Function::Yielddisc => functions.yielddisc.clone(),
            Function::Yieldmat => functions.yieldmat.clone(),
            Function::Cumipmt => functions.cumipmt.clone(),
            Function::Cumprinc => functions.cumprinc.clone(),
            Function::Db => functions.db.clone(),
            Function::Ddb => functions.ddb.clone(),
            Function::Dollarde => functions.dollarde.clone(),
            Function::Dollarfr => functions.dollarfr.clone(),
            Function::Effect => functions.effect.clone(),
            Function::Fv => functions.fv.clone(),
            Function::Ipmt => functions.ipmt.clone(),
            Function::Irr => functions.irr.clone(),
            Function::Ispmt => functions.ispmt.clone(),
            Function::Mirr => functions.mirr.clone(),
            Function::Nominal => functions.nominal.clone(),
            Function::Nper => functions.nper.clone(),
            Function::Npv => functions.npv.clone(),
            Function::Pduration => functions.pduration.clone(),
            Function::Pmt => functions.pmt.clone(),
            Function::Ppmt => functions.ppmt.clone(),
            Function::Pv => functions.pv.clone(),
            Function::Rate => functions.rate.clone(),
            Function::Rri => functions.rri.clone(),
            Function::Sln => functions.sln.clone(),
            Function::Syd => functions.syd.clone(),
            Function::Tbilleq => functions.tbilleq.clone(),
            Function::Tbillprice => functions.tbillprice.clone(),
            Function::Tbillyield => functions.tbillyield.clone(),
            Function::Xirr => functions.xirr.clone(),
            Function::Xnpv => functions.xnpv.clone(),
            Function::Duration => functions.duration.clone(),
            Function::Mduration => functions.mduration.clone(),
            Function::Price => functions.price.clone(),
            Function::Yield => functions.r#yield.clone(),
            Function::Oddfprice => functions.oddfprice.clone(),
            Function::Oddfyield => functions.oddfyield.clone(),
            Function::Oddlprice => functions.oddlprice.clone(),
            Function::Oddlyield => functions.oddlyield.clone(),
            Function::Coupdaybs => functions.coupdaybs.clone(),
            Function::Coupdays => functions.coupdays.clone(),
            Function::Coupdaysnc => functions.coupdaysnc.clone(),
            Function::Coupncd => functions.coupncd.clone(),
            Function::Coupnum => functions.coupnum.clone(),
            Function::Couppcd => functions.couppcd.clone(),
            Function::Amordegrc => functions.amordegrc.clone(),
            Function::Amorlinc => functions.amorlinc.clone(),
            Function::Vdb => functions.vdb.clone(),
            Function::Besseli => functions.besseli.clone(),
            Function::Besselj => functions.besselj.clone(),
            Function::Besselk => functions.besselk.clone(),
            Function::Bessely => functions.bessely.clone(),
            Function::Erf => functions.erf.clone(),
            Function::Erfc => functions.erfc.clone(),
            Function::ErfcPrecise => functions.erfcprecise.clone(),
            Function::ErfPrecise => functions.erfprecise.clone(),
            Function::Bin2dec => functions.bin2dec.clone(),
            Function::Bin2hex => functions.bin2hex.clone(),
            Function::Bin2oct => functions.bin2oct.clone(),
            Function::Dec2Bin => functions.dec2bin.clone(),
            Function::Dec2hex => functions.dec2hex.clone(),
            Function::Dec2oct => functions.dec2oct.clone(),
            Function::Hex2bin => functions.hex2bin.clone(),
            Function::Hex2dec => functions.hex2dec.clone(),
            Function::Hex2oct => functions.hex2oct.clone(),
            Function::Oct2bin => functions.oct2bin.clone(),
            Function::Oct2dec => functions.oct2dec.clone(),
            Function::Oct2hex => functions.oct2hex.clone(),
            Function::Bitand => functions.bitand.clone(),
            Function::Bitlshift => functions.bitlshift.clone(),
            Function::Bitor => functions.bitor.clone(),
            Function::Bitrshift => functions.bitrshift.clone(),
            Function::Bitxor => functions.bitxor.clone(),
            Function::Complex => functions.complex.clone(),
            Function::Imabs => functions.imabs.clone(),
            Function::Imaginary => functions.imaginary.clone(),
            Function::Imargument => functions.imargument.clone(),
            Function::Imconjugate => functions.imconjugate.clone(),
            Function::Imcos => functions.imcos.clone(),
            Function::Imcosh => functions.imcosh.clone(),
            Function::Imcot => functions.imcot.clone(),
            Function::Imcsc => functions.imcsc.clone(),
            Function::Imcsch => functions.imcsch.clone(),
            Function::Imdiv => functions.imdiv.clone(),
            Function::Imexp => functions.imexp.clone(),
            Function::Imln => functions.imln.clone(),
            Function::Imlog10 => functions.imlog10.clone(),
            Function::Imlog2 => functions.imlog2.clone(),
            Function::Impower => functions.impower.clone(),
            Function::Improduct => functions.improduct.clone(),
            Function::Imreal => functions.imreal.clone(),
            Function::Imsec => functions.imsec.clone(),
            Function::Imsech => functions.imsech.clone(),
            Function::Imsin => functions.imsin.clone(),
            Function::Imsinh => functions.imsinh.clone(),
            Function::Imsqrt => functions.imsqrt.clone(),
            Function::Imsub => functions.imsub.clone(),
            Function::Imsum => functions.imsum.clone(),
            Function::Imtan => functions.imtan.clone(),
            Function::Convert => functions.convert.clone(),
            Function::Delta => functions.delta.clone(),
            Function::Gestep => functions.gestep.clone(),
            Function::Subtotal => functions.subtotal.clone(),
            Function::Aggregate => "AGGREGATE".to_string(), // MACRO
            Function::Getpivotdata => "GETPIVOTDATA".to_string(), // MACRO
            Function::Daverage => functions.daverage.clone(),
            Function::Dcount => functions.dcount.clone(),
            Function::Dget => functions.dget.clone(),
            Function::Dmax => functions.dmax.clone(),
            Function::Dmin => functions.dmin.clone(),
            Function::Dsum => functions.dsum.clone(),
            Function::Dcounta => functions.dcounta.clone(),
            Function::Dproduct => functions.dproduct.clone(),
            Function::Dstdev => functions.dstdev.clone(),
            Function::Dvar => functions.dvar.clone(),
            Function::Dvarp => functions.dvarp.clone(),
            Function::Dstdevp => functions.dstdevp.clone(),
            Function::Correl => functions.correl.clone(),
            Function::Rsq => functions.rsq.clone(),
            Function::Intercept => functions.intercept.clone(),
            Function::Slope => functions.slope.clone(),
            Function::Steyx => functions.steyx.clone(),
            Function::Forecast => functions.forecast.clone(),
            Function::ForecastLinear => functions.forecastlinear.clone(),
            Function::ForecastEts => functions.forecastets.clone(),
            Function::ForecastEtsConfint => functions.forecastetsconfint.clone(),
            Function::ForecastEtsSeasonality => functions.forecastetsseasonality.clone(),
            Function::ForecastEtsStat => functions.forecastetsstat.clone(),
            Function::Frequency => functions.frequency.clone(),
            Function::Growth => functions.growth.clone(),
            Function::Linest => functions.linest.clone(),
            Function::Logest => functions.logest.clone(),
            Function::ModeMult => functions.modemult.clone(),
            Function::ModeSingl => functions.modesngl.clone(),
            Function::PercentileExc => functions.percentileexc.clone(),
            Function::PercentileInc => functions.percentileinc.clone(),
            Function::PercentrankExc => functions.percentrankexc.clone(),
            Function::PercentrankInc => functions.percentrankinc.clone(),
            Function::Permut => functions.permut.clone(),
            Function::Permutationa => functions.permutationa.clone(),
            Function::Prob => functions.prob.clone(),
            Function::QuartileExc => functions.quartileexc.clone(),
            Function::QuartileInc => functions.quartileinc.clone(),
            Function::Trend => functions.trend.clone(),
            Function::Trimmean => functions.trimmean.clone(),
        }
    }

    pub fn into_iter() -> IntoIter<Function, 498> {
        // MACRO: AGGREGATE and GETPIVOTDATA
        [
            Function::And,
            Function::False,
            Function::If,
            Function::Iferror,
            Function::Ifna,
            Function::Ifs,
            Function::Lambda,
            Function::Let,
            Function::Not,
            Function::Or,
            Function::Switch,
            Function::True,
            Function::Xor,
            Function::Bycol,
            Function::Byrow,
            Function::Map,
            Function::Reduce,
            Function::Scan,
            Function::Makearray,
            Function::Sin,
            Function::Cos,
            Function::Tan,
            Function::Asin,
            Function::Acos,
            Function::Atan,
            Function::Sinh,
            Function::Cosh,
            Function::Tanh,
            Function::Asinh,
            Function::Acosh,
            Function::Atanh,
            Function::Abs,
            Function::Pi,
            Function::Ln,
            Function::Log,
            Function::Log10,
            Function::Sqrt,
            Function::Sqrtpi,
            Function::Atan2,
            Function::Acot,
            Function::Acoth,
            Function::Cot,
            Function::Coth,
            Function::Csc,
            Function::Csch,
            Function::Sec,
            Function::Sech,
            Function::Power,
            Function::Exp,
            Function::Fact,
            Function::Factdouble,
            Function::Sign,
            Function::Int,
            Function::Even,
            Function::Odd,
            Function::Ceiling,
            Function::CeilingMath,
            Function::CeilingPrecise,
            Function::Floor,
            Function::FloorMath,
            Function::FloorPrecise,
            Function::IsoCeiling,
            Function::Mod,
            Function::Quotient,
            Function::Mround,
            Function::Trunc,
            Function::Gcd,
            Function::Lcm,
            Function::Base,
            Function::Decimal,
            Function::Max,
            Function::Min,
            Function::Product,
            Function::Rand,
            Function::Randbetween,
            Function::Radians,
            Function::Degrees,
            Function::Round,
            Function::Rounddown,
            Function::Roundup,
            Function::Sum,
            Function::Sumif,
            Function::Sumifs,
            Function::Sumx2my2,
            Function::Sumx2py2,
            Function::Sumxmy2,
            Function::Address,
            Function::Areas,
            Function::Choose,
            Function::Choosecols,
            Function::Chooserows,
            Function::Column,
            Function::Columns,
            Function::Expand,
            Function::Index,
            Function::Indirect,
            Function::Hlookup,
            Function::Hstack,
            Function::Hyperlink,
            Function::Filter,
            Function::Lookup,
            Function::Match,
            Function::Offset,
            Function::Row,
            Function::Rows,
            Function::Sort,
            Function::Sortby,
            Function::Unique,
            Function::Vlookup,
            Function::Vstack,
            Function::Wrapcols,
            Function::Wraprows,
            Function::Xlookup,
            Function::Xmatch,
            Function::Trimrange,
            Function::Take,
            Function::Drop,
            Function::Tocol,
            Function::Torow,
            Function::Transpose,
            Function::Mmult,
            Function::Sequence,
            Function::Randarray,
            Function::Concatenate,
            Function::Exact,
            Function::Value,
            Function::T,
            Function::Valuetotext,
            Function::Concat,
            Function::Find,
            Function::Left,
            Function::Len,
            Function::Lower,
            Function::Mid,
            Function::Right,
            Function::Search,
            Function::Text,
            Function::Trim,
            Function::Unicode,
            Function::Unichar,
            Function::Char,
            Function::Clean,
            Function::Code,
            Function::Asc,
            Function::Arraytotext,
            Function::Dollar,
            Function::Encodeurl,
            Function::Findb,
            Function::Fixed,
            Function::Leftb,
            Function::Lenb,
            Function::Midb,
            Function::Numbervalue,
            Function::Proper,
            Function::Replace,
            Function::Replaceb,
            Function::Rightb,
            Function::Searchb,
            Function::Upper,
            Function::Isnumber,
            Function::Isnontext,
            Function::Istext,
            Function::Islogical,
            Function::Isblank,
            Function::Iserr,
            Function::Iserror,
            Function::Isna,
            Function::Na,
            Function::Isref,
            Function::Isodd,
            Function::Iseven,
            Function::ErrorType,
            Function::Formulatext,
            Function::Isformula,
            Function::Isomitted,
            Function::Type,
            Function::Sheet,
            Function::Average,
            Function::Avedev,
            Function::Averagea,
            Function::Averageif,
            Function::Averageifs,
            Function::Count,
            Function::Counta,
            Function::Countblank,
            Function::Countif,
            Function::Countifs,
            Function::Maxifs,
            Function::Minifs,
            Function::Geomean,
            Function::Year,
            Function::Day,
            Function::Month,
            Function::Eomonth,
            Function::Date,
            Function::Datedif,
            Function::Datevalue,
            Function::Edate,
            Function::Networkdays,
            Function::NetworkdaysIntl,
            Function::Time,
            Function::Timevalue,
            Function::Hour,
            Function::Minute,
            Function::Second,
            Function::Today,
            Function::Now,
            Function::Days,
            Function::Days360,
            Function::Weekday,
            Function::Weeknum,
            Function::Workday,
            Function::WorkdayIntl,
            Function::Yearfrac,
            Function::Isoweeknum,
            Function::Pmt,
            Function::Pv,
            Function::Rate,
            Function::Nper,
            Function::Fv,
            Function::Ppmt,
            Function::Ipmt,
            Function::Npv,
            Function::Mirr,
            Function::Irr,
            Function::Xirr,
            Function::Xnpv,
            Function::Rept,
            Function::Textafter,
            Function::Textbefore,
            Function::Textsplit,
            Function::Textjoin,
            Function::Substitute,
            Function::Regexextract,
            Function::Regexreplace,
            Function::Regextest,
            Function::Ispmt,
            Function::Rri,
            Function::Sln,
            Function::Syd,
            Function::Nominal,
            Function::Effect,
            Function::Pduration,
            Function::Tbillyield,
            Function::Tbillprice,
            Function::Tbilleq,
            Function::Dollarde,
            Function::Dollarfr,
            Function::Ddb,
            Function::Db,
            Function::Cumprinc,
            Function::Cumipmt,
            Function::Accrint,
            Function::Accrintm,
            Function::Disc,
            Function::Fvschedule,
            Function::Intrate,
            Function::Pricedisc,
            Function::Pricemat,
            Function::Received,
            Function::Yielddisc,
            Function::Yieldmat,
            Function::Duration,
            Function::Mduration,
            Function::Price,
            Function::Yield,
            Function::Oddfprice,
            Function::Oddfyield,
            Function::Oddlprice,
            Function::Oddlyield,
            Function::Coupdaybs,
            Function::Coupdays,
            Function::Coupdaysnc,
            Function::Coupncd,
            Function::Coupnum,
            Function::Couppcd,
            Function::Amordegrc,
            Function::Amorlinc,
            Function::Vdb,
            Function::Besseli,
            Function::Besselj,
            Function::Besselk,
            Function::Bessely,
            Function::Erf,
            Function::ErfPrecise,
            Function::Erfc,
            Function::ErfcPrecise,
            Function::Bin2dec,
            Function::Bin2hex,
            Function::Bin2oct,
            Function::Dec2Bin,
            Function::Dec2hex,
            Function::Dec2oct,
            Function::Hex2bin,
            Function::Hex2dec,
            Function::Hex2oct,
            Function::Oct2bin,
            Function::Oct2dec,
            Function::Oct2hex,
            Function::Bitand,
            Function::Bitlshift,
            Function::Bitor,
            Function::Bitrshift,
            Function::Bitxor,
            Function::Complex,
            Function::Imabs,
            Function::Imaginary,
            Function::Imargument,
            Function::Imconjugate,
            Function::Imcos,
            Function::Imcosh,
            Function::Imcot,
            Function::Imcsc,
            Function::Imcsch,
            Function::Imdiv,
            Function::Imexp,
            Function::Imln,
            Function::Imlog10,
            Function::Imlog2,
            Function::Impower,
            Function::Improduct,
            Function::Imreal,
            Function::Imsec,
            Function::Imsech,
            Function::Imsin,
            Function::Imsinh,
            Function::Imsqrt,
            Function::Imsub,
            Function::Imsum,
            Function::Imtan,
            Function::Convert,
            Function::Delta,
            Function::Gestep,
            Function::Subtotal,
            Function::Aggregate,    // MACRO
            Function::Getpivotdata, // MACRO
            Function::Roman,
            Function::Arabic,
            Function::Combin,
            Function::Combina,
            Function::Sumsq,
            Function::Mdeterm,
            Function::Minverse,
            Function::Munit,
            Function::Multinomial,
            Function::Seriessum,
            Function::Sumproduct,
            Function::Percentof,
            Function::N,
            Function::Cell,
            Function::Info,
            Function::Sheets,
            Function::Daverage,
            Function::Dcount,
            Function::Dget,
            Function::Dmax,
            Function::Dmin,
            Function::Dsum,
            Function::Dcounta,
            Function::Dproduct,
            Function::Dstdev,
            Function::Dvar,
            Function::Dvarp,
            Function::Dstdevp,
            Function::BetaDist,
            Function::BetaInv,
            Function::BinomDist,
            Function::BinomDistRange,
            Function::BinomInv,
            Function::ChisqDist,
            Function::ChisqDistRT,
            Function::ChisqInv,
            Function::ChisqInvRT,
            Function::ChisqTest,
            Function::ConfidenceNorm,
            Function::ConfidenceT,
            Function::CovarianceP,
            Function::CovarianceS,
            Function::Devsq,
            Function::ExponDist,
            Function::FDist,
            Function::FDistRT,
            Function::FInv,
            Function::FInvRT,
            Function::FTest,
            Function::Fisher,
            Function::FisherInv,
            Function::Gamma,
            Function::GammaDist,
            Function::GammaInv,
            Function::GammaLn,
            Function::GammaLnPrecise,
            Function::HypGeomDist,
            Function::LogNormDist,
            Function::LogNormInv,
            Function::NegbinomDist,
            Function::NormDist,
            Function::NormInv,
            Function::NormSdist,
            Function::NormSInv,
            Function::Pearson,
            Function::Phi,
            Function::PoissonDist,
            Function::Standardize,
            Function::Stdev,
            Function::StDevP,
            Function::StDevS,
            Function::Stdeva,
            Function::Stdevpa,
            Function::TDist,
            Function::TDist2T,
            Function::TDistRT,
            Function::TInv,
            Function::TInv2T,
            Function::TTest,
            Function::VarP,
            Function::VarS,
            Function::VarpA,
            Function::VarA,
            Function::WeibullDist,
            Function::ZTest,
            Function::BetaDistCompat,
            Function::HypGeomDistCompat,
            Function::LogNormDistCompat,
            Function::NegbinomDistCompat,
            Function::NormSDistCompat,
            Function::TDistCompat,
            Function::BetaInvCompat,
            Function::BinomDistCompat,
            Function::ChiDistCompat,
            Function::ChiInvCompat,
            Function::ChiTestCompat,
            Function::ConfidenceCompat,
            Function::CovarCompat,
            Function::CritbinomCompat,
            Function::ExponDistCompat,
            Function::FDistCompat,
            Function::FInvCompat,
            Function::FTestCompat,
            Function::GammaDistCompat,
            Function::GammaInvCompat,
            Function::LoginvCompat,
            Function::ModeCompat,
            Function::NormDistCompat,
            Function::NormInvCompat,
            Function::NormSInvCompat,
            Function::PercentileCompat,
            Function::PercentrankCompat,
            Function::PoissonCompat,
            Function::QuartileCompat,
            Function::RankCompat,
            Function::StDevPCompat,
            Function::TInvCompat,
            Function::TTestCompat,
            Function::VarCompat,
            Function::VarPCompat,
            Function::WeibullCompat,
            Function::ZTestCompat,
            Function::Correl,
            Function::Rsq,
            Function::Intercept,
            Function::Slope,
            Function::Steyx,
            Function::Forecast,
            Function::ForecastLinear,
            Function::ForecastEts,
            Function::ForecastEtsConfint,
            Function::ForecastEtsSeasonality,
            Function::ForecastEtsStat,
            Function::Frequency,
            Function::Growth,
            Function::Linest,
            Function::Logest,
            Function::ModeMult,
            Function::ModeSingl,
            Function::PercentileExc,
            Function::PercentileInc,
            Function::PercentrankExc,
            Function::PercentrankInc,
            Function::Permut,
            Function::Permutationa,
            Function::Prob,
            Function::QuartileExc,
            Function::QuartileInc,
            Function::Trend,
            Function::Trimmean,
            Function::Large,
            Function::Median,
            Function::Small,
            Function::RankAvg,
            Function::RankEq,
            Function::Skew,
            Function::SkewP,
            Function::Harmean,
            Function::Gauss,
            Function::Kurt,
            Function::MaxA,
            Function::MinA,
        ]
        .into_iter()
    }
}

impl Function {
    /// Some functions in Excel like CONCAT are stringified as `_xlfn.CONCAT`. (known as "future functions")
    /// FILTER and SORT are stringified as `_xlfn._xlws.FILTER`. (known as "worksheet only functions")
    /// See <https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/3d025add-118d-4413-9856-ab65712ec1b0>
    pub fn to_xlsx_string(&self) -> String {
        match self {
            Function::Concat => "_xlfn.CONCAT".to_string(),
            Function::Ifna => "_xlfn.IFNA".to_string(),
            Function::Ifs => "_xlfn.IFS".to_string(),
            Function::Lambda => "_xlfn.LAMBDA".to_string(),
            Function::Let => "_xlfn.LET".to_string(),
            Function::Maxifs => "_xlfn.MAXIFS".to_string(),
            Function::Minifs => "_xlfn.MINIFS".to_string(),
            Function::Switch => "_xlfn.SWITCH".to_string(),
            Function::Filter => "_xlfn._xlws.FILTER".to_string(),
            Function::Sort => "_xlfn._xlws.SORT".to_string(),
            Function::Sortby => "_xlfn.SORTBY".to_string(),
            Function::Unique => "_xlfn.UNIQUE".to_string(),
            Function::Xlookup => "_xlfn.XLOOKUP".to_string(),
            Function::Xmatch => "_xlfn.XMATCH".to_string(),
            Function::Trimrange => "_xlfn.TRIMRANGE".to_string(),
            Function::Take => "_xlfn.TAKE".to_string(),
            Function::Drop => "_xlfn.DROP".to_string(),
            Function::Tocol => "_xlfn.TOCOL".to_string(),
            Function::Torow => "_xlfn.TOROW".to_string(),
            Function::Choosecols => "_xlfn.CHOOSECOLS".to_string(),
            Function::Chooserows => "_xlfn.CHOOSEROWS".to_string(),
            Function::Expand => "_xlfn.EXPAND".to_string(),
            Function::Hstack => "_xlfn.HSTACK".to_string(),
            Function::Vstack => "_xlfn.VSTACK".to_string(),
            Function::Wrapcols => "_xlfn.WRAPCOLS".to_string(),
            Function::Wraprows => "_xlfn.WRAPROWS".to_string(),
            Function::Bycol => "_xlfn.BYCOL".to_string(),
            Function::Byrow => "_xlfn.BYROW".to_string(),
            Function::Map => "_xlfn.MAP".to_string(),
            Function::Reduce => "_xlfn.REDUCE".to_string(),
            Function::Scan => "_xlfn.SCAN".to_string(),
            Function::Makearray => "_xlfn.MAKEARRAY".to_string(),
            Function::Xor => "_xlfn.XOR".to_string(),
            Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
            Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
            Function::Textsplit => "_xlfn.TEXTSPLIT".to_string(),
            Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
            Function::Sequence => "_xlfn.SEQUENCE".to_string(),
            Function::Randarray => "_xlfn.RANDARRAY".to_string(),
            Function::Unicode => "_xlfn.UNICODE".to_string(),
            Function::Unichar => "_xlfn.UNICHAR".to_string(),
            Function::Numbervalue => "_xlfn.NUMBERVALUE".to_string(),
            Function::Arraytotext => "_xlfn.ARRAYTOTEXT".to_string(),
            Function::Encodeurl => "_xlfn.ENCODEURL".to_string(),
            Function::Rri => "_xlfn.RRI".to_string(),
            Function::Pduration => "_xlfn.PDURATION".to_string(),
            Function::Bitand => "_xlfn.BITAND".to_string(),
            Function::Bitor => "_xlfn.BITOR".to_string(),
            Function::Bitxor => "_xlfn.BITXOR".to_string(),
            Function::Bitlshift => "_xlfn.BITLSHIFT".to_string(),
            Function::Bitrshift => "_xlfn.BITRSHIFT".to_string(),
            Function::Imtan => "_xlfn.IMTAN".to_string(),
            Function::Imsinh => "_xlfn.IMSINH".to_string(),
            Function::Imcosh => "_xlfn.IMCOSH".to_string(),
            Function::Imcot => "_xlfn.IMCOT".to_string(),
            Function::Imcsc => "_xlfn.IMCSC".to_string(),
            Function::Imcsch => "_xlfn.IMCSCH".to_string(),
            Function::Imsec => "_xlfn.IMSEC".to_string(),
            Function::ErfcPrecise => "_xlfn.ERFC.PRECISE".to_string(),
            Function::ErfPrecise => "_xlfn.ERF.PRECISE".to_string(),
            Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
            Function::Regexextract => "_xlfn.REGEXEXTRACT".to_string(),
            Function::Regexreplace => "_xlfn.REGEXREPLACE".to_string(),
            Function::Regextest => "_xlfn.REGEXTEST".to_string(),
            Function::Isformula => "_xlfn.ISFORMULA".to_string(),
            Function::Isomitted => "_xlfn.ISOMITTED".to_string(),
            Function::Sheet => "_xlfn.SHEET".to_string(),
            Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
            Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
            Function::Ceiling => "_xlfn.CEILING".to_string(),
            Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
            Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
            Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
            Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
            Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
            Function::Base => "_xlfn.BASE".to_string(),
            Function::Decimal => "_xlfn.DECIMAL".to_string(),
            Function::Arabic => "_xlfn.ARABIC".to_string(),
            Function::Combina => "_xlfn.COMBINA".to_string(),
            Function::Sheets => "_xlfn.SHEETS".to_string(),
            Function::Acoth => "_xlfn.ACOTH".to_string(),
            Function::Cot => "_xlfn.COT".to_string(),
            Function::Coth => "_xlfn.COTH".to_string(),
            Function::Csc => "_xlfn.CSC".to_string(),
            Function::Csch => "_xlfn.CSCH".to_string(),
            Function::Sec => "_xlfn.SEC".to_string(),
            Function::Sech => "_xlfn.SECH".to_string(),
            Function::Acot => "_xlfn.ACOT".to_string(),
            Function::GammaLnPrecise => "_xlfn.GAMMALN.PRECISE".to_string(),
            Function::Gamma => "_xlfn.GAMMA".to_string(),
            Function::GammaInv => "_xlfn.GAMMA.INV".to_string(),
            Function::GammaLn => "_xlfn.GAMMALN".to_string(),
            Function::BetaDist => "_xlfn.BETA.DIST".to_string(),
            Function::BetaInv => "_xlfn.BETA.INV".to_string(),

            Function::BinomDist => "_xlfn.BINOM.DIST".to_string(),
            Function::BinomDistRange => "_xlfn.BINOM.DIST.RANGE".to_string(),
            Function::BinomInv => "_xlfn.BINOM.INV".to_string(),
            Function::NegbinomDist => "_xlfn.NEGBINOM.DIST".to_string(),

            Function::ChisqDist => "_xlfn.CHISQ.DIST".to_string(),
            Function::ChisqDistRT => "_xlfn.CHISQ.DIST.RT".to_string(),
            Function::ChisqInv => "_xlfn.CHISQ.INV".to_string(),
            Function::ChisqInvRT => "_xlfn.CHISQ.INV.RT".to_string(),
            Function::ChisqTest => "_xlfn.CHISQ.TEST".to_string(),

            Function::ConfidenceNorm => "_xlfn.CONFIDENCE.NORM".to_string(),
            Function::ConfidenceT => "_xlfn.CONFIDENCE.T".to_string(),

            Function::CovarianceP => "_xlfn.COVARIANCE.P".to_string(),
            Function::CovarianceS => "_xlfn.COVARIANCE.S".to_string(),

            Function::ExponDist => "_xlfn.EXPON.DIST".to_string(),

            Function::FDist => "_xlfn.F.DIST".to_string(),
            Function::FDistRT => "_xlfn.F.DIST.RT".to_string(),
            Function::FInv => "_xlfn.F.INV".to_string(),
            Function::FInvRT => "_xlfn.F.INV.RT".to_string(),
            Function::FTest => "_xlfn.F.TEST".to_string(),

            Function::HypGeomDist => "_xlfn.HYPGEOM.DIST".to_string(),

            Function::LogNormDist => "_xlfn.LOGNORM.DIST".to_string(),
            Function::LogNormInv => "_xlfn.LOGNORM.INV".to_string(),

            Function::NormDist => "_xlfn.NORM.DIST".to_string(),
            Function::NormInv => "_xlfn.NORM.INV".to_string(),
            Function::NormSdist => "_xlfn.NORM.S.DIST".to_string(),
            Function::NormSInv => "_xlfn.NORM.S.INV".to_string(),

            Function::Phi => "_xlfn.PHI".to_string(),

            Function::PoissonDist => "_xlfn.POISSON.DIST".to_string(),

            Function::StDevP => "_xlfn.STDEV.P".to_string(),
            Function::StDevS => "_xlfn.STDEV.S".to_string(),

            Function::TDist => "_xlfn.T.DIST".to_string(),
            Function::TDist2T => "_xlfn.T.DIST.2T".to_string(),
            Function::TDistRT => "_xlfn.T.DIST.RT".to_string(),
            Function::TInv => "_xlfn.T.INV".to_string(),
            Function::TInv2T => "_xlfn.T.INV.2T".to_string(),
            Function::TTest => "_xlfn.T.TEST".to_string(),

            Function::VarP => "_xlfn.VAR.P".to_string(),
            Function::VarS => "_xlfn.VAR.S".to_string(),

            Function::WeibullDist => "_xlfn.WEIBULL.DIST".to_string(),
            Function::ZTest => "_xlfn.Z.TEST".to_string(),
            Function::SkewP => "_xlfn.SKEW.P".to_string(),
            Function::RankAvg => "_xlfn.RANK.AVG".to_string(),
            Function::RankEq => "_xlfn.RANK.EQ".to_string(),
            Function::Munit => "_xlfn.MUNIT".to_string(),

            Function::ModeMult => "_xlfn.MODE.MULT".to_string(),
            Function::ModeSingl => "_xlfn.MODE.SNGL".to_string(),
            Function::PercentileExc => "_xlfn.PERCENTILE.EXC".to_string(),
            Function::PercentileInc => "_xlfn.PERCENTILE.INC".to_string(),
            Function::PercentrankExc => "_xlfn.PERCENTRANK.EXC".to_string(),
            Function::PercentrankInc => "_xlfn.PERCENTRANK.INC".to_string(),
            Function::Permutationa => "_xlfn.PERMUTATIONA".to_string(),
            Function::QuartileExc => "_xlfn.QUARTILE.EXC".to_string(),
            Function::QuartileInc => "_xlfn.QUARTILE.INC".to_string(),

            Function::ForecastEts => "_xlfn.FORECAST.ETS".to_string(),
            Function::ForecastEtsConfint => "_xlfn.FORECAST.ETS.CONFINT".to_string(),
            Function::ForecastEtsSeasonality => "_xlfn.FORECAST.ETS.SEASONALITY".to_string(),
            Function::ForecastEtsStat => "_xlfn.FORECAST.ETS.STAT".to_string(),

            _ => {
                let language = get_default_language();
                self.to_localized_name(language)
            }
        }
    }

    pub(crate) fn returns_reference(&self) -> bool {
        matches!(self, Function::Indirect | Function::Offset)
    }
}

impl<'a> Model<'a> {
    pub(crate) fn evaluate_function(
        &mut self,
        kind: &Function,
        args: &[Node],
        cell: CellReferenceIndex,
    ) -> CalcResult {
        // MACRO: single-value parameters receiving ranges or arrays.
        if let Some(result) = self.evaluate_lifted_function(kind, args, cell) {
            return result;
        }
        self.dispatch_function(kind, args, cell)
    }

    pub(crate) fn dispatch_function(
        &mut self,
        kind: &Function,
        args: &[Node],
        cell: CellReferenceIndex,
    ) -> CalcResult {
        match kind {
            Function::And => self.fn_and(args, cell),
            Function::False => self.fn_false(args, cell),
            Function::If => self.fn_if(args, cell),
            Function::Iferror => self.fn_iferror(args, cell),
            Function::Ifna => self.fn_ifna(args, cell),
            Function::Ifs => self.fn_ifs(args, cell),
            Function::Lambda => self.fn_lambda(args, cell),
            Function::Let => self.fn_let(args, cell),
            Function::Not => self.fn_not(args, cell),
            Function::Or => self.fn_or(args, cell),
            Function::Switch => self.fn_switch(args, cell),
            Function::True => self.fn_true(args, cell),
            Function::Xor => self.fn_xor(args, cell),
            Function::Bycol => self.fn_bycol(args, cell),
            Function::Byrow => self.fn_byrow(args, cell),
            Function::Map => self.fn_map(args, cell),
            Function::Reduce => self.fn_reduce(args, cell),
            Function::Scan => self.fn_scan(args, cell),
            Function::Makearray => self.fn_makearray(args, cell),
            Function::Log => self.fn_log(args, cell),
            Function::Log10 => self.fn_log10(args, cell),
            Function::Ln => self.fn_ln(args, cell),
            Function::Sin => self.fn_sin(args, cell),
            Function::Cos => self.fn_cos(args, cell),
            Function::Tan => self.fn_tan(args, cell),
            Function::Asin => self.fn_asin(args, cell),
            Function::Acos => self.fn_acos(args, cell),
            Function::Atan => self.fn_atan(args, cell),
            Function::Sinh => self.fn_sinh(args, cell),
            Function::Cosh => self.fn_cosh(args, cell),
            Function::Tanh => self.fn_tanh(args, cell),
            Function::Asinh => self.fn_asinh(args, cell),
            Function::Acosh => self.fn_acosh(args, cell),
            Function::Atanh => self.fn_atanh(args, cell),
            Function::Pi => self.fn_pi(args, cell),
            Function::Abs => self.fn_abs(args, cell),
            Function::Sqrt => self.fn_sqrt(args, cell),
            Function::Sqrtpi => self.fn_sqrtpi(args, cell),
            Function::Atan2 => self.fn_atan2(args, cell),
            Function::Power => self.fn_power(args, cell),
            Function::Max => self.fn_max(args, cell),
            Function::Min => self.fn_min(args, cell),
            Function::Product => self.fn_product(args, cell),
            Function::Rand => self.fn_rand(args, cell),
            Function::Randbetween => self.fn_randbetween(args, cell),
            Function::Round => self.fn_round(args, cell),
            Function::Rounddown => self.fn_rounddown(args, cell),
            Function::Roundup => self.fn_roundup(args, cell),
            Function::Sum => self.fn_sum(args, cell),
            Function::Sumif => self.fn_sumif(args, cell),
            Function::Sumifs => self.fn_sumifs(args, cell),
            Function::Choose => self.fn_choose(args, cell),
            Function::Column => self.fn_column(args, cell),
            Function::Address => self.fn_address(args, cell),
            Function::Areas => self.fn_areas(args, cell),
            Function::Columns => self.fn_columns(args, cell),
            Function::Choosecols => self.fn_choosecols(args, cell),
            Function::Chooserows => self.fn_chooserows(args, cell),
            Function::Expand => self.fn_expand(args, cell),
            Function::Index => self.fn_index(args, cell),
            Function::Indirect => self.fn_indirect(args, cell),
            Function::Hlookup => self.fn_hlookup(args, cell),
            Function::Hstack => self.fn_hstack(args, cell),
            Function::Hyperlink => self.fn_hyperlink(args, cell),
            Function::Lookup => self.fn_lookup(args, cell),
            Function::Match => self.fn_match(args, cell),
            Function::Offset => self.fn_offset(args, cell),
            Function::Row => self.fn_row(args, cell),
            Function::Rows => self.fn_rows(args, cell),
            Function::Filter => self.fn_filter(args, cell),
            Function::Sort => self.fn_sort(args, cell),
            Function::Sortby => self.fn_sortby(args, cell),
            Function::Unique => self.fn_unique(args, cell),
            Function::Vlookup => self.fn_vlookup(args, cell),
            Function::Vstack => self.fn_vstack(args, cell),
            Function::Wrapcols => self.fn_wrapcols(args, cell),
            Function::Wraprows => self.fn_wraprows(args, cell),
            Function::Xlookup => self.fn_xlookup(args, cell),
            Function::Xmatch => self.fn_xmatch(args, cell),
            Function::Trimrange => self.fn_trimrange(args, cell),
            Function::Take => self.fn_take(args, cell),
            Function::Drop => self.fn_drop(args, cell),
            Function::Tocol => self.fn_tocol(args, cell),
            Function::Torow => self.fn_torow(args, cell),
            Function::Transpose => self.fn_transpose(args, cell),
            Function::Mmult => self.fn_mmult(args, cell),
            Function::Sequence => self.fn_sequence(args, cell),
            Function::Randarray => self.fn_randarray(args, cell),
            Function::Concatenate => self.fn_concatenate(args, cell),
            Function::Exact => self.fn_exact(args, cell),
            Function::Value => self.fn_value(args, cell),
            Function::T => self.fn_t(args, cell),
            Function::Valuetotext => self.fn_valuetotext(args, cell),
            Function::Concat => self.fn_concat(args, cell),
            Function::Find => self.fn_find(args, cell),
            Function::Left => self.fn_left(args, cell),
            Function::Len => self.fn_len(args, cell),
            Function::Lower => self.fn_lower(args, cell),
            Function::Mid => self.fn_mid(args, cell),
            Function::Right => self.fn_right(args, cell),
            Function::Search => self.fn_search(args, cell),
            Function::Text => self.fn_text(args, cell),
            Function::Trim => self.fn_trim(args, cell),
            Function::Unicode => self.fn_unicode(args, cell),
            Function::Unichar => self.fn_unichar(args, cell),
            Function::Char => self.fn_char(args, cell),
            Function::Clean => self.fn_clean(args, cell),
            Function::Code => self.fn_code(args, cell),
            Function::Asc => self.fn_asc(args, cell),
            Function::Arraytotext => self.fn_arraytotext(args, cell),
            Function::Dollar => self.fn_dollar(args, cell),
            Function::Encodeurl => self.fn_encodeurl(args, cell),
            Function::Findb => self.fn_findb(args, cell),
            Function::Fixed => self.fn_fixed(args, cell),
            Function::Leftb => self.fn_leftb(args, cell),
            Function::Lenb => self.fn_lenb(args, cell),
            Function::Midb => self.fn_midb(args, cell),
            Function::Numbervalue => self.fn_numbervalue(args, cell),
            Function::Proper => self.fn_proper(args, cell),
            Function::Replace => self.fn_replace(args, cell),
            Function::Replaceb => self.fn_replaceb(args, cell),
            Function::Rightb => self.fn_rightb(args, cell),
            Function::Searchb => self.fn_searchb(args, cell),
            Function::Upper => self.fn_upper(args, cell),
            Function::Isnumber => self.fn_isnumber(args, cell),
            Function::Isnontext => self.fn_isnontext(args, cell),
            Function::Istext => self.fn_istext(args, cell),
            Function::Islogical => self.fn_islogical(args, cell),
            Function::Isblank => self.fn_isblank(args, cell),
            Function::Iserr => self.fn_iserr(args, cell),
            Function::Iserror => self.fn_iserror(args, cell),
            Function::Isna => self.fn_isna(args, cell),
            Function::Na => CalcResult::new_error(Error::NA, cell, "".to_string()),
            Function::Isref => self.fn_isref(args, cell),
            Function::Isodd => self.fn_isodd(args, cell),
            Function::Isomitted => self.fn_isomitted(args, cell),
            Function::Iseven => self.fn_iseven(args, cell),
            Function::ErrorType => self.fn_errortype(args, cell),
            Function::Formulatext => self.fn_formulatext(args, cell),
            Function::Isformula => self.fn_isformula(args, cell),
            Function::Type => self.fn_type(args, cell),
            Function::Sheet => self.fn_sheet(args, cell),
            Function::Average => self.fn_average(args, cell),
            Function::Averagea => self.fn_averagea(args, cell),
            Function::Avedev => self.fn_avedev(args, cell),
            Function::Averageif => self.fn_averageif(args, cell),
            Function::Averageifs => self.fn_averageifs(args, cell),
            Function::Count => self.fn_count(args, cell),
            Function::Counta => self.fn_counta(args, cell),
            Function::Countblank => self.fn_countblank(args, cell),
            Function::Countif => self.fn_countif(args, cell),
            Function::Countifs => self.fn_countifs(args, cell),
            Function::Maxifs => self.fn_maxifs(args, cell),
            Function::Minifs => self.fn_minifs(args, cell),
            Function::Geomean => self.fn_geomean(args, cell),
            Function::Year => self.fn_year(args, cell),
            Function::Day => self.fn_day(args, cell),
            Function::Eomonth => self.fn_eomonth(args, cell),
            Function::Month => self.fn_month(args, cell),
            Function::Date => self.fn_date(args, cell),
            Function::Datedif => self.fn_datedif(args, cell),
            Function::Datevalue => self.fn_datevalue(args, cell),
            Function::Edate => self.fn_edate(args, cell),
            Function::Networkdays => self.fn_networkdays(args, cell),
            Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
            Function::Time => self.fn_time(args, cell),
            Function::Timevalue => self.fn_timevalue(args, cell),
            Function::Hour => self.fn_hour(args, cell),
            Function::Minute => self.fn_minute(args, cell),
            Function::Second => self.fn_second(args, cell),
            Function::Today => self.fn_today(args, cell),
            Function::Now => self.fn_now(args, cell),
            Function::Days => self.fn_days(args, cell),
            Function::Days360 => self.fn_days360(args, cell),
            Function::Weekday => self.fn_weekday(args, cell),
            Function::Weeknum => self.fn_weeknum(args, cell),
            Function::Workday => self.fn_workday(args, cell),
            Function::WorkdayIntl => self.fn_workday_intl(args, cell),
            Function::Yearfrac => self.fn_yearfrac(args, cell),
            Function::Isoweeknum => self.fn_isoweeknum(args, cell),
            Function::Pmt => self.fn_pmt(args, cell),
            Function::Pv => self.fn_pv(args, cell),
            Function::Rate => self.fn_rate(args, cell),
            Function::Nper => self.fn_nper(args, cell),
            Function::Fv => self.fn_fv(args, cell),
            Function::Ppmt => self.fn_ppmt(args, cell),
            Function::Ipmt => self.fn_ipmt(args, cell),
            Function::Npv => self.fn_npv(args, cell),
            Function::Mirr => self.fn_mirr(args, cell),
            Function::Irr => self.fn_irr(args, cell),
            Function::Xirr => self.fn_xirr(args, cell),
            Function::Xnpv => self.fn_xnpv(args, cell),
            Function::Rept => self.fn_rept(args, cell),
            Function::Textafter => self.fn_textafter(args, cell),
            Function::Textbefore => self.fn_textbefore(args, cell),
            Function::Textsplit => self.fn_textsplit(args, cell),
            Function::Textjoin => self.fn_textjoin(args, cell),
            Function::Substitute => self.fn_substitute(args, cell),
            Function::Regexextract => self.fn_regexextract(args, cell),
            Function::Regexreplace => self.fn_regexreplace(args, cell),
            Function::Regextest => self.fn_regextest(args, cell),
            Function::Ispmt => self.fn_ispmt(args, cell),
            Function::Rri => self.fn_rri(args, cell),
            Function::Sln => self.fn_sln(args, cell),
            Function::Syd => self.fn_syd(args, cell),
            Function::Nominal => self.fn_nominal(args, cell),
            Function::Effect => self.fn_effect(args, cell),
            Function::Pduration => self.fn_pduration(args, cell),
            Function::Tbillyield => self.fn_tbillyield(args, cell),
            Function::Tbillprice => self.fn_tbillprice(args, cell),
            Function::Tbilleq => self.fn_tbilleq(args, cell),
            Function::Dollarde => self.fn_dollarde(args, cell),
            Function::Dollarfr => self.fn_dollarfr(args, cell),
            Function::Ddb => self.fn_ddb(args, cell),
            Function::Db => self.fn_db(args, cell),
            Function::Cumprinc => self.fn_cumprinc(args, cell),
            Function::Cumipmt => self.fn_cumipmt(args, cell),
            Function::Accrint => self.fn_accrint(args, cell),
            Function::Accrintm => self.fn_accrintm(args, cell),
            Function::Disc => self.fn_disc(args, cell),
            Function::Fvschedule => self.fn_fvschedule(args, cell),
            Function::Intrate => self.fn_intrate(args, cell),
            Function::Pricedisc => self.fn_pricedisc(args, cell),
            Function::Pricemat => self.fn_pricemat(args, cell),
            Function::Received => self.fn_received(args, cell),
            Function::Yielddisc => self.fn_yielddisc(args, cell),
            Function::Yieldmat => self.fn_yieldmat(args, cell),
            Function::Duration => self.fn_duration(args, cell),
            Function::Mduration => self.fn_mduration(args, cell),
            Function::Price => self.fn_price(args, cell),
            Function::Yield => self.fn_yield(args, cell),
            Function::Oddfprice => self.fn_oddfprice(args, cell),
            Function::Oddfyield => self.fn_oddfyield(args, cell),
            Function::Oddlprice => self.fn_oddlprice(args, cell),
            Function::Oddlyield => self.fn_oddlyield(args, cell),
            Function::Coupdaybs => self.fn_coupdaybs(args, cell),
            Function::Coupdays => self.fn_coupdays(args, cell),
            Function::Coupdaysnc => self.fn_coupdaysnc(args, cell),
            Function::Coupncd => self.fn_coupncd(args, cell),
            Function::Coupnum => self.fn_coupnum(args, cell),
            Function::Couppcd => self.fn_couppcd(args, cell),
            Function::Amordegrc => self.fn_amordegrc(args, cell),
            Function::Amorlinc => self.fn_amorlinc(args, cell),
            Function::Vdb => self.fn_vdb(args, cell),
            Function::Besseli => self.fn_besseli(args, cell),
            Function::Besselj => self.fn_besselj(args, cell),
            Function::Besselk => self.fn_besselk(args, cell),
            Function::Bessely => self.fn_bessely(args, cell),
            Function::Erf => self.fn_erf(args, cell),
            Function::ErfPrecise => self.fn_erfprecise(args, cell),
            Function::Erfc => self.fn_erfc(args, cell),
            Function::ErfcPrecise => self.fn_erfcprecise(args, cell),
            Function::Bin2dec => self.fn_bin2dec(args, cell),
            Function::Bin2hex => self.fn_bin2hex(args, cell),
            Function::Bin2oct => self.fn_bin2oct(args, cell),
            Function::Dec2Bin => self.fn_dec2bin(args, cell),
            Function::Dec2hex => self.fn_dec2hex(args, cell),
            Function::Dec2oct => self.fn_dec2oct(args, cell),
            Function::Hex2bin => self.fn_hex2bin(args, cell),
            Function::Hex2dec => self.fn_hex2dec(args, cell),
            Function::Hex2oct => self.fn_hex2oct(args, cell),
            Function::Oct2bin => self.fn_oct2bin(args, cell),
            Function::Oct2dec => self.fn_oct2dec(args, cell),
            Function::Oct2hex => self.fn_oct2hex(args, cell),
            Function::Bitand => self.fn_bitand(args, cell),
            Function::Bitlshift => self.fn_bitlshift(args, cell),
            Function::Bitor => self.fn_bitor(args, cell),
            Function::Bitrshift => self.fn_bitrshift(args, cell),
            Function::Bitxor => self.fn_bitxor(args, cell),
            Function::Complex => self.fn_complex(args, cell),
            Function::Imabs => self.fn_imabs(args, cell),
            Function::Imaginary => self.fn_imaginary(args, cell),
            Function::Imargument => self.fn_imargument(args, cell),
            Function::Imconjugate => self.fn_imconjugate(args, cell),
            Function::Imcos => self.fn_imcos(args, cell),
            Function::Imcosh => self.fn_imcosh(args, cell),
            Function::Imcot => self.fn_imcot(args, cell),
            Function::Imcsc => self.fn_imcsc(args, cell),
            Function::Imcsch => self.fn_imcsch(args, cell),
            Function::Imdiv => self.fn_imdiv(args, cell),
            Function::Imexp => self.fn_imexp(args, cell),
            Function::Imln => self.fn_imln(args, cell),
            Function::Imlog10 => self.fn_imlog10(args, cell),
            Function::Imlog2 => self.fn_imlog2(args, cell),
            Function::Impower => self.fn_impower(args, cell),
            Function::Improduct => self.fn_improduct(args, cell),
            Function::Imreal => self.fn_imreal(args, cell),
            Function::Imsec => self.fn_imsec(args, cell),
            Function::Imsech => self.fn_imsech(args, cell),
            Function::Imsin => self.fn_imsin(args, cell),
            Function::Imsinh => self.fn_imsinh(args, cell),
            Function::Imsqrt => self.fn_imsqrt(args, cell),
            Function::Imsub => self.fn_imsub(args, cell),
            Function::Imsum => self.fn_imsum(args, cell),
            Function::Imtan => self.fn_imtan(args, cell),
            Function::Convert => self.fn_convert(args, cell),
            Function::Delta => self.fn_delta(args, cell),
            Function::Gestep => self.fn_gestep(args, cell),
            Function::Subtotal => self.fn_subtotal(args, cell),
            Function::Aggregate => self.fn_aggregate(args, cell), // MACRO
            Function::Getpivotdata => self.fn_getpivotdata(args, cell), // MACRO
            Function::Acot => self.fn_acot(args, cell),
            Function::Acoth => self.fn_acoth(args, cell),
            Function::Cot => self.fn_cot(args, cell),
            Function::Coth => self.fn_coth(args, cell),
            Function::Csc => self.fn_csc(args, cell),
            Function::Csch => self.fn_csch(args, cell),
            Function::Sec => self.fn_sec(args, cell),
            Function::Sech => self.fn_sech(args, cell),
            Function::Exp => self.fn_exp(args, cell),
            Function::Fact => self.fn_fact(args, cell),
            Function::Factdouble => self.fn_factdouble(args, cell),
            Function::Sign => self.fn_sign(args, cell),
            Function::Radians => self.fn_radians(args, cell),
            Function::Degrees => self.fn_degrees(args, cell),
            Function::Int => self.fn_int(args, cell),
            Function::Even => self.fn_even(args, cell),
            Function::Odd => self.fn_odd(args, cell),
            Function::Ceiling => self.fn_ceiling(args, cell),
            Function::CeilingMath => self.fn_ceiling_math(args, cell),
            Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
            Function::Floor => self.fn_floor(args, cell),
            Function::FloorMath => self.fn_floor_math(args, cell),
            Function::FloorPrecise => self.fn_floor_precise(args, cell),
            Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
            Function::Mod => self.fn_mod(args, cell),
            Function::Quotient => self.fn_quotient(args, cell),
            Function::Mround => self.fn_mround(args, cell),
            Function::Trunc => self.fn_trunc(args, cell),
            Function::Gcd => self.fn_gcd(args, cell),
            Function::Lcm => self.fn_lcm(args, cell),
            Function::Base => self.fn_base(args, cell),
            Function::Decimal => self.fn_decimal(args, cell),
            Function::Roman => self.fn_roman(args, cell),
            Function::Arabic => self.fn_arabic(args, cell),
            Function::Combin => self.fn_combin(args, cell),
            Function::Combina => self.fn_combina(args, cell),
            Function::Sumsq => self.fn_sumsq(args, cell),
            Function::Mdeterm => self.fn_mdeterm(args, cell),
            Function::Minverse => self.fn_minverse(args, cell),
            Function::Munit => self.fn_munit(args, cell),
            Function::Multinomial => self.fn_multinomial(args, cell),
            Function::Seriessum => self.fn_seriessum(args, cell),
            Function::Sumproduct => self.fn_sumproduct(args, cell),
            Function::Percentof => self.fn_percentof(args, cell),
            Function::N => self.fn_n(args, cell),
            Function::Cell => self.fn_cell(args, cell),
            Function::Info => self.fn_info(args, cell),
            Function::Sheets => self.fn_sheets(args, cell),
            Function::Daverage => self.fn_daverage(args, cell),
            Function::Dcount => self.fn_dcount(args, cell),
            Function::Dget => self.fn_dget(args, cell),
            Function::Dmax => self.fn_dmax(args, cell),
            Function::Dmin => self.fn_dmin(args, cell),
            Function::Dsum => self.fn_dsum(args, cell),
            Function::Dcounta => self.fn_dcounta(args, cell),
            Function::Dproduct => self.fn_dproduct(args, cell),
            Function::Dstdev => self.fn_dstdev(args, cell),
            Function::Dvar => self.fn_dvar(args, cell),
            Function::Dvarp => self.fn_dvarp(args, cell),
            Function::Dstdevp => self.fn_dstdevp(args, cell),
            Function::BetaDist => self.fn_beta_dist(args, cell),
            Function::BetaInv => self.fn_beta_inv(args, cell),
            Function::BinomDist => self.fn_binom_dist(args, cell),
            Function::BinomDistRange => self.fn_binom_dist_range(args, cell),
            Function::BinomInv => self.fn_binom_inv(args, cell),
            Function::ChisqDist => self.fn_chisq_dist(args, cell),
            Function::ChisqDistRT => self.fn_chisq_dist_rt(args, cell),
            Function::ChisqInv => self.fn_chisq_inv(args, cell),
            Function::ChisqInvRT => self.fn_chisq_inv_rt(args, cell),
            Function::ChisqTest => self.fn_chisq_test(args, cell),
            Function::ConfidenceNorm => self.fn_confidence_norm(args, cell),
            Function::ConfidenceT => self.fn_confidence_t(args, cell),
            Function::CovarianceP => self.fn_covariance_p(args, cell),
            Function::CovarianceS => self.fn_covariance_s(args, cell),
            Function::Devsq => self.fn_devsq(args, cell),
            Function::ExponDist => self.fn_expon_dist(args, cell),
            Function::FDist => self.fn_f_dist(args, cell),
            Function::FDistRT => self.fn_f_dist_rt(args, cell),
            Function::FInv => self.fn_f_inv(args, cell),
            Function::FInvRT => self.fn_f_inv_rt(args, cell),
            Function::Fisher => self.fn_fisher(args, cell),
            Function::FisherInv => self.fn_fisher_inv(args, cell),
            Function::FTest => self.fn_f_test(args, cell),
            Function::Gamma => self.fn_gamma(args, cell),
            Function::GammaDist => self.fn_gamma_dist(args, cell),
            Function::GammaInv => self.fn_gamma_inv(args, cell),
            Function::GammaLn => self.fn_gamma_ln(args, cell),
            Function::GammaLnPrecise => self.fn_gamma_ln_precise(args, cell),
            Function::HypGeomDist => self.fn_hyp_geom_dist(args, cell),
            Function::LogNormDist => self.fn_log_norm_dist(args, cell),
            Function::LogNormInv => self.fn_log_norm_inv(args, cell),
            Function::NegbinomDist => self.fn_negbinom_dist(args, cell),
            Function::NormDist => self.fn_norm_dist(args, cell),
            Function::NormInv => self.fn_norm_inv(args, cell),
            Function::NormSdist => self.fn_norm_s_dist(args, cell),
            Function::NormSInv => self.fn_norm_s_inv(args, cell),
            Function::Pearson => self.fn_pearson(args, cell),
            Function::Phi => self.fn_phi(args, cell),
            Function::PoissonDist => self.fn_poisson_dist(args, cell),
            Function::Standardize => self.fn_standardize(args, cell),
            Function::Stdev => self.fn_stdev_s(args, cell),
            Function::StDevP => self.fn_stdev_p(args, cell),
            Function::StDevS => self.fn_stdev_s(args, cell),
            Function::Stdeva => self.fn_stdeva(args, cell),
            Function::Stdevpa => self.fn_stdevpa(args, cell),
            Function::TDist => self.fn_t_dist(args, cell),
            Function::TDist2T => self.fn_t_dist_2t(args, cell),
            Function::TDistRT => self.fn_t_dist_rt(args, cell),
            Function::TInv => self.fn_t_inv(args, cell),
            Function::TInv2T => self.fn_t_inv_2t(args, cell),
            Function::TTest => self.fn_t_test(args, cell),
            Function::VarP => self.fn_var_p(args, cell),
            Function::VarS => self.fn_var_s(args, cell),
            Function::VarpA => self.fn_varpa(args, cell),
            Function::VarA => self.fn_vara(args, cell),
            Function::WeibullDist => self.fn_weibull_dist(args, cell),
            Function::ZTest => self.fn_z_test(args, cell),
            Function::BetaDistCompat => self.fn_betadist_compat(args, cell),
            Function::HypGeomDistCompat => self.fn_hypgeomdist_compat(args, cell),
            Function::LogNormDistCompat => self.fn_lognormdist_compat(args, cell),
            Function::NegbinomDistCompat => self.fn_negbinomdist_compat(args, cell),
            Function::NormSDistCompat => self.fn_normsdist_compat(args, cell),
            Function::TDistCompat => self.fn_tdist_compat(args, cell),
            Function::BetaInvCompat => self.fn_beta_inv(args, cell),
            Function::BinomDistCompat => self.fn_binom_dist(args, cell),
            Function::ChiDistCompat => self.fn_chisq_dist_rt(args, cell),
            Function::ChiInvCompat => self.fn_chisq_inv_rt(args, cell),
            Function::ChiTestCompat => self.fn_chisq_test(args, cell),
            Function::ConfidenceCompat => self.fn_confidence_norm(args, cell),
            Function::CovarCompat => self.fn_covariance_p(args, cell),
            Function::CritbinomCompat => self.fn_binom_inv(args, cell),
            Function::ExponDistCompat => self.fn_expon_dist(args, cell),
            Function::FDistCompat => self.fn_f_dist_rt(args, cell),
            Function::FInvCompat => self.fn_f_inv_rt(args, cell),
            Function::FTestCompat => self.fn_f_test(args, cell),
            Function::GammaDistCompat => self.fn_gamma_dist(args, cell),
            Function::GammaInvCompat => self.fn_gamma_inv(args, cell),
            Function::LoginvCompat => self.fn_log_norm_inv(args, cell),
            Function::ModeCompat => self.fn_mode_sngl(args, cell),
            Function::NormDistCompat => self.fn_norm_dist(args, cell),
            Function::NormInvCompat => self.fn_norm_inv(args, cell),
            Function::NormSInvCompat => self.fn_norm_s_inv(args, cell),
            Function::PercentileCompat => self.fn_percentile_inc(args, cell),
            Function::PercentrankCompat => self.fn_percentrank_inc(args, cell),
            Function::PoissonCompat => self.fn_poisson_dist(args, cell),
            Function::QuartileCompat => self.fn_quartile_inc(args, cell),
            Function::RankCompat => self.fn_rank_eq(args, cell),
            Function::StDevPCompat => self.fn_stdev_p(args, cell),
            Function::TInvCompat => self.fn_t_inv_2t(args, cell),
            Function::TTestCompat => self.fn_t_test(args, cell),
            Function::VarCompat => self.fn_var_s(args, cell),
            Function::VarPCompat => self.fn_var_p(args, cell),
            Function::WeibullCompat => self.fn_weibull_dist(args, cell),
            Function::ZTestCompat => self.fn_z_test(args, cell),
            Function::Sumx2my2 => self.fn_sumx2my2(args, cell),
            Function::Sumx2py2 => self.fn_sumx2py2(args, cell),
            Function::Sumxmy2 => self.fn_sumxmy2(args, cell),
            Function::Correl => self.fn_correl(args, cell),
            Function::Rsq => self.fn_rsq(args, cell),
            Function::Intercept => self.fn_intercept(args, cell),
            Function::Slope => self.fn_slope(args, cell),
            Function::Steyx => self.fn_steyx(args, cell),
            Function::Forecast => self.fn_forecast(args, cell),
            Function::ForecastLinear => self.fn_forecast_linear(args, cell),
            Function::ForecastEts => self.fn_forecast_ets(args, cell),
            Function::ForecastEtsConfint => self.fn_forecast_ets_confint(args, cell),
            Function::ForecastEtsSeasonality => self.fn_forecast_ets_seasonality(args, cell),
            Function::ForecastEtsStat => self.fn_forecast_ets_stat(args, cell),
            Function::Frequency => self.fn_frequency(args, cell),
            Function::Growth => self.fn_growth(args, cell),
            Function::Linest => self.fn_linest(args, cell),
            Function::Logest => self.fn_logest(args, cell),
            Function::ModeMult => self.fn_mode_mult(args, cell),
            Function::ModeSingl => self.fn_mode_sngl(args, cell),
            Function::PercentileExc => self.fn_percentile_exc(args, cell),
            Function::PercentileInc => self.fn_percentile_inc(args, cell),
            Function::PercentrankExc => self.fn_percentrank_exc(args, cell),
            Function::PercentrankInc => self.fn_percentrank_inc(args, cell),
            Function::Permut => self.fn_permut(args, cell),
            Function::Permutationa => self.fn_permutationa(args, cell),
            Function::Prob => self.fn_prob(args, cell),
            Function::QuartileExc => self.fn_quartile_exc(args, cell),
            Function::QuartileInc => self.fn_quartile_inc(args, cell),
            Function::Trend => self.fn_trend(args, cell),
            Function::Trimmean => self.fn_trimmean(args, cell),
            Function::Gauss => self.fn_gauss(args, cell),
            Function::Harmean => self.fn_harmean(args, cell),
            Function::Kurt => self.fn_kurt(args, cell),
            Function::Large => self.fn_large(args, cell),
            Function::MaxA => self.fn_maxa(args, cell),
            Function::Median => self.fn_median(args, cell),
            Function::MinA => self.fn_mina(args, cell),
            Function::RankAvg => self.fn_rank_avg(args, cell),
            Function::RankEq => self.fn_rank_eq(args, cell),
            Function::Skew => self.fn_skew(args, cell),
            Function::SkewP => self.fn_skew_p(args, cell),
            Function::Small => self.fn_small(args, cell),
        }
    }
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used)]
    use std::{
        fs::File,
        io::{BufRead, BufReader},
    };

    #[test]
    fn function_iterator() {
        // This checks that the number of functions in the enum is the same
        // as the number of functions in the Iterator.

        // This is tricky. In Rust we cannot loop over all the members of an enum.
        // There are alternatives like using an external crate like strum.
        // But I am not in the mood for that.

        // What we do here is read this file , extract the functions in the enum
        // and check they are the same as in the iterator
        let file = File::open("src/functions/mod.rs").unwrap();
        let reader = BufReader::new(file);
        let mut start = false;
        let mut list = Vec::new();

        for line in reader.lines() {
            let text = line.unwrap();
            let text = text.trim().trim_end_matches(',');
            if text == "pub enum Function {" {
                start = true;
                continue;
            }
            if start {
                if text == "}" {
                    break;
                }
                if text.starts_with("//") {
                    // skip comments
                    continue;
                }
                if text.is_empty() {
                    // skip empty lines
                    continue;
                }
                list.push(text.to_owned());
            }
        }
        // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
        // let iter_list = Function::into_iter()
        //     .map(|f| format!("{f}").replace('.', ""))
        //     .collect::<Vec<_>>();

        // let len = iter_list.len();

        // assert_eq!(list.len(), len);
        // // We still need to check there are no duplicates. This will fail if a function in iter_list
        // // is included twice and one is missing
        // for function in list {
        //     assert!(iter_list.contains(&function.to_uppercase()));
        // }
    }
}