@trebco/treb 30.12.0 → 30.16.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) {
@@ -305,6 +305,15 @@ export const ApplyArrayX = <TFunc extends (...args: any[]) => UnionValue>(map: b
           // 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-charts/src/chart-functions.ts

@@ -48,7 +48,7 @@ export type ChartFunction
   | 'Box.Plot'
   ;
 
-type SupportFunction = 'Group'|'Series';
+type SupportFunction = 'Group'|'Series' ; // |'Scatter.Series';
 
 /**
  * chart functions for registration
@@ -87,20 +87,57 @@ export const ChartFunctions: Record<ChartFunction|SupportFunction, CompositeFunc
       { name: 'X', metadata: true, },
       { name: 'Y', metadata: true, },
       { name: 'Z', metadata: true, },
-      { name: 'index', },
-      { name: 'subtype', },
+      { name: 'Index', },
+      { name: 'Subtype', },
       { name: 'Labels', description: 'Labels for bubble charts only (atm)' },
+      { name: 'Axis', description: `Series axis (scatter plot only)` },
     ],
     fn: (...args: unknown[]) => {
       return {
         type: ValueType.object,
-        value: args,
+        value: {
+          label: args[0],
+          x: args[1],
+          y: args[2],
+          z: args[3],
+          index: args[4],
+          subtype: args[5],
+          data_labels: args[6],
+          axis: args[7],
+        },
         key: 'series',
       };
     },
     category: ['chart functions'],
   },
 
+  /*
+  'Scatter.Series': {
+    arguments: [
+      { name: 'Label' }, // , metadata: true, },
+      { name: 'X', metadata: true, },
+      { name: 'Y', metadata: true, },
+      { name: 'index', },
+      { name: 'subtype', },
+      { name: 'axis', },
+    ],
+    fn: (...args: unknown[]) => {
+      return {
+        type: ValueType.object,
+        value: {
+          label: args[0],
+          x: args[1],
+          y: args[2],
+          index: args[3],
+          subtype: args[4],
+          axis: args[5],
+        },
+        key: 'series',
+      };
+    },
+  },
+  */
+
   'Bar.Chart': {
     arguments: [
       { name: 'Data', metadata: true, },

package/treb-charts/src/chart-types.ts

@@ -33,6 +33,18 @@ export interface ReferenceMetadata {
 
 export interface ReferenceSeries extends ExtendedUnion {
   key: 'series',
+  value: {
+    label?: string;
+    x?: UnionValue;
+    y?: UnionValue;
+    z?: UnionValue;
+    index?: number;
+    subtype?: string;
+    data_labels?: string[];
+    axis?: number;
+  }
+
+  /*
   value: [
     CellValue?, // { name: 'Label' }, // , metadata: true, },
     UnionValue?, // { name: 'X', metadata: true, },
@@ -42,6 +54,8 @@ export interface ReferenceSeries extends ExtendedUnion {
     CellValue?, // { name: 'subtype', },
     CellValue?, // { name: 'Labels', description: 'Labels for bubble charts only (atm)' },
   ];
+  */
+
 }
 
 export const IsMetadata = (value?: unknown): value is ExtendedUnion & { value: ReferenceMetadata } => {
@@ -54,7 +68,8 @@ export const IsMetadata = (value?: unknown): value is ExtendedUnion & { value: R
 export const IsSeries = (value?: unknown): value is ReferenceSeries => {
   return (!!value && (typeof value === 'object')
     && (value as ReferenceSeries).key === 'series'
-    && Array.isArray((value as ReferenceSeries).value));
+    // && Array.isArray((value as ReferenceSeries).value));
+    && (typeof (value as ReferenceSeries).value === 'object'));
 };
 
 export const IsArrayUnion = (value?: unknown): value is ArrayUnion => {
@@ -140,9 +155,11 @@ export interface ScatterData2 extends ChartDataBaseType {
 
   x_scale: RangeScale;
   y_scale: RangeScale;
+  y2_scale?: RangeScale;
 
   x_labels?: string[];
   y_labels?: string[];
+  y2_labels?: string[];
 
   style?: 'plot'|'line'|'area';
 
@@ -311,8 +328,10 @@ export interface SeriesType {
   subtype?: string;
   x: SubSeries;
   y: SubSeries;
+  y2?: SubSeries;
   z?: SubSeries;
   index?: number;
   labels?: string[];
+  axis?: number;
 }