@gridsheet/functions 3.0.0-rc.10

package/dist/statistics/index.js

@@ -0,0 +1,706 @@
+import { BaseFunction as y, conditionArg as b, ensureString as M, eachMatrix as m, stripMatrix as T, check as R, FormulaError as d, Sheet as w, createBooleanMask as q, ensureNumber as f } from "@gridsheet/core";
+const k = "Returns the average of a series of cells that meet a condition.";
+class S extends y {
+  constructor() {
+    super(...arguments), this.example = 'AVERAGEIF(A1:A10,">20")', this.description = k, this.defs = [
+      { name: "range", description: "A condition range.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      b,
+      {
+        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 = [];
+    m(
+      t,
+      (s) => {
+        a.push(s);
+      },
+      this.at
+    ), r && m(
+      r,
+      (s) => {
+        i.push(s);
+      },
+      this.at
+    );
+    let c = 0, o = 0;
+    if (a.forEach((s, l) => {
+      const h = T((r ? i[l] : s) ?? 0, this.at);
+      typeof h == "number" && R(s, e) && (c += h, o++);
+    }), o === 0)
+      throw new d("#DIV/0!", "No cells match the condition.");
+    return c / o;
+  }
+}
+const I = "Returns the average of a range depending on multiple criteria.";
+class V extends y {
+  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"] },
+      { ...b, name: "condition1" },
+      {
+        name: "range2",
+        description: "Additional condition range.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"],
+        optional: !0,
+        variadic: !0
+      },
+      { ...b, 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].numRows, e = n[0].numCols, 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].numRows !== r || n[s].numCols !== e)
+        throw new d("#VALUE!", "Array arguments to AVERAGEIFS are of different size.");
+      a.push(n[s]), i.push(M(n[s + 1]));
+    }
+    const c = n[0], o = q(a, i, this.at);
+    return [c, o];
+  }
+  main(t, n) {
+    let r = 0, e = 0;
+    return m(
+      t,
+      (a, i) => {
+        if (i && n[i.y][i.x]) {
+          const c = T(a ?? 0, this.at);
+          typeof c == "number" && (r += c, 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 C extends y {
+  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)
+      m(
+        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 D = "Returns the standard deviation based on a sample.";
+class B extends y {
+  constructor() {
+    super(...arguments), this.example = "STDEV.S(A1:A100)", this.description = D, 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)
+      m(
+        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 y {
+  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)
+      m(
+        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 U = "Returns the variance based on a sample.";
+class _ extends y {
+  constructor() {
+    super(...arguments), this.example = "VAR.S(A1:A100)", this.description = U, 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)
+      m(
+        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 y {
+  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)
+      m(
+        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 G = "Returns the k-th percentile of values in a range, where k is in the range 0 to 1, inclusive.";
+class O extends y {
+  constructor() {
+    super(...arguments), this.example = "PERCENTILE.INC(A1:A100, 0.9)", this.description = G, 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 (m(
+      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, c) => i - c);
+    const r = n * (t.length - 1), e = Math.floor(r), a = Math.ceil(r);
+    return t[e] + (t[a] - t[e]) * (r - e);
+  }
+}
+const v = "Returns the quartile of a dataset, based on percentile values from 0 to 1, inclusive.";
+class X extends y {
+  constructor() {
+    super(...arguments), this.example = "QUARTILE.INC(A1:A100, 1)", this.description = v, 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 (m(
+      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((c, o) => c - 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 y {
+  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 (m(
+      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 y {
+  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 (m(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+      },
+      this.at
+    ), m(
+      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, c = 0, o = 0;
+    for (let l = 0; l < r; l++) {
+      const h = t[l] - e, p = n[l] - a;
+      i += h * p, c += h * h, o += p * p;
+    }
+    const s = Math.sqrt(c * 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 y {
+  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 (m(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+      },
+      this.at
+    ), m(
+      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, c) => i + c, 0) / r, a = n.reduce((i, c) => i + c, 0) / r;
+    return t.reduce((i, c, o) => i + (c - e) * (n[o] - a), 0) / (r - 1);
+  }
+}
+const Z = "Returns the population covariance, the average of the products of deviations for each data point pair in two datasets.";
+class z extends y {
+  constructor() {
+    super(...arguments), this.example = "COVARIANCE.P(A1:A100, B1:B100)", this.description = Z, 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 (m(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+      },
+      this.at
+    ), m(
+      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 < 1)
+      throw new d("#N/A", "COVARIANCE.P requires two ranges of equal length with at least 1 value.");
+    return [n, r];
+  }
+  main(t, n) {
+    const r = t.length, e = t.reduce((i, c) => i + c, 0) / r, a = n.reduce((i, c) => i + c, 0) / r;
+    return t.reduce((i, c, o) => i + (c - e) * (n[o] - a), 0) / r;
+  }
+}
+const ee = "Returns the most commonly occurring value in a dataset. If there are multiple modes, the smallest is returned.";
+class te extends y {
+  constructor() {
+    super(...arguments), this.example = "MODE.SNGL(A1:A100)", this.description = ee, 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)
+      m(
+        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 ne = "Returns the square of the Pearson product-moment correlation coefficient (R²).";
+class re extends y {
+  constructor() {
+    super(...arguments), this.example = "RSQ(A1:A10, B1:B10)", this.description = ne, 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 (m(
+      t[0],
+      (e) => {
+        e == null || e === "" || typeof e == "boolean" || (typeof e == "number" || typeof e == "string" && !isNaN(Number(e))) && n.push(f(e));
+      },
+      this.at
+    ), m(
+      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, c = 0, o = 0;
+    for (let h = 0; h < r; h++) {
+      const p = t[h] - e, g = n[h] - a;
+      i += p * g, c += p * p, o += g * g;
+    }
+    const s = Math.sqrt(c * o);
+    if (s === 0)
+      throw new d("#DIV/0!", "Standard deviation of one dataset is zero.");
+    const l = i / s;
+    return l * l;
+  }
+}
+const ae = `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(u, t, n) {
+  if (u <= 0)
+    return 0;
+  if (u >= 1)
+    return 1;
+  if (u > (t + 1) / (t + n + 2))
+    return 1 - E(1 - u, n, t);
+  const r = x(t) + x(n) - x(t + n), e = Math.exp(Math.log(u) * t + Math.log(1 - u) * n - r) / t, a = 200, i = 3e-7;
+  let c = 1, o = 1, s = 1 - (t + n) * u / (t + 1);
+  Math.abs(s) < 1e-30 && (s = 1e-30), s = 1 / s, c = s;
+  for (let l = 1; l <= a; l++) {
+    let h = l * (n - l) * u / ((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, c *= s * o, h = -(t + l) * (t + n + l) * u / ((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 (c *= p, Math.abs(p - 1) < i)
+      break;
+  }
+  return e * c;
+}
+function x(u) {
+  const n = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    9984369578019572e-21,
+    15056327351493116e-23
+  ];
+  if (u < 0.5)
+    return Math.log(Math.PI / Math.sin(Math.PI * u)) - x(1 - u);
+  u--;
+  let r = n[0];
+  for (let a = 1; a < 9; a++)
+    r += n[a] / (u + a);
+  const e = u + 7 + 0.5;
+  return 0.5 * Math.log(2 * Math.PI) + (u + 0.5) * Math.log(e) - e + Math.log(r);
+}
+function se(u, t) {
+  const n = t / (t + u * u);
+  return E(n, t / 2, 0.5);
+}
+class ie extends y {
+  constructor() {
+    super(...arguments), this.example = "T.TEST(A1:A100, B1:B100, 2, 2)", this.description = ae, 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 (m(
+      t[0],
+      (i) => {
+        i == null || i === "" || typeof i == "boolean" || e.push(f(i));
+      },
+      this.at
+    ), m(
+      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, g) => p - n[g]), s = o.length, l = o.reduce((p, g) => p + g, 0) / s, h = o.reduce((p, g) => p + (g - l) ** 2, 0) / (s - 1);
+      a = l / Math.sqrt(h / s), i = s - 1;
+    } else if (e === 2) {
+      const o = t.reduce((g, A) => g + A, 0) / t.length, s = n.reduce((g, A) => g + A, 0) / n.length, l = t.reduce((g, A) => g + (A - o) ** 2, 0) / (t.length - 1), h = n.reduce((g, A) => g + (A - 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((A, N) => A + N, 0) / t.length, s = n.reduce((A, N) => A + N, 0) / n.length, l = t.reduce((A, N) => A + (N - o) ** 2, 0) / (t.length - 1), h = n.reduce((A, N) => A + (N - s) ** 2, 0) / (n.length - 1), p = l / t.length, g = h / n.length;
+      a = (o - s) / Math.sqrt(p + g), i = (p + g) ** 2 / (p ** 2 / (t.length - 1) + g ** 2 / (n.length - 1));
+    }
+    const c = se(Math.abs(a), i);
+    return r === 1 ? c / 2 : c;
+  }
+}
+const ce = {
+  averageif: S,
+  averageifs: V,
+  median: C,
+  "stdev.s": B,
+  "stdev.p": $,
+  "var.s": _,
+  "var.p": Q,
+  "percentile.inc": O,
+  "quartile.inc": X,
+  "rank.eq": K,
+  correl: j,
+  "covariance.s": J,
+  "covariance.p": z,
+  "mode.sngl": te,
+  rsq: re,
+  "t.test": ie
+};
+export {
+  ce as default,
+  ce as statisticsFunctions
+};
+//# sourceMappingURL=index.js.map