mulmoclaude 2.7.0 → 2.8.1

package/src/plugins/spreadsheet/engine/functions/lookup-math.ts

@@ -1,28 +0,0 @@
-/**
- * Pure lookup rules, separated from the range-reading handlers so they can be
- * unit-tested directly.
- */
-
-import type { CellValue } from "../types";
-import { isSpreadsheetErrorValue } from "../spreadsheet-errors";
-
-/**
- * Interpret VLOOKUP/HLOOKUP's 4th argument (range_lookup): TRUE (or omitted) =
- * approximate match, FALSE = exact.
- *
- * The literal `TRUE` reaches the handler as the STRING `"TRUE"` — the evaluator
- * leaves bare words unquoted — so an accept-only-`true | 1 | "1"` check silently
- * fell back to exact match and returned `#N/A` for a valid approximate lookup
- * (#2360). Read it the way Excel coerces a logical instead: a boolean as-is, a
- * non-zero number as TRUE, and the words `TRUE` / `FALSE` (case-insensitive)
- * and `"1"` / `"0"` as their logical value. Anything else (blank, stray text)
- * is treated as FALSE, matching Excel's coercion of a blank range_lookup — and
- * so is a formula error, which is neither of the two logicals.
- */
-export function isApproximateMatch(rangeLookup: CellValue): boolean {
-  if (typeof rangeLookup === "boolean") return rangeLookup;
-  if (typeof rangeLookup === "number") return rangeLookup !== 0;
-  if (isSpreadsheetErrorValue(rangeLookup)) return false;
-  const normalized = rangeLookup.trim().toUpperCase();
-  return normalized === "TRUE" || normalized === "1";
-}

package/src/plugins/spreadsheet/engine/functions/lookup.ts

