@trebco/treb 30.2.14 → 30.6.0

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

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

@@ -25,6 +25,95 @@ import { ValueError, ArgumentError, NAError } from '../function-error';
 import { type Complex, type UnionValue, ValueType, type CellValue } from 'treb-base-types';
 import * as ComplexMath from '../complex-math';
 
+const Median = (data: number[]) => {
+  const n = data.length;
+  if (n % 2) {
+    return data[Math.floor(n/2)];
+  }
+  else {
+    return (data[n/2] + data[n/2 - 1])/2;
+  }
+};
+
+const InterpolatedQuartiles = (data: number[], include_median = true) => {
+
+  data.sort((a, b) => a - b);
+  const n = data.length;
+ 
+  const interp = (p: number, base: number, skip: number) => {
+    const index = base * p + skip;
+    const offset = index % 1;
+    if (offset) {
+      const a = data[Math.floor(index)];
+      const b = data[Math.ceil(index)];
+      return a + (b - a) * offset;
+    }
+    else {
+      return data[index];
+    }
+      
+  }
+
+  if (include_median) {
+    return [data[0], interp(.25, n - 1, 0), Median(data), interp(.75, n - 1, 0), data[n-1]];
+  }
+  else {
+    if (n % 1) {
+      return [data[0], interp(.25, n - 2, 0), Median(data), interp(.75, n - 2, 1), data[n-1]];
+    }
+    else {
+      return [data[0], interp(.25, n - 3, 0), Median(data), interp(.75, n - 3, 2), data[n-1]];
+    }
+  }
+
+};
+
+const Gamma = (z: Complex): Complex => {
+
+  // this is a Lanczos approximation. could be cleaned up.
+
+  const coefficients = [
+    0.99999999999980993,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.32342877765313,
+    -176.61502916214059,
+    12.507343278686905,
+    -0.13857109526572012,
+    9.9843695780195716e-6,
+    1.5056327351493116e-7
+  ];
+
+  // generally speaking I'm against operator overloading but 
+  // it would be a big help for complex math
+
+  const pi = Math.PI;
+  const sin = ComplexMath.Sin;
+  const div = ComplexMath.Divide;
+  const mul = ComplexMath.Multiply;
+  const cpx = (a: number) => ({ real: a, imaginary: 0 });
+  const add = (a: Complex, b: Complex): Complex => ({ real: a.real + b.real, imaginary: a.imaginary + b.imaginary });
+  const pow = ComplexMath.Power;
+  const exp = ComplexMath.Exp;
+  const inv = (a: Complex) => ({ real: -a.real, imaginary: -a.imaginary });
+  const prod = ComplexMath.Product;
+
+  if (z.real < 0.5) {
+    return div(cpx(pi), mul(sin(mul(cpx(pi), z)), Gamma({ real: 1 - z.real, imaginary: -z.imaginary })));
+  }
+
+  z.real -= 1;
+  let x = cpx(coefficients[0]);
+
+  for (let i = 1; i < coefficients.length; i++) {
+    x = add(x, div(cpx(coefficients[i]), add(z, cpx(i))));
+  }
+
+  const t = add(z, cpx(7.5));
+  return prod(cpx(Math.sqrt(2 * pi)), pow(t, add(z, cpx(0.5))), exp(inv(t)), x);
+
+};
+
 export const Variance = (data: number[], sample = false) => {
 
   const len = data.length;
@@ -307,6 +396,48 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     },
   },
 
+  Gamma: {
+    description: 'Returns the gamma function for the given value',
+    arguments: [{ name: 'value', boxed: true }],
+    fn: (value: UnionValue) => {
+
+      let complex: Complex = { real: 0, imaginary: 0 };
+
+      if (value.type === ValueType.complex) {
+        complex = {...value.value};
+      }
+      else if (value.type === ValueType.number) {
+        complex.real = value.value;
+      }
+      else {
+        return ArgumentError();
+      }
+
+      if (complex.imaginary === 0 && complex.real % 1 === 0 && complex.real <= 0) {
+        return ValueError();
+      }
+
+      const gamma = Gamma(complex);
+
+      if (Math.abs(gamma.imaginary) <= 1e-7) {
+        return { type: ValueType.number, value: gamma.real };
+      }
+
+      return {type: ValueType.complex, value: gamma};
+      
+    },
+  },
+
+  Delta: {
+    arguments: [{ name: 'number', }, { name: 'number', default: 0 }],
+    fn: (a: CellValue, b: CellValue = 0) => {
+      if (typeof a !== 'number' || typeof b !== 'number') {
+        return ValueError();
+      }
+      return { type: ValueType.number, value: (a === b) ? 1 : 0 };
+    },
+  },
+
   GCD: {
     description: 'Finds the greatest common divisor of the arguments',
     arguments: [{ boxed: true }],
@@ -457,6 +588,46 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     },
   },
 
