@trebco/treb 32.1.1 → 32.3.1

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

@@ -0,0 +1,143 @@
+/**
+ * functions and constants for gamma distribution. we're
+ * returning false instead of throwing so we can return
+ * a spreadsheet-style eror. TODO: optional?
+ */
+
+const max_iterations = 1000;
+const epsilon = 3.0e-9;
+const min_value = 1.0e-30;
+
+/**
+ * faster approximation for real numbers
+ */
+export const gamma_ln = (z: number): 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));
+
+};
+
+/** 
+ * series representation
+ */
+export const gamma_series = (a: number, x: number): number|false => {
+
+  const gamma_ln_a = gamma_ln(a);
+
+  if (x === 0) {
+    return 0;
+  }
+
+  let ap = a;
+  let sum = 1.0 / a;
+  let del = sum;
+  for (let n = 1; n < max_iterations; n++) {
+    ++ap;
+    del *= x / ap;
+    sum += del;
+    if (Math.abs(del) < Math.abs(sum) * epsilon) {
+      return sum * Math.exp(-x + a * Math.log(x) - (gamma_ln_a));
+    }
+  }
+
+  // throw new Error('too many iterations');
+  console.error('too many iterations');
+  return false;
+
+};
+
+/**
+ * continued fraction
+ */
+export const gamma_cf = (a: number, x: number): number|false => {
+
+  const gamma_ln_a = gamma_ln(a);
+
+  let b = x + 1.0 - a;
+  let c = 1.0 / min_value;
+  let d = 1.0 / b;
+  let h = d;
+
+  for (let i = 1; i <= max_iterations; i++) {
+
+    const an = -i * (i - a); b += 2.0; d = an * d + b;
+
+    if (Math.abs(d) < min_value) d = min_value;
+    c = b + an / c;
+
+    if (Math.abs(c) < min_value) c = min_value;
+
+    d = 1.0 / d;
+    const del = d * c;
+    h *= del;
+
+    if (Math.abs(del - 1.0) < epsilon) {
+      return Math.exp(-x + a * Math.log(x) - (gamma_ln_a)) * h;
+    }
+
+  }
+
+  // throw new Error('too many iterations');
+  console.error('too many iterations');
+  return false;
+
+};
+
+/**
+ * regularized gamma function; CDF of gamma distribution with scale 1
+ */
+export const gamma_p = (a: number, x: number) => {
+
+  if (x < 0.0 || a <= 0.0) {
+    // throw new Error('invalid parameter');
+    console.error('invalid parameter');
+    return false;
+  }
+  if (x < (a + 1.0)) {
+    return gamma_series(a, x);
+  }
+  else {
+    const cf = gamma_cf(a, x);
+    if (cf === false) { return false; }
+    return 1 - cf;
+  }
+
+}
+
+/** 
+ * regularized gamma function 
+ */
+export const gamma_q = (a: number, x: number) => {
+
+  if (x < 0.0 || a <= 0.0) {
+    // throw new Error('invalid parameter');
+    console.error('invalid parameter');
+    return false;
+  }
+  if (x < (a + 1.0)) {
+    const series = gamma_series(a, x);
+    if (series === false) { return false; }
+    return 1 - series;
+  }
+  else {
+    return gamma_cf(a, x);
+  }
+}

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

