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