@trebco/treb 32.1.1 → 32.3.3

package/package.json

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

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

@@ -318,6 +318,26 @@ export const Style = {
     };
   },
 
+  Serialize: (style: CellStyle): string => {
+    const clone: CellStyle = JSON.parse(JSON.stringify(style));
+
+    // scrub border colors without widths
+    if (clone.border_bottom_fill && !clone.border_bottom) {
+      clone.border_bottom_fill = undefined;
+    }
+    if (clone.border_top_fill && !clone.border_top) {
+      clone.border_top_fill = undefined;
+    }
+    if (clone.border_left_fill && !clone.border_left) {
+      clone.border_left_fill = undefined;
+    }
+    if (clone.border_right_fill && !clone.border_right) {
+      clone.border_right_fill = undefined;
+    }
+
+    return JSON.stringify(clone);
+  },
+
   /**
    * merge. returns a new object, does not update dest in place.
    * NOTE: if it does not update dest in place, then what would be

package/treb-calculator/src/calculator.ts

@@ -48,6 +48,7 @@ import { ComplexFunctionLibrary } from './functions/complex-functions';
 import { MatrixFunctionLibrary } from './functions/matrix-functions';
 import { RegexFunctionLibrary } from './functions/regex-functions';
 import { LambdaFunctionLibrary } from './functions/lambda-functions';
+import { FPFunctionLibrary } from './functions/fp';
 
 import { Variance } from './functions/statistics-functions';
 
@@ -242,6 +243,7 @@ export class Calculator extends Graph {
       MatrixFunctionLibrary,
       RegexFunctionLibrary,
       LambdaFunctionLibrary,
+      FPFunctionLibrary,
       );
    
     // aliases

package/treb-calculator/src/descriptors.ts

@@ -19,7 +19,7 @@
  * 
  */
 
-import type { RenderFunction, ClickFunction, UnionValue, ICellAddress, IArea } from 'treb-base-types';
+import type { RenderFunction, ClickFunction, UnionValue, ICellAddress, IArea, FunctionUnion } from 'treb-base-types';
 import type { ExpressionUnit } from 'treb-parser';
 
 /**
@@ -28,6 +28,9 @@ import type { ExpressionUnit } from 'treb-parser';
 export interface FunctionContext {
   address: ICellAddress;
   area?: IArea;
+
+  /** application function for fp functions */
+  apply?: (fn: FunctionUnion, args: UnionValue[]) => UnionValue;
 }
 
 // FIXME: at least some of this could move to base types
@@ -235,6 +238,9 @@ export interface CompositeFunctionDescriptor {
     descriptors: ArgumentDescriptor[];
   }) => ContextResult | undefined;
 
+  /** flag indicating this function needs fp support */
+  fp?: boolean;
+
 }
 
 export interface FunctionMap {

package/treb-calculator/src/expression-calculator.ts

@@ -27,11 +27,13 @@ import type { Cell, ICellAddress,
          UndefinedUnion,
          ComplexUnion, 
          DimensionedQuantityUnion,
-         IArea} from 'treb-base-types';
+         IArea,
+         FunctionUnion} from 'treb-base-types';
 import { ValueType, GetValueType, Area } from 'treb-base-types';
 import type { Parser, ExpressionUnit, UnitBinary, UnitIdentifier,
          UnitGroup, UnitUnary, UnitAddress, UnitRange, UnitCall, UnitDimensionedQuantity, UnitStructuredReference, 
-         UnitImplicitCall} from 'treb-parser';
+         UnitImplicitCall,
+         UnitArray} from 'treb-parser';
 import type { DataModel, MacroFunction, Sheet } from 'treb-data-model';
 import { NameError, ReferenceError, ExpressionError, UnknownError, SpillError, ValueError, ArgumentError } from './function-error';
 
@@ -448,6 +450,133 @@ export class ExpressionCalculator {
       
   }
 
