@trebco/treb 31.1.3 → 31.3.2

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v31.1. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v31.3. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -908,7 +908,7 @@ export declare class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
      *
      * @public
      */
-    FormatNumber(value: number, format?: string): string;
+    FormatNumber(value: number | Complex, format?: string): string;
 
     /**
      * convert a javascript date (or timestamp) to a spreadsheet date

package/package.json

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

package/test/parser.ts

@@ -0,0 +1,13 @@
+
+import { Parser } from '../treb-parser/src/parser.js';
+
+const parser = new Parser();
+
+let text = "=NORMDIST((LN(S/K)+(r+s^2/2)*T)/(s*SQRT(T)), 0, 1, TRUE)*S - NORMDIST((LN(S/K)+(r-s^2/2)*T)/(s*SQRT(T)), 0, 1, TRUE)*K*EXP(-r*T)";
+let result = parser.Parse(text);
+// console.info('valid?', result.valid, result.expression);
+
+text = "=s*SQRT(T)";
+result = parser.Parse(text);
+console.info('valid?', result.valid, result.expression);
+

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

@@ -175,6 +175,110 @@ export const Sin = (z: Complex) => {
 
 };
 
+export const ASin = (cpx: Complex) => {
+
+  if (cpx.imaginary === 0) {
+    return { 
+      real: Math.asin(cpx.real), 
+      imaginary: 0,
+    };
+  }
+
+  const x = Math.hypot(cpx.real + 1, cpx.imaginary) / 2;
+  const y = Math.hypot(cpx.real - 1, cpx.imaginary) / 2;
+
+  const sum = x + y;
+  const difference = x - y;
+
+  const result: Complex = {
+    real: Math.asin(difference),
+    imaginary: Math.log(sum + Math.sqrt(sum * sum - 1)),
+  };
+
+  if(cpx.imaginary < 0 || (cpx.imaginary === 0 && cpx.real > 1)) {
+    result.imaginary = -result.imaginary;
+  }
+
+  return result;
+
+};
+
+export const ACos = (cpx: Complex) => {
+
+  if (cpx.imaginary === 0) {
+    return {
+      real: Math.acos(cpx.real),
+      imaginary: 0,
+    };
+  }
+
+  const asin = ASin(cpx);
+
+  return {
+    real: Math.PI / 2 - asin.real,
+    imaginary: asin.imaginary,
+  }
+
+};
+
+export const ATan = (cpx: Complex): Complex => {
+
+  const { real: x, imaginary: y } = cpx;
+  
+  // Handle special case where z is purely imaginary
+  if (x === 0) {
+    if (y > 1) {
+      return { real: Math.PI / 2, imaginary: 0.5 * Math.log((y - 1) / (y + 1)) };
+    } else if (y < -1) {
+      return { real: -Math.PI / 2, imaginary: 0.5 * Math.log((1 - y) / (-1 - y)) };
+    }
+  }
+  
+  const x2 = x * x;
+  const y2 = y * y;
+  
+  // Calculate real and imaginary parts
+  const realPart = 0.5 * Math.atan2(2 * x, 1 - x2 - y2);
+  const imagPart = 0.25 * Math.log((x2 + (y + 1) * (y + 1)) / (x2 + (y - 1) * (y - 1)));
+  
+  return { real: realPart, imaginary: imagPart };
+
+};
+
+export const ATan2 = (y: Complex, x: Complex): Complex|false => {
+
+    // Special case: both arguments are zero
+    if (x.real === 0 && x.imaginary === 0 && y.real === 0 && y.imaginary === 0) {
+      // throw new Error("Both arguments of arctan2 are zero");
+      return false;
+    }
+  
+    // Calculate z = y / x
+    const denominator = x.real * x.real + x.imaginary * x.imaginary;
+    const z: Complex = {
+      real: (y.real * x.real + y.imaginary * x.imaginary) / denominator,
+      imaginary: (y.imaginary * x.real - y.real * x.imaginary) / denominator
+    };
+  
+    // Now calculate arctan(z)
+    const x2 = z.real * z.real;
+    const y2 = z.imaginary * z.imaginary;
+  
+    const result = {
+      real: 0.5 * Math.atan2(2 * z.real, 1 - x2 - y2),
+      imaginary: 0.25 * Math.log((x2 + (z.imaginary + 1) * (z.imaginary + 1)) / (x2 + (z.imaginary - 1) * (z.imaginary - 1))),
+    };
+ 
+    // Adjust the real part based on the quadrant of x
+    if (x.real < 0) {
+      result.real += (y.real >= 0 || y.imaginary >= 0) ? Math.PI : -Math.PI;
+    }
+  
+    return result;
+  
+
+};
+
 export const Product = (...args: Complex[]): Complex => {
   let base = args.shift();
   if (!base) { 

package/treb-calculator/src/descriptors.ts

@@ -71,6 +71,12 @@ export interface ArgumentDescriptor {
    */
   boxed?: boolean;
 