+  'Quartile.Inc': {
+    description: 'Returns the interpolated quartile of the data set (including median)', 
+    arguments: [
+      { name: 'range', },
+      { name: 'quartile' }, 
+    ],
+    xlfn: true,
+    fn: (data: CellValue[], quartile: CellValue) => {
+
+      if (typeof quartile !== 'number' || quartile < 0 || quartile > 4 || quartile % 1) {
+        return ArgumentError();
+      }
+
+      const flat = Utils.FlattenNumbers(data);
+      const quartiles = InterpolatedQuartiles(flat, true);
+     
+      return { type: ValueType.number, value: quartiles[quartile] };
+    }
+  },
+
+  'Quartile.Exc': {
+    description: 'Returns the interpolated quartile of the data set (excluding median)', 
+    arguments: [
+      { name: 'range', },
+      { name: 'quartile' }, 
+    ],
+    xlfn: true,
+    fn: (data: CellValue[], quartile: CellValue) => {
+
+      if (typeof quartile !== 'number' || quartile < 1 || quartile > 3 || quartile % 1) {
+        return ArgumentError();
+      }
+
+      const flat = Utils.FlattenNumbers(data);
+      const quartiles = InterpolatedQuartiles(flat, false);
+     
+      return { type: ValueType.number, value: quartiles[quartile] };
+    }
+  },
+
   Median: {
     description: 'Returns the median value of the range of data',
     arguments: [
@@ -515,4 +686,5 @@ export const StatisticsFunctionAliases: {[index: string]: string} = {
   Mean: 'Average',
   'StDev': 'StDev.S',
   'Var': 'Var.S',
+  'Quartile': 'Quartile.Inc',
 };

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

@@ -301,6 +301,31 @@ export const TextFunctionLibrary: FunctionMap = {
     },
   },
 
+  Upper: {
+    description: 'Converts text to upper case',
+    arguments: [{ name: 'text', unroll: true }],
+    fn: (text?: string) => {
+      if (text === null || text === undefined) {
+        return { type: ValueType.undefined };
+      }
+      return {
+        type: ValueType.string, value: text.toString().toUpperCase(),
+      };
+    },
+  },
+  Lower: {
+    description: 'Converts text to lower case',
+    arguments: [{ name: 'text', unroll: true }],
+    fn: (text?: string) => {
+      if (text === null || text === undefined) {
+        return { type: ValueType.undefined };
+      }
+      return {
+        type: ValueType.string, value: text.toString().toLowerCase(),
+      };
+    },
+  },
+
  /** canonical should be CONCAT; concatenate can be an alias */
  Concat: {
   description: 'Pastes strings together',

package/treb-calculator/src/utilities.ts

@@ -172,12 +172,12 @@ export const FlattenCellValues = (args: any[]): any[] => {
  * to using any, although we're still kind of hacking at it. also we
  * need to allow typed arrays (I think we've mostly gotten those out?)
  */
-export const FlattenCellValues = (args: (CellValue|CellValue[]|CellValue[][]|Float32Array|Float64Array)[]): CellValue[] => {
+export const FlattenCellValues = (args: (CellValue|CellValue[]|CellValue[][]|Float32Array|Float64Array)[], keep_undefined = false): CellValue[] => {
 
   if (!Array.isArray(args)) { return [args]; } // special case
   return args.reduce((a: CellValue[], b) => {
-    if (typeof b === 'undefined') return a;
-    if (Array.isArray(b)) return a.concat(FlattenCellValues(b));
+    if (typeof b === 'undefined' && !keep_undefined) return a;
+    if (Array.isArray(b)) return a.concat(FlattenCellValues(b, keep_undefined));
     if (b instanceof Float32Array) return a.concat(Array.from(b));
     if (b instanceof Float64Array) return a.concat(Array.from(b));
     return a.concat([b]);
@@ -193,7 +193,21 @@ export const FlattenCellValues = (args: (CellValue|CellValue[]|CellValue[][]|Flo
 export const FlattenNumbers = (args: Parameters<typeof FlattenCellValues>[0]) => 
   (FlattenCellValues(args)).filter((value): value is number => typeof value === 'number');
 
-export const FilterIntrinsics = (data: unknown[]): (string|number|boolean|undefined)[] => {
+export const FilterIntrinsics = (data: unknown[], fill = false): (string|number|boolean|undefined)[] => {
+
+  if (fill) {
+    return data.map((value => {
+      switch (typeof value) {
+        case 'number':
+        case 'undefined':
+        case 'string':
+        case 'boolean':
+          return value;
+      }
+      return undefined;
+    }));
+  }
+
   return data.filter((value): value is number|boolean|undefined|string => {
     switch (typeof value) {
       case 'number':

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

@@ -17,6 +17,26 @@ import type { RangeScale } from 'treb-utils';
 
 const DEFAULT_FORMAT = '#,##0.00'; // why not use "general", or whatever the usual default is?
 
+export const ArrayMinMax = (data: number[]) => {
+
+  let min = data[0];
+  let max = data[0];
+
+  for (const entry of data) { 
+    if (entry < min) { min = entry; }
+    if (entry > max) { max = entry; }
+  }
+
+  return { min, max };
+
+  /*
+  const copy = data.slice(0);
+  copy.sort((a, b) => a - b);
+  return {min: copy[0], max: copy[copy.length - 1]};
+  */
+
+};
+
 export const ReadSeries = (data: ReferenceSeries['value']): SeriesType => {
 
   const [label, x, y, z, index, subtype, data_labels] = data;
@@ -111,10 +131,7 @@ export const ReadSeries = (data: ReferenceSeries['value']): SeriesType => {
     // in case of no values
     if (subseries.data.length) {
       const values = subseries.data.filter(value => value || value === 0) as number[];
-      subseries.range = {
-        min: Math.min.apply(0, values),
-        max: Math.max.apply(0, values),
-      };
+      subseries.range = ArrayMinMax(values);
     }
   }
 
@@ -174,10 +191,7 @@ export const ArrayToSeries = (array_data: ArrayUnion): SeriesType => {
   }
 
   const values = series.y.data.filter(value => value || value === 0) as number[];
-  series.y.range = {
-    min: Math.min.apply(0, values),
-    max: Math.max.apply(0, values),
-  };
+  series.y.range = ArrayMinMax(values);
 
   // experimenting with complex... this should only be set if we populated
   // it from complex values
@@ -185,10 +199,7 @@ export const ArrayToSeries = (array_data: ArrayUnion): SeriesType => {
   if (series.x.data.length) {
 
     const filtered: number[] = series.x.data.filter(test => typeof test === 'number') as number[];
-    series.x.range = {
-      min: Math.min.apply(0, filtered),
-      max: Math.max.apply(0, filtered),
-    }
+    series.x.range = ArrayMinMax(filtered);
 
     if (first_format) {
       series.x.format = first_format;
@@ -281,10 +292,7 @@ export const TransformSeriesData = (raw_data?: UnionValue, default_x?: UnionValu
     baseline_x = {
       data,
       format,
-      range: {
-        min: Math.min.apply(0, filtered),
-        max: Math.max.apply(0, filtered),
-      }
+      range: ArrayMinMax(filtered),
     }
   }
 
@@ -511,26 +519,27 @@ const ApplyLabels = (series_list: SeriesType[], pattern: string, category_labels
  */
 export const BoxStats = (data: number[]) => {
 
-  const median = (data: number[]) => {
-    const n = data.length;
+  // removed copying. still has 3 loops though.
+  
+  const median = (data: number[], start = 0, n = data.length) => {
     if (n % 2) {
-      return data[Math.floor(n/2)];
+      return data[Math.floor(n/2) + start];
     }
     else {
-      return (data[n/2] + data[n/2 - 1])/2;
+      return (data[n/2 + start] + data[n/2 - 1 + start])/2;
     }
   };
 
   const n = data.length;
   const quartiles: [number, number, number] = [0, median(data), 0];
-
   if (n % 2) {
-    quartiles[0] = median(data.slice(0, Math.ceil(n/2)));
-    quartiles[2] = median(data.slice(Math.floor(n/2)));
+    const floor = Math.floor(n/2);
+    quartiles[0] = median(data, 0, Math.ceil(n/2));
+    quartiles[2] = median(data, floor, data.length - floor);
   }
   else {
-    quartiles[0] = median(data.slice(0, n/2));
-    quartiles[2] = median(data.slice(n/2));
+    quartiles[0] = median(data, 0, n/2);
+    quartiles[2] = median(data, n/2, data.length - n/2);
   }
 
   const iqr = quartiles[2] - quartiles[0];
@@ -556,7 +565,7 @@ export const BoxStats = (data: number[]) => {
       break;
     }
   }
-  
+ 
   return {
     data, 
     quartiles, 
@@ -581,7 +590,13 @@ export const CreateBoxPlot = (args: UnionValue[]): ChartData => {
   let max_n = 0;
 
   const stats: BoxPlotData['data'] = series.map(series => {
-    const data = series.y.data.slice(0).filter((test): test is number => test !== undefined).sort((a, b) => a - b);
+    // const data = series.y.data.slice(0).filter((test): test is number => test !== undefined).sort((a, b) => a - b);
+    const data: number[] = [];
+    for (const entry of series.y.data) {
+      if (entry !== undefined) { data.push(entry); }
+    }
+    data.sort((a, b) => a - b);
+
     const result = BoxStats(data);
     max_n = Math.max(max_n, result.n);
     return result;

package/treb-data-model/src/types.ts

@@ -48,6 +48,16 @@ export interface SerializedNamedExpression {
 }
 
 export interface SerializedModel {
+
+  // has this been superceded by TREBDocument?
+  // I can't tell why we're still using this.
+
+  // ...
+
+  // it seems like TREBDocument was a replacment,
+  // but it has some required fields that this type
+  // doesn't have. 
+
   sheet_data: SerializedSheet[];
   active_sheet: number;
 

package/treb-embed/modern.tsconfig.json

@@ -12,7 +12,6 @@
     "../treb-parser/**/*.ts",
     "../treb-calculator/**/*.ts",
     "../treb-base-types/**/*.ts",
-    "../treb-export/**/*.ts",
     "src/content-types.d.ts"
   ],
   "exclude": [

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

@@ -107,13 +107,6 @@ import type { StateLeafVertex } from 'treb-calculator';
  */
 import './content-types.d.ts';
 
-/**
- * import the worker as a script file. tsc will read this on typecheck but 
- * that's actually to the good; when we build with esbuild we will inline
- * the script so we can run it as a worker.
- */
-import * as export_worker_script from 'worker:../../treb-export/src/export-worker/index.worker';
-
 // --- types -------------------------------------------------------------------
 
 /**
@@ -2853,7 +2846,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * 
    * @internal
    */
-  public async ExportBlob(): Promise<Blob> {
+  public async ExportBlob(serialized?: SerializedModel): Promise<Blob> {
 
     // this is inlined to ensure the code will be tree-shaken properly
     if (!process.env.XLSX_SUPPORT) {
@@ -2877,19 +2870,19 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
           reject(event);
         };
 
-        // FIXME: type
-
-        const serialized: SerializedModel = this.Serialize({ // this.grid.Serialize({
-          rendered_values: true,
-          expand_arrays: true,
-          export_colors: true,
-          decorated_cells: true,
-          tables: true,
-          share_resources: false,
-          export_functions: true,
-          apply_row_pattern: true, // if there's a row pattern, set it on rows so they export properly
-        });
-
+        if (!serialized) {        
+          serialized = this.Serialize({
+            rendered_values: true,
+            expand_arrays: true,
+            export_colors: true,
+            decorated_cells: true,
+            tables: true,
+            share_resources: false,
+            export_functions: true,
+            apply_row_pattern: true, // if there's a row pattern, set it on rows so they export properly
+          });
+        }
+        
         // why do _we_ put this in, instead of the grid method? 
         serialized.decimal_mark = Localization.decimal_separator;
 
@@ -6162,39 +6155,21 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   }
 
   /**
-   * load worker. optionally uses an ambient path as prefix; intended for
-   * loading in different directories (or different hosts?)
+   * worker now uses a dynamic import with a module built separately.
+   * see `export-worker.ts` (in this directory) for more detail.
    */
   protected async LoadWorker(): Promise<Worker> {
-
-    // this is inlined to ensure the code will be tree-shaken properly
-    // (we're trying to force it to remove the imported worker script)
-
-    if (process.env.XLSX_SUPPORT) {
-    
-      // for esm we now support embedding the worker as a blob
-      // (as text, actually); we can construct it from the text 
-      // as necessary.
-
-      if (export_worker_script) {
-        try {
-          const worker = new Worker(
-              URL.createObjectURL(new Blob([(export_worker_script as {default: string}).default], { type: 'application/javascript' })));
-          return worker;
-        }
-        catch (err) {
-          console.info('embedded worker failed');
-          console.error(err);
-        }
-      }
-
-    } 
-    else {
-      console.warn('this build does not include xlsx support.');
+    try {
+      const worker = `export`;
+      const mod = await import(`esbuild-ignore-import:./treb-${worker}-worker.mjs`) as {
+        CreateWorker: () => Promise<Worker>;
+      };
+      return await mod.CreateWorker();
+    }
+    catch (err) {
+      console.error(err);
+      throw(err);
     }
-
-    throw new Error('creating worker failed');
-
   }
 
   /**