@trebco/treb 31.9.1 → 32.3.1

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

@@ -0,0 +1,339 @@
+/**
+ * functional programming
+ */
+
+import type { FunctionMap } from '../descriptors';
+import type { FunctionUnion, UnionValue} from 'treb-base-types';
+import { ValueType } from 'treb-base-types';
+import { ArgumentError, ValueError } from '../function-error';
+
+export const FPFunctionLibrary: FunctionMap = {
+ 
+  MakeArray: {
+    description: 'Create an array using a function',
+    arguments: [
+      { name: 'rows' },
+      { name: 'columns' },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(rows: number, columns: number, lambda: FunctionUnion) {
+      if (rows > 0 && columns > 0 && lambda?.type === ValueType.function) {
+        const apply = this?.apply;
+        if (!apply) {
+          return ValueError();
+        }
+
+        const value: UnionValue[][] = [];
+        for (let c = 0; c < columns; c++) {
+          const values_col: UnionValue[] = [];
+          for (let r = 0; r < rows; r++) {
+            values_col.push(apply(lambda, [
+              { type: ValueType.number, value: r + 1 },
+              { type: ValueType.number, value: c + 1 },
+            ]));
+          }
+          value.push(values_col);
+        } 
+
+        return {
+          type: ValueType.array,
+          value,
+        };
+
+      }
+      return ArgumentError();
+    },
+  },
+
+  Reduce: {
+    description: 'Accumulates a value by applying a function to a set of values',
+    arguments: [
+      { 
+        name: 'initial value', 
+        boxed: true,
+      },
+      {
+        name: 'data', 
+        description: 'Input data',
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(initial: UnionValue, data: UnionValue, lambda: FunctionUnion) {
+
+      if (!this?.apply) { 
+        return ValueError(); 
+      }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array, 
+          value: [[data]],
+        }
+      }
+
+      for (let r = 0; r < data.value.length; r++) {
+        const row = data.value[r];
+        for (let c = 0; c < row.length; c++) {
+          const apply_args: UnionValue[] = [initial, row[c]];
+          const result = this.apply(lambda, apply_args)
+          initial = result;
+        }
+      }
+
+      return initial;
+
+    },
+  },
+
+  Scan: {
+    description: 'Applies a function to a set of values, iteratively',
+    arguments: [
+      { 
+        name: 'initial value', 
+        boxed: true,
+      },
+      {
+        name: 'data', 
+        description: 'Input data',
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(initial: UnionValue, data: UnionValue, lambda: FunctionUnion) {
+
+      if (!this?.apply) { 
+        return ValueError(); 
+      }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array, 
+          value: [[data]],
+        }
+      }
+
+      const results: UnionValue[][] = [];
+      for (let r = 0; r < data.value.length; r++) {
+        const row = data.value[r];
+        const results_row: UnionValue[] = [];
+        for (let c = 0; c < row.length; c++) {
+          const apply_args: UnionValue[] = [initial, row[c]];
+          const result = this.apply(lambda, apply_args)
+          results_row.push(result);
+          initial = result;
+        }
+        results.push(results_row);
+      }
+
+      return {
+        type: ValueType.array,
+        value: results,
+      }
+
+    },
+  },
+
+  ByRow: {
+    description: 'Apply a function to each row in an array',
+    arguments: [
+      {
+        name: 'data', 
+        description: 'Input data',
+        repeat: true,
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(data: UnionValue, lambda: FunctionUnion) {
+      if (!this?.apply) { return ValueError(); }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array,
+          value: [[data]],
+        };
+      }
+
+      const cols = data.value.length;
+      const rows = data.value[0].length;
+
+      const value: UnionValue[][] = [[]];
+      for (let r = 0; r < rows; r++) {
+        const args: UnionValue[] = [];
+        for (let c = 0; c < cols; c++) {
+          args.push(data.value[c][r]);
+        }
+        value[0].push(this.apply(lambda, [{
+          type: ValueType.array, value: [args],
+        }]));
+      }
+      
+      return {
+        type: ValueType.array,
+        value,
+      }
+
+    }
+  },
+
+
+  ByCol: {
+    description: 'Apply a function to each column in an array',
+    arguments: [
+      {
+        name: 'data', 
+        description: 'Input data',
+        repeat: true,
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(data: UnionValue, lambda: FunctionUnion) {
+      if (!this?.apply) { return ValueError(); }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array,
+          value: [[data]],
+        };
+      }
+
+      const cols = data.value.length;
+      const rows = data.value[0].length;
+
+      const value: UnionValue[][] = [];
+      for (let c = 0; c < cols; c++) {
+        const args: UnionValue[] = [];
+        for (let r = 0; r < rows; r++) {
+          args.push(data.value[c][r]);
+        }
+        value.push([this.apply(lambda, [{
+          type: ValueType.array, value: [args],
+        }])]);
+      }
+      
+      return {
+        type: ValueType.array,
+        value,
+      }
+
+    }
+  },
+
+  Map: {
+    description: 'Apply a function to a set of values',
+    arguments: [
+      {
+        name: 'data', 
+        description: 'Input data',
+        repeat: true,
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+
+    fp: true,
+    fn: function(...args: UnionValue[]) {
+
+      if (args.length < 2) {
+        return ArgumentError();
+      }
+      
+      const lambda = args[args.length - 1];
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      const apply = this?.apply;
+      if (!apply) {
+        return ValueError();
+      }
+
+      for (let i = 0; i < args.length - 1; i++) {
+        const arg = args[i];
+        if (arg.type !== ValueType.array) {
+          args[i] = {
+            type: ValueType.array,
+            value: [[arg]],
+          };
+        }
+      }
+
+      const key = args[0];
+      const results: UnionValue[][] = [];
+      if (key.type === ValueType.array) {
+        for (let r = 0; r < key.value.length; r++) {
+          const row = key.value[r];
+          const results_row: UnionValue[] = [];
+          for (let c = 0; c < row.length; c++) {
+            const apply_args: UnionValue[] = [row[c]];
+
+            for (let i = 1; i < args.length - 1; i++) {
+              const arg = args[i];
+              if (arg.type === ValueType.array) {
+                apply_args.push(arg.value[r][c])
+              }
+            }
+
+            results_row.push(apply(lambda, apply_args));
+          }
+          results.push(results_row);
+        }
+      }
+      
+      return {
+        type: ValueType.array,
+        value: results,
+      };
+
+    },
+
+  },
+
+};

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

@@ -0,0 +1,143 @@
+/**
+ * functions and constants for gamma distribution. we're
+ * returning false instead of throwing so we can return
+ * a spreadsheet-style eror. TODO: optional?
+ */
+
+const max_iterations = 1000;
+const epsilon = 3.0e-9;
+const min_value = 1.0e-30;
+
+/**
+ * faster approximation for real numbers
+ */
+export const gamma_ln = (z: number): number => {
+
+  let x = z - 1.0;
+  let y = x + 5.5;
+  y -= (x + 0.5) * Math.log(y);
+  let a = 1.0;
+
+  const coefficients = [
+    76.18009173,
+    -86.50532033,
+    24.01409822,
+    -1.231739516,
+    0.120858003e-2,
+    -0.536382e-5,
+  ];
+
+  for (const coeff of coefficients) {
+    a += coeff / (++x);
+  }
+
+  return (-y + Math.log(2.50662827465 * a));
+
+};
+
+/** 
+ * series representation
+ */
+export const gamma_series = (a: number, x: number): number|false => {
+
+  const gamma_ln_a = gamma_ln(a);
+
+  if (x === 0) {
+    return 0;
+  }
+
+  let ap = a;
+  let sum = 1.0 / a;
+  let del = sum;
+  for (let n = 1; n < max_iterations; n++) {
+    ++ap;
+    del *= x / ap;
+    sum += del;
+    if (Math.abs(del) < Math.abs(sum) * epsilon) {
+      return sum * Math.exp(-x + a * Math.log(x) - (gamma_ln_a));
+    }
+  }
+
+  // throw new Error('too many iterations');
+  console.error('too many iterations');
+  return false;
+
+};
+
+/**
+ * continued fraction
+ */
+export const gamma_cf = (a: number, x: number): number|false => {
+
+  const gamma_ln_a = gamma_ln(a);
+
+  let b = x + 1.0 - a;
+  let c = 1.0 / min_value;
+  let d = 1.0 / b;
+  let h = d;
+
+  for (let i = 1; i <= max_iterations; i++) {
+
+    const an = -i * (i - a); b += 2.0; d = an * d + b;
+
+    if (Math.abs(d) < min_value) d = min_value;
+    c = b + an / c;
+
+    if (Math.abs(c) < min_value) c = min_value;
+
+    d = 1.0 / d;
+    const del = d * c;
+    h *= del;
+
+    if (Math.abs(del - 1.0) < epsilon) {
+      return Math.exp(-x + a * Math.log(x) - (gamma_ln_a)) * h;
+    }
+
+  }
+
+  // throw new Error('too many iterations');
+  console.error('too many iterations');
+  return false;
+
+};
+
+/**
+ * regularized gamma function; CDF of gamma distribution with scale 1
+ */
+export const gamma_p = (a: number, x: number) => {
+
+  if (x < 0.0 || a <= 0.0) {
+    // throw new Error('invalid parameter');
+    console.error('invalid parameter');
+    return false;
+  }
+  if (x < (a + 1.0)) {
+    return gamma_series(a, x);
+  }
+  else {
+    const cf = gamma_cf(a, x);
+    if (cf === false) { return false; }
+    return 1 - cf;
+  }
+
+}
+
+/** 
+ * regularized gamma function 
+ */
+export const gamma_q = (a: number, x: number) => {
+
+  if (x < 0.0 || a <= 0.0) {
+    // throw new Error('invalid parameter');
+    console.error('invalid parameter');
+    return false;
+  }
+  if (x < (a + 1.0)) {
+    const series = gamma_series(a, x);
+    if (series === false) { return false; }
+    return 1 - series;
+  }
+  else {
+    return gamma_cf(a, x);
+  }
+}

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

@@ -0,0 +1,96 @@
+
+import type { FunctionMap } from '../descriptors';
+import type { UnionValue} from 'treb-base-types';
+import { ValueType } from 'treb-base-types';
+import type { ExpressionUnit } from 'treb-parser';
+
+export const LambdaFunctionLibrary: FunctionMap = {
+
+  Lambda: {
+
+    // FIXME: we could use the create_binding_context callback
+    // here to validate the original parameters, might be useful
+
+    description: 'Creates a function',
+    arguments: [
+      { name: 'Argument', repeat: true, boxed: true, passthrough: true },
+      { name: 'Function', boxed: true, passthrough: true },
+    ],
+
+    fn: (...args: ExpressionUnit[]) => {
+      return {
+        type: ValueType.function, 
+
+        // FIXME: lock down this type
+
+        value: {
+
+          // we should probably clone these
+
+          bindings: args.slice(0, args.length - 1),
+          func: args[args.length - 1],
+
+          alt: 'LAMBDA',    // metadata
+          type: 'function', // metadata
+        },
+      };
+
+    }
+
+  },
+
+  Let: {
+
+    // this function has weird semantics we don't normally see -- 
+    // the first two arguments repeat, and the last one is constant.
+    // our tooltips aren't prepared for this.
+
+    // also it creates temporary names, we'll need to create some sort
+    // of temporary binding context. complicated!
+
+    description: 'Binds values to names for a calculation',
+    arguments: [
+      { name: 'Name', repeat: true },
+      { name: 'Value', repeat: true },
+      { name: 'Calculation', boxed: true },
+    ],
+
+    create_binding_context: ({args, descriptors}) => {
+      
+      if (args.length % 2 !== 1) {
+        return undefined; // error
+      }
+      
+      const context: Record<string, ExpressionUnit> = {};
+
+      for (let i = 0; i < args.length - 1; i += 2) {
+        const name = args[i];
+        const value = args[i+1];
+
+        if (name.type === 'identifier') {
+          context[name.name] = value;
+        }
+        else {
+          return undefined; // error
+        }
+
+      }
+      
+      return {
+        context,
+        args: args.slice(-1),
+        argument_descriptors: descriptors.slice(-1),
+      }
+    },
+
+    fn: (arg?: UnionValue) => {
+      return arg ? arg : { type: ValueType.undefined };
+    },
+
+  },
+
+};
+
+
+
+

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

@@ -26,6 +26,7 @@ import { type Complex, type UnionValue, ValueType, type CellValue, ComplexOrReal
 import * as ComplexMath from '../complex-math';
 
 import { BetaCDF, BetaPDF, InverseBeta, LnGamma } from './beta';
+import { gamma_p } from './gamma';
 
 /** error function (for gaussian distribution) */
 const erf = (x: number): number => {
@@ -172,6 +173,46 @@ const Gamma = (z: Complex): Complex => {
 
 };
 
+const GammaPDF = (x: number, alpha: number, beta: number): number => {
+  const gamma_alpha = Gamma({real: alpha, imaginary: 0}).real;
+  return (Math.pow(x, alpha - 1) * Math.exp(-x / beta)) / (gamma_alpha * Math.pow(beta, alpha));
+};
+
+/** bisection */
+const InverseGamma = (p: number, alpha: number, beta: number): number|false => {
+
+  let lower = 0;
+  let upper = alpha * 10;
+
+  const tolerance = 1e-6;
+
+  let iterations = 0;
+
+  while (upper - lower > tolerance) {
+    iterations++;
+
+    const mid = (upper + lower) / 2;
+
+    const f_lower = gamma_p(alpha, lower/beta);
+    const f_mid = gamma_p(alpha, mid/beta);
+
+    if (f_lower === false || f_mid === false) {
+      return false;
+    }
+
+    if ((f_mid - p) * (f_lower - p) < 0) {
+      upper = mid;
+    }
+    else {
+      lower = mid;
+    }
+
+  }
+
+  return (lower + upper) / 2;
+
+};
+
 export const Variance = (data: number[], sample = false) => {
 
   const len = data.length;
@@ -743,6 +784,53 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     },
   },
 
+  'Gamma.Inv': {
+    description: 'Returns the inverse of the gamma distribution',
+    arguments: [
+      {name: 'probability', unroll: true},
+      {name: 'alpha', },
+      {name: 'beta', },
+    ],
+    fn: (p: number, alpha: number, beta: number) => {
+
+      if (p < 0 || p > 1) {
+        return ArgumentError();
+      }
+      
+      const value = InverseGamma(p, alpha, beta);
+
+      if (value === false) {
+        return ValueError();
+      }
+
+      return {
+        type: ValueType.number,
+        value,
+      }
+    },
+  },
+
+  'Gamma.Dist': {
+    fn: (x: number, alpha: number, beta: number, cumulative?: boolean) => {
+
+      if (x < 0 || alpha <= 0 || beta <= 0) {
+        return ArgumentError();
+      }
+  
+      const value = cumulative ? gamma_p(alpha, x/beta) : GammaPDF(x, alpha, beta);
+        
+      if (value === false) {
+        return ValueError();
+      }
+
+      return {
+        type: ValueType.number,
+        value,
+      };
+
+    }    
+  },
+
   GammaLn: {
     description: 'Returns the natural log of the gamma function',
     arguments: [{ name: 'value', boxed: true, unroll: true }],