@@ -1,257 +0,0 @@
-/**
- * Lookup and Reference Functions
- */
-
-import { functionRegistry, rawRangeReader, requiredArg, toNumber, parseCriteria, type FunctionHandler, type FunctionContext } from "../registry";
-import { indexToColumn } from "../parser";
-import { parseRangeBounds, resolveIndexTarget, resolveTableOffset } from "../formulaRefs";
-import { isApproximateMatch } from "./lookup-math";
-import type { CellValue } from "../types";
-import { NA_ERROR, REF_ERROR } from "../spreadsheet-errors";
-
-const inclusiveRange = (start: number, end: number): number[] => Array.from({ length: Math.max(0, end - start + 1) }, (_, i) => start + i);
-
-// Read a vertical slice (one column, `startRow`..`endRow`) as VLOOKUP's lookup column.
-const columnValues = (context: FunctionContext, sheetPrefix: string, colStr: string, startRow: number, endRow: number): CellValue[] =>
-  inclusiveRange(startRow, endRow).map((r) => context.getCellValue(`${sheetPrefix}${colStr}${r}`));
-
-// Read a horizontal slice (one row, `startCol`..`endCol`) as HLOOKUP's lookup row.
-const rowValues = (context: FunctionContext, sheetPrefix: string, row: number, startCol: number, endCol: number): CellValue[] =>
-  inclusiveRange(startCol, endCol).map((c) => context.getCellValue(`${sheetPrefix}${indexToColumn(c)}${row}`));
-
-/** The index of the LAST value that satisfies `matches`, or -1. Array.findIndex
- *  only walks forward, and XLOOKUP's `searchMode: -1` searches from the end. */
-const findLastMatchIndex = (values: CellValue[], matches: (value: CellValue) => boolean): number =>
-  values.reduce<number>((found, value, index) => (matches(value) ? index : found), -1);
-
-/** The index of the last value in a SORTED list before `keepGoing` stops
- *  holding, or -1 when the very first value already fails. The list is assumed
- *  sorted (as Excel's approximate match requires), so the first failure ends the
- *  run. */
-const lastIndexWhile = (values: CellValue[], keepGoing: (value: CellValue) => boolean): number => {
-  const stop = values.findIndex((value) => !keepGoing(value));
-  return (stop === -1 ? values.length : stop) - 1;
-};
-
-// Helper to find match index
-const findMatchIndex = (
-  lookupValue: CellValue,
-  lookupArray: CellValue[],
-  matchType: number = 1, // 1 = less than (sorted asc), 0 = exact, -1 = greater than (sorted desc)
-  searchMode: number = 1, // 1 = first to last, -1 = last to first (for XLOOKUP)
-): number => {
-  const compare = (a: CellValue, b: CellValue) => {
-    if (typeof a === "number" && typeof b === "number") return a - b;
-    return String(a).localeCompare(String(b));
-  };
-
-  // Exact match
-  if (matchType === 0) {
-    // Handle wildcards for strings if it's an exact match request.
-    // Loose equality otherwise, for "10" == 10.
-    const usesWildcards = typeof lookupValue === "string" && (lookupValue.includes("*") || lookupValue.includes("?"));
-    const isMatch = usesWildcards ? parseCriteria(lookupValue) : (item: CellValue) => item == lookupValue;
-    return searchMode === 1 ? lookupArray.findIndex(isMatch) : findLastMatchIndex(lookupArray, isMatch);
-  }
-
-  // Approximate match (requires sorted array)
-  // We'll assume the user knows what they are doing regarding sorting, as per Excel behavior
-
-  // Less than or equal to, over an array sorted ascending: once we exceed, stop.
-  if (matchType === 1) return lastIndexWhile(lookupArray, (item) => compare(item, lookupValue) <= 0);
-
-  // Greater than or equal to, over an array sorted descending.
-  if (matchType === -1) return lastIndexWhile(lookupArray, (item) => compare(item, lookupValue) >= 0);
-
-  return -1;
-};
-
-const vlookupHandler: FunctionHandler = (args, context) => {
-  const lookupValue = context.evaluateFormula(requiredArg(context, args, 0));
-  const bounds = parseRangeBounds(requiredArg(context, args, 1));
-  if (!bounds) throw new Error("Invalid table array range");
-  const colIndexNum = toNumber(context.evaluateFormula(requiredArg(context, args, 2)));
-  const rangeLookup = args.length === 4 ? context.evaluateFormula(requiredArg(context, args, 3)) : true;
-  const matchType = isApproximateMatch(rangeLookup) ? 1 : 0;
-
-  // Excel rejects a col_index_num past the table's width; reading on regardless
-  // addressed a cell outside the range and usually returned a silent 0 (#2360).
-  // Checked before the search: an out-of-range index is an argument error, so it
-  // wins over the #N/A a missing key would otherwise mask it with (Codex review).
-  const colOffset = resolveTableOffset(colIndexNum, bounds.endCol - bounds.startCol + 1);
-  if (colOffset === null) return REF_ERROR;
-
-  const startColStr = indexToColumn(bounds.startCol);
-  const lookupArray = columnValues(context, bounds.sheetPrefix, startColStr, bounds.startRow, bounds.endRow);
-  const matchIdx = findMatchIndex(lookupValue, lookupArray, matchType);
-  if (matchIdx === -1) return NA_ERROR;
-
-  const resultColStr = indexToColumn(bounds.startCol + colOffset);
-  const resultRow = bounds.startRow + matchIdx;
-  return context.getCellValue(`${bounds.sheetPrefix}${resultColStr}${resultRow}`);
-};
-
-const hlookupHandler: FunctionHandler = (args, context) => {
-  const lookupValue = context.evaluateFormula(requiredArg(context, args, 0));
-  const bounds = parseRangeBounds(requiredArg(context, args, 1));
-  if (!bounds) throw new Error("Invalid range format");
-  const rowIndexNum = toNumber(context.evaluateFormula(requiredArg(context, args, 2)));
-  const rangeLookup = args.length === 4 ? context.evaluateFormula(requiredArg(context, args, 3)) : true;
-  const matchType = isApproximateMatch(rangeLookup) ? 1 : 0;
-
-  const rowOffset = resolveTableOffset(rowIndexNum, bounds.endRow - bounds.startRow + 1);
-  if (rowOffset === null) return REF_ERROR;
-
-  const lookupArray = rowValues(context, bounds.sheetPrefix, bounds.startRow, bounds.startCol, bounds.endCol);
-  const matchIdx = findMatchIndex(lookupValue, lookupArray, matchType);
-  if (matchIdx === -1) return NA_ERROR;
-
-  const resultColStr = indexToColumn(bounds.startCol + matchIdx);
-  const resultRow = bounds.startRow + rowOffset;
-  return context.getCellValue(`${bounds.sheetPrefix}${resultColStr}${resultRow}`);
-};
-
-const matchHandler: FunctionHandler = (args, context) => {
-  const lookupValue = context.evaluateFormula(requiredArg(context, args, 0));
-  const lookupArrayRange = requiredArg(context, args, 1);
-  const matchType = args.length === 3 ? toNumber(context.evaluateFormula(requiredArg(context, args, 2))) : 1;
-
-  // Raw, not numeric-only: MATCH answers with a POSITION, so a dropped text
-  // cell renumbers everything after it and returns a different row (#2765).
-  const lookupArray = rawRangeReader(context)(lookupArrayRange);
-
-  const index = findMatchIndex(lookupValue, lookupArray, matchType);
-
-  return index === -1 ? NA_ERROR : index + 1; // 1-based index
-};
-
-const indexHandler: FunctionHandler = (args, context) => {
-  const bounds = parseRangeBounds(requiredArg(context, args, 0));
-  if (!bounds) throw new Error("Invalid range format");
-  const rowNum = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  const colNum = args.length >= 3 ? toNumber(context.evaluateFormula(requiredArg(context, args, 2))) : 1; // Default to 1 if omitted (for 1D arrays)
-
-  const target = resolveIndexTarget(bounds, rowNum, colNum);
-  if (!target) return REF_ERROR;
-  return context.getCellValue(`${bounds.sheetPrefix}${indexToColumn(target.colIndex)}${target.row}`);
-};
-
-const xlookupHandler: FunctionHandler = (args, context) => {
-  const lookupValue = context.evaluateFormula(requiredArg(context, args, 0));
-  const lookupArrayRange = requiredArg(context, args, 1);
-  const returnArrayRange = requiredArg(context, args, 2);
-  const ifNotFound = args.length >= 4 ? context.evaluateFormula(requiredArg(context, args, 3)) : NA_ERROR;
-  const matchMode = args.length >= 5 ? toNumber(context.evaluateFormula(requiredArg(context, args, 4))) : 0;
-  const searchMode = args.length >= 6 ? toNumber(context.evaluateFormula(requiredArg(context, args, 5))) : 1;
-
-  // Both raw, and for a second reason beyond MATCH's: the numeric-only reader
-  // filters these two INDEPENDENTLY, so a text cell in one range shifts it
-  // against the other and the match index reads a different row's value — a
-  // wrong number with no error, which is the worst outcome a formula can have.
-  const readRange = rawRangeReader(context);
-  const lookupArray = readRange(lookupArrayRange);
-  const returnArray = readRange(returnArrayRange);
-
-  // XLOOKUP match modes:
-  // 0 = Exact match (default)
-  // -1 = Exact match or next smaller
-  // 1 = Exact match or next larger
-  // 2 = Wildcard match
-
-  // Map XLOOKUP modes to our internal findMatchIndex modes
-  // Our internal: 0=exact, 1=less than (sorted), -1=greater than (sorted)
-  // XLOOKUP is more complex because it doesn't require sorted arrays for next smaller/larger
-  // For now, we'll implement exact (0) and wildcard (2 -> handled by exact with wildcard logic in findMatchIndex)
-  // For -1 and 1, we'll do a linear search for best match if not sorted
-
-  let matchIdx = -1;
-
-  if (matchMode === 0 || matchMode === 2) {
-    matchIdx = findMatchIndex(lookupValue, lookupArray, 0, searchMode);
-  } else {
-    // Implement exact or next smaller/larger for unsorted arrays
-    // This is O(N)
-    let bestDiff = Infinity;
-
-    for (let i = 0; i < lookupArray.length; i++) {
-      const idx = searchMode === 1 ? i : lookupArray.length - 1 - i;
-      const item = lookupArray[idx];
-
-      if (item == lookupValue) {
-        matchIdx = idx;
-        break;
-      }
-
-      if (typeof item === "number" && typeof lookupValue === "number") {
-        const diff = item - lookupValue;
-        if (matchMode === -1 && diff < 0 && Math.abs(diff) < bestDiff) {
-          // Next smaller (closest negative difference)
-          bestDiff = Math.abs(diff);
-          matchIdx = idx;
-        } else if (matchMode === 1 && diff > 0 && diff < bestDiff) {
-          // Next larger (closest positive difference)
-          bestDiff = diff;
-          matchIdx = idx;
-        }
-      }
-    }
-  }
-
-  if (matchIdx === -1) return ifNotFound;
-
-  // A match past the end of the return range has nothing to return — the two
-  // ranges are independent arguments and need not be the same length.
-  const found = returnArray[matchIdx];
-  return found === undefined ? NA_ERROR : found;
-};
-
-// Register functions
-functionRegistry.register({
-  name: "VLOOKUP",
-  handler: vlookupHandler,
-  minArgs: 3,
-  maxArgs: 4,
-  description: "Looks for a value in the leftmost column of a table, and then returns a value in the same row from a column you specify",
-  examples: ["VLOOKUP(105, A2:C10, 2)", 'VLOOKUP("Smith", A2:E10, 5, FALSE)'],
-  category: "Lookup & Reference",
-});
-
-functionRegistry.register({
-  name: "HLOOKUP",
-  handler: hlookupHandler,
-  minArgs: 3,
-  maxArgs: 4,
-  description: "Looks for a value in the top row of a table, and then returns a value in the same column from a row you specify",
-  examples: ['HLOOKUP("Axles", A1:C10, 2, TRUE)'],
-  category: "Lookup & Reference",
-});
-
-functionRegistry.register({
-  name: "MATCH",
-  handler: matchHandler,
-  minArgs: 2,
-  maxArgs: 3,
-  description: "Returns the relative position of an item in an array that matches a specified value",
-  examples: ["MATCH(25, A1:A10, 0)", 'MATCH("b", A1:A5, 0)'],
-  category: "Lookup & Reference",
-});
-
-functionRegistry.register({
-  name: "INDEX",
-  handler: indexHandler,
-  minArgs: 2,
-  maxArgs: 4,
-  description: "Returns the value of an element in a table or an array, selected by the row and column number indexes",
-  examples: ["INDEX(A1:B5, 2, 2)", "INDEX(A1:A10, 5)"],
-  category: "Lookup & Reference",
-});
-
-functionRegistry.register({
-  name: "XLOOKUP",
-  handler: xlookupHandler,
-  minArgs: 3,
-  maxArgs: 6,
-  description: "Searches a range or an array, and returns an item corresponding to the first match it finds",
-  examples: ["XLOOKUP(A1, B1:B10, C1:C10)", 'XLOOKUP("USA", Countries, Populations)'],
-  category: "Lookup & Reference",
-});

