@trebco/treb 30.11.2 → 30.15.0

package/treb-calculator/src/functions/statistics-functions.ts

@@ -22,9 +22,61 @@
 import type { FunctionMap } from '../descriptors';
 import * as Utils from '../utilities';
 import { ValueError, ArgumentError, NAError } from '../function-error';
-import { type Complex, type UnionValue, ValueType, type CellValue } from 'treb-base-types';
+import { type Complex, type UnionValue, ValueType, type CellValue, ComplexOrReal } from 'treb-base-types';
 import * as ComplexMath from '../complex-math';
 
+import { BetaCDF, BetaPDF, InverseBeta, LnGamma } from './beta';
+
+/** error function (for gaussian distribution) */
+const erf = (x: number): number => {
+
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+
+  x = Math.abs(x);
+  const t = 1 / (1 + p * x);
+  return 1 - ((((((a5 * t + a4) * t) + a3) * t + a2) * t) + a1) * t * Math.exp(-1 * x * x);
+
+};
+
+const sqrt2pi = Math.sqrt(2 * Math.PI);
+
+const norm_dist = (x: number, mean: number, stdev: number, cumulative: boolean) => {
+  
+  let value = 0;
+
+  if (cumulative) {
+    const sign = (x < mean) ? -1 : 1;
+    value = 0.5 * (1.0 + sign * erf((Math.abs(x - mean)) / (stdev * Math.sqrt(2))));
+  }
+  else {
+    value = Math.exp(-1/2 * Math.pow((x - mean) / stdev, 2)) / (stdev * sqrt2pi);
+  }
+
+  return value;
+
+}
+
+/** imprecise but reasonably fast normsinv function */
+const inverse_normal = (q: number): number => {
+
+  if (q === 0.50) {
+    return 0;
+  }
+  
+  const p = (q < 1.0 && q > 0.5) ? (1 - q) : q;
+  const t = Math.sqrt(Math.log(1.0 / Math.pow(p, 2.0)));
+  const x = t - (2.515517 + 0.802853 * t + 0.010328 * Math.pow(t, 2.0)) /
+    (1.0 + 1.432788 * t + 0.189269 * Math.pow(t, 2.0) + 0.001308 * Math.pow(t, 3.0));
+
+  return (q > 0.5 ? x : -x);
+
+};
+
 const Median = (data: number[]) => {
   const n = data.length;
   if (n % 2) {
@@ -68,10 +120,13 @@ const InterpolatedQuartiles = (data: number[], include_median = true) => {
 
 };
 
+/**
+ * this is a Lanczos approximation. could be cleaned up.
+ * @param z 
+ * @returns 
+ */
 const Gamma = (z: Complex): Complex => {
 
-  // this is a Lanczos approximation. could be cleaned up.
-
   const coefficients = [
     0.99999999999980993,
     676.5203681218851,
@@ -87,6 +142,9 @@ const Gamma = (z: Complex): Complex => {
   // generally speaking I'm against operator overloading but 
   // it would be a big help for complex math
 
+  // how about a class based on the complex type? then you could
+  // use class methods on values. would be a little cleaner?
+
   const pi = Math.PI;
   const sin = ComplexMath.Sin;
   const div = ComplexMath.Divide;
@@ -144,6 +202,295 @@ export const Variance = (data: number[], sample = false) => {
 
 export const StatisticsFunctionLibrary: FunctionMap = {
 
+  Slope: {
+    arguments: [
+      { name: 'known_y' },
+      { name: 'known_x' },
+    ],
+    fn: (y: CellValue[][], x: CellValue[][]) => {
+
+      const flat_x = Utils.FlattenNumbers(x);
+      const flat_y = Utils.FlattenNumbers(y);
+
+      if (flat_x.length !== flat_y.length) {
+        return ArgumentError();
+      }
+
+      let sum_x = 0;
+      let sum_y = 0;
+      let sum_products = 0;
+      let sum_squared_x = 0;
+  
+      for (let i = 0; i < flat_x.length; i++) {
+  
+        const x = flat_x[i];
+        const y = flat_y[i];
+  
+        sum_products += (x * y);
+        sum_x += x;
+        sum_y += y;
+  
+        sum_squared_x += (x * x);
+        // sum_squared_y += (y * y);
+  
+      }
+  
+      const value = 
+        ((flat_x.length * sum_products) - (sum_x * sum_y) ) /
+         ((flat_x.length * sum_squared_x) - (sum_x * sum_x));
+
+      return {
+        type: ValueType.number,
+        value,
+      }
+
+    },
+  },
+
+  Intercept: {
+    arguments: [
+      { name: 'known_y' },
+      { name: 'known_x' },
+    ],
+    fn: (y: CellValue[][], x: CellValue[][]) => {
+      const flat_x = Utils.FlattenNumbers(x);
+      const flat_y = Utils.FlattenNumbers(y);
+
+      if (flat_x.length !== flat_y.length) {
+        return ArgumentError();
+      }
+
+      const N = flat_x.length;
+
+      let sum_x = 0;
+      let sum_y = 0;
+      let sum_products = 0;
+      let sum_squared_x = 0;
+
+      for (let i = 0; i < N; i++) {
+
+        const x = flat_x[i];
+        const y = flat_y[i];
+
+        sum_products += (x * y);
+        sum_x += x;
+        sum_y += y;
+
+        sum_squared_x += (x * x);
+
+      }
+
+      let m = ((N * sum_products) - (sum_x * sum_y) );
+      m /= ((N * sum_squared_x) - (sum_x * sum_x));
+
+      return {
+        type: ValueType.number, value: (sum_y - (m * sum_x)) / N,
+      };
+
+    },
+  },
+
+  Phi: {
+    arguments: [
+      { name: 'x', boxed: true, unroll: true }
+    ],
+    fn: (x: UnionValue) => {
+
+      if (x.type === ValueType.number) {
+        return {
+          type: ValueType.number,
+          value: (1 / Math.sqrt(Math.PI * 2)) * Math.exp(-x.value * x.value / 2),
+        };
+      }
+
+      return ArgumentError();
+    }
+  },
+
+  'Z.Test': {
+    arguments: [
+      { name: 'Array', boxed: true,  },
+      { name: 'x', boxed: true, unroll: true, },
+      { name: 'Sigma', boxed: true, unroll: true, },
+    ],
+    fn: (array: UnionValue, x: UnionValue, sigma?: UnionValue) => {
+
+      const data: number[] = [];
+
+      if (array.type === ValueType.array) {
+        for (const row of array.value) {
+          for (const cell of row) { 
+            if (cell.type === ValueType.number) {
+              data.push(cell.value);
+            }
+          }
+        }
+      }
+      else if (array.type === ValueType.number) {
+        data.push(array.value);
+      }
+
+      if (data.length && x.type === ValueType.number) {
+
+        let average = 0; 
+        const n = data.length;
+        for (const value of data) { average += value; }
+        average /= n;
+
+        const s = sigma?.type === ValueType.number ? sigma.value : 
+          Math.sqrt(Variance(data, true));
+
+        return {
+          type: ValueType.number,
+          value: 1 - norm_dist((average - x.value) / (s / Math.sqrt(n)), 0, 1, true),
+        };
+
+      }
+
+      return ArgumentError();
+
+    },
+  },
+
+  'Beta.Dist': {
+    description: 'beta distribution',
+    arguments: [
+      { name: 'x', unroll: true},
+      { name: 'a', },
+      { name: 'b', },
+      { name: 'cumulative', },
+    ],
+    fn: (x: number, a: number, b: number, cumulative: boolean) => {
+
+      if (a < 0 || b < 0) {
+        return ArgumentError();
+      }
+
+      if (cumulative) {
+        return {
+          type: ValueType.number,
+          value: BetaCDF(x, a, b),
+        };
+      }
+      else {
+        return {
+          type: ValueType.number,
+          value: BetaPDF(x, a, b),
+        };
+      }
+
+      return ArgumentError();
+    }
+  },
+
+  'Beta.Inv': {
+    description: 'Inverse of the beta distribution',
+    arguments: [
+      {name: 'probability', unroll: true},
+      {name: 'a', },
+      {name: 'b', },
+    ],
+    fn: (x: number, a: number, b: number) => {
+
+      if (a < 0 || b < 0) {
+        return ArgumentError();
+      }
+
+      return {
+        type: ValueType.number,
+        value: InverseBeta(x, a, b),
+      }
+    }
+  },
+
+  Erf: {
+    fn: (a: number): UnionValue => {
+      return { type: ValueType.number, value: erf(a) };
+    },
+  },
+
+  'NormsInv': {
+    
+    description: 'Inverse of the normal cumulative distribution', 
+    arguments: [
+      {name: 'probability'},
+    ],
+
+    fn: (q: number): UnionValue => {
+      return {
+        type: ValueType.number,
+        value: inverse_normal(q),
+      }
+    }
+  },
+  
+  'Norm.Inv': {
+    description: 'Inverse of the normal cumulative distribution', 
+    arguments: [
+      {name: 'probability'},
+      {name: 'mean', default: 0},
+      {name: 'standard deviation', default: 1},
+    ],
+    xlfn: true,
+    fn: (q: number, mean = 0, stdev = 1): UnionValue => {
+      return {
+        type: ValueType.number,
+        value: inverse_normal(q) * stdev + mean,
+      }
+    }
+  },
+
+  'Norm.S.Inv': {
+    description: 'Inverse of the normal cumulative distribution', 
+    arguments: [
+      {name: 'probability'},
+      {name: 'mean', default: 0},
+      {name: 'standard deviation', default: 1},
+    ],
+    xlfn: true,
+    fn: (q: number, mean = 0, stdev = 1): UnionValue => {
+      return {
+        type: ValueType.number,
+        value: inverse_normal(q) * stdev + mean,
+      }
+    }
+  }, 
+
+  'Norm.Dist': {
+
+    description: 'Cumulative normal distribution',
+    arguments: [
+      {name: 'value'},
+      {name: 'mean', default: 0},
+      {name: 'standard deviation', default: 1},
+      {name: 'cumulative', default: true},
+    ],
+
+    // this does need xlfn but it also requires four parameters
+    // (we have three and they are not required).
+    
+    xlfn: true,
+
+    fn: (x: number, mean = 0, stdev = 1, cumulative = true): UnionValue => {
+      return { type: ValueType.number, value: norm_dist(x, mean, stdev, cumulative) };
+    },
+  },
+
+  'Norm.S.Dist': {
+
+    description: 'Cumulative normal distribution',
+    arguments: [
+      {name: 'value'},
+      {name: 'cumulative', default: true},
+    ],
+
+    xlfn: true,
+
+    fn: (x: number, cumulative = true): UnionValue => {
+      return { type: ValueType.number, value: norm_dist(x, 0, 1, cumulative) };
+    },
+  },
+
   'StDev.P': {
     description: 'Returns the standard deviation of a set of values, corresponding to a population',
     arguments: [{ name: 'data', }],
@@ -396,9 +743,46 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     },
   },
 
+  GammaLn: {
+    description: 'Returns the natural log of the gamma function',
+    arguments: [{ name: 'value', boxed: true, unroll: true }],
+    fn: (value: UnionValue) => {
+      if (value.type === ValueType.number) {
+        return {
+          type: ValueType.number,
+          value: LnGamma(value.value),
+        };
+      }
+      return ArgumentError();
+    },
+  },
+
+  'GammaLn.Precise': {
+    description: 'Returns the natural log of the gamma function',
+    arguments: [{ name: 'value', boxed: true, unroll: true }],
+    fn: (value: UnionValue) => {
+
+      let cpx: Complex|undefined;
+
+      if (value.type === ValueType.number) {
+        cpx = { real: value.value, imaginary: 0 };
+      } 
+      else if (value.type === ValueType.complex) {
+        cpx = value.value;
+      }
+
+      if (cpx) {
+        const gamma = Gamma(cpx);
+        return ComplexOrReal(ComplexMath.Log(gamma));
+      }
+
+      return ArgumentError();
+    },
+  },
+
   Gamma: {
     description: 'Returns the gamma function for the given value',
-    arguments: [{ name: 'value', boxed: true }],
+    arguments: [{ name: 'value', boxed: true, unroll: true }],
     fn: (value: UnionValue) => {
 
       let complex: Complex = { real: 0, imaginary: 0 };

package/treb-calculator/src/utilities.ts

@@ -127,7 +127,7 @@ export const FlattenBoxed = (args: UnionValue[]): UnionValue[] => {
 
   let result: UnionValue[] = [];
   for (const arg of args) {
-    if (arg.type === ValueType.array) {
+    if (arg?.type === ValueType.array) {
 
       // possibly recursive
       for (const row of arg.value) {
@@ -280,7 +280,9 @@ export const ApplyArrayX = <TFunc extends (...args: any[]) => UnionValue>(map: b
     let shape: unknown[][] = [];
     
     for (const [i, arg] of args.entries()) {
+
       if (arg && map[i]) {
+
         const arr = Array.isArray(arg) ? arg : IsArrayUnion(arg) ? arg.value : undefined;
         if (arr) {
           arrays[i] = arr;
@@ -298,8 +300,24 @@ export const ApplyArrayX = <TFunc extends (...args: any[]) => UnionValue>(map: b
       return {
         type: ValueType.array,
         value: shape.map((_, i) => _.map((_, j) => {
-          const apply = args.map((arg, index) => arrays[index] ? (arrays[index][i][j] || { type: ValueType.undefined }) : arg);
+
+          // this was breaking on boolean false, because 
+          // it used || instead of ??. if we don't require 
+          // boxed arguments, we need to handle naked booleans
+
+          // actually, this is still slightly wrong. we know (actually the 
+          // caller of this function knows) if each argument is boxed or not, 
+          // and if it's not, we should not return the boxed undefined type, 
+          // we should just return undefined.
+
+          // that actually would basically solve false booleans as well, even
+          // if it were incorrectly returning undefined. the issue is we were
+          // returning a boxed undefined, which evaluates to true.
+
+          const apply = args.map((arg, index) => arrays[index] ? (arrays[index][i][j] ?? { type: ValueType.undefined }) : arg);
+
           return base(...apply as Parameters<TFunc>);
+
         })),
       };
 

package/treb-embed/src/embedded-spreadsheet.ts

@@ -2611,6 +2611,19 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     this.grid.ShowSheet(index, !hide);
   }
 
+  /** list sheets in the model */
+  public ListSheets() {
+    return this.model.sheets.list.map(sheet => {
+      const entry: { name: string, hidden?: boolean } = {
+        name: sheet.name, 
+      };
+      if (!sheet.visible) {
+        entry.hidden = true;
+      }
+      return entry;
+    });
+  }
+
   /**
    * Show or hide sheet. This method is deprecated because it's ambiguous.
    * To set a sheet's visibility, use `HideSheet`. To activate a sheet, use

package/treb-grid/src/types/grid.ts

@@ -7524,7 +7524,7 @@ export class Grid extends GridBase {
     if (typeof column === 'number') column = [column];
 
     const auto = typeof command.width !== 'number';
-    const width = Math.round(command.width || 0 / this.scale)
+    const width = Math.round((command.width || 0) / this.scale);
 
     if (auto) {
       for (const entry of column) {