@@ -26,6 +26,7 @@ import { type Complex, type UnionValue, ValueType, type CellValue, ComplexOrReal
 import * as ComplexMath from '../complex-math';
 
 import { BetaCDF, BetaPDF, InverseBeta, LnGamma } from './beta';
+import { gamma_p } from './gamma';
 
 /** error function (for gaussian distribution) */
 const erf = (x: number): number => {
@@ -172,6 +173,46 @@ const Gamma = (z: Complex): Complex => {
 
 };
 
+const GammaPDF = (x: number, alpha: number, beta: number): number => {
+  const gamma_alpha = Gamma({real: alpha, imaginary: 0}).real;
+  return (Math.pow(x, alpha - 1) * Math.exp(-x / beta)) / (gamma_alpha * Math.pow(beta, alpha));
+};
+
+/** bisection */
+const InverseGamma = (p: number, alpha: number, beta: number): number|false => {
+
+  let lower = 0;
+  let upper = alpha * 10;
+
+  const tolerance = 1e-6;
+
+  let iterations = 0;
+
+  while (upper - lower > tolerance) {
+    iterations++;
+
+    const mid = (upper + lower) / 2;
+
+    const f_lower = gamma_p(alpha, lower/beta);
+    const f_mid = gamma_p(alpha, mid/beta);
+
+    if (f_lower === false || f_mid === false) {
+      return false;
+    }
+
+    if ((f_mid - p) * (f_lower - p) < 0) {
+      upper = mid;
+    }
+    else {
+      lower = mid;
+    }
+
+  }
+
+  return (lower + upper) / 2;
+
+};
+
 export const Variance = (data: number[], sample = false) => {
 
   const len = data.length;
@@ -743,6 +784,53 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     },
   },
 
+  'Gamma.Inv': {
+    description: 'Returns the inverse of the gamma distribution',
+    arguments: [
+      {name: 'probability', unroll: true},
+      {name: 'alpha', },
+      {name: 'beta', },
+    ],
+    fn: (p: number, alpha: number, beta: number) => {
+
+      if (p < 0 || p > 1) {
+        return ArgumentError();
+      }
+      
+      const value = InverseGamma(p, alpha, beta);
+
+      if (value === false) {
+        return ValueError();
+      }
+
+      return {
+        type: ValueType.number,
+        value,
+      }
+    },
+  },
+
+  'Gamma.Dist': {
+    fn: (x: number, alpha: number, beta: number, cumulative?: boolean) => {
+
+      if (x < 0 || alpha <= 0 || beta <= 0) {
+        return ArgumentError();
+      }
+  
+      const value = cumulative ? gamma_p(alpha, x/beta) : GammaPDF(x, alpha, beta);
+        
+      if (value === false) {
+        return ValueError();
+      }
+
+      return {
+        type: ValueType.number,
+        value,
+      };
+
+    }    
+  },
+
   GammaLn: {
     description: 'Returns the natural log of the gamma function',
     arguments: [{ name: 'value', boxed: true, unroll: true }],

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

@@ -2556,7 +2556,7 @@ export class Sheet {
         cell_reference_map[c] = [];
         for (let r = 0; r < column.length; r++) {
           if (column[r]) {
-            const style_as_json = JSON.stringify(column[r]);
+            const style_as_json = Style.Serialize(column[r]); // JSON.stringify(column[r]);
             if (style_as_json !== empty_json) {
               let reference_index = cell_style_map[style_as_json];
               if (typeof reference_index !== 'number') {
@@ -2579,7 +2579,7 @@ export class Sheet {
      */
     const StyleToRef = (style: CellStyle) => {
 
-      const style_as_json = JSON.stringify(style);
+      const style_as_json = Style.Serialize(style); // JSON.stringify(style);
       if (style_as_json === empty_json) {
         return 0;
       }

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

@@ -2242,8 +2242,11 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     // console.info({events});
 
+    // FIXME: composite? (...)
+
     for (const event of events) {
       switch (event.type) {
+        case 'composite':
         case 'data':
           recalc = true;
           break;
@@ -4000,8 +4003,13 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     // API v1 OK
 
     let area: Area | undefined;
-    if (event && event.type === 'data' && event.area) {
-      area = event.area;
+    switch (event?.type) {
+      case 'data':
+        area = event.area;
+        break;
+      case 'composite':
+        area = event.data_area;
+        break;
     }
 
     this.calculator.Calculate(area);

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

@@ -1036,11 +1036,25 @@ export class Editor<E = FormulaEditorEvent> extends EventSource<E|FormulaEditorE
     if (matcher) {
       Promise.resolve().then(() => {
         const exec_result = matcher.Exec({ text, cursor: substring_end.length });
+
+        // fix behavior around "f16round", which is a function we accidentally
+        // inherit from Math in Safari and Firefox. it breaks arrow-selection
+        // because it pops up an AC window. we don't want to break AC behavior
+        // on tooltips, though, so we still want to call AC methods. just block
+        // the completion list.
+
+        if (this.selecting && exec_result.completions?.length) {
+          // console.info("Blocking completion list", JSON.stringify(exec_result.completions));
+          exec_result.completions = undefined;
+        }
+        
         const node = 
           this.NodeAtIndex(exec_result.completions?.length ? 
                 (exec_result.position || 0) :
                 (exec_result.function_position || 0));
+
         this.Autocomplete(exec_result, node);
+        
       });
     }
 

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

@@ -2041,6 +2041,7 @@ export class Grid extends GridBase {
         command.expression = parse_result.expression;
       }
       else {
+        console.info({expression, parse_result});
         throw new Error('invalid expression');
       }
     }
@@ -4554,20 +4555,8 @@ export class Grid extends GridBase {
         if (selecting_argument) {
           this.UpdateSelectedArgument(selection);
         }
-        else if (!selection.empty && !selection.area.entire_sheet) {
-          if (selection.area.entire_column) {
-            this.UpdateAddressLabel(undefined, selection.area.columns + 'C');
-          }
-          else if (selection.area.entire_row) {
-            this.UpdateAddressLabel(undefined, selection.area.rows + 'R');
-          }
-          else if (selection.area.count > 1) {
-            this.UpdateAddressLabel(undefined, selection.area.rows + 'R x ' +
-              selection.area.columns + 'C');
-          }
-          else {
-            this.UpdateAddressLabel(selection);
-          }
+        else {
+          this.UpdateAddressLabelArea(selection); // 3R x 2C
         }
       }
     }, () => {
@@ -5114,6 +5103,9 @@ export class Grid extends GridBase {
 
         if (!selection.empty && (delta.columns || delta.rows)) {
           if (this.BlockSelection(selection, !!event.shiftKey, delta.columns, delta.rows)) {
+            if (event.shiftKey && !selecting_argument) {
+              this.UpdateAddressLabelArea(selection);
+            }
             return;
           }
         }
@@ -5280,6 +5272,9 @@ export class Grid extends GridBase {
 
     if (delta.rows || delta.columns) {
       this.AdvanceSelection(delta, selection, within_selection, expand_selection, !editor_open);
+      if (event.shiftKey && !selecting_argument) {
+        this.UpdateAddressLabelArea(selection);
+      }
     }
 
   }
@@ -5660,7 +5655,13 @@ export class Grid extends GridBase {
               }
             }
           }
-          if (formula_parse_result.dependencies) {
+          if (formula_parse_result.expression) {
+
+            // we were previously looking at address arguments, and ignoring
+            // ranges. this leads to inconsistent behavior. we'll now look at 
+            // ranges when inferring number format.
+
+            // there was also an issue with using the correct sheet, also fixed.
 
             // this was set up to just use the first format we found. 
             // updating to change priority -- if the first one is a 
@@ -5669,14 +5670,10 @@ export class Grid extends GridBase {
 
             let found_number_format: string|undefined = undefined;
 
-            const list = formula_parse_result.dependencies;
-            for (const key of Object.keys(list.addresses)) {
-              const address = list.addresses[key];
-              if (this.active_sheet.HasCellStyle({ ...address })) {
-
-                // FIXME: this should not be active_sheet
-
-                const test = this.active_sheet.CellData({ ...address });
+            /** returns true if we've found a non-% number format */
+            const Check = (address: ICellAddress, sheet = this.active_sheet) => {
+              if (sheet.HasCellStyle({...address})) {
+                const test = sheet.CellData({ ...address });
                 if (test.style && test.style.number_format) {
                   if (!found_number_format || /%/.test(found_number_format)) {
 
@@ -5686,13 +5683,43 @@ export class Grid extends GridBase {
 
                     found_number_format = NumberFormatCache.Translate(test.style.number_format);
                     if (!/%/.test(found_number_format)) {
-                      break;
+                      return true;
                     }
 
                   }
                 }
               }
-            }
+              return false;
+            };
+
+            let finished = false;
+            let sheet: Sheet|undefined = this.active_sheet;
+
+            this.parser.Walk(formula_parse_result.expression, unit => {
+              
+              if (finished) { 
+                return false; 
+              }
+
+              switch (unit.type) {
+                case 'address':
+                  this.model.ResolveSheetID(unit);
+                  sheet = this.model.sheets.Find(unit.sheet_id || 0);
+                  finished = finished || Check(unit, sheet);
+                  break;
+
+                case 'range':
+                  this.model.ResolveSheetID(unit);
+                  sheet = this.model.sheets.Find(unit.start.sheet_id || 0);
+                  for (const address of new Area(unit.start, unit.end)) {
+                    finished = finished || Check(address, sheet);
+                    if (finished) { break; }
+                  }
+                  break;
+              }
+              return !finished;
+
+            });
 
             if (found_number_format) {
 
@@ -7025,6 +7052,24 @@ export class Grid extends GridBase {
     }
   }
 
+  private UpdateAddressLabelArea(selection: GridSelection) {
+    if (!selection.empty && !selection.area.entire_sheet) {
+      if (selection.area.entire_column) {
+        this.UpdateAddressLabel(undefined, selection.area.columns + 'C');
+      }
+      else if (selection.area.entire_row) {
+        this.UpdateAddressLabel(undefined, selection.area.rows + 'R');
+      }
+      else if (selection.area.count > 1) {
+        this.UpdateAddressLabel(undefined, selection.area.rows + 'R x ' +
+          selection.area.columns + 'C');
+      }
+      else {
+        this.UpdateAddressLabel(selection);
+      }
+    }
+  }
+
   private UpdateAddressLabel(selection = this.primary_selection, text?: string) {
 
     if (!this.formula_bar) { return; }

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

@@ -445,6 +445,9 @@ export interface RenderOptions {
   /** base for offsetting relative R1C1 addresses */
   r1c1_base?: UnitAddress;
 
+  /** force addresses to be relative */
+  r1c1_force_relative?: boolean;
+
   /** if we're just translating, don't have to render addresses */
   pass_through_addresses?: boolean;
 

package/treb-parser/src/parser.ts

@@ -602,14 +602,15 @@ export class Parser {
         if (options.pass_through_addresses) { 
           return unit.label;
         }
-        return options.r1c1 ? this.R1C1Label(unit, options.r1c1_base) : this.AddressLabel(unit, offset);
+        return options.r1c1 ? this.R1C1Label(unit, options.r1c1_base, options.r1c1_force_relative) : this.AddressLabel(unit, offset);
 
       case 'range':
         if (options.pass_through_addresses) { 
           return unit.label;
         }
         return options.r1c1 ? 
-          this.R1C1Label(unit.start, options.r1c1_base) + ':' + this.R1C1Label(unit.end, options.r1c1_base) : 
+          this.R1C1Label(unit.start, options.r1c1_base, options.r1c1_force_relative) + ':' + 
+            this.R1C1Label(unit.end, options.r1c1_base, options.r1c1_force_relative) : 
           this.AddressLabel(unit.start, offset) + ':' + this.AddressLabel(unit.end, offset);
 
       case 'missing':
@@ -955,10 +956,14 @@ export class Parser {
 
   /**
    * generates absolute or relative R1C1 address
+   * 
+   * FIXME: not supporting relative (offset) addresses atm? I'd like to
+   * change this but I don't want to break anything...
    */
   protected R1C1Label(
     address: UnitAddress,
     base?: UnitAddress,
+    force_relative = false,
   ): string {
 
     let label = '';
@@ -968,8 +973,25 @@ export class Parser {
         '\'' + address.sheet + '\'' : address.sheet) + '!';
     }
 
-    const row = address.offset_row ? `[${address.row}]` : address.row + 1;
-    const column = address.offset_column ? `[${address.column}]` : address.column + 1;
+    let row = '';
+    let column = '';
+
+    if (force_relative && base) { 
+      const delta_row = address.row - base.row;
+      const delta_column = address.column - base.column;
+
+      if (delta_row) {
+        row = `[${delta_row}]`;
+      }
+      if (delta_column) {
+        column = `[${delta_column}]`;
+      }
+
+    }
+    else {
+      row = address.offset_row ? `[${address.row}]` : (address.row + 1).toString();
+      column = address.offset_column ? `[${address.column}]` : (address.column + 1).toString();
+    }
 
     /*    
     const row = (address.absolute_row || !base) ? (address.row + 1).toString() : `[${address.row - base.row}]`;
@@ -1063,14 +1085,18 @@ export class Parser {
 
           // skip nulls
 
-          if (group) {
+          // ...don't skip nulls? don't know what the rationale was
+          // but for implicit calls we will need to support empty arguments 
+
+          // if (group) {
             stream.push({
               type: 'group',
               id: this.id_counter++,
-              elements: [group],
+              elements: group? [group] : [],
               explicit: true,
             });
-          }
+          //}
+
         }
         else {
           // this can probably move to PNext? except for the test

package/treb-calculator/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../tsproject.json",
-  "include": [
-    "../treb-base-types/**/*.ts"
-  ]
-}
-