@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/src/functions/module_statistical.ts

@@ -0,0 +1,882 @@
+import { isNumber } from "../helpers/index";
+import { _lt } from "../translation";
+import { FunctionDescription } from "../types";
+import { args } from "./arguments";
+import { parseDateTime } from "./dates";
+import {
+  dichotomicPredecessorSearch,
+  extractDateValue,
+  reduceArgs,
+  reduceNumbers,
+  reduceNumbersTextAs0,
+  toNumber,
+  visitAny,
+  visitMatchingRanges,
+} from "./helpers";
+
+// Note: dataY and dataX may not have the same dimension
+function covariance(dataY: any[], dataX: any[], isSample: boolean): number {
+  let flatDataY: any[] = [];
+  let flatDataX: any[] = [];
+  let lenY = 0;
+  let lenX = 0;
+
+  visitAny(dataY, (y) => {
+    flatDataY.push(y);
+    lenY += 1;
+  });
+
+  visitAny(dataX, (x) => {
+    flatDataX.push(x);
+    lenX += 1;
+  });
+
+  if (lenY !== lenX) {
+    throw new Error(
+      _lt(
+        "[[FUNCTION_NAME]] has mismatched argument count %s vs %s.",
+        lenY.toString(),
+        lenX.toString()
+      )
+    );
+  }
+
+  let count = 0;
+  let sumY = 0;
+  let sumX = 0;
+  for (let i = 0; i < lenY; i++) {
+    const valueY = flatDataY[i];
+    const valueX = flatDataX[i];
+    if (typeof valueY === "number" && typeof valueX === "number") {
+      count += 1;
+      sumY += valueY;
+      sumX += valueX;
+    }
+  }
+
+  if (count === 0 || (isSample && count === 1)) {
+    throw new Error(_lt(`Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error.`));
+  }
+
+  const averageY = sumY / count;
+  const averageX = sumX / count;
+
+  let acc = 0;
+  for (let i = 0; i < lenY; i++) {
+    const valueY = flatDataY[i];
+    const valueX = flatDataX[i];
+    if (typeof valueY === "number" && typeof valueX === "number") {
+      acc += (valueY - averageY) * (valueX - averageX);
+    }
+  }
+
+  return acc / (count - (isSample ? 1 : 0));
+}
+
+function variance(args: IArguments | any[], isSample: boolean, textAs0: boolean): number {
+  let count = 0;
+  let sum = 0;
+  const reduceFuction = textAs0 ? reduceNumbersTextAs0 : reduceNumbers;
+
+  sum = reduceFuction(
+    args,
+    (acc, a) => {
+      count += 1;
+      return acc + a;
+    },
+    0
+  );
+
+  if (count === 0 || (isSample && count === 1)) {
+    throw new Error(_lt(`Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error.`));
+  }
+
+  const average = sum / count;
+  return (
+    reduceFuction(args, (acc, a) => acc + Math.pow(a - average, 2), 0) /
+    (count - (isSample ? 1 : 0))
+  );
+}
+
+// -----------------------------------------------------------------------------
+// AVEDEV
+// -----------------------------------------------------------------------------
+export const AVEDEV: FunctionDescription = {
+  description: _lt("Average magnitude of deviations from mean."),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range of the sample.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to include in the sample."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    let count = 0;
+    const sum = reduceNumbers(
+      arguments,
+      (acc, a) => {
+        count += 1;
+        return acc + a;
+      },
+      0
+    );
+    if (count === 0) {
+      throw new Error(_lt(`Evaluation of function AVEDEV caused a divide by zero error.`));
+    }
+    const average = sum / count;
+    return reduceNumbers(arguments, (acc, a) => acc + Math.abs(average - a), 0) / count;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// AVERAGE
+// -----------------------------------------------------------------------------
+export const AVERAGE: FunctionDescription = {
+  description: _lt(`Numerical average value in a dataset, ignoring text.`),
+  args: args(`
+      value1 (number, range<number>) ${_lt(
+        "The first value or range to consider when calculating the average value."
+      )}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to consider when calculating the average value."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    let count = 0;
+    const sum = reduceNumbers(
+      arguments,
+      (acc, a) => {
+        count += 1;
+        return acc + a;
+      },
+      0
+    );
+    if (count === 0) {
+      throw new Error(_lt(`Evaluation of function AVERAGE caused a divide by zero error.`));
+    }
+    return sum / count;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// AVERAGE.WEIGHTED
+// -----------------------------------------------------------------------------
+const rangeError = _lt(`AVERAGE.WEIGHTED has mismatched range sizes.`);
+const negativeWeightError = _lt(
+  `AVERAGE.WEIGHTED expects the weight to be positive or equal to 0.`
+);
+
+export const AVERAGE_WEIGHTED: FunctionDescription = {
+  description: _lt(`Weighted average.`),
+  args: args(`
+      values (number, range<number>) ${_lt("Values to average.")}
+      weights (number, range<number>) ${_lt("Weights for each corresponding value.")}
+      additional_values (number, range<number>, optional, repeating) ${_lt(
+        "Additional values to average with weights."
+      )}
+    `),
+  // @compatibility: on google sheets, args difinitions are next:
+  // additional_values (number, range<number>, optional, repeating) Additional values to average.
+  // additional_weights (number, range<number>, optional, repeating) Additional weights.
+  returns: ["NUMBER"],
+  compute: function (): number {
+    let sum = 0;
+    let count = 0;
+    let value;
+    let weight;
+    if (arguments.length % 2 === 1) {
+      throw new Error(_lt(`Wrong number of arguments. Expected an even number of arguments.`));
+    }
+    for (let n = 0; n < arguments.length - 1; n += 2) {
+      value = arguments[n];
+      weight = arguments[n + 1];
+      // if (typeof value != typeof weight) {
+      //   throw new Error(rangeError);
+      // }
+      if (Array.isArray(value)) {
+        if (!Array.isArray(weight)) {
+          throw new Error(rangeError);
+        }
+        let dimColValue = value.length;
+        let dimLinValue = value[0].length;
+        if (dimColValue !== weight.length || dimLinValue != weight[0].length) {
+          throw new Error(rangeError);
+        }
+        for (let i = 0; i < dimColValue; i++) {
+          for (let j = 0; j < dimLinValue; j++) {
+            let subValue = value[i][j];
+            let subWeight = weight[i][j];
+            let subValueIsNumber = typeof subValue === "number";
+            let subWeightIsNumber = typeof subWeight === "number";
+            // typeof subValue or subWeight can be 'number' or 'undefined'
+            if (subValueIsNumber !== subWeightIsNumber) {
+              throw new Error(_lt(`AVERAGE.WEIGHTED expects number values.`));
+            }
+            if (subWeightIsNumber) {
+              if (subWeight < 0) {
+                throw new Error(negativeWeightError);
+              }
+              sum += subValue * subWeight;
+              count += subWeight;
+            }
+          }
+        }
+      } else {
+        weight = toNumber(weight);
+        value = toNumber(value);
+        if (weight < 0) {
+          throw new Error(negativeWeightError);
+        }
+        sum += value * weight;
+        count += weight;
+      }
+    }
+    if (count === 0) {
+      throw new Error(
+        _lt(`Evaluation of function AVERAGE.WEIGHTED caused a divide by zero error.`)
+      );
+    }
+    return sum / count;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// AVERAGEA
+// -----------------------------------------------------------------------------
+export const AVERAGEA: FunctionDescription = {
+  description: _lt(`Numerical average value in a dataset.`),
+  args: args(`
+      value1 (number, range<number>) ${_lt(
+        "The first value or range to consider when calculating the average value."
+      )}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to consider when calculating the average value."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    let count = 0;
+    const sum = reduceNumbersTextAs0(
+      arguments,
+      (acc, a) => {
+        count += 1;
+        return acc + a;
+      },
+      0
+    );
+    if (count === 0) {
+      throw new Error(_lt(`Evaluation of function AVERAGEA caused a divide by zero error.`));
+    }
+    return sum / count;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// AVERAGEIF
+// -----------------------------------------------------------------------------
+export const AVERAGEIF: FunctionDescription = {
+  description: _lt(`Average of values depending on criteria.`),
+  args: args(`
+      criteria_range (range) ${_lt("The range to check against criterion.")}
+      criterion (string) ${_lt("The pattern or test to apply to criteria_range.")}
+      average_range (range, optional, default=criteria_range) ${_lt(
+        "The range to average. If not included, criteria_range is used for the average instead."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (criteria_range: any, criterion: any, average_range: any = undefined): number {
+    if (average_range === undefined) {
+      average_range = criteria_range;
+    }
+
+    let count = 0;
+    let sum = 0;
+
+    visitMatchingRanges([criteria_range, criterion], (i, j) => {
+      const value = average_range[i][j];
+      if (typeof value === "number") {
+        count += 1;
+        sum += value;
+      }
+    });
+
+    if (count === 0) {
+      throw new Error(_lt(`Evaluation of function AVERAGEIF caused a divide by zero error.`));
+    }
+    return sum / count;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// AVERAGEIFS
+// -----------------------------------------------------------------------------
+export const AVERAGEIFS: FunctionDescription = {
+  description: _lt(`Average of values depending on multiple criteria.`),
+  args: args(`
+      average_range (range) ${_lt("The range to average.")}
+      criteria_range1 (range) ${_lt("The range to check against criterion1.")}
+      criterion1 (string) ${_lt("The pattern or test to apply to criteria_range1.")}
+      additional_values (any, range, optional, repeating) ${_lt(
+        "Additional criteria_range and criterion to check."
+      )}
+    `),
+  // @compatibility: on google sheets, args definitions are next:
+  // average_range (any, range) The range to average.
+  // criteria_range1 (any, range) The range to check against criterion1.
+  // criterion1 (string) The pattern or test to apply to criteria_range1.
+  // criteria_range2 (any, range, optional, repeating) Additional ranges to check.
+  // criterion2 (string, optional, repeating) Additional criteria to check.
+  returns: ["NUMBER"],
+  compute: function (average_range, ...args): number {
+    let count = 0;
+    let sum = 0;
+    visitMatchingRanges(args, (i, j) => {
+      const value = average_range[i][j];
+      if (typeof value === "number") {
+        count += 1;
+        sum += value;
+      }
+    });
+    if (count === 0) {
+      throw new Error(_lt(`Evaluation of function AVERAGEIFS caused a divide by zero error.`));
+    }
+    return sum / count;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// COUNT
+// -----------------------------------------------------------------------------
+export const COUNT: FunctionDescription = {
+  description: _lt(`The number of numeric values in dataset.`),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range to consider when counting.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to consider when counting."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    let count = 0;
+    for (let n of arguments) {
+      if (Array.isArray(n)) {
+        for (let i of n) {
+          for (let j of i) {
+            if (typeof j === "number" || (typeof j === "object" && j !== null && j.jsDate)) {
+              count += 1;
+            }
+          }
+        }
+      } else if (typeof n !== "string" || isNumber(n) || parseDateTime(n)) {
+        count += 1;
+      }
+    }
+    return count;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// COUNTA
+// -----------------------------------------------------------------------------
+export const COUNTA: FunctionDescription = {
+  description: _lt(`The number of values in a dataset.`),
+  args: args(`
+    value1 (any, range) ${_lt("The first value or range to consider when counting.")}
+    value2 (any, range, optional, repeating) ${_lt(
+      "Additional values or ranges to consider when counting."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return reduceArgs(arguments, (acc, a) => (a !== undefined && a !== null ? acc + 1 : acc), 0);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// COVAR
+// -----------------------------------------------------------------------------
+
+// Note: Unlike the VAR function which corresponds to the variance over a sample (VAR.S),
+// the COVAR function corresponds to the covariance over an entire population (COVAR.P)
+export const COVAR: FunctionDescription = {
+  description: _lt(`The covariance of a dataset.`),
+  args: args(`
+    data_y (any, range) ${_lt("The range representing the array or matrix of dependent data.")}
+    data_x (any, range) ${_lt("The range representing the array or matrix of independent data.")}
+  `),
+  returns: ["NUMBER"],
+  compute: function (data_y: any[], data_x: any[]): number {
+    return covariance(data_y, data_x, false);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// COVARIANCE.P
+// -----------------------------------------------------------------------------
+export const COVARIANCE_P: FunctionDescription = {
+  description: _lt(`The covariance of a dataset.`),
+  args: args(`
+    data_y (any, range) ${_lt("The range representing the array or matrix of dependent data.")}
+    data_x (any, range) ${_lt("The range representing the array or matrix of independent data.")}
+  `),
+  returns: ["NUMBER"],
+  compute: function (data_y: any[], data_x: any[]): number {
+    return covariance(data_y, data_x, false);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// COVARIANCE.S
+// -----------------------------------------------------------------------------
+export const COVARIANCE_S: FunctionDescription = {
+  description: _lt(`The sample covariance of a dataset.`),
+  args: args(`
+    data_y (any, range) ${_lt("The range representing the array or matrix of dependent data.")}
+    data_x (any, range) ${_lt("The range representing the array or matrix of independent data.")}
+  `),
+  returns: ["NUMBER"],
+  compute: function (data_y: any[], data_x: any[]): number {
+    return covariance(data_y, data_x, true);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// LARGE
+// -----------------------------------------------------------------------------
+export const LARGE: FunctionDescription = {
+  description: _lt("Nth largest element from a data set."),
+  args: args(`
+      data (any, range) ${_lt("Array or range containing the dataset to consider.")}
+      n (number) ${_lt("The rank from largest to smallest of the element to return.")}
+    `),
+  returns: ["NUMBER"],
+  compute: function (data: any, n: any): number {
+    n = Math.trunc(toNumber(n));
+    let largests: number[] = [];
+    let index: number;
+    let count = 0;
+    visitAny(data, (d) => {
+      d = extractDateValue(d);
+      if (typeof d === "number") {
+        index = dichotomicPredecessorSearch(largests, d);
+        largests.splice(index + 1, 0, d);
+        count++;
+        if (count > n) {
+          largests.shift();
+          count--;
+        }
+      }
+    });
+    const result = largests.shift();
+    if (result === undefined) {
+      throw new Error(_lt(`LARGE has no valid input data.`));
+    }
+    if (count < n) {
+      throw new Error(_lt("Function LARGE parameter 2 value %s is out of range.", n.toString()));
+    }
+    return result;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// MAX
+// -----------------------------------------------------------------------------
+export const MAX: FunctionDescription = {
+  description: _lt("Maximum value in a numeric dataset."),
+  args: args(`
+      value1 (number, range<number>) ${_lt(
+        "The first value or range to consider when calculating the maximum value."
+      )}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to consider when calculating the maximum value."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    const result = reduceNumbers(arguments, (acc, a) => (acc < a ? a : acc), -Infinity);
+    return result === -Infinity ? 0 : result;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// MAXA
+// -----------------------------------------------------------------------------
+export const MAXA: FunctionDescription = {
+  description: _lt("Maximum numeric value in a dataset."),
+  args: args(`
+      value1 (any, range) ${_lt(
+        "The first value or range to consider when calculating the maximum value."
+      )}
+      value2 (any, range, optional, repeating) ${_lt(
+        "Additional values or ranges to consider when calculating the maximum value."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    const maxa = reduceNumbersTextAs0(
+      arguments,
+      (acc, a) => {
+        return Math.max(a, acc);
+      },
+      -Infinity
+    );
+    return maxa === -Infinity ? 0 : maxa;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// MAXIFS
+// -----------------------------------------------------------------------------
+export const MAXIFS: FunctionDescription = {
+  description: _lt("Returns the maximum value in a range of cells, filtered by a set of criteria."),
+  args: args(`
+      range (range) ${_lt("The range of cells from which the maximum will be determined.")}
+      criteria_range1 (range) ${_lt("The range of cells over which to evaluate criterion1.")}
+      criterion1 (string) ${_lt(
+        "The pattern or test to apply to criteria_range1, such that each cell that evaluates to TRUE will be included in the filtered set."
+      )}
+      additional_values (any, range, optional, repeating) ${_lt(
+        "Additional criteria_range and criterion to check."
+      )}
+    `),
+  // @compatibility: on google sheets, args definitions are next:
+  // range (any, range) The range of cells from which the maximum will be determined.
+  // criteria_range1 (any, range) The range of cells over which to evaluate criterion1.
+  // criterion1 (string) The pattern or test to apply to criteria_range1, such that each cell that evaluates to TRUE will be included in the filtered set.
+  // criteria_range2 (any, range, optional, repeating) Additional ranges over which to evaluate the additional criteria. The filtered set will be the intersection of the sets produced by each criterion-range pair.
+  // criterion2 (string, optional, repeating) The pattern or test to apply to criteria_range2.
+  returns: ["NUMBER"],
+  compute: function (range, ...args): number {
+    let result = -Infinity;
+    visitMatchingRanges(args, (i, j) => {
+      const value = range[i][j];
+      if (typeof value === "number") {
+        result = result < value ? value : result;
+      }
+    });
+    return result === -Infinity ? 0 : result;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// MIN
+// -----------------------------------------------------------------------------
+export const MIN: FunctionDescription = {
+  description: _lt("Minimum value in a numeric dataset."),
+  args: args(`
+      value1 (number, range<number>) ${_lt(
+        "The first value or range to consider when calculating the minimum value."
+      )}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to consider when calculating the minimum value."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    const result = reduceNumbers(arguments, (acc, a) => (a < acc ? a : acc), Infinity);
+    return result === Infinity ? 0 : result;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// MINA
+// -----------------------------------------------------------------------------
+export const MINA: FunctionDescription = {
+  description: _lt("Minimum numeric value in a dataset."),
+  args: args(`
+      value1 (number, range<number>) ${_lt(
+        "The first value or range to consider when calculating the minimum value."
+      )}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to consider when calculating the minimum value."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    const mina: number = reduceNumbersTextAs0(
+      arguments,
+      (acc, a) => {
+        return Math.min(a, acc);
+      },
+      Infinity
+    );
+    return mina === Infinity ? 0 : mina;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// MINIFS
+// -----------------------------------------------------------------------------
+export const MINIFS: FunctionDescription = {
+  description: _lt("Returns the minimum value in a range of cells, filtered by a set of criteria."),
+  args: args(`
+      range (range) ${_lt("The range of cells from which the minimum will be determined.")}
+      criteria_range1 (range) ${_lt("The range of cells over which to evaluate criterion1.")}
+      criterion1 (string) ${_lt(
+        "The pattern or test to apply to criteria_range1, such that each cell that evaluates to TRUE will be included in the filtered set."
+      )}
+      additional_values (any, range, optional, repeating) ${_lt(
+        "Additional criteria_range and criterion to check."
+      )}
+    `),
+  // @compatibility: on google sheets, args definitions are next:
+  // range (any, range) The range of cells from which the minimum will be determined.
+  // criteria_range1 (any, range) The range of cells over which to evaluate criterion1.
+  // criterion1 (string) The pattern or test to apply to criteria_range1, such that each cell that evaluates to TRUE will be included in the filtered set.
+  // criteria_range2 (any, range, optional, repeating) Additional ranges over which to evaluate the additional criteria. The filtered set will be the intersection of the sets produced by each criterion-range pair.
+  // criterion2 (string, optional, repeating) The pattern or test to apply to criteria_range2.
+  returns: ["NUMBER"],
+  compute: function (range, ...args): number {
+    let result = Infinity;
+    visitMatchingRanges(args, (i, j) => {
+      const value = range[i][j];
+      if (typeof value === "number") {
+        result = result > value ? value : result;
+      }
+    });
+    return result === Infinity ? 0 : result;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// SMALL
+// -----------------------------------------------------------------------------
+export const SMALL: FunctionDescription = {
+  description: _lt("Nth smallest element in a data set."),
+  args: args(`
+      data (any, range) ${_lt("The array or range containing the dataset to consider.")}
+      n (number) ${_lt("The rank from smallest to largest of the element to return.")}
+    `),
+  returns: ["NUMBER"],
+  compute: function (data: any, n: any): number {
+    n = Math.trunc(toNumber(n));
+    let largests: number[] = [];
+    let index: number;
+    let count = 0;
+    visitAny(data, (d) => {
+      d = extractDateValue(d);
+      if (typeof d === "number") {
+        index = dichotomicPredecessorSearch(largests, d);
+        largests.splice(index + 1, 0, d);
+        count++;
+        if (count > n) {
+          largests.pop();
+          count--;
+        }
+      }
+    });
+    const result = largests.pop();
+    if (result === undefined) {
+      throw new Error(_lt(`SMALL has no valid input data.`));
+    }
+    if (count < n) {
+      throw new Error(_lt("Function SMALL parameter 2 value %s is out of range.", n.toString()));
+    }
+    return result;
+  },
+};
+
+// -----------------------------------------------------------------------------
+// STDEV
+// -----------------------------------------------------------------------------
+export const STDEV: FunctionDescription = {
+  description: _lt("Standard deviation."),
+  args: args(`
+      value1 (number, range<number>) ${_lt("The first value or range of the sample.")}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to include in the sample."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return Math.sqrt(VAR.compute(...arguments));
+  },
+};
+
+// -----------------------------------------------------------------------------
+// STDEV.P
+// -----------------------------------------------------------------------------
+export const STDEV_P: FunctionDescription = {
+  description: _lt("Standard deviation of entire population."),
+  args: args(`
+      value1 (number, range<number>) ${_lt("The first value or range of the population.")}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to include in the population."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return Math.sqrt(VAR_P.compute(...arguments));
+  },
+};
+
+// -----------------------------------------------------------------------------
+// STDEV.S
+// -----------------------------------------------------------------------------
+export const STDEV_S: FunctionDescription = {
+  description: _lt("Standard deviation."),
+  args: args(`
+      value1 (number, range<number>) ${_lt("The first value or range of the sample.")}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to include in the sample."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return Math.sqrt(VAR_S.compute(...arguments));
+  },
+};
+
+// -----------------------------------------------------------------------------
+// STDEVA
+// -----------------------------------------------------------------------------
+export const STDEVA: FunctionDescription = {
+  description: _lt("Standard deviation of sample (text as 0)."),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range of the sample.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to include in the sample."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return Math.sqrt(VARA.compute(...arguments));
+  },
+};
+
+// -----------------------------------------------------------------------------
+// STDEVP
+// -----------------------------------------------------------------------------
+export const STDEVP: FunctionDescription = {
+  description: _lt("Standard deviation of entire population."),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range of the population.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to include in the population."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return Math.sqrt(VARP.compute(...arguments));
+  },
+};
+
+// -----------------------------------------------------------------------------
+// STDEVPA
+// -----------------------------------------------------------------------------
+export const STDEVPA: FunctionDescription = {
+  description: _lt("Standard deviation of entire population (text as 0)."),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range of the population.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to include in the population."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return Math.sqrt(VARPA.compute(...arguments));
+  },
+};
+
+// -----------------------------------------------------------------------------
+// VAR
+// -----------------------------------------------------------------------------
+export const VAR: FunctionDescription = {
+  description: _lt("Variance."),
+  args: args(`
+      value1 (number, range<number>) ${_lt("The first value or range of the sample.")}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to include in the sample."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return variance(arguments, true, false);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// VAR.P
+// -----------------------------------------------------------------------------
+export const VAR_P: FunctionDescription = {
+  description: _lt("Variance of entire population."),
+  args: args(`
+      value1 (number, range<number>) ${_lt("The first value or range of the population.")}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to include in the population."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return variance(arguments, false, false);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// VAR.S
+// -----------------------------------------------------------------------------
+export const VAR_S: FunctionDescription = {
+  description: _lt("Variance."),
+  args: args(`
+      value1 (number, range<number>) ${_lt("The first value or range of the sample.")}
+      value2 (number, range<number>, optional, repeating) ${_lt(
+        "Additional values or ranges to include in the sample."
+      )}
+    `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return variance(arguments, true, false);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// VARA
+// -----------------------------------------------------------------------------
+export const VARA: FunctionDescription = {
+  description: _lt("Variance of sample (text as 0)."),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range of the sample.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to include in the sample."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return variance(arguments, true, true);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// VARP
+// -----------------------------------------------------------------------------
+export const VARP: FunctionDescription = {
+  description: _lt("Variance of entire population."),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range of the population.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to include in the population."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return variance(arguments, false, false);
+  },
+};
+
+// -----------------------------------------------------------------------------
+// VARPA
+// -----------------------------------------------------------------------------
+export const VARPA: FunctionDescription = {
+  description: _lt("Variance of entire population (text as 0)."),
+  args: args(`
+    value1 (number, range<number>) ${_lt("The first value or range of the population.")}
+    value2 (number, range<number>, optional, repeating) ${_lt(
+      "Additional values or ranges to include in the population."
+    )}
+  `),
+  returns: ["NUMBER"],
+  compute: function (): number {
+    return variance(arguments, false, true);
+  },
+};