+  /** 
+   * this argument repeasts. this has no impact on the function descriptor
+   * but it's useful to know for clients.
+   */
+  repeat?: boolean;
+
   /**
    * similar to collector, this flag will return metadata about the cell
    *

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

@@ -19,7 +19,7 @@
  * 
  */
 
-import type { FunctionMap, IntrinsicValue } from '../descriptors';
+import type { CompositeFunctionDescriptor, FunctionMap, IntrinsicValue } from '../descriptors';
 import * as Utils from '../utilities';
 // import { StringUnion, NumberUnion } from '../utilities';
 import { ReferenceError, NAError, ArgumentError, DivideByZeroError, ValueError } from '../function-error';
@@ -213,6 +213,27 @@ const NumberArgument = (argument?: UnionValue, default_value: number|false = fal
 
 };
 
+/**
+ * helper for trig functions, curious what this does to size
+ */
+const TrigFunction = (real: (value: number) => number, complex: (value: Complex) => Complex, description?: string): CompositeFunctionDescriptor => {
+  return {
+    description,
+    arguments: [
+      { name: 'number', boxed: true, unroll: true },
+    ],
+    fn: (a: UnionValue) => {
+      if (a.type === ValueType.number) {
+        return { type: ValueType.number, value: real(a.value) };
+      }
+      if (a.type === ValueType.complex) {
+        return { type: ValueType.complex, value: complex(a.value) }; 
+      }
+      return ArgumentError();
+    },
+  };
+}
+
 /**
  * alternate functions. these are used (atm) only for changing complex 
  * behavior.
@@ -345,7 +366,11 @@ export const BaseFunctionLibrary: FunctionMap = {
 
   Sum: {
     description: 'Adds arguments and ranges',
-    arguments: [{ boxed: true, name: 'values or ranges' }],
+    arguments: [{ 
+      boxed: true, 
+      name: 'values or ranges' ,
+      repeat: true,
+    }],
     fn: (...args: UnionValue[]) => {
 
       const sum = { real: 0, imaginary: 0 };
@@ -374,7 +399,7 @@ export const BaseFunctionLibrary: FunctionMap = {
 
   SumSQ: {
     description: 'Returns the sum of the squares of all arguments',
-    arguments: [{ boxed: true, name: 'values or ranges' }],
+    arguments: [{ boxed: true, name: 'values or ranges', repeat: true, }],
     fn: (...args: UnionValue[]) => {
 
       const sum = { real: 0, imaginary: 0 };
@@ -1982,7 +2007,13 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Log: {
-      arguments: [ { unroll: true }, { unroll: true } ], 
+      arguments: [ { 
+        name: 'number',
+        unroll: true 
+      }, { 
+        name: 'base',
+        unroll: true 
+      } ], 
 
       /** default is base 10; allow specific base */
       fn: (a: number, base = 10): UnionValue => {
@@ -1991,26 +2022,115 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Log10: {
-      arguments: [{ unroll: true }], 
+      arguments: [{ 
+        name: 'number',
+        unroll: true,
+      }], 
       fn: (a: number): UnionValue => {
         return { type: ValueType.number, value: Math.log(a) / Math.log(10) };
       },
     },
 
     Ln: {
-      arguments: [{ unroll: true }], 
+      arguments: [{ 
+        name: 'number',
+        unroll: true,
+      }], 
       fn: (a: number): UnionValue => {
         return { type: ValueType.number, value: Math.log(a) };
       },
     },
 
-    Ceiling: {
-      arguments: [ { unroll: true }, { unroll: true } ], // FIXME: lazy
+    'Ceiling.Math': {
+      arguments: [ { 
+        name: 'number',
+        unroll: true 
+      }, { 
+        name: 'significance',
+        unroll: true 
+      }, { 
+        name: 'away from zero',
+        unroll: true, 
+      } ],
+
+      fn: (a: number, significance = 1, mode?: number) => {
+
+        let value = 0;
+
+        if (mode && a < 0) {
+          value = -Math.ceil(-a / significance) * significance;
+        }
+        else {
+          value = Math.ceil(a / significance) * significance;
+        }
 
-      fn: (a: number) => {
         return { 
           type: ValueType.number, 
-          value: Math.ceil(a),
+          value,
+        };
+      },
+    },
+    
+    'Floor.Math': {
+      arguments: [ { 
+        name: 'number',
+        unroll: true 
+      }, { 
+        name: 'significance',
+        unroll: true 
+      }, { 
+        name: 'away from zero',
+        unroll: true, 
+      } ],
+
+      fn: (a: number, significance = 1, mode?: number) => {
+
+        let value = 0;
+
+        if (mode && a < 0) {
+          value = -Math.floor(-a / significance) * significance;
+        }
+        else {
+          value = Math.floor(a / significance) * significance;
+        }
+
+        return { 
+          type: ValueType.number, 
+          value,
+        };
+      },
+    },
+
+    Floor: {
+      arguments: [ { 
+        name: 'number',
+        unroll: true 
+      }, { 
+        name: 'significance',
+        unroll: true 
+      } ],
+
+      fn: (a: number, significance = 1) => {
+        return { 
+          type: ValueType.number, 
+          value: Math.floor(a / significance) * significance,
+        };
+      },
+    },
+
+    Ceiling: {
+      arguments: [ { 
+        name: 'number',
+        unroll: true 
+      }, { 
+        name: 'significance',
+        unroll: true 
+      } ],
+
+      fn: (a: number, significance = 1) => {
+        return { 
+          type: ValueType.number, 
+          value: Math.ceil(a / significance) * significance,
         };
       },
     },
@@ -2476,113 +2596,62 @@ 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: {
+    ATan2: {
       arguments: [
-        { name: 'angle in radians', boxed: true, unroll: true, }
+        { name: 'y', boxed: true, unroll: true },
+        { name: 'x', boxed: true, unroll: true },
       ],
-      fn: (a: UnionValue) => {
+      fn: (y: UnionValue, x: UnionValue) => {
 
-        if (a.type === ValueType.number) {
-          return { type: ValueType.number, value: Math.sin(a.value) };
-        }
-        if (a.type === ValueType.complex) {
-          return { type: ValueType.complex, value: ComplexMath.Sin(a.value) }; 
+        if (y.type === ValueType.number && x.type === ValueType.number) {
+          return { type: ValueType.number, value: Math.atan2(y.value, x.value) };
         }
 
-        return ArgumentError();
-
-      },
-    },
-
-    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) }; 
+        if (y.type === ValueType.number) {
+          y = { type: ValueType.complex, value: { real: y.value, imaginary: 0 }};
         }
 
-        return ArgumentError();
-
-      },
-    },
-
-    Cos: {
-      arguments: [
-        { name: 'angle in radians', boxed: true, unroll: true, }
-      ],
-      fn: (a: UnionValue) => {
-
-        if (a.type === ValueType.number) {
-          return { type: ValueType.number, value: Math.cos(a.value) };
-        }
-        if (a.type === ValueType.complex) {
-          return { type: ValueType.complex, value: ComplexMath.Cos(a.value) }; 
+        if (x.type === ValueType.number) {
+          x = { type: ValueType.complex, value: { real: x.value, imaginary: 0 }};
         }
 
-        return ArgumentError();
+        if (y.type === ValueType.complex && x.type === ValueType.complex) {
+          
+          const value = ComplexMath.ATan2(y.value, x.value);
 
-      },
-    },
+          // should we have an error for infinities? not sure. not sure
+          // why this hasn't come up before...
 
-    TanH: {
-      arguments: [
-        { name: 'number', boxed: true, unroll: true, }
-      ],
-      fn: (a: UnionValue) => {
+          if (value === false) {
+            return ArgumentError();
+          }
 
-        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 {
+            type: ValueType.complex, value,
+          }
         }
-
+        
         return ArgumentError();
 
       },
     },
 
-    Tan: {
-      arguments: [
-        { name: 'angle in radians', boxed: true, unroll: true, }
-      ],
-      fn: (a: UnionValue) => {
+    Sin: TrigFunction(Math.sin, ComplexMath.Sin),
+    SinH: TrigFunction(Math.sinh, ComplexMath.SinH),
+    ASin: TrigFunction(Math.asin, ComplexMath.ASin),
 
-        if (a.type === ValueType.number) {
-          return { type: ValueType.number, value: Math.tan(a.value) };
-        }
-        if (a.type === ValueType.complex) {
-          return { type: ValueType.complex, value: ComplexMath.Tan(a.value) }; 
-        }
+    Cos: TrigFunction(Math.cos, ComplexMath.Cos),
+    CosH: TrigFunction(Math.cosh, ComplexMath.CosH),
+    ACos: TrigFunction(Math.acos, ComplexMath.ACos),
 
-        return ArgumentError();
+    Tan: TrigFunction(Math.tan, ComplexMath.Tan),
+    TanH: TrigFunction(Math.tanh, ComplexMath.TanH),
+    ATan: TrigFunction(Math.atan, ComplexMath.ATan),
 
-      },
-    },
+    E: { fn: () => { return { type: ValueType.number, value: Math.E } } },
+    PI: { fn: () => { return { type: ValueType.number, value: Math.PI } } },
+    SQRT2: { fn: () => { return { type: ValueType.number, value: Math.SQRT2 } } },
+    SQRT1_2: { fn: () => { return { type: ValueType.number, value: Math.SQRT1_2 } } },
 
     Sequence: {
       arguments:[
@@ -2637,7 +2706,19 @@ for (const key of Object.keys(BaseFunctionLibrary)) {
 // block these names from auto-import from Math
 
 const block_list = [
+  'ceil',
   'pow', 
+  'ln10', 
+  'ln2', 
+  'log10', 
+  'log10e', 
+  'log1p', 
+  'log2', 
+  'log2e', 
+  'random',
+  'imul',
+  'clz32',
+  'fround',
 ];
 
 const block_map: Record<string, string> = {};

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

@@ -1075,5 +1075,6 @@ export const StatisticsFunctionAliases: {[index: string]: string} = {
   'Quartile': 'Quartile.Inc',
   'NormSInv': 'Norm.S.Inv',
   'NormSDist': 'Norm.S.Dist',
+  'NormDist': 'Norm.Dist',
 
 };

package/treb-calculator/tsconfig.json

@@ -1,9 +1,5 @@
 {
   "extends": "../tsproject.json",
-  "references": [
-    { "path": "../treb-grid/tsconfig.json" },
-    { "path": "../treb-utils/tsconfig.json" }
-  ],
   "include": [
     "../treb-base-types/**/*.ts"
   ]

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

@@ -4217,11 +4217,14 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * 
    * @public
    */
-  public FormatNumber(value: number, format = 'General'): string {
-
-    // API v1 OK
+  public FormatNumber(value: number|Complex, format = 'General'): string {
 
+    if (IsComplex(value)) {
+      return NumberFormat.FormatPartsAsText(NumberFormatCache.Get(format).FormatComplex(value));
+    }
+   
     return NumberFormatCache.Get(format).Format(value);
+
   }
 
   /**

package/treb-format/src/format.ts

@@ -489,6 +489,14 @@ export class NumberFormat {
     //     all zeros
     // (5) change default fraction to #/## (actually we should do that always)
 
+    if (value.imaginary === Infinity || value.imaginary === -Infinity || 
+        value.real === Infinity || value.real === -Infinity) {
+      return [
+        {
+          text: 'Infinity',
+        }
+      ]
+    }
 
     // check if the imaginary format will render as 0.00i -- we want to 
     // handle this differently.

package/treb-grid/src/editors/editor.ts

@@ -1133,11 +1133,11 @@ export class Editor<E = FormulaEditorEvent> extends EventSource<E|FormulaEditorE
    * @param node 
    * @returns [substring to start of selection, substring to end of selection]
    */
-  protected SubstringToCaret2(node: HTMLElement): [string, string] {
+  protected SubstringToCaret2(node: HTMLElement, force = false): [string, string] {
 
     const result: [string, string] = ['', ''];
 
-    if (node !== node.ownerDocument.activeElement || node !== this.active_editor?.node) {
+    if (!force && node !== node.ownerDocument.activeElement || node !== this.active_editor?.node) {
       return result;
     }