package/src/plugins/spreadsheet/engine/functions/mathematical.ts

@@ -1,283 +0,0 @@
-/**
- * Mathematical Functions
- */
-
-import { functionRegistry, requiredArg, toNumber, type FunctionHandler } from "../registry";
-import {
-  roundTo,
-  roundUpTo,
-  roundDownTo,
-  floorToSignificance,
-  ceilingToSignificance,
-  modulo,
-  power,
-  safeLog,
-  safeLog10,
-  safeSqrt,
-  logWithBase,
-} from "../math-ops";
-import { toScalarNumber } from "../numericCoercion";
-import { isSpreadsheetErrorValue } from "../spreadsheet-errors";
-
-const roundHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const digits = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  return roundTo(number, digits);
-};
-
-const roundupHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const digits = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  return roundUpTo(number, digits);
-};
-
-const rounddownHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const digits = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  return roundDownTo(number, digits);
-};
-
-const floorHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const significance = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  return floorToSignificance(number, significance);
-};
-
-const ceilingHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const significance = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  return ceilingToSignificance(number, significance);
-};
-
-const absHandler: FunctionHandler = (args, context) => {
-  const number = toScalarNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  return isSpreadsheetErrorValue(number) ? number : Math.abs(number);
-};
-
-const powerHandler: FunctionHandler = (args, context) => {
-  const base = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const exponent = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  return power(base, exponent);
-};
-
-const sqrtHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  return safeSqrt(number);
-};
-
-const modHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const divisor = toNumber(context.evaluateFormula(requiredArg(context, args, 1)));
-  return modulo(number, divisor);
-};
-
-const intHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  return Math.floor(number);
-};
-
-const truncHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const digits = args.length === 2 ? toNumber(context.evaluateFormula(requiredArg(context, args, 1))) : 0;
-  const multiplier = Math.pow(10, digits);
-  return Math.trunc(number * multiplier) / multiplier;
-};
-
-const signHandler: FunctionHandler = (args, context) => {
-  const number = toScalarNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  return isSpreadsheetErrorValue(number) ? number : Math.sign(number);
-};
-
-const piHandler: FunctionHandler = () => Math.PI;
-
-const expHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  return Math.exp(number);
-};
-
-const lnHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  return safeLog(number);
-};
-
-const logHandler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  const base = args.length === 2 ? toNumber(context.evaluateFormula(requiredArg(context, args, 1))) : 10;
-  return logWithBase(number, base);
-};
-
-const log10Handler: FunctionHandler = (args, context) => {
-  const number = toNumber(context.evaluateFormula(requiredArg(context, args, 0)));
-  return safeLog10(number);
-};
-
-// Register all mathematical functions
-functionRegistry.register({
-  name: "ROUND",
-  handler: roundHandler,
-  minArgs: 2,
-  maxArgs: 2,
-  description: "Rounds a number to a specified number of digits",
-  examples: ["ROUND(3.14159, 2)", "ROUND(A1, 0)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "ROUNDUP",
-  handler: roundupHandler,
-  minArgs: 2,
-  maxArgs: 2,
-  description: "Rounds a number up, away from zero",
-  examples: ["ROUNDUP(3.14159, 2)", "ROUNDUP(A1, 0)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "ROUNDDOWN",
-  handler: rounddownHandler,
-  minArgs: 2,
-  maxArgs: 2,
-  description: "Rounds a number down, toward zero",
-  examples: ["ROUNDDOWN(3.14159, 2)", "ROUNDDOWN(A1, 0)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "FLOOR",
-  handler: floorHandler,
-  minArgs: 2,
-  maxArgs: 2,
-  description: "Rounds a number down to the nearest multiple of significance",
-  examples: ["FLOOR(3.7, 1)", "FLOOR(24, 5)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "CEILING",
-  handler: ceilingHandler,
-  minArgs: 2,
-  maxArgs: 2,
-  description: "Rounds a number up to the nearest multiple of significance",
-  examples: ["CEILING(3.2, 1)", "CEILING(24, 5)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "ABS",
-  handler: absHandler,
-  minArgs: 1,
-  maxArgs: 1,
-  description: "Returns the absolute value of a number",
-  examples: ["ABS(-5)", "ABS(A1)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "POWER",
-  handler: powerHandler,
-  minArgs: 2,
-  maxArgs: 2,
-  description: "Returns the result of a number raised to a power",
-  examples: ["POWER(2, 3)", "POWER(A1, 2)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "SQRT",
-  handler: sqrtHandler,
-  minArgs: 1,
-  maxArgs: 1,
-  description: "Returns the square root of a number",
-  examples: ["SQRT(16)", "SQRT(A1)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "MOD",
-  handler: modHandler,
-  minArgs: 2,
-  maxArgs: 2,
-  description: "Returns the remainder after division",
-  examples: ["MOD(10, 3)", "MOD(A1, 2)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "INT",
-  handler: intHandler,
-  minArgs: 1,
-  maxArgs: 1,
-  description: "Rounds a number down to the nearest integer",
-  examples: ["INT(3.7)", "INT(A1)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "TRUNC",
-  handler: truncHandler,
-  minArgs: 1,
-  maxArgs: 2,
-  description: "Truncates a number to a specified number of decimal places",
-  examples: ["TRUNC(3.14159, 2)", "TRUNC(A1)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "SIGN",
-  handler: signHandler,
-  minArgs: 1,
-  maxArgs: 1,
-  description: "Returns the sign of a number (1, 0, or -1)",
-  examples: ["SIGN(-5)", "SIGN(A1)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "PI",
-  handler: piHandler,
-  minArgs: 0,
-  maxArgs: 0,
-  description: "Returns the value of pi (3.14159...)",
-  examples: ["PI()", "PI()*2"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "EXP",
-  handler: expHandler,
-  minArgs: 1,
-  maxArgs: 1,
-  description: "Returns e raised to the power of a number",
-  examples: ["EXP(1)", "EXP(A1)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "LN",
-  handler: lnHandler,
-  minArgs: 1,
-  maxArgs: 1,
-  description: "Returns the natural logarithm of a number",
-  examples: ["LN(10)", "LN(A1)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "LOG",
-  handler: logHandler,
-  minArgs: 1,
-  maxArgs: 2,
-  description: "Returns the logarithm of a number to a specified base",
-  examples: ["LOG(100)", "LOG(8, 2)"],
-  category: "Mathematical",
-});
-
-functionRegistry.register({
-  name: "LOG10",
-  handler: log10Handler,
-  minArgs: 1,
-  maxArgs: 1,
-  description: "Returns the base-10 logarithm of a number",
-  examples: ["LOG10(100)", "LOG10(A1)"],
-  category: "Mathematical",
-});

package/src/plugins/spreadsheet/engine/functions/statistical-math.ts

@@ -1,91 +0,0 @@
-/**
- * Pure statistical rules, separated from the range-reading handlers so they can
- * be unit-tested directly.
- */
-
-import { DIV_ZERO_ERROR, NA_ERROR, NUM_ERROR, type SpreadsheetError } from "../spreadsheet-errors";
-
-const arithmeticMean = (values: number[]): number => values.reduce((sum, value) => sum + value, 0) / values.length;
-
-/**
- * The arithmetic mean, or `#DIV/0!` when there is nothing to average.
- *
- * Excel divides by the count of NUMBERS, so a range of blanks or text leaves a
- * zero denominator and reports the division rather than a 0 that reads like a
- * genuine average of zeros.
- */
-export function computeAverage(values: number[]): number | SpreadsheetError {
-  if (values.length === 0) return DIV_ZERO_ERROR;
-  return arithmeticMean(values);
-}
-
-/**
- * The middle value (the mean of the middle two when the count is even), or
- * `#NUM!` when there is no value to sit in the middle.
- *
- * Excel's code here is `#NUM!`, not AVERAGE's `#DIV/0!` — nothing is divided by
- * zero, the median of an empty set simply does not exist. Sorts a copy so the
- * caller's array keeps its order.
- */
-export function computeMedian(values: number[]): number | SpreadsheetError {
-  if (values.length === 0) return NUM_ERROR;
-  return arithmeticMean(middleValues([...values].sort((a, b) => a - b)));
-}
-
-/** The one or two values sitting in the middle of a sorted list — two when the
- *  count is even, one when it is odd. Sliced rather than indexed, so the middle
- *  of an empty list is simply nothing. */
-function middleValues(sorted: number[]): number[] {
-  const half = Math.floor(sorted.length / 2);
-  return sorted.slice(sorted.length % 2 === 0 ? half - 1 : half, half + 1);
-}
-
-/**
- * The most frequently occurring value, or `#N/A` when no value repeats.
- *
- * Excel's MODE is undefined for an all-distinct set, so returning the first
- * element (as a naive "highest frequency wins" loop does when every count is 1)
- * is a silent wrong answer. Ties resolve to the value that appears first, which
- * Map insertion order preserves.
- */
-export function computeMode(values: number[]): number | SpreadsheetError {
-  const frequency = new Map<number, number>();
-  for (const value of values) {
-    frequency.set(value, (frequency.get(value) ?? 0) + 1);
-  }
-
-  let topFrequency = 0;
-  let mode: number | SpreadsheetError = NA_ERROR;
-  for (const [value, count] of frequency.entries()) {
-    if (count > topFrequency) {
-      topFrequency = count;
-      mode = value;
-    }
-  }
-
-  const REPEAT_THRESHOLD = 2;
-  return topFrequency >= REPEAT_THRESHOLD ? mode : NA_ERROR;
-}
-
-/** Sample size below which a sample variance/stdev is undefined. */
-const MIN_SAMPLE_SIZE = 2;
-
-/**
- * Sample variance (Excel VAR): the mean squared deviation divided by `n - 1`,
- * not `n`. Dividing by `n` is the POPULATION variance (Excel's VARP); using it
- * for VAR understates the spread. Fewer than two values leave no `n - 1` to
- * divide by, so Excel reports `#DIV/0!` rather than a silent 0.
- */
-export function sampleVariance(values: number[]): number | SpreadsheetError {
-  if (values.length < MIN_SAMPLE_SIZE) return DIV_ZERO_ERROR;
-  const mean = arithmeticMean(values);
-  const sumSquaredDiffs = values.reduce((sum, value) => sum + (value - mean) ** 2, 0);
-  return sumSquaredDiffs / (values.length - 1);
-}
-
-/** Sample standard deviation (Excel STDEV): the square root of the sample
- *  variance, and `#DIV/0!` on the same fewer-than-two-values boundary. */
-export function sampleStdev(values: number[]): number | SpreadsheetError {
-  const variance = sampleVariance(values);
-  return typeof variance === "number" ? Math.sqrt(variance) : variance;
-}