@trebco/treb 30.12.0 → 30.16.0

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v30.12. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v30.16. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -515,6 +515,12 @@ export declare class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
      */
     HideSheet(index?: number | string, hide?: boolean): void;
 
+    /** list sheets in the model */
+    ListSheets(): {
+        name: string;
+        hidden?: boolean;
+    }[];
+
     /**
      * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "30.12.0",
+  "version": "30.16.0",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

package/treb-calculator/src/complex-math.ts

@@ -99,6 +99,24 @@ export const RectangularToPolar = (value: Complex): { r: number, theta: number }
   return { r, theta };
 };
 
+export const TanH = (z: Complex): Complex => {
+
+  // tanh(a+bi) = (sinh a cos b + i cosh a sin b) / (cosh a cos b + i sinh a sin b)
+
+  const num: Complex = {
+    real: Math.sinh(z.real) * Math.cos(z.imaginary),
+    imaginary: Math.cosh(z.real) * Math.sin(z.imaginary),
+  };
+
+  const denom: Complex = {
+    real: Math.cosh(z.real) * Math.cos(z.imaginary),
+    imaginary: Math.sinh(z.real) * Math.sin(z.imaginary),
+  };
+
+  return Divide(num, denom);
+
+};
+
 export const Tan = (z: Complex) => {
 
   // tan(a+bi) = (tan(a) + i tanh(b)) / (1 - i tan(a) tanh(b))
@@ -113,6 +131,17 @@ export const Tan = (z: Complex) => {
 
 };
 
+export const CosH = (z: Complex): Complex => {
+
+  // cosh(a+bi) = cosh a cos b + i sinh a sin b
+
+  return {
+    real: Math.cosh(z.real) * Math.cos(z.imaginary),
+    imaginary: Math.sinh(z.real) * Math.sin(z.imaginary),
+  };
+
+};
+
 export const Cos = (z: Complex) => {
    
   // sin(a+bi) = cos(a) cosh(b) + i sin(a) sinh(b)
@@ -124,6 +153,16 @@ export const Cos = (z: Complex) => {
 
 };
 
+export const SinH = (z: Complex): Complex => {
+
+  // sinh(a+bi) = sinh a cos b + i cosh a sin b
+
+  return {
+    real: Math.sinh(z.real) * Math.cos(z.imaginary),
+    imaginary: Math.cosh(z.real) * Math.sin(z.imaginary),
+  };
+  
+};
 
 export const Sin = (z: Complex) => {
    

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

@@ -62,56 +62,6 @@ import { ConstructDate } from './date-utils';
 
 // OK, just one.
 
-/** 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 edate_calc = (start: number, months: number) => {
   
@@ -2175,94 +2125,6 @@ export const BaseFunctionLibrary: FunctionMap = {
       },
     },
  
-    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) };
-      },
-    },
-
     Sqrt: {
       description: 'Returns the square root of the argument',
       arguments: [
@@ -2561,6 +2423,24 @@ export const BaseFunctionLibrary: FunctionMap = {
       },
     },
 
+    SinH: {
+      arguments: [
+        { name: 'number', boxed: true, unroll: true },
+      ],
+      fn: (a: UnionValue) => {
+
+        if (a.type === ValueType.number) {
+          return { type: ValueType.number, value: Math.sinh(a.value) };
+        }
+        if (a.type === ValueType.complex) {
+          return { type: ValueType.complex, value: ComplexMath.SinH(a.value) }; 
+        }
+
+        return ArgumentError();
+
+      },
+    },
+
     Sin: {
       arguments: [
         { name: 'angle in radians', boxed: true, unroll: true, }
@@ -2579,6 +2459,24 @@ export const BaseFunctionLibrary: FunctionMap = {
       },
     },
 
+    CosH: {
+      arguments: [
+        { name: 'number', boxed: true, unroll: true },
+      ],
+      fn: (a: UnionValue) => {
+
+        if (a.type === ValueType.number) {
+          return { type: ValueType.number, value: Math.cosh(a.value) };
+        }
+        if (a.type === ValueType.complex) {
+          return { type: ValueType.complex, value: ComplexMath.CosH(a.value) }; 
+        }
+
+        return ArgumentError();
+
+      },
+    },
+
     Cos: {
       arguments: [
         { name: 'angle in radians', boxed: true, unroll: true, }
@@ -2596,7 +2494,25 @@ export const BaseFunctionLibrary: FunctionMap = {
 
       },
     },
-    
+
+    TanH: {
+      arguments: [
+        { name: 'number', boxed: true, unroll: true, }
+      ],
+      fn: (a: UnionValue) => {
+
+        if (a.type === ValueType.number) {
+          return { type: ValueType.number, value: Math.tanh(a.value) };
+        }
+        if (a.type === ValueType.complex) {
+          return { type: ValueType.complex, value: ComplexMath.TanH(a.value) }; 
+        }
+
+        return ArgumentError();
+
+      },
+    },
+
     Tan: {
       arguments: [
         { name: 'angle in radians', boxed: true, unroll: true, }

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

@@ -0,0 +1,244 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2024 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+const EPSILON = 2.2204460492503131e-16;
+
+/**
+ * natural log of (1+x)
+ */
+const Log1p = (x: number) => {
+  const y = 1 + x;
+  return Math.log(y) - ((y - 1) - x) / y;
+}
+
+/** 
+ * continued fraction expansion 
+ */
+const BetaContFrac = (a: number, b: number, x: number, epsabs: number) => {
+
+  const cutoff = 2.0 * Number.MIN_VALUE;
+
+  let cf = 0;
+
+  let numerator = 1.0;
+  let denominator = 1.0 - (a + b) * x / (a + 1.0);
+
+  if (Math.abs(denominator) < cutoff) {
+    denominator = Number.NaN;
+  }
+
+  denominator = 1.0 / denominator;
+  cf = denominator;
+
+  for (let k = 1; k <= 512; k++) {
+
+    let coeff = k * (b - k) * x / (((a - 1.0) + 2 * k) * (a + 2 * k));
+    let delta_frac = 0;
+
+    denominator = 1.0 + coeff * denominator;
+    numerator = 1.0 + coeff / numerator;
+
+    if (Math.abs(denominator) < cutoff) {
+      denominator = Number.NaN;
+    }
+    if (Math.abs(numerator) < cutoff) {
+      numerator = Number.NaN;
+    }
+
+    denominator = 1.0 / denominator;
+
+    delta_frac = denominator * numerator;
+    cf *= delta_frac;
+
+    coeff = -(a + k) * (a + b + k) * x / ((a + 2 * k) * (a + 2 * k + 1.0));
+
+    denominator = 1.0 + coeff * denominator;
+    numerator = 1.0 + coeff / numerator;
+
+    if (Math.abs(denominator) < cutoff) {
+      denominator = Number.NaN;
+    }
+    if (Math.abs(numerator) < cutoff) {
+      numerator = Number.NaN;
+    }
+
+    denominator = 1.0 / denominator;
+
+    delta_frac = denominator * numerator;
+    cf *= delta_frac;
+
+    if ((Math.abs(delta_frac - 1.0) < 2.0 * EPSILON) || (cf * Math.abs(delta_frac - 1.0) < epsabs)) {
+      return cf;
+    };
+
+  }
+
+  return Number.NaN;
+
+};
+
+/**
+ * inverse beta function for beta (a, b)
+ */
+export const InverseBeta = (p: number, a: number, b: number): number => {
+
+  if (a < 0.0 || b < 0.0) {
+    return Number.NaN;
+  }
+
+  if (p <= 0) {
+    return 0.0;
+  }
+
+  if (p >= 1) {
+    return 1.0;
+  }
+
+  if (p > 0.5) {
+    return 1 - InverseBeta(1 - p, b, a);
+  }
+
+  const mean = a / (a + b);
+
+  let x = 0;
+
+  if (p < 0.1) {
+    const lx = (Math.log(a) + LnGamma(a) + LnGamma(b) - LnGamma(a + b) + Math.log(p)) / a;
+    if (lx <= 0) {
+      x = Math.exp(lx);
+      x *= Math.pow(1 - x, -(b - 1) / a);
+    }
+    else {
+      x = mean;
+    }
+
+    if (x > mean) {
+      x = mean;
+    }
+  }
+  else {
+    x = mean;
+  }
+
+  for(let n = 0; n < 64; n++) {
+
+    const dP = p - BetaCDF(x, a, b);
+    const phi = BetaPDF(x, a, b);
+
+    if (dP === 0) {
+      return x;
+    }
+
+    const lambda = dP / Math.max(2 * Math.abs(dP / x), phi);
+
+    const step0 = lambda;
+    const step1 = -((a - 1) / x - (b - 1) / (1 - x)) * lambda * lambda / 2;
+    let step = step0;
+
+    if (Math.abs(step1) < Math.abs(step0)) {
+      step += step1;
+    }
+    else {
+      step *= 2 * Math.abs(step0 / step1);
+    }
+
+    if (x + step > 0 && x + step < 1) {
+      x += step;
+    }
+    else {
+      x = Math.sqrt(x) * Math.sqrt(mean);
+    }
+
+    if (Math.abs(step0) <= 1e-10 * x) {
+      return x;
+    }
+
+  }
+
+  return x;
+
+};
+
+/**
+ * this is a faster approximation for real numbers
+ */
+export const LnGamma = (z: 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));
+
+};
+
+/** PDF of the beta distribution */
+export const BetaPDF = (x: number, a: number, b: number) => {
+  if (x < 0 || x > 1) {
+    return 0;
+  }
+  return Math.exp(LnGamma(a + b) - LnGamma(a) - LnGamma(b)) *
+    Math.pow(x, a - 1) * Math.pow(1 - x, b - 1);
+};
+
+/** CDF of the beta distribution */
+export const BetaCDF = (x: number, a: number, b: number) => {
+
+  if (x <= 0.0) {
+    return 0.0;
+  }
+
+  if (x >= 1.0) {
+    return 1.0;
+  }
+
+  const ln_beta = (LnGamma(a) + LnGamma(b) - LnGamma(a + b));
+  const ln_pre = -ln_beta + a * Math.log(x) + b * Log1p(-x);
+  const prefactor = Math.exp(ln_pre);
+
+  if (x < (a + 1.0) / (a + b + 2.0)) {
+    const cf = BetaContFrac(a, b, x, 0);
+    return (prefactor * cf / a);
+  }
+  else {
+    const epsabs = Math.abs(b / prefactor) * EPSILON;
+    const cf = BetaContFrac(b, a, 1.0 - x, epsabs);
+    const term = prefactor * cf / b;
+    return (1 - term);
+
+  }
+
+};
+