@trebco/treb 30.3.2 → 30.6.0

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v30.3. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v30.6. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map

package/package.json

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

package/treb-base-types/src/cells.ts

@@ -709,7 +709,7 @@ export class Cells {
                 typeof cell.calculated !== 'undefined') { // && cell.calculated_type !== ValueType.error) {
               obj.calculated = cell.calculated;
               if (cell.spill) {
-                obj.spill = cell.spill;
+                obj.spill = cell.spill.toJSON();
               }
 
               // always preserve error type, because we can't infer

package/treb-calculator/src/calculator.ts

@@ -253,6 +253,7 @@ export class Calculator extends Graph {
     // special functions... need reference to the graph (this)
     // moving countif here so we can reference it in COUNTIFS... 
 
+    /*
     const FlattenBooleans = (value: ArrayUnion) => {
       const result: boolean[] = [];
       for (const col of value.value) {
@@ -262,6 +263,58 @@ export class Calculator extends Graph {
       }
       return result;
     };
+    */
+
+    /**
+     * this is a function that does sumif/averageif/countif.
+     * args is one or more sets of [criteria_range, criteria]
+     */
+    const XIf = (type: 'sum'|'count'|'average', value_range: CellValue[][], ...args: unknown[]): UnionValue => {
+
+      const filter: boolean[] = [];
+
+      for (let i = 0; i < args.length; i += 2) {
+        if (Array.isArray(args[i])) {
+          const step = CountIfInternal(args[i] as CellValue[][], args[i+1] as CellValue);
+          if (step.type !== ValueType.array) {
+            return step;
+          }
+          for (const [r, cell] of step.value[0].entries()) {
+            filter[r] = (!!cell.value && (filter[r] !== false));
+          }
+        }
+      }
+
+      const values = Utilities.FlattenCellValues(value_range, true); // keep undefineds
+        
+      let count = 0;
+      let sum = 0;
+      for (const [index, test] of filter.entries()) {
+      if (test) {
+          count++; 
+          const value = values[index];
+          if (typeof value === 'number') {
+            sum += value;
+          }
+        }
+      }
+
+      switch (type) {
+        case 'count': 
+          return { type: ValueType.number, value: count };
+
+        case 'sum':
+          return { type: ValueType.number, value: sum };
+
+        case 'average':
+          if (count === 0) {
+            return DivideByZeroError();
+          }
+          return { type: ValueType.number, value: sum/count };
+      }
+
+
+    }
 
     const CountIfInternal = (range: CellValue[][], criteria: CellValue): UnionValue => {
 
@@ -271,7 +324,7 @@ export class Calculator extends Graph {
       // in any event there are no dynamic dependencies with this 
       // function.
 
-      const data = Utilities.FlattenCellValues(range);
+      const data = Utilities.FlattenCellValues(range, true); // keep undefineds, important for mapping
 
       let parse_result: ParseResult|undefined;
       let expression: ExpressionUnit|undefined;
@@ -326,7 +379,7 @@ export class Calculator extends Graph {
             }
 
             if (expression?.type === 'call' && expression.args[0]?.type === 'array') {
-              expression.args[0].values = [Utilities.FilterIntrinsics(data)];
+              expression.args[0].values = [Utilities.FilterIntrinsics(data, true)];
             }
 
           }
@@ -377,7 +430,7 @@ export class Calculator extends Graph {
           }
         }
 
-        expression.left.values = [Utilities.FilterIntrinsics(data)];
+        expression.left.values = [Utilities.FilterIntrinsics(data, true)];
 
       }
 
@@ -388,22 +441,6 @@ export class Calculator extends Graph {
       const result = this.CalculateExpression(expression);
       return result;
 
-      /*
-      // console.info({expression, result});
-
-      if (result.type === ValueType.array) {
-        let count = 0;
-        for (const column of (result as ArrayUnion).value) {
-          for (const cell of column) {
-            if (cell.value) { count++; }
-          }
-        }
-        return { type: ValueType.number, value: count };
-      }
-
-      return result; // error?
-      */
-
     };
 
     this.library.Register({
@@ -615,47 +652,63 @@ export class Calculator extends Graph {
        */
       CountIfs: {
         arguments: [
-          { name: 'range1', },
-          { name: 'criteria1', },
-          { name: 'range2', },
-          { name: 'criteria2', }
+          { name: 'range', },
+          { name: 'criteria', },
+          { name: 'range', },
+          { name: 'criteria', }
         ],
         fn: (...args): UnionValue => {
+          return XIf('count', args[0], ...args);
+        },
+      },
 
-          let count = 0;
-
-          const result = CountIfInternal(args[0], args[1]);
-          if (result.type !== ValueType.array) {
-            return result; // error
-          }
-
-          const base = FlattenBooleans(result);
-
-          for (let i = 2; i < args.length; i += 2) {
-            if (args[i] && args[i + 1]) {
-
-              const result = CountIfInternal(args[i], args[i+1]);
-              if (result.type !== ValueType.array) {
-                return result;
-              }
+      /** @see CountIf */
+      AverageIf: {
+        arguments: [
+          { name: 'range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], criteria: CellValue, average_range?: CellValue[][]) => {
+          return XIf('average', average_range||range, range, criteria);
+        },
+      },
 
-              const step = FlattenBooleans(result);
-              for (const [index, value] of base.entries()) {
-                base[index] = value && step[index];
-              }
-              
-            }
-          }
+      /** @see CountIf */
+      AverageIfs: {
+        arguments: [
+          { name: 'value range', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], ...args) => {
+          return XIf('average', range, ...args);
+        },
+      },
 
-          for (const element of base) {
-            if (element) { count++; }
-          }
-          
-          return {
-            type: ValueType.number,
-            value: count,
-          }
+      /** @see CountIf */
+      SumIf: {
+        arguments: [
+          { name: 'range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], criteria: CellValue, sum_range?: CellValue[][]) => {
+          return XIf('sum', sum_range||range, range, criteria);
+        },
+      },
 
+      /** @see CountIf */
+      SumIfs: {
+        arguments: [
+          { name: 'value range', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], ...args) => {
+          return XIf('sum', range, ...args);
         },
       },
 
@@ -680,21 +733,7 @@ export class Calculator extends Graph {
           { name: 'criteria', }
         ],
         fn: (range, criteria): UnionValue => {
-
-          const result = CountIfInternal(range, criteria);
-
-          if (result.type === ValueType.array) {
-            let count = 0;
-            for (const column of (result as ArrayUnion).value) {
-              for (const cell of column) {
-                if (cell.value) { count++; }
-              }
-            }
-            return { type: ValueType.number, value: count };
-          }
-
-          return result; // error
-
+          return XIf('count', range, range, criteria);
         },
       },
 

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

@@ -99,6 +99,54 @@ export const RectangularToPolar = (value: Complex): { r: number, theta: number }
   return { r, theta };
 };
 
+export const Tan = (z: Complex) => {
+
+  // tan(a+bi) = (tan(a) + i tanh(b)) / (1 - i tan(a) tanh(b))
+
+  return Divide({
+    real: Math.tan(z.real),
+    imaginary: Math.tanh(z.imaginary),
+  }, {
+    real: 1,
+    imaginary: -(Math.tan(z.real) * Math.tanh(z.imaginary)),
+  });
+
+};
+
+export const Cos = (z: Complex) => {
+   
+  // sin(a+bi) = cos(a) cosh(b) + i sin(a) sinh(b)
+
+  return {
+    real: Math.cos(z.real) * Math.cosh(z.imaginary),
+    imaginary: Math.sin(z.real) * Math.sinh(z.imaginary),
+  };
+
+};
+
+
+export const Sin = (z: Complex) => {
+   
+  // sin(a+bi) = sin(a) cosh(b) + i cos(a) sinh(b)
+
+  return {
+    real: Math.sin(z.real) * Math.cosh(z.imaginary),
+    imaginary: Math.cos(z.real) * Math.sinh(z.imaginary),
+  };
+
+};
+
+export const Product = (...args: Complex[]): Complex => {
+  let base = args.shift();
+  if (!base) { 
+    return { real: 0, imaginary: 0 };
+  }
+  for (const arg of args) {
+    base = Multiply(base, arg);
+  }
+  return base;
+};
+
 export const Multiply = (a: Complex, b: Complex): Complex => {
   return {
     real: (a.real * b.real) - (a.imaginary * b.imaginary),

package/treb-calculator/src/dag/graph.ts

@@ -179,7 +179,10 @@ export abstract class Graph implements GraphCallbacks {
   public GetVertex(address: ICellAddress, create?: boolean): SpreadsheetVertex | undefined {
 
     if (!address.sheet_id) { 
-      console.info({address, create});
+      console.info(JSON.stringify({address, create}));
+      console.trace();
+
+      
       throw new Error('getvertex with no sheet id'); 
     }
 

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

@@ -35,8 +35,11 @@ import { ClickCheckbox, RenderCheckbox } from './checkbox';
 import { UnionIsMetadata } from '../expression-calculator';
 
 import { Exp as ComplexExp, Power as ComplexPower, Multiply as ComplexMultply } from '../complex-math';
+import * as ComplexMath from '../complex-math';
+
 import { CoerceComplex } from './function-utilities';
 import type { UnitAddress, UnitRange } from 'treb-parser';
+import { ConstructDate } from './date-utils';
 
 /**
  * BaseFunctionLibrary is a static object that has basic spreadsheet
@@ -77,6 +80,22 @@ const erf = (x: number): number => {
 
 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 => {
 
@@ -93,6 +112,7 @@ const inverse_normal = (q: number): number => {
 
 };
 
+
 const edate_calc = (start: number, months: number) => {
   
   let date = new Date(LotusDate(start));
@@ -519,36 +539,18 @@ export const BaseFunctionLibrary: FunctionMap = {
   },
 
   Date: {
-    description: 'Constructs a Lotus date from parts',
+    description: 'Constructs a date from year/month/day',
     arguments: [
       { name: 'year', unroll: true },
       { name: 'month', unroll: true },
       { name: 'day', unroll: true },
     ],
     fn: (year: number, month: number, day: number) => {
-      const date = new Date();
-      date.setMilliseconds(0);
-      date.setSeconds(0);
-      date.setMinutes(0);
-      date.setHours(0);
-      
-      if (year < 0 || year > 10000) { 
+      const date = ConstructDate(year, month, day);
+      if (date === false) {
         return ArgumentError();
       }
-      if (year < 1899) { year += 1900; }
-      date.setFullYear(year);
-
-      if (month < 1 || month > 12) {
-        return ArgumentError();
-      }
-      date.setMonth(month - 1);
-
-      if (day < 1 || day > 31) {
-        return ArgumentError();
-      }
-      date.setDate(day);
-
-      return { type: ValueType.number, value: UnlotusDate(date.getTime()) };
+      return { type: ValueType.number, value: date };
     },
   },
 
@@ -2122,6 +2124,22 @@ export const BaseFunctionLibrary: FunctionMap = {
       }
     },
 
+    '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',
@@ -2138,22 +2156,22 @@ export const BaseFunctionLibrary: FunctionMap = {
       xlfn: true,
 
       fn: (x: number, mean = 0, stdev = 1, cumulative = true): UnionValue => {
+        return { type: ValueType.number, value: norm_dist(x, mean, stdev, cumulative) };
+      },
+    },
 
-        let value = 0;
+    'Norm.S.Dist': {
 
-        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);
-        }
+      description: 'Cumulative normal distribution',
+      arguments: [
+        {name: 'value'},
+        {name: 'cumulative', default: true},
+      ],
 
-        return { 
-          type: ValueType.number, 
-          value,
-        };
+      xlfn: true,
 
+      fn: (x: number, cumulative = true): UnionValue => {
+        return { type: ValueType.number, value: norm_dist(x, 0, 1, cumulative) };
       },
     },
 
@@ -2437,6 +2455,60 @@ export const BaseFunctionLibrary: FunctionMap = {
           return ArgumentError();
         }
   
+      },
+    },
+
+    Sin: {
+      arguments: [
+        { name: 'angle in radians', boxed: true, unroll: true, }
+      ],
+      fn: (a: 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) }; 
+        }
+
+        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) }; 
+        }
+
+        return ArgumentError();
+
+      },
+    },
+    
+    Tan: {
+      arguments: [
+        { name: 'angle in radians', boxed: true, unroll: true, }
+      ],
+      fn: (a: UnionValue) => {
+
+        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) }; 
+        }
+
+        return ArgumentError();
+
       },
     }
 

package/treb-calculator/src/functions/date-utils.ts

@@ -0,0 +1,64 @@
+/*
+ * 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
+ * 
+ */
+
+import { UnlotusDate } from 'treb-format';
+
+export const DaysInYear = (year: number) => {
+  return (year % 4 === 0 && (year % 100 !== 0 || year === 1900)) ? 366 : 365;
+};
+
+export const DayOfYear = (year: number, month: number, day: number): number|false => {
+  const a = ConstructDate(year, 1, 1);
+  const b = ConstructDate(year, month, day);
+  if (a === false || b === false) { return false; }
+  return Math.round(b - a + 1);
+};
+
+export const ConstructDate = (year: number, month: number, day: number): number|false => {
+
+  const date = new Date();
+  date.setMilliseconds(0);
+  date.setSeconds(0);
+  date.setMinutes(0);
+  date.setHours(0);
+  
+  if (year < 0 || year > 10000) { 
+    // return ArgumentError();
+    return false;
+  }
+  if (year < 1899) { year += 1900; }
+  date.setFullYear(year);
+
+  if (month < 1 || month > 12) {
+    // return ArgumentError();
+    return false;
+  }
+  date.setMonth(month - 1);
+
+  if (day < 1 || day > 31) {
+    // return ArgumentError();
+    return false;
+  }
+  date.setDate(day);
+
+  return UnlotusDate(date.getTime());
+
+};

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

@@ -24,6 +24,8 @@ import { type CellValue, type UnionValue, ValueType } from 'treb-base-types';
 import { FlattenCellValues } from '../utilities';
 
 import { ArgumentError, ValueError } from '../function-error';
+import { LotusDate, UnlotusDate } from 'treb-format';
+import { ConstructDate, DaysInYear } from './date-utils';
 
 // use a single, static object for base functions
 
@@ -84,8 +86,68 @@ const ppmt_function = (rate: number, period: number, periods: number, pv = 0, fv
     ipmt_function(rate, period, periods, pv, fv, type);
 };
 
+
+
 export const FinanceFunctionLibrary: FunctionMap = {
 
+  /*
+  CoupNum: {
+    fn: (settlement: CellValue, maturity: CellValue, frequency: CellValue, basis: CellValue = 0) => {
+
+      if (typeof settlement !== 'number' || typeof maturity !== 'number' || settlement > maturity ) {
+        return ArgumentError();
+      }
+
+      if (frequency !== 1 && frequency !== 2 && frequency !== 4) {
+        return ArgumentError();
+      }
+
+      if (basis === 1) {
+        const settlement_date = LotusDate(settlement);
+        const maturity_date = LotusDate(maturity);
+
+        const comparison = ConstructDate(maturity_date.getUTCFullYear(), settlement_date.getUTCMonth() + 1, settlement_date.getUTCDay());
+        let years = Math.max(0, maturity_date.getUTCFullYear() - settlement_date.getUTCFullYear());
+        
+        if (comparison && comparison < maturity) {
+          years += Math.round(maturity - comparison) / DaysInYear(maturity_date.getUTCFullYear());
+        }
+
+        return {
+          type: ValueType.number,
+          value: Math.round(years * frequency),
+        };
+      }
+
+      return { 
+        type: ValueType.number,
+        value: 100,
+      };
+
+    }
+  },
+  */
+
+  /*
+  Price: {
+    fn: (settlement: CellValue, maturity: CellValue, rate: CellValue, yld: CellValue, redemption: CellValue, frequency: CellValue, basis: CellValue = 0) => {
+
+      if (typeof settlement !== 'number' || typeof maturity !== 'number' || typeof rate !== 'number' || typeof yld !== 'number' || typeof redemption !== 'number') {
+        return ArgumentError();
+      }
+
+      if (frequency !== 1 && frequency !== 2 && frequency !== 4) {
+        return ArgumentError();
+      }
+
+      return { 
+        type: ValueType.number,
+        value: 100,
+      };
+    }
+  },
+  */
+
   /**
    * Excel's NPV function is somewhat broken because it assumes the first
    * (usually negative) cashflow is in year 1, not year 0. so the thing to