@gridsheet/functions 3.0.0-rc.2

package/dist/statistics/index.js

@@ -0,0 +1,663 @@
+import { BaseFunction as A, conditionArg as x, ensureString as M, eachMatrix as g, stripTable as T, check as R, FormulaError as d, Table as w, createBooleanMask as q, ensureNumber as f } from "@gridsheet/react-core";
+const k = "Returns the average of a series of cells that meet a condition.";
+class S extends A {
+  constructor() {
+    super(...arguments), this.example = 'AVERAGEIF(A1:A10,">20")', this.description = k, this.defs = [
+      { name: "range", description: "A condition range.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      x,
+      {
+        name: "average_range",
+        description: "A range to be averaged.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"],
+        optional: !0
+      }
+    ], this.category = "statistics";
+  }
+  main(t, n, r) {
+    const e = M(n), a = [], i = [];
+    g(
+      t,
+      (s) => {
+        a.push(s);
+      },
+      this.at
+    ), r && g(
+      r,
+      (s) => {
+        i.push(s);
+      },
+      this.at
+    );
+    let u = 0, o = 0;
+    if (a.forEach((s, l) => {
+      const h = T({ value: (r ? i[l] : s) ?? 0 });
+      typeof h == "number" && R(s, e) && (u += h, o++);
+    }), o === 0)
+      throw new d("#DIV/0!", "No cells match the condition.");
+    return u / o;
+  }
+}
+const I = "Returns the average of a range depending on multiple criteria.";
+class V extends A {
+  constructor() {
+    super(...arguments), this.example = 'AVERAGEIFS(A1:A10, B1:B10, ">20")', this.description = I, this.defs = [
+      { name: "average_range", description: "The range to be averaged.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { name: "range1", description: "First condition range.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { ...x, name: "condition1" },
+      {
+        name: "range2",
+        description: "Additional condition range.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"],
+        optional: !0,
+        variadic: !0
+      },
+      { ...x, name: "condition2", optional: !0, variadic: !0 }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = super.validate(t);
+    if ((n.length - 1) % 2 !== 0)
+      throw new d("#N/A", "AVERAGEIFS requires average_range and at least one range/condition pair.");
+    if (!(n[0] instanceof w))
+      throw new d("#VALUE!", "First argument of AVERAGEIFS must be a range.");
+    const r = n[0].getNumRows(), e = n[0].getNumCols(), a = [], i = [];
+    for (let s = 1; s < n.length; s += 2) {
+      if (!(n[s] instanceof w))
+        throw new d("#VALUE!", `Argument ${s + 1} of AVERAGEIFS must be a range.`);
+      if (n[s].getNumRows() !== r || n[s].getNumCols() !== e)
+        throw new d("#VALUE!", "Array arguments to AVERAGEIFS are of different size.");
+      a.push(n[s]), i.push(M(n[s + 1]));
+    }
+    const u = n[0], o = q(a, i, this.at);
+    return [u, o];
+  }
+  main(t, n) {
+    let r = 0, e = 0;
+    return g(
+      t,
+      (a, i) => {
+        if (i && n[i.y][i.x]) {
+          const u = T({ value: a ?? 0 });
+          typeof u == "number" && (r += u, e++);
+        }
+      },
+      this.at
+    ), e === 0 ? new d("#DIV/0!", "No matching cells found for AVERAGEIFS.") : r / e;
+  }
+}
+const F = "Returns the median value in a numeric dataset.";
+class D extends A {
+  constructor() {
+    super(...arguments), this.example = "MEDIAN(A1:A100)", this.description = F, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to compute the median of.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [];
+    for (const r of t)
+      g(
+        r,
+        (e) => {
+          e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+        },
+        this.at
+      );
+    if (n.length === 0)
+      throw new d("#NUM!", "MEDIAN requires at least one numeric value.");
+    return [n];
+  }
+  main(t) {
+    t.sort((r, e) => r - e);
+    const n = Math.floor(t.length / 2);
+    return t.length % 2 === 0 ? (t[n - 1] + t[n]) / 2 : t[n];
+  }
+}
+const B = "Returns the standard deviation based on a sample.";
+class C extends A {
+  constructor() {
+    super(...arguments), this.example = "STDEV.S(A1:A100)", this.description = B, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges representing the sample.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [];
+    for (const r of t)
+      g(
+        r,
+        (e) => {
+          e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+        },
+        this.at
+      );
+    if (n.length < 2)
+      throw new d("#DIV/0!", "STDEV.S requires at least 2 numeric values.");
+    return [n];
+  }
+  main(t) {
+    const n = t.reduce((e, a) => e + a, 0) / t.length, r = t.reduce((e, a) => e + (a - n) ** 2, 0) / (t.length - 1);
+    return Math.sqrt(r);
+  }
+}
+const P = "Returns the standard deviation based on the entire population.";
+class $ extends A {
+  constructor() {
+    super(...arguments), this.example = "STDEV.P(A1:A100)", this.description = P, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges representing the entire population.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [];
+    for (const r of t)
+      g(
+        r,
+        (e) => {
+          e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+        },
+        this.at
+      );
+    if (n.length < 1)
+      throw new d("#DIV/0!", "STDEV.P requires at least 1 numeric value.");
+    return [n];
+  }
+  main(t) {
+    const n = t.reduce((e, a) => e + a, 0) / t.length, r = t.reduce((e, a) => e + (a - n) ** 2, 0) / t.length;
+    return Math.sqrt(r);
+  }
+}
+const v = "Returns the variance based on a sample.";
+class U extends A {
+  constructor() {
+    super(...arguments), this.example = "VAR.S(A1:A100)", this.description = v, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges representing the sample.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [];
+    for (const r of t)
+      g(
+        r,
+        (e) => {
+          e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+        },
+        this.at
+      );
+    if (n.length < 2)
+      throw new d("#DIV/0!", "VAR.S requires at least 2 numeric values.");
+    return [n];
+  }
+  main(t) {
+    const n = t.reduce((r, e) => r + e, 0) / t.length;
+    return t.reduce((r, e) => r + (e - n) ** 2, 0) / (t.length - 1);
+  }
+}
+const L = "Returns the variance based on the entire population.";
+class Q extends A {
+  constructor() {
+    super(...arguments), this.example = "VAR.P(A1:A100)", this.description = L, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges representing the entire population.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [];
+    for (const r of t)
+      g(
+        r,
+        (e) => {
+          e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+        },
+        this.at
+      );
+    if (n.length < 1)
+      throw new d("#DIV/0!", "VAR.P requires at least 1 numeric value.");
+    return [n];
+  }
+  main(t) {
+    const n = t.reduce((r, e) => r + e, 0) / t.length;
+    return t.reduce((r, e) => r + (e - n) ** 2, 0) / t.length;
+  }
+}
+const _ = "Returns the k-th percentile of values in a range, where k is in the range 0 to 1, inclusive.";
+class G extends A {
+  constructor() {
+    super(...arguments), this.example = "PERCENTILE.INC(A1:A100, 0.9)", this.description = _, this.defs = [
+      {
+        name: "data",
+        description: "The array or range of data to consider.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      },
+      { name: "percentile", description: "The percentile value between 0 and 1, inclusive.", acceptedTypes: ["number"] }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = f(t[1]);
+    if (n < 0 || n > 1)
+      throw new d("#NUM!", "Percentile must be between 0 and 1.");
+    const r = [];
+    if (g(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && r.push(f(e));
+      },
+      this.at
+    ), r.length === 0)
+      throw new d("#NUM!", "PERCENTILE.INC requires at least one numeric value.");
+    return [r, n];
+  }
+  main(t, n) {
+    t.sort((i, u) => i - u);
+    const r = n * (t.length - 1), e = Math.floor(r), a = Math.ceil(r);
+    return t[e] + (t[a] - t[e]) * (r - e);
+  }
+}
+const O = "Returns the quartile of a dataset, based on percentile values from 0 to 1, inclusive.";
+class X extends A {
+  constructor() {
+    super(...arguments), this.example = "QUARTILE.INC(A1:A100, 1)", this.description = O, this.defs = [
+      {
+        name: "data",
+        description: "The array or range of data to consider.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      },
+      {
+        name: "quartile_number",
+        description: "Which quartile to return: 0 (min), 1 (Q1), 2 (median), 3 (Q3), 4 (max).",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = Math.floor(f(t[1]));
+    if (n < 0 || n > 4)
+      throw new d("#NUM!", "Quartile number must be between 0 and 4.");
+    const r = [];
+    if (g(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && r.push(f(e));
+      },
+      this.at
+    ), r.length === 0)
+      throw new d("#NUM!", "QUARTILE.INC requires at least one numeric value.");
+    return [r, n];
+  }
+  main(t, n) {
+    t.sort((u, o) => u - o);
+    const e = n / 4 * (t.length - 1), a = Math.floor(e), i = Math.ceil(e);
+    return t[a] + (t[i] - t[a]) * (e - a);
+  }
+}
+const Y = "Returns the rank of a number in a list of numbers. If more than one value has the same rank, the top rank of that set of values is returned.";
+class K extends A {
+  constructor() {
+    super(...arguments), this.example = "RANK.EQ(A1, A1:A100)", this.description = Y, this.defs = [
+      { name: "value", description: "The value whose rank will be determined.", acceptedTypes: ["number"] },
+      {
+        name: "data",
+        description: "The array or range of data to consider.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      },
+      {
+        name: "is_ascending",
+        description: "Whether to rank in ascending order. Default is FALSE (descending).",
+        acceptedTypes: ["boolean"],
+        optional: !0
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = f(t[0]), r = [];
+    if (g(
+      t[1],
+      (a) => {
+        a == null || a === "" || typeof a == "boolean" || (typeof a == "number" || typeof a == "string" && !isNaN(Number(a))) && r.push(f(a));
+      },
+      this.at
+    ), r.length === 0)
+      throw new d("#NUM!", "RANK.EQ requires at least one numeric value in data.");
+    if (!r.includes(n))
+      throw new d("#N/A", "Value not found in data range.");
+    const e = t[2] ?? !1;
+    return [n, r, e];
+  }
+  main(t, n, r) {
+    return n.sort((e, a) => r ? e - a : a - e), n.indexOf(t) + 1;
+  }
+}
+const W = "Returns the correlation coefficient of two datasets.";
+class j extends A {
+  constructor() {
+    super(...arguments), this.example = "CORREL(A1:A100, B1:B100)", this.description = W, this.defs = [
+      {
+        name: "data_y",
+        description: "The range representing the dependent data.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      },
+      {
+        name: "data_x",
+        description: "The range representing the independent data.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [], r = [];
+    if (g(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+      },
+      this.at
+    ), g(
+      t[1],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && r.push(f(e));
+      },
+      this.at
+    ), n.length !== r.length || n.length < 2)
+      throw new d("#N/A", "CORREL requires two ranges of equal length with at least 2 values.");
+    return [n, r];
+  }
+  main(t, n) {
+    const r = t.length, e = t.reduce((l, h) => l + h, 0) / r, a = n.reduce((l, h) => l + h, 0) / r;
+    let i = 0, u = 0, o = 0;
+    for (let l = 0; l < r; l++) {
+      const h = t[l] - e, p = n[l] - a;
+      i += h * p, u += h * h, o += p * p;
+    }
+    const s = Math.sqrt(u * o);
+    if (s === 0)
+      throw new d("#DIV/0!", "Standard deviation of one dataset is zero.");
+    return i / s;
+  }
+}
+const H = "Returns the sample covariance, the average of the products of deviations for each data point pair in two datasets.";
+class J extends A {
+  constructor() {
+    super(...arguments), this.example = "COVARIANCE.S(A1:A100, B1:B100)", this.description = H, this.defs = [
+      {
+        name: "data_y",
+        description: "The range representing the first dataset.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      },
+      {
+        name: "data_x",
+        description: "The range representing the second dataset.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [], r = [];
+    if (g(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+      },
+      this.at
+    ), g(
+      t[1],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && r.push(f(e));
+      },
+      this.at
+    ), n.length !== r.length || n.length < 2)
+      throw new d("#N/A", "COVARIANCE.S requires two ranges of equal length with at least 2 values.");
+    return [n, r];
+  }
+  main(t, n) {
+    const r = t.length, e = t.reduce((i, u) => i + u, 0) / r, a = n.reduce((i, u) => i + u, 0) / r;
+    return t.reduce((i, u, o) => i + (u - e) * (n[o] - a), 0) / (r - 1);
+  }
+}
+const Z = "Returns the most commonly occurring value in a dataset. If there are multiple modes, the smallest is returned.";
+class z extends A {
+  constructor() {
+    super(...arguments), this.example = "MODE.SNGL(A1:A100)", this.description = Z, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to compute the mode of.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [];
+    for (const r of t)
+      g(
+        r,
+        (e) => {
+          e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+        },
+        this.at
+      );
+    if (n.length === 0)
+      throw new d("#N/A", "MODE.SNGL requires at least one numeric value.");
+    return [n];
+  }
+  main(t) {
+    const n = /* @__PURE__ */ new Map();
+    for (const a of t)
+      n.set(a, (n.get(a) ?? 0) + 1);
+    const r = Math.max(...n.values());
+    if (r < 2)
+      throw new d("#N/A", "No value appears more than once.");
+    const e = [...n.entries()].filter(([, a]) => a === r).map(([a]) => a);
+    return Math.min(...e);
+  }
+}
+const ee = "Returns the square of the Pearson product-moment correlation coefficient (R²).";
+class te extends A {
+  constructor() {
+    super(...arguments), this.example = "RSQ(A1:A10, B1:B10)", this.description = ee, this.defs = [
+      {
+        name: "data_y",
+        description: "The range representing the dependent data.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      },
+      {
+        name: "data_x",
+        description: "The range representing the independent data.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"]
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = [], r = [];
+    if (g(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+      },
+      this.at
+    ), g(
+      t[1],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && r.push(f(e));
+      },
+      this.at
+    ), n.length !== r.length)
+      throw new d("#N/A", "RSQ requires two ranges of equal length.");
+    if (n.length < 2)
+      throw new d("#N/A", "RSQ requires at least 2 data points.");
+    return [n, r];
+  }
+  main(t, n) {
+    const r = t.length, e = t.reduce((h, p) => h + p, 0) / r, a = n.reduce((h, p) => h + p, 0) / r;
+    let i = 0, u = 0, o = 0;
+    for (let h = 0; h < r; h++) {
+      const p = t[h] - e, m = n[h] - a;
+      i += p * m, u += p * p, o += m * m;
+    }
+    const s = Math.sqrt(u * o);
+    if (s === 0)
+      throw new d("#DIV/0!", "Standard deviation of one dataset is zero.");
+    const l = i / s;
+    return l * l;
+  }
+}
+const ne = `Returns the probability associated with a Student's t-test.
+tails: 1 (one-tailed) or 2 (two-tailed).
+type: 1 (paired), 2 (two-sample equal variance), 3 (two-sample unequal variance).`;
+function E(c, t, n) {
+  if (c <= 0)
+    return 0;
+  if (c >= 1)
+    return 1;
+  if (c > (t + 1) / (t + n + 2))
+    return 1 - E(1 - c, n, t);
+  const r = b(t) + b(n) - b(t + n), e = Math.exp(Math.log(c) * t + Math.log(1 - c) * n - r) / t, a = 200, i = 3e-7;
+  let u = 1, o = 1, s = 1 - (t + n) * c / (t + 1);
+  Math.abs(s) < 1e-30 && (s = 1e-30), s = 1 / s, u = s;
+  for (let l = 1; l <= a; l++) {
+    let h = l * (n - l) * c / ((t + 2 * l - 1) * (t + 2 * l));
+    s = 1 + h * s, Math.abs(s) < 1e-30 && (s = 1e-30), o = 1 + h / o, Math.abs(o) < 1e-30 && (o = 1e-30), s = 1 / s, u *= s * o, h = -(t + l) * (t + n + l) * c / ((t + 2 * l) * (t + 2 * l + 1)), s = 1 + h * s, Math.abs(s) < 1e-30 && (s = 1e-30), o = 1 + h / o, Math.abs(o) < 1e-30 && (o = 1e-30), s = 1 / s;
+    const p = s * o;
+    if (u *= p, Math.abs(p - 1) < i)
+      break;
+  }
+  return e * u;
+}
+function b(c) {
+  const n = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    9984369578019572e-21,
+    15056327351493116e-23
+  ];
+  if (c < 0.5)
+    return Math.log(Math.PI / Math.sin(Math.PI * c)) - b(1 - c);
+  c--;
+  let r = n[0];
+  for (let a = 1; a < 9; a++)
+    r += n[a] / (c + a);
+  const e = c + 7 + 0.5;
+  return 0.5 * Math.log(2 * Math.PI) + (c + 0.5) * Math.log(e) - e + Math.log(r);
+}
+function re(c, t) {
+  const n = t / (t + c * c);
+  return E(n, t / 2, 0.5);
+}
+class ae extends A {
+  constructor() {
+    super(...arguments), this.example = "T.TEST(A1:A100, B1:B100, 2, 2)", this.description = ne, this.defs = [
+      { name: "range1", description: "The first sample of data.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { name: "range2", description: "The second sample of data.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { name: "tails", description: "The number of distribution tails: 1 or 2.", acceptedTypes: ["number"] },
+      {
+        name: "type",
+        description: "The type of t-test: 1 (paired), 2 (equal variance), 3 (unequal variance).",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "statistics";
+  }
+  validate(t) {
+    const n = Math.floor(f(t[2])), r = Math.floor(f(t[3]));
+    if (n !== 1 && n !== 2)
+      throw new d("#NUM!", "tails must be 1 or 2.");
+    if (r < 1 || r > 3)
+      throw new d("#NUM!", "type must be 1, 2, or 3.");
+    const e = [], a = [];
+    if (g(
+      t[0],
+      (i) => {
+        i == null || i === "" || typeof i == "boolean" || e.push(f(i));
+      },
+      this.at
+    ), g(
+      t[1],
+      (i) => {
+        i == null || i === "" || typeof i == "boolean" || a.push(f(i));
+      },
+      this.at
+    ), r === 1) {
+      if (e.length !== a.length || e.length < 2)
+        throw new d("#N/A", "Paired T.TEST requires equal-length ranges with at least 2 values.");
+    } else if (e.length < 2 || a.length < 2)
+      throw new d("#DIV/0!", `T.TEST type ${r} requires at least 2 values per range.`);
+    return [e, a, n, r];
+  }
+  main(t, n, r, e) {
+    let a, i;
+    if (e === 1) {
+      const o = t.map((p, m) => p - n[m]), s = o.length, l = o.reduce((p, m) => p + m, 0) / s, h = o.reduce((p, m) => p + (m - l) ** 2, 0) / (s - 1);
+      a = l / Math.sqrt(h / s), i = s - 1;
+    } else if (e === 2) {
+      const o = t.reduce((m, y) => m + y, 0) / t.length, s = n.reduce((m, y) => m + y, 0) / n.length, l = t.reduce((m, y) => m + (y - o) ** 2, 0) / (t.length - 1), h = n.reduce((m, y) => m + (y - s) ** 2, 0) / (n.length - 1), p = ((t.length - 1) * l + (n.length - 1) * h) / (t.length + n.length - 2);
+      a = (o - s) / Math.sqrt(p * (1 / t.length + 1 / n.length)), i = t.length + n.length - 2;
+    } else {
+      const o = t.reduce((y, N) => y + N, 0) / t.length, s = n.reduce((y, N) => y + N, 0) / n.length, l = t.reduce((y, N) => y + (N - o) ** 2, 0) / (t.length - 1), h = n.reduce((y, N) => y + (N - s) ** 2, 0) / (n.length - 1), p = l / t.length, m = h / n.length;
+      a = (o - s) / Math.sqrt(p + m), i = (p + m) ** 2 / (p ** 2 / (t.length - 1) + m ** 2 / (n.length - 1));
+    }
+    const u = re(Math.abs(a), i);
+    return r === 1 ? u / 2 : u;
+  }
+}
+const ie = {
+  averageif: S,
+  averageifs: V,
+  median: D,
+  "stdev.s": C,
+  "stdev.p": $,
+  "var.s": U,
+  "var.p": Q,
+  "percentile.inc": G,
+  "quartile.inc": X,
+  "rank.eq": K,
+  correl: j,
+  "covariance.s": J,
+  "mode.sngl": z,
+  rsq: te,
+  "t.test": ae
+};
+export {
+  ie as default,
+  ie as statisticsFunctions
+};

package/dist/statistics/median.d.ts

@@ -0,0 +1,10 @@
+import { BaseFunction, FunctionArgumentDefinition, FunctionCategory } from '@gridsheet/react-core';
+export declare class MedianFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected validate(args: any[]): any[];
+    protected main(nums: number[]): number;
+}
+//# sourceMappingURL=median.d.ts.map

package/dist/statistics/median.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"median.d.ts","sourceRoot":"","sources":["../../src/statistics/median.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,KAAK,0BAA0B,EAAc,MAAM,uBAAuB,CAAC;AAElG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAI9D,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,SAAqB;IAC5B,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAQhC;IACF,QAAQ,EAAE,gBAAgB,CAAgB;IAE1C,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;IAsBtC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE;CAK9B"}

package/dist/statistics/mode_sngl.d.ts

@@ -0,0 +1,10 @@
+import { BaseFunction, FunctionArgumentDefinition, FunctionCategory } from '@gridsheet/react-core';
+export declare class ModeSnglFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected validate(args: any[]): any[];
+    protected main(nums: number[]): number;
+}
+//# sourceMappingURL=mode_sngl.d.ts.map

package/dist/statistics/mode_sngl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode_sngl.d.ts","sourceRoot":"","sources":["../../src/statistics/mode_sngl.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,KAAK,0BAA0B,EAAc,MAAM,uBAAuB,CAAC;AAElG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAI9D,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,SAAwB;IAC/B,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAQhC;IACF,QAAQ,EAAE,gBAAgB,CAAgB;IAE1C,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;IAsBtC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE;CAY9B"}