+  /**
+   * split out from ImplicitCall so we can reuse
+   */
+  public ImplicitCallTail(result: FunctionUnion, args: ExpressionUnit[]) {
+
+    const value = result.value as {
+      bindings: ExpressionUnit[];
+      func: ExpressionUnit|undefined;
+    };
+
+    if (!value.func || !value.bindings) {
+      return ExpressionError();
+    }
+
+    // let frame = value.bindings(expr.args);
+
+    const frame: BindingFrame = {};
+
+    for (let i = 0; i < value.bindings.length; i++) {
+      const name = value.bindings[i];
+      if (name?.type === 'identifier') {
+        frame[name.name.toUpperCase()] = args[i] || { type: 'missing' };
+      }
+      else { 
+        // should not happen, error
+        return ExpressionError();
+      }
+    }
+
+    // frame = this.NormalizeBindings(frame); // inline
+
+    const munged = JSON.parse(JSON.stringify(value.func));
+    
+    this.parser.Walk2(munged, (unit: ExpressionUnit) => {
+      if (unit.type === 'identifier') {
+        const upper_case = unit.name.toUpperCase();
+        const binding = frame[upper_case];
+        if (binding) {
+          return JSON.parse(JSON.stringify(binding));
+        }
+      }
+      return true;
+    });
+    
+    // console.info({frame, func, munged});
+   
+    // const exec_result = this.CalculateExpression(munged as ExtendedExpressionUnit);
+    // return exec_result || ExpressionError();
+
+    return this.CalculateExpression(munged as ExtendedExpressionUnit);
+
+  }
+
+  /**
+   * an FP call will need to set bindings and call an expression, 
+   * possibly multiple times. this is a support function for that.
+   */
+  protected Apply(fn: FunctionUnion, args: UnionValue[]) {
+
+    // kind of going backwards here, converting values to expressions...
+    // the reason is that we rewrite lambdas to support recursion
+
+    const mapped: ExpressionUnit[] = args.map(arg => {
+      switch (arg.type) {
+        case ValueType.number:
+        case ValueType.boolean:
+        case ValueType.string:
+          return {
+            type: 'literal', value: arg.value, id: 0, position: 0,
+          }
+  
+        case ValueType.error:
+          return {
+            type: 'literal', value: '#' + arg.value, id: 0, position: 0,
+          }
+  
+        case ValueType.array:
+          {
+            const values: UnitArray['values'] = [];
+            for (let c = 0; c < arg.value.length; c++) {
+              const col = arg.value[c];
+              const mapped_col: UnitArray['values'][0] = [];
+              for (let r = 0; r < col.length; r++ ) {
+                const val = col[r];
+                switch (val.type) {
+                  case ValueType.boolean:
+                  case ValueType.number:
+                  case ValueType.string:
+                    mapped_col.push(val.value || undefined);
+                    break;
+                  default:
+                    console.warn('unhandled array value', val);
+                    mapped_col.push(undefined);
+                }
+              }
+              values.push(mapped_col);
+            }
+
+            return {
+              type: 'array', 
+              values,
+              id: 0, position: 0,
+            };
+          }
+  
+        case ValueType.undefined:
+          return {
+            type: 'missing', id: 0,
+          };
+        
+        default:
+
+          // this (logging) is a problem in a simulation because
+          // it can bog down. we probably should only log once.
+          // or perhaps not at all?
+
+          console.warn('unhandled parameter value', arg);
+  
+      }
+      return { type: 'missing', id: 0 };
+ 
+    });
+
+    return this.ImplicitCallTail(fn, mapped);
+
+  }
+
   /** 
    * this method can take a `call` type if it looked like a call at 
    * the parsing stage, it's a simple translation between the two
@@ -473,53 +602,7 @@ export class ExpressionCalculator {
       const result = this.CalculateExpression(expr.call as ExtendedExpressionUnit);
 
       if (result.type === ValueType.function) {
-
-        const value = result.value as {
-          bindings: ExpressionUnit[];
-          func: ExpressionUnit|undefined;
-        };
-
-        if (!value.func || !value.bindings) {
-          return ExpressionError();
-        }
-
-        // let frame = value.bindings(expr.args);
-
-        const frame: BindingFrame = {};
-
-        for (let i = 0; i < value.bindings.length; i++) {
-          const name = value.bindings[i];
-          if (name?.type === 'identifier') {
-            frame[name.name.toUpperCase()] = expr.args[i] || { type: 'missing' };
-          }
-          else { 
-            // should not happen, error
-            return ExpressionError();
-          }
-        }
-
-        // frame = this.NormalizeBindings(frame); // inline
-
-        const munged = JSON.parse(JSON.stringify(value.func));
-        
-        this.parser.Walk2(munged, (unit: ExpressionUnit) => {
-          if (unit.type === 'identifier') {
-            const upper_case = unit.name.toUpperCase();
-            const binding = frame[upper_case];
-            if (binding) {
-              return JSON.parse(JSON.stringify(binding));
-            }
-          }
-          return true;
-        });
-        
-        // console.info({frame, func, munged});
-        
-        // const exec_result = this.CalculateExpression(munged as ExtendedExpressionUnit);
-        // return exec_result || ExpressionError();
-
-        return this.CalculateExpression(munged as ExtendedExpressionUnit);
-
+        return this.ImplicitCallTail(result, expr.args)
       }
 
       return ExpressionError();
@@ -721,11 +804,12 @@ export class ExpressionCalculator {
           start: { ...this.context.area.start, },
           end: { ...this.context.area.end, },
         } : undefined,
+        apply: func.fp ? this.Apply.bind(this) : undefined,
       };
 
-      if (func.return_type === 'reference') {
+      const result = func.fn.apply(ctx, mapped_args);
 
-        const result = func.fn.apply(ctx, mapped_args);
+      if (func.return_type === 'reference') {
         
         if (return_reference) { 
           return result; 
@@ -744,7 +828,7 @@ export class ExpressionCalculator {
 
       }
 
-      return func.fn.apply(ctx, mapped_args);
+      return result; // func.fn.apply(ctx, mapped_args);
 
     };
 
@@ -1162,11 +1246,11 @@ export class ExpressionCalculator {
 
     switch (upper_case){
     case 'FALSE':
-    case 'F':
+    // case 'F':
       return () => {return {value: false, type: ValueType.boolean}};
 
     case 'TRUE':
-    case 'T':
+    // case 'T':
       return () => {return {value: true, type: ValueType.boolean}};
 
     case 'UNDEFINED':
@@ -1215,6 +1299,7 @@ export class ExpressionCalculator {
         return value;
       }
     }
+
     return undefined;
   }
 

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

@@ -2767,6 +2767,7 @@ const block_list = [
   'imul',
   'clz32',
   'fround',
+  'f16round',
 ];
 
 const block_map: Record<string, string> = {};

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

@@ -0,0 +1,360 @@
+/*
+ * 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 type { FunctionMap } from '../descriptors';
+import type { FunctionUnion, UnionValue} from 'treb-base-types';
+import { ValueType } from 'treb-base-types';
+import { ArgumentError, ValueError } from '../function-error';
+
+export const FPFunctionLibrary: FunctionMap = {
+ 
+  MakeArray: {
+    description: 'Create an array using a function',
+    arguments: [
+      { name: 'rows' },
+      { name: 'columns' },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(rows: number, columns: number, lambda: FunctionUnion) {
+      if (rows > 0 && columns > 0 && lambda?.type === ValueType.function) {
+        const apply = this?.apply;
+        if (!apply) {
+          return ValueError();
+        }
+
+        const value: UnionValue[][] = [];
+        for (let c = 0; c < columns; c++) {
+          const values_col: UnionValue[] = [];
+          for (let r = 0; r < rows; r++) {
+            values_col.push(apply(lambda, [
+              { type: ValueType.number, value: r + 1 },
+              { type: ValueType.number, value: c + 1 },
+            ]));
+          }
+          value.push(values_col);
+        } 
+
+        return {
+          type: ValueType.array,
+          value,
+        };
+
+      }
+      return ArgumentError();
+    },
+  },
+
+  Reduce: {
+    description: 'Accumulates a value by applying a function to a set of values',
+    arguments: [
+      { 
+        name: 'initial value', 
+        boxed: true,
+      },
+      {
+        name: 'data', 
+        description: 'Input data',
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(initial: UnionValue, data: UnionValue, lambda: FunctionUnion) {
+
+      if (!this?.apply) { 
+        return ValueError(); 
+      }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array, 
+          value: [[data]],
+        }
+      }
+
+      const cols = data.value.length;
+      const rows = data.value[0].length;
+
+      for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+          const apply_args: UnionValue[] = [initial, data.value[c][r]];
+          const result = this.apply(lambda, apply_args)
+          initial = result;
+        }
+      }
+
+      return initial;
+
+    },
+  },
+
+  Scan: {
+    description: 'Applies a function to a set of values, iteratively',
+    arguments: [
+      { 
+        name: 'initial value', 
+        boxed: true,
+      },
+      {
+        name: 'data', 
+        description: 'Input data',
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(initial: UnionValue, data: UnionValue, lambda: FunctionUnion) {
+
+      if (!this?.apply) { 
+        return ValueError(); 
+      }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array, 
+          value: [[data]],
+        }
+      }
+
+      const results: UnionValue[][] = [];
+      const cols = data.value.length;
+      const rows = data.value[0].length;
+
+      for (let i = 0; i < cols; i++) { results.push([])}
+
+      for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+          const apply_args: UnionValue[] = [initial, data.value[c][r]];
+          const result = this.apply(lambda, apply_args)
+          results[c][r] = result;
+          initial = result;
+        }
+      }
+
+      return {
+        type: ValueType.array,
+        value: results,
+      }
+
+    },
+  },
+
+  ByRow: {
+    description: 'Apply a function to each row in an array',
+    arguments: [
+      {
+        name: 'data', 
+        description: 'Input data',
+        repeat: true,
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(data: UnionValue, lambda: FunctionUnion) {
+      if (!this?.apply) { return ValueError(); }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array,
+          value: [[data]],
+        };
+      }
+
+      const cols = data.value.length;
+      const rows = data.value[0].length;
+
+      const value: UnionValue[][] = [[]];
+      for (let r = 0; r < rows; r++) {
+        const args: UnionValue[] = [];
+        for (let c = 0; c < cols; c++) {
+          args.push(data.value[c][r]);
+        }
+        value[0].push(this.apply(lambda, [{
+          type: ValueType.array, value: [args],
+        }]));
+      }
+      
+      return {
+        type: ValueType.array,
+        value,
+      }
+
+    }
+  },
+
+
+  ByCol: {
+    description: 'Apply a function to each column in an array',
+    arguments: [
+      {
+        name: 'data', 
+        description: 'Input data',
+        repeat: true,
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+    fp: true,
+    fn: function(data: UnionValue, lambda: FunctionUnion) {
+      if (!this?.apply) { return ValueError(); }
+
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      if (data.type !== ValueType.array) {
+        data = {
+          type: ValueType.array,
+          value: [[data]],
+        };
+      }
+
+      const cols = data.value.length;
+      const rows = data.value[0].length;
+
+      const value: UnionValue[][] = [];
+      for (let c = 0; c < cols; c++) {
+        const args: UnionValue[] = [];
+        for (let r = 0; r < rows; r++) {
+          args.push(data.value[c][r]);
+        }
+        value.push([this.apply(lambda, [{
+          type: ValueType.array, value: [args],
+        }])]);
+      }
+      
+      return {
+        type: ValueType.array,
+        value,
+      }
+
+    }
+  },
+
+  Map: {
+    description: 'Apply a function to a set of values',
+    arguments: [
+      {
+        name: 'data', 
+        description: 'Input data',
+        repeat: true,
+        boxed: true,
+      },
+      {
+        name: 'lambda',
+        description: 'Function to apply',
+        boxed: true,
+      },
+    ],
+
+    fp: true,
+    fn: function(...args: UnionValue[]) {
+
+      if (args.length < 2) {
+        return ArgumentError();
+      }
+      
+      const lambda = args[args.length - 1];
+      if (lambda.type !== ValueType.function) {
+        return ArgumentError();
+      }
+
+      const apply = this?.apply;
+      if (!apply) {
+        return ValueError();
+      }
+
+      for (let i = 0; i < args.length - 1; i++) {
+        const arg = args[i];
+        if (arg.type !== ValueType.array) {
+          args[i] = {
+            type: ValueType.array,
+            value: [[arg]],
+          };
+        }
+      }
+
+      const key = args[0];
+      const results: UnionValue[][] = [];
+      if (key.type === ValueType.array) {
+        for (let r = 0; r < key.value.length; r++) {
+          const row = key.value[r];
+          const results_row: UnionValue[] = [];
+          for (let c = 0; c < row.length; c++) {
+            const apply_args: UnionValue[] = [row[c]];
+
+            for (let i = 1; i < args.length - 1; i++) {
+              const arg = args[i];
+              if (arg.type === ValueType.array) {
+                apply_args.push(arg.value[r][c])
+              }
+            }
+
+            results_row.push(apply(lambda, apply_args));
+          }
+          results.push(results_row);
+        }
+      }
+      
+      return {
+        type: ValueType.array,
+        value: results,
+      };
+
+    },
+
+  },
+
+};