public static void Register(CalcEngine ce) { ce.RegisterFunction("ASC", 1, Asc); // Changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters //ce.RegisterFunction("BAHTTEXT Converts a number to text, using the ß (baht) currency format ce.RegisterFunction("CHAR", 1, _Char); // Returns the character specified by the code number ce.RegisterFunction("CLEAN", 1, Clean); // Removes all nonprintable characters from text ce.RegisterFunction("CODE", 1, Code); // Returns a numeric code for the first character in a text string ce.RegisterFunction("CONCATENATE", 1, int.MaxValue, Concat); // Joins several text items into one text item ce.RegisterFunction("DOLLAR", 1, 2, Dollar); // Converts a number to text, using the $ (dollar) currency format ce.RegisterFunction("EXACT", 2, Exact); // Checks to see if two text values are identical ce.RegisterFunction("FIND", 2, 3, Find); //Finds one text value within another (case-sensitive) ce.RegisterFunction("FIXED", 1, 3, Fixed); // Formats a number as text with a fixed number of decimals //ce.RegisterFunction("JIS Changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters ce.RegisterFunction("LEFT", 1, 2, Left); // LEFTB Returns the leftmost characters from a text value ce.RegisterFunction("LEN", 1, Len); //, Returns the number of characters in a text string ce.RegisterFunction("LOWER", 1, Lower); // Converts text to lowercase ce.RegisterFunction("MID", 3, Mid); // Returns a specific number of characters from a text string starting at the position you specify //ce.RegisterFunction("PHONETIC Extracts the phonetic (furigana) characters from a text string ce.RegisterFunction("PROPER", 1, Proper); // Capitalizes the first letter in each word of a text value ce.RegisterFunction("REPLACE", 4, Replace); // Replaces characters within text ce.RegisterFunction("REPT", 2, Rept); // Repeats text a given number of times ce.RegisterFunction("RIGHT", 1, 2, Right); // Returns the rightmost characters from a text value ce.RegisterFunction("SEARCH", 2, Search); // Finds one text value within another (not case-sensitive) ce.RegisterFunction("SUBSTITUTE", 3, 4, Substitute); // Substitutes new text for old text in a text string ce.RegisterFunction("T", 1, T); // Converts its arguments to text ce.RegisterFunction("TEXT", 2, _Text); // Formats a number and converts it to text ce.RegisterFunction("TRIM", 1, Trim); // Removes spaces from text ce.RegisterFunction("UPPER", 1, Upper); // Converts text to uppercase ce.RegisterFunction("VALUE", 1, Value); // Converts a text argument to a number ce.RegisterFunction("HYPERLINK", 1, Hyperlink); }
public static void Register(CalcEngine ce) { ce.RegisterFunction("AND", 1, int.MaxValue, And); ce.RegisterFunction("OR", 1, int.MaxValue, Or); ce.RegisterFunction("NOT", 1, Not); ce.RegisterFunction("IF", 2, 3, If); ce.RegisterFunction("TRUE", 0, True); ce.RegisterFunction("FALSE", 0, False); }
public ExpressionCache(CalcEngine ce) { _ce = ce; _dct = new Dictionary<string, WeakReference>(); }
private static bool ValueSatisfiesCriteria(object value, object criteria, CalcEngine ce) { // safety... if (value == null) { return false; } // if criteria is a number, straight comparison if (criteria is double) { return (double) value == (double) criteria; } // convert criteria to string var cs = criteria as string; if (!string.IsNullOrEmpty(cs)) { // if criteria is an expression (e.g. ">20"), use calc engine if (cs[0] == '=' || cs[0] == '<' || cs[0] == '>') { // build expression var expression = string.Format("{0}{1}", value, cs); // add quotes if necessary var pattern = @"(\w+)(\W+)(\w+)"; var m = Regex.Match(expression, pattern); if (m.Groups.Count == 4) { double d; if (!double.TryParse(m.Groups[1].Value, out d) || !double.TryParse(m.Groups[3].Value, out d)) { expression = string.Format("\"{0}\"{1}\"{2}\"", m.Groups[1].Value, m.Groups[2].Value, m.Groups[3].Value); } } // evaluate return (bool) ce.Evaluate(expression); } // if criteria is a regular expression, use regex if (cs.IndexOf('*') > -1) { var pattern = cs.Replace(@"\", @"\\"); pattern = pattern.Replace(".", @"\"); pattern = pattern.Replace("*", ".*"); return Regex.IsMatch(value.ToString(), pattern, RegexOptions.IgnoreCase); } // straight string comparison return string.Equals(value.ToString(), cs, StringComparison.OrdinalIgnoreCase); } // should never get here? Debug.Assert(false, "failed to evaluate criteria in SumIf"); return false; }
private static object SumIf(List<Expression> p) { // get parameters var range = p[0] as IEnumerable; var sumRange = p.Count < 3 ? range : p[2] as IEnumerable; var criteria = p[1].Evaluate(); // build list of values in range and sumRange var rangeValues = new List<object>(); foreach (var value in range) { rangeValues.Add(value); } var sumRangeValues = new List<object>(); foreach (var value in sumRange) { sumRangeValues.Add(value); } // compute total var ce = new CalcEngine(); var tally = new Tally(); for (var i = 0; i < Math.Min(rangeValues.Count, sumRangeValues.Count); i++) { if (ValueSatisfiesCriteria(rangeValues[i], criteria, ce)) { tally.AddValue(sumRangeValues[i]); } } // done return tally.Sum(); }
public static void Register(CalcEngine ce) { ce.RegisterFunction("ABS", 1, Abs); ce.RegisterFunction("ACOS", 1, Acos); ce.RegisterFunction("ACOSH", 1, Acosh); ce.RegisterFunction("ASIN", 1, Asin); ce.RegisterFunction("ASINH", 1, Asinh); ce.RegisterFunction("ATAN", 1, Atan); ce.RegisterFunction("ATAN2", 2, Atan2); ce.RegisterFunction("ATANH", 1, Atanh); ce.RegisterFunction("CEILING", 1, Ceiling); ce.RegisterFunction("COMBIN", 2, Combin); ce.RegisterFunction("COS", 1, Cos); ce.RegisterFunction("COSH", 1, Cosh); ce.RegisterFunction("DEGREES", 1, Degrees); ce.RegisterFunction("EVEN", 1, Even); ce.RegisterFunction("EXP", 1, Exp); ce.RegisterFunction("FACT", 1, Fact); ce.RegisterFunction("FACTDOUBLE", 1, FactDouble); ce.RegisterFunction("FLOOR", 1, Floor); ce.RegisterFunction("GCD", 1, 255, Gcd); ce.RegisterFunction("INT", 1, Int); ce.RegisterFunction("LCM", 1, 255, Lcm); ce.RegisterFunction("LN", 1, Ln); ce.RegisterFunction("LOG", 1, 2, Log); ce.RegisterFunction("LOG10", 1, Log10); ce.RegisterFunction("MDETERM", 1, MDeterm); ce.RegisterFunction("MINVERSE", 1, MInverse); ce.RegisterFunction("MMULT", 2, MMult); ce.RegisterFunction("MOD", 2, Mod); ce.RegisterFunction("MROUND", 2, MRound); ce.RegisterFunction("MULTINOMIAL", 1, 255, Multinomial); ce.RegisterFunction("ODD", 1, Odd); ce.RegisterFunction("PI", 0, Pi); ce.RegisterFunction("POWER", 2, Power); ce.RegisterFunction("PRODUCT", 1, 255, Product); ce.RegisterFunction("QUOTIENT", 2, Quotient); ce.RegisterFunction("RADIANS", 1, Radians); ce.RegisterFunction("RAND", 0, Rand); ce.RegisterFunction("RANDBETWEEN", 2, RandBetween); ce.RegisterFunction("ROMAN", 1, 2, Roman); ce.RegisterFunction("ROUND", 2, Round); ce.RegisterFunction("ROUNDDOWN", 2, RoundDown); ce.RegisterFunction("ROUNDUP", 1, 2, RoundUp); ce.RegisterFunction("SERIESSUM", 4, SeriesSum); ce.RegisterFunction("SIGN", 1, Sign); ce.RegisterFunction("SIN", 1, Sin); ce.RegisterFunction("SINH", 1, Sinh); ce.RegisterFunction("SQRT", 1, Sqrt); ce.RegisterFunction("SQRTPI", 1, SqrtPi); ce.RegisterFunction("SUBTOTAL", 2, 255, Subtotal); ce.RegisterFunction("SUM", 1, int.MaxValue, Sum); ce.RegisterFunction("SUMIF", 2, 3, SumIf); //ce.RegisterFunction("SUMPRODUCT", 1, SumProduct); ce.RegisterFunction("SUMSQ", 1, 255, SumSq); //ce.RegisterFunction("SUMX2MY2", SumX2MY2, 1); //ce.RegisterFunction("SUMX2PY2", SumX2PY2, 1); //ce.RegisterFunction("SUMXMY2", SumXMY2, 1); ce.RegisterFunction("TAN", 1, Tan); ce.RegisterFunction("TANH", 1, Tanh); ce.RegisterFunction("TRUNC", 1, Trunc); }
public static void Register(CalcEngine ce) { ce.RegisterFunction("ISBLANK", 1, IsBlank); }
public static void Register(CalcEngine ce) { //ce.RegisterFunction("AVEDEV", AveDev, 1, int.MaxValue); ce.RegisterFunction("AVERAGE", 1, int.MaxValue, Average); ce.RegisterFunction("AVERAGEA", 1, int.MaxValue, AverageA); //BETADIST Returns the beta cumulative distribution function //BETAINV Returns the inverse of the cumulative distribution function for a specified beta distribution //BINOMDIST Returns the individual term binomial distribution probability //CHIDIST Returns the one-tailed probability of the chi-squared distribution //CHIINV Returns the inverse of the one-tailed probability of the chi-squared distribution //CHITEST Returns the test for independence //CONFIDENCE Returns the confidence interval for a population mean //CORREL Returns the correlation coefficient between two data sets ce.RegisterFunction("COUNT", 1, int.MaxValue, Count); ce.RegisterFunction("COUNTA", 1, int.MaxValue, CountA); ce.RegisterFunction("COUNTBLANK", 1, int.MaxValue, CountBlank); ce.RegisterFunction("COUNTIF", 2, CountIf); //COVAR Returns covariance, the average of the products of paired deviations //CRITBINOM Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value //DEVSQ Returns the sum of squares of deviations //EXPONDIST Returns the exponential distribution //FDIST Returns the F probability distribution //FINV Returns the inverse of the F probability distribution //FISHER Returns the Fisher transformation //FISHERINV Returns the inverse of the Fisher transformation //FORECAST Returns a value along a linear trend //FREQUENCY Returns a frequency distribution as a vertical array //FTEST Returns the result of an F-test //GAMMADIST Returns the gamma distribution //GAMMAINV Returns the inverse of the gamma cumulative distribution //GAMMALN Returns the natural logarithm of the gamma function, Γ(x) //GEOMEAN Returns the geometric mean //GROWTH Returns values along an exponential trend //HARMEAN Returns the harmonic mean //HYPGEOMDIST Returns the hypergeometric distribution //INTERCEPT Returns the intercept of the linear regression line //KURT Returns the kurtosis of a data set //LARGE Returns the k-th largest value in a data set //LINEST Returns the parameters of a linear trend //LOGEST Returns the parameters of an exponential trend //LOGINV Returns the inverse of the lognormal distribution //LOGNORMDIST Returns the cumulative lognormal distribution ce.RegisterFunction("MAX", 1, int.MaxValue, Max); ce.RegisterFunction("MAXA", 1, int.MaxValue, MaxA); //MEDIAN Returns the median of the given numbers ce.RegisterFunction("MIN", 1, int.MaxValue, Min); ce.RegisterFunction("MINA", 1, int.MaxValue, MinA); //MODE Returns the most common value in a data set //NEGBINOMDIST Returns the negative binomial distribution //NORMDIST Returns the normal cumulative distribution //NORMINV Returns the inverse of the normal cumulative distribution //NORMSDIST Returns the standard normal cumulative distribution //NORMSINV Returns the inverse of the standard normal cumulative distribution //PEARSON Returns the Pearson product moment correlation coefficient //PERCENTILE Returns the k-th percentile of values in a range //PERCENTRANK Returns the percentage rank of a value in a data set //PERMUT Returns the number of permutations for a given number of objects //POISSON Returns the Poisson distribution //PROB Returns the probability that values in a range are between two limits //QUARTILE Returns the quartile of a data set //RANK Returns the rank of a number in a list of numbers //RSQ Returns the square of the Pearson product moment correlation coefficient //SKEW Returns the skewness of a distribution //SLOPE Returns the slope of the linear regression line //SMALL Returns the k-th smallest value in a data set //STANDARDIZE Returns a normalized value ce.RegisterFunction("STDEV", 1, int.MaxValue, StDev); ce.RegisterFunction("STDEVA", 1, int.MaxValue, StDevA); ce.RegisterFunction("STDEVP", 1, int.MaxValue, StDevP); ce.RegisterFunction("STDEVPA", 1, int.MaxValue, StDevPA); //STEYX Returns the standard error of the predicted y-value for each x in the regression //TDIST Returns the Student's t-distribution //TINV Returns the inverse of the Student's t-distribution //TREND Returns values along a linear trend //TRIMMEAN Returns the mean of the interior of a data set //TTEST Returns the probability associated with a Student's t-test ce.RegisterFunction("VAR", 1, int.MaxValue, Var); ce.RegisterFunction("VARA", 1, int.MaxValue, VarA); ce.RegisterFunction("VARP", 1, int.MaxValue, VarP); ce.RegisterFunction("VARPA", 1, int.MaxValue, VarPA); //WEIBULL Returns the Weibull distribution //ZTEST Returns the one-tailed probability-value of a z-test }
static object CountIf(List<Expression> p) { CalcEngine ce = new CalcEngine(); var cnt = 0.0; var ienum = p[0] as IEnumerable; if (ienum != null) { var crit = (string)p[1].Evaluate(); foreach (var value in ienum) { if (!IsBlank(value)) { var exp = string.Format("{0}{1}", value, crit); if ((bool)ce.Evaluate(exp)) cnt++; } } } return cnt; }
public ExpressionCache(CalcEngine ce) { _ce = ce; _dct = new Dictionary <string, WeakReference>(); }
private static object SumIfs(List <Expression> p) { // get parameters var sumRange = p[0] as IEnumerable; var sumRangeValues = new List <object>(); foreach (var value in sumRange) { sumRangeValues.Add(value); } var ce = new CalcEngine(); var tally = new Tally(); int numberOfCriteria = p.Count / 2; // int division returns floor() automatically, that's what we want. // prepare criteria-parameters: var criteriaRanges = new Tuple <object, IList <object> > [numberOfCriteria]; for (int criteriaPair = 0; criteriaPair < numberOfCriteria; criteriaPair++) { var criteriaRange = p[criteriaPair * 2 + 1] as IEnumerable; if (criteriaRange == null) { throw new CellReferenceException($"Expected parameter {criteriaPair * 2 + 2} to be a range"); } var criterion = p[criteriaPair * 2 + 2].Evaluate(); var criteriaRangeValues = criteriaRange.Cast <Object>().ToList(); criteriaRanges[criteriaPair] = new Tuple <object, IList <object> >( criterion, criteriaRangeValues); } for (var i = 0; i < sumRangeValues.Count; i++) { bool shouldUseValue = true; foreach (var criteriaPair in criteriaRanges) { if (!CalcEngineHelpers.ValueSatisfiesCriteria( i < criteriaPair.Item2.Count ? criteriaPair.Item2[i] : string.Empty, criteriaPair.Item1, ce)) { shouldUseValue = false; break; // we're done with the inner loop as we can't ever get true again. } } if (shouldUseValue) { tally.AddValue(sumRangeValues[i]); } } // done return(tally.Sum()); }
public static void Register(CalcEngine ce) { ce.RegisterFunction("ABS", 1, Abs); ce.RegisterFunction("ACOS", 1, Acos); ce.RegisterFunction("ACOSH", 1, Acosh); ce.RegisterFunction("ACOT", 1, Acot); ce.RegisterFunction("ACOTH", 1, Acoth); ce.RegisterFunction("ARABIC", 1, Arabic); ce.RegisterFunction("ASIN", 1, Asin); ce.RegisterFunction("ASINH", 1, Asinh); ce.RegisterFunction("ATAN", 1, Atan); ce.RegisterFunction("ATAN2", 2, Atan2); ce.RegisterFunction("ATANH", 1, Atanh); ce.RegisterFunction("BASE", 2, 3, Base); ce.RegisterFunction("CEILING", 2, Ceiling); ce.RegisterFunction("CEILING.MATH", 1, 3, CeilingMath); ce.RegisterFunction("COMBIN", 2, Combin); ce.RegisterFunction("COMBINA", 2, CombinA); ce.RegisterFunction("COS", 1, Cos); ce.RegisterFunction("COSH", 1, Cosh); ce.RegisterFunction("COT", 1, Cot); ce.RegisterFunction("COTH", 1, Coth); ce.RegisterFunction("CSC", 1, Csc); ce.RegisterFunction("CSCH", 1, Csch); ce.RegisterFunction("DECIMAL", 2, MathTrig.Decimal); ce.RegisterFunction("DEGREES", 1, Degrees); ce.RegisterFunction("EVEN", 1, Even); ce.RegisterFunction("EXP", 1, Exp); ce.RegisterFunction("FACT", 1, Fact); ce.RegisterFunction("FACTDOUBLE", 1, FactDouble); ce.RegisterFunction("FLOOR", 2, Floor); ce.RegisterFunction("FLOOR.MATH", 1, 3, FloorMath); ce.RegisterFunction("GCD", 1, 255, Gcd); ce.RegisterFunction("INT", 1, Int); ce.RegisterFunction("LCM", 1, 255, Lcm); ce.RegisterFunction("LN", 1, Ln); ce.RegisterFunction("LOG", 1, 2, Log); ce.RegisterFunction("LOG10", 1, Log10); ce.RegisterFunction("MDETERM", 1, MDeterm); ce.RegisterFunction("MINVERSE", 1, MInverse); ce.RegisterFunction("MMULT", 2, MMult); ce.RegisterFunction("MOD", 2, Mod); ce.RegisterFunction("MROUND", 2, MRound); ce.RegisterFunction("MULTINOMIAL", 1, 255, Multinomial); ce.RegisterFunction("ODD", 1, Odd); ce.RegisterFunction("PI", 0, Pi); ce.RegisterFunction("POWER", 2, Power); ce.RegisterFunction("PRODUCT", 1, 255, Product); ce.RegisterFunction("QUOTIENT", 2, Quotient); ce.RegisterFunction("RADIANS", 1, Radians); ce.RegisterFunction("RAND", 0, Rand); ce.RegisterFunction("RANDBETWEEN", 2, RandBetween); ce.RegisterFunction("ROMAN", 1, 2, Roman); ce.RegisterFunction("ROUND", 2, Round); ce.RegisterFunction("ROUNDDOWN", 2, RoundDown); ce.RegisterFunction("ROUNDUP", 1, 2, RoundUp); ce.RegisterFunction("SEC", 1, Sec); ce.RegisterFunction("SECH", 1, Sech); ce.RegisterFunction("SERIESSUM", 4, SeriesSum); ce.RegisterFunction("SIGN", 1, Sign); ce.RegisterFunction("SIN", 1, Sin); ce.RegisterFunction("SINH", 1, Sinh); ce.RegisterFunction("SQRT", 1, Sqrt); ce.RegisterFunction("SQRTPI", 1, SqrtPi); ce.RegisterFunction("SUBTOTAL", 2, 255, Subtotal); ce.RegisterFunction("SUM", 1, int.MaxValue, Sum); ce.RegisterFunction("SUMIF", 2, 3, SumIf); ce.RegisterFunction("SUMIFS", 3, 255, SumIfs); ce.RegisterFunction("SUMPRODUCT", 1, 30, SumProduct); ce.RegisterFunction("SUMSQ", 1, 255, SumSq); //ce.RegisterFunction("SUMX2MY2", SumX2MY2, 1); //ce.RegisterFunction("SUMX2PY2", SumX2PY2, 1); //ce.RegisterFunction("SUMXMY2", SumXMY2, 1); ce.RegisterFunction("TAN", 1, Tan); ce.RegisterFunction("TANH", 1, Tanh); ce.RegisterFunction("TRUNC", 1, 2, Trunc); }
public static void Register(CalcEngine ce) { //ce.RegisterFunction("AVEDEV", AveDev, 1, int.MaxValue); ce.RegisterFunction("AVERAGE", 1, int.MaxValue, Average); // Returns the average (arithmetic mean) of the arguments ce.RegisterFunction("AVERAGEA", 1, int.MaxValue, AverageA); //BETADIST Returns the beta cumulative distribution function //BETAINV Returns the inverse of the cumulative distribution function for a specified beta distribution //BINOMDIST Returns the individual term binomial distribution probability //CHIDIST Returns the one-tailed probability of the chi-squared distribution //CHIINV Returns the inverse of the one-tailed probability of the chi-squared distribution //CHITEST Returns the test for independence //CONFIDENCE Returns the confidence interval for a population mean //CORREL Returns the correlation coefficient between two data sets ce.RegisterFunction("COUNT", 1, int.MaxValue, Count); ce.RegisterFunction("COUNTA", 1, int.MaxValue, CountA); ce.RegisterFunction("COUNTBLANK", 1, CountBlank); ce.RegisterFunction("COUNTIF", 2, CountIf); //COVAR Returns covariance, the average of the products of paired deviations //CRITBINOM Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value //DEVSQ Returns the sum of squares of deviations //EXPONDIST Returns the exponential distribution //FDIST Returns the F probability distribution //FINV Returns the inverse of the F probability distribution //FISHER Returns the Fisher transformation //FISHERINV Returns the inverse of the Fisher transformation //FORECAST Returns a value along a linear trend //FREQUENCY Returns a frequency distribution as a vertical array //FTEST Returns the result of an F-test //GAMMADIST Returns the gamma distribution //GAMMAINV Returns the inverse of the gamma cumulative distribution //GAMMALN Returns the natural logarithm of the gamma function, Γ(x) //GEOMEAN Returns the geometric mean //GROWTH Returns values along an exponential trend //HARMEAN Returns the harmonic mean //HYPGEOMDIST Returns the hypergeometric distribution //INTERCEPT Returns the intercept of the linear regression line //KURT Returns the kurtosis of a data set //LARGE Returns the k-th largest value in a data set //LINEST Returns the parameters of a linear trend //LOGEST Returns the parameters of an exponential trend //LOGINV Returns the inverse of the lognormal distribution //LOGNORMDIST Returns the cumulative lognormal distribution ce.RegisterFunction("MAX", 1, int.MaxValue, Max); ce.RegisterFunction("MAXA", 1, int.MaxValue, MaxA); //MEDIAN Returns the median of the given numbers ce.RegisterFunction("MIN", 1, int.MaxValue, Min); ce.RegisterFunction("MINA", 1, int.MaxValue, MinA); //MODE Returns the most common value in a data set //NEGBINOMDIST Returns the negative binomial distribution //NORMDIST Returns the normal cumulative distribution //NORMINV Returns the inverse of the normal cumulative distribution //NORMSDIST Returns the standard normal cumulative distribution //NORMSINV Returns the inverse of the standard normal cumulative distribution //PEARSON Returns the Pearson product moment correlation coefficient //PERCENTILE Returns the k-th percentile of values in a range //PERCENTRANK Returns the percentage rank of a value in a data set //PERMUT Returns the number of permutations for a given number of objects //POISSON Returns the Poisson distribution //PROB Returns the probability that values in a range are between two limits //QUARTILE Returns the quartile of a data set //RANK Returns the rank of a number in a list of numbers //RSQ Returns the square of the Pearson product moment correlation coefficient //SKEW Returns the skewness of a distribution //SLOPE Returns the slope of the linear regression line //SMALL Returns the k-th smallest value in a data set //STANDARDIZE Returns a normalized value ce.RegisterFunction("STDEV", 1, int.MaxValue, StDev); ce.RegisterFunction("STDEVA", 1, int.MaxValue, StDevA); ce.RegisterFunction("STDEVP", 1, int.MaxValue, StDevP); ce.RegisterFunction("STDEVPA", 1, int.MaxValue, StDevPA); ce.RegisterFunction("STDEV.S", 1, int.MaxValue, StDev); ce.RegisterFunction("STDEV.P", 1, int.MaxValue, StDevP); //STEYX Returns the standard error of the predicted y-value for each x in the regression //TDIST Returns the Student's t-distribution //TINV Returns the inverse of the Student's t-distribution //TREND Returns values along a linear trend //TRIMMEAN Returns the mean of the interior of a data set //TTEST Returns the probability associated with a Student's t-test ce.RegisterFunction("VAR", 1, int.MaxValue, Var); ce.RegisterFunction("VARA", 1, int.MaxValue, VarA); ce.RegisterFunction("VARP", 1, int.MaxValue, VarP); ce.RegisterFunction("VARPA", 1, int.MaxValue, VarPA); ce.RegisterFunction("VAR.S", 1, int.MaxValue, Var); ce.RegisterFunction("VAR.P", 1, int.MaxValue, VarP); //WEIBULL Returns the Weibull distribution //ZTEST Returns the one-tailed probability-value of a z-test }