@trebco/treb 30.3.2 → 30.6.0

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/src/embedded-spreadsheet.ts

@@ -2846,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) {
@@ -2870,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;
 

package/treb-embed/style/dark-theme.scss

@@ -97,7 +97,7 @@
   --treb-grid-background: rgb(30,30,30);
   --treb-grid-header-background: rgb(86,86,86);
   --treb-grid-header-color: rgb(221,221,221);
-  --treb-tab-bar-active-tab-background: field;
+  --treb-tab-bar-active-tab-background: #444;
   --treb-tab-bar-tab-background: transparent;
   --treb-tab-bar-tab-border-color: #444;
   --treb-ui-border-color: #aaa;

package/treb-export/src/export.ts

@@ -2076,12 +2076,33 @@ export class Exporter {
               }
             }
 
+            const color_series: {
+              rgb?: string;
+              tint?: string;
+              theme?: string;
+            } = {
+              rgb: 'FF376092' // default
+            };
+
+            if (sparkline.style?.text) {
+              if (IsHTMLColor(sparkline.style.text)) {
+                color_series.rgb = sparkline.style.text.text;
+              }
+              else if (IsThemeColor(sparkline.style.text)) {
+                color_series.rgb = undefined;
+                color_series.theme = sparkline.style.text.theme.toString(); 
+                color_series.tint = typeof sparkline.style.text.tint === 'number' ?
+                  sparkline.style.text.tint.toString() : undefined;
+              }
+            }
+
             return {
               a$: {
                 displayEmptyCellsAs: 'gap',
+                displayHidden: '1',
                 type: /column/i.test(sparkline.formula) ? 'column' : undefined,
               },
-              'x14:colorSeries': { a$: { rgb: 'FF376092' }},
+              'x14:colorSeries': { a$: { ...color_series }},
               'x14:sparklines': {
                 'x14:sparkline': {
                   'xm:f': source,

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

@@ -418,7 +418,7 @@ export class OverlayEditor extends Editor<ResetSelectionEvent> {
       case 'Down':
       case 'Left':
       case 'Right':
-        return this.selecting ? undefined : 'handled';
+        return this.selecting ? undefined : 'commit';
 
     }
 

package/treb-grid/src/types/grid.ts

@@ -4014,7 +4014,15 @@ export class Grid extends GridBase {
     // unless we're selecting an argument, close the ICE
 
     if (this.overlay_editor?.editing && !this.overlay_editor?.selecting) {
-      this.DismissEditor();
+
+      // commit 
+
+      if (this.overlay_editor?.selection) {
+        const value = this.overlay_editor?.edit_node.textContent || undefined;
+        this.SetInferredType(this.overlay_editor.selection, value, false);
+      }
+
+      this.DismissEditor(); 
     }
 
     const offset_point = {