@trebco/treb 28.17.5 → 29.1.2

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

@@ -19,11 +19,11 @@
  * 
  */
 
-import type { FunctionMap } from '../descriptors';
+import type { FunctionMap, IntrinsicValue } from '../descriptors';
 import * as Utils from '../utilities';
-import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError, NameError } from '../function-error';
+import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError } from '../function-error';
 import type { UnionValue, 
-         RenderFunctionResult, RenderFunctionOptions, Complex } from 'treb-base-types';
+         RenderFunctionResult, RenderFunctionOptions, Complex, CellValue } from 'treb-base-types';
 import { Box, ValueType, GetValueType, ComplexOrReal, IsComplex } from 'treb-base-types';
 import { Sparkline } from './sparkline';
 import { LotusDate, UnlotusDate } from 'treb-format';
@@ -32,6 +32,7 @@ import { ClickCheckbox, RenderCheckbox } from './checkbox';
 import { UnionIsMetadata } from '../expression-calculator';
 
 import { Exp as ComplexExp, Power as ComplexPower, Multiply as ComplexMultply } from '../complex-math';
+import { CoerceComplex } from './function-utilities';
 
 /**
  * BaseFunctionLibrary is a static object that has basic spreadsheet
@@ -108,7 +109,7 @@ const zlookup_arguments = [
  * unified VLOOKUP/HLOOKUP. ordinarily we'd call it XLOOKUP but that's taken.
  * FIXME: can't use use that function for this? 
  */
-const ZLookup = (value: any, table: any[][], col: number, inexact = true, transpose = false): UnionValue => {
+const ZLookup = (value: number|string|boolean|undefined, table: (number|string|boolean|undefined)[][], col: number, inexact = true, transpose = false): UnionValue => {
 
   if (transpose) {
     table = Utils.TransposeArray(table);
@@ -128,7 +129,7 @@ const ZLookup = (value: any, table: any[][], col: number, inexact = true, transp
 
   if (inexact) {
 
-    let result: any = table[col][0];
+    let result: number|string|boolean|undefined = table[col][0];
 
     if (typeof value === 'number') {
 
@@ -149,7 +150,7 @@ const ZLookup = (value: any, table: any[][], col: number, inexact = true, transp
     }
     else {
 
-      value = value.toLowerCase(); // ?
+      value = (value||'').toString().toLowerCase(); // ?
       let compare: string = (table[0][0] || '').toString().toLowerCase();
       if (compare.localeCompare(value) > 0) {
         return NAError();
@@ -189,9 +190,9 @@ export const AltFunctionLibrary: FunctionMap = {
   Sqrt: {
     description: 'Returns the square root of the argument',
     arguments: [
-      {boxed: true},
+      { boxed: true, unroll: true },
     ],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+    fn: (ref: UnionValue): UnionValue => {
 
       if (ref.type === ValueType.complex) {
         const value = ComplexPower(ref.value, {real: 0.5, imaginary: 0});
@@ -209,23 +210,33 @@ export const AltFunctionLibrary: FunctionMap = {
           value,
         }
       }
+      else if (ref.type === ValueType.number) {
+        const value = Math.sqrt(ref.value);
+        if (isNaN(value)) {
+          return ValueError();
+        }
+        return { type: ValueType.number, value };
+      }
       else {
+        /*
         const value = Math.sqrt(ref.value);
         if (isNaN(value)) {
           return ValueError();
         }
         return { type: ValueType.number, value };
+        */
+        return ValueError();
       }
-    }),
+    },
   },
   
   Power: {
     description: 'Returns base raised to the given power',
     arguments: [
-      { name: 'base', boxed: true, },
-      { name: 'exponent', boxed: true, }
+      { name: 'base', boxed: true, unroll: true, },
+      { name: 'exponent', boxed: true, unroll: true, }
     ],
-    fn: Utils.ApplyAsArray2((base: UnionValue, exponent: UnionValue): UnionValue => {
+    fn: (base: UnionValue, exponent: UnionValue): UnionValue => {
 
       // we're leaking complex numbers here because our functions are
       // very slightly imprecise. I would like to stop doing that. try to
@@ -247,25 +258,18 @@ export const AltFunctionLibrary: FunctionMap = {
         }
       }
       
-      /*
-      if (base.type === ValueType.number) {
-        base = {
-          type: ValueType.complex,
-          value: { imaginary: 0, real: base.value },
-        };
-      }
-      */
+      const a = CoerceComplex(base);
+      const b = CoerceComplex(exponent);
 
-      const a = base.type === ValueType.complex ? base.value : 
-        { real: base.value || 0, imaginary: 0, };
+      if (a && b) {
+        const value = ComplexPower(a, b);
+        return ComplexOrReal(value);
+      }
 
-      const b = exponent.type === ValueType.complex ? exponent.value :
-        { real: exponent.value || 0, imaginary: 0, };
+      return ValueError();
 
-      const value = ComplexPower(a, b);
-      return ComplexOrReal(value);
 
-    }),
+    },
   },
 
 };
@@ -381,9 +385,9 @@ export const BaseFunctionLibrary: FunctionMap = {
   Date: {
     description: 'Constructs a Lotus date from parts',
     arguments: [
-      { name: 'year' },
-      { name: 'month' },
-      { name: 'day' },
+      { name: 'year', unroll: true },
+      { name: 'month', unroll: true },
+      { name: 'day', unroll: true },
     ],
     fn: (year: number, month: number, day: number) => {
       const date = new Date();
@@ -490,8 +494,8 @@ export const BaseFunctionLibrary: FunctionMap = {
     Cell: {
       description: 'Returns data about a cell',
       arguments: [
-        { name: 'type', description: 'Type of data to return' },
-        { name: 'reference', description: 'Cell reference', metadata: true },
+        { name: 'type', description: 'Type of data to return', unroll: true,  },
+        { name: 'reference', description: 'Cell reference', metadata: true, unroll: true,  },
       ],
 
       // there's no concept of "structure volatile", and structure events
@@ -500,7 +504,7 @@ export const BaseFunctionLibrary: FunctionMap = {
       
       // volatile: true, 
 
-      fn: Utils.ApplyAsArray2((type: string, reference: UnionValue): UnionValue => {
+      fn: (type: string, reference: UnionValue): UnionValue => {
 
         if (!UnionIsMetadata(reference)) {
           return ReferenceError();
@@ -518,13 +522,14 @@ export const BaseFunctionLibrary: FunctionMap = {
 
         return { type: ValueType.error, value: NotImplError.error };
 
-      }),
+      },
+
     },
 
     Year: {
       description: 'Returns year from date',
       arguments: [{
-        name: 'date',
+        name: 'date', unroll: true,
       }],
       fn: (source: number): UnionValue => {
         return Box(new Date(LotusDate(source)).getUTCFullYear());
@@ -535,7 +540,7 @@ export const BaseFunctionLibrary: FunctionMap = {
     Month: {
       description: 'Returns month from date',
       arguments: [{
-        name: 'date',
+        name: 'date', unroll: true,
       }],
       fn: (source: number): UnionValue => {
         return Box(new Date(LotusDate(source)).getUTCMonth() + 1); // 0-based
@@ -546,7 +551,7 @@ export const BaseFunctionLibrary: FunctionMap = {
     Day: {
       description: 'Returns day of month from date',
       arguments: [{
-        name: 'date',
+        name: 'date', unroll: true,
       }],
       fn: (source: number): UnionValue => {
         return Box(new Date(LotusDate(source)).getUTCDate());
@@ -555,24 +560,24 @@ export const BaseFunctionLibrary: FunctionMap = {
 
     Radians: {
       description: 'Converts degrees to radians',
-      arguments: [{ name: 'Degrees', description: 'Angle in degrees' }],
-      fn: Utils.ApplyAsArray((degrees: number): UnionValue => {
+      arguments: [{ name: 'Degrees', description: 'Angle in degrees', unroll: true }],
+      fn: (degrees: number): UnionValue => {
         return Box(degrees * Math.PI / 180);
-      }),
+      },
     },
 
     Degrees: {
       description: 'Converts radians to degrees',
-      arguments: [{ name: 'Radians', description: 'Angle in radians' }],
-      fn: Utils.ApplyAsArray((radians: number): UnionValue => {
+      arguments: [{ name: 'Radians', description: 'Angle in radians', unroll: true }],
+      fn: (radians: number): UnionValue => {
         return Box(radians / Math.PI * 180);
-      }),
+      },
     },
 
     CountA: {
       description: 'Counts cells that are not empty',
-      fn: (...args: unknown[]): UnionValue => {
-        return Box(Utils.FlattenUnboxed(args).reduce((a: number, b: unknown) => {
+      fn: (...args: CellValue[]): UnionValue => {
+        return Box(Utils.FlattenCellValues(args).reduce((a: number, b: unknown) => {
           if (typeof b === 'undefined') return a;
           return a + 1;
         }, 0));
@@ -581,8 +586,8 @@ export const BaseFunctionLibrary: FunctionMap = {
 
     Count: {
       description: 'Counts cells that contain numbers',
-      fn: (...args: unknown[]): UnionValue => {
-        return Box(Utils.FlattenUnboxed(args).reduce((a: number, b: unknown) => {
+      fn: (...args: CellValue[]): UnionValue => {
+        return Box(Utils.FlattenCellValues(args).reduce((a: number, b: unknown) => {
           if (typeof b === 'number' || IsComplex(b)) return a + 1;
           return a;
         }, 0));
@@ -590,9 +595,9 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Or: {
-      fn: (...args: unknown[]): UnionValue => {
+      fn: (...args: CellValue[]): UnionValue => {
         let result = false;
-        args = Utils.FlattenUnboxed(args);
+        args = Utils.FlattenCellValues(args);
         for (const arg of args) {
           result = result || !!arg;
         }
@@ -601,9 +606,9 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     And: {
-      fn: (...args: unknown[]): UnionValue => {
+      fn: (...args: CellValue[]): UnionValue => {
         let result = true;
-        args = Utils.FlattenUnboxed(args);
+        args = Utils.FlattenCellValues(args);
         for (const arg of args) {
           result = result && !!arg;
         }
@@ -612,7 +617,8 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Not: {
-      fn: Utils.ApplyAsArray((...args: unknown[]): UnionValue => {
+      arguments: [{ unroll: true }],
+      fn: (...args: unknown[]): UnionValue => {
         if (args.length === 0) {
           return ArgumentError();
         }
@@ -620,7 +626,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           return Box(!args[0]);
         }
         return Box(true);
-      })
+      },
     },
 
     If: {
@@ -663,10 +669,11 @@ export const BaseFunctionLibrary: FunctionMap = {
     Fact: {
       description: 'Returns the factorial of a number',
       arguments: [
-        { name: 'number' },
+        { name: 'number', unroll: true },
       ],
-      fn: Utils.ApplyAsArray((number: number): UnionValue => {
-        number = Math.floor(number);
+      fn: (number: number): UnionValue => {
+        number = Math.round(number);
+
         let value = 1;
         while (number > 1) {
           value *= number;
@@ -676,40 +683,29 @@ export const BaseFunctionLibrary: FunctionMap = {
           type: ValueType.number,
           value,
         }
-      }),
+      },
     },
 
     Power: {
       description: 'Returns base raised to the given power',
       arguments: [
-        { name: 'base', boxed: true, },
-        { name: 'exponent', boxed: true, }
+        { name: 'base', boxed: true, unroll: true, },
+        { name: 'exponent', boxed: true, unroll: true, }
       ],
-      fn: Utils.ApplyAsArray2((base: UnionValue, exponent: UnionValue): UnionValue => {
+      fn: (base: UnionValue, exponent: UnionValue): UnionValue => {
+      
+        const a = CoerceComplex(base);
+        const b = CoerceComplex(exponent);
 
-        /*
-        if (base.type === ValueType.number) {
-          base = {
-            type: ValueType.complex,
-            value: { imaginary: 0, real: base.value },
-          };
+        if (!a || !b) {
+          return ValueError();
         }
-        */
 
         if (base.type === ValueType.complex || exponent.type === ValueType.complex) {
-
-          const a = base.type === ValueType.complex ? base.value : 
-            { real: base.value || 0, imaginary: 0, };
-          const b = exponent.type === ValueType.complex ? exponent.value :
-            { real: exponent.value || 0, imaginary: 0, };
-
-          const value = ComplexPower(a, b);
-
-          return ComplexOrReal(value);
-
+          return ComplexOrReal(ComplexPower(a, b));
         }
         else {
-          const value = Math.pow(base.value, exponent.value);
+          const value = Math.pow(a.real, b.real);
           if (isNaN(value)) {
             return ValueError();
           }
@@ -717,16 +713,20 @@ export const BaseFunctionLibrary: FunctionMap = {
           // return Box(Math.pow(base.value, exponent.value))
         }
 
-      }),
+      },
     },
 
     Mod: {
-      fn: Utils.ApplyAsArray2((num: number, divisor: number): UnionValue => {
+      arguments: [
+        { unroll: true },
+        { unroll: true },
+      ],
+      fn: (num: number, divisor: number): UnionValue => {
         if (!divisor) { 
           return DivideByZeroError();
         }
         return Box(num % divisor);
-      })
+      },
     },
 
     Large: {
@@ -736,22 +736,19 @@ export const BaseFunctionLibrary: FunctionMap = {
           name: 'values',
         }, 
         {
-          name: 'index',
+          name: 'index', unroll: true,
         }
       ],
 
-      // OK a little tricky here -- we're going to reverse the arguments
-      // so we can call apply as array, but applying against the trailing
-      // arguments.
-
-      fn: Utils.ApplyAsArraySwap((data: any, index: number) => {
+      fn: (data: CellValue[], index: number) => {
 
         if (index <= 0) {
           return ArgumentError();
         }
 
-        const flat = Utils.FlattenUnboxed(data);
-        const numeric: number[] = flat.filter(test => typeof test === 'number');
+        // const flat = Utils.FlattenCellValues(data);
+        // const numeric: number[] = flat.filter((test): test is number => typeof test === 'number');
+        const numeric = Utils.FlattenNumbers(data);
         numeric.sort((a, b) => b - a);
 
         if (index <= numeric.length) {
@@ -762,7 +759,8 @@ export const BaseFunctionLibrary: FunctionMap = {
         }
 
         return ArgumentError();
-      }),
+      },
+
     },
 
     Small: {
@@ -772,20 +770,19 @@ export const BaseFunctionLibrary: FunctionMap = {
           name: 'values',
         }, 
         {
-          name: 'index',
+          name: 'index', unroll: true,
         }
       ],
 
-      // see large, above
-
-      fn: Utils.ApplyAsArraySwap((data: any, index: number) => {
+      fn: (data: CellValue[], index: number) => {
 
         if (index <= 0) {
           return ArgumentError();
         }
 
-        const flat = Utils.FlattenUnboxed(data);
-        const numeric: number[] = flat.filter(test => typeof test === 'number');
+        // const flat = Utils.FlattenCellValues(data);
+        // const numeric: number[] = flat.filter((test): test is number => typeof test === 'number');
+        const numeric = Utils.FlattenNumbers(data);
         numeric.sort((a, b) => a - b);
 
         if (index <= numeric.length) {
@@ -797,7 +794,8 @@ export const BaseFunctionLibrary: FunctionMap = {
 
         return ArgumentError();
 
-      }),
+      },
+
     },
 
     /**
@@ -811,12 +809,12 @@ export const BaseFunctionLibrary: FunctionMap = {
       arguments: [
         { name: 'values' }
       ],
-      fn: (...args: any[]): UnionValue => {
+      fn: (...args: CellValue[]): UnionValue => {
 
-        args = Utils.FlattenUnboxed(args);
+        args = Utils.FlattenCellValues(args);
 
         if(args.every(test => typeof test === 'number')) {
-          args.sort((a, b) => a - b);
+          (args as number[]).sort((a, b) => a - b);
         }
         else {
           args.sort(); // lexical
@@ -850,19 +848,21 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Max: {
-      fn: (...args: any[]): UnionValue => {
+      fn: (...args: number[]): UnionValue => {
         return { 
           type: ValueType.number, 
-          value: Math.max.apply(0, Utils.FlattenUnboxed(args).filter(x => typeof x === 'number')),
+          // value: Math.max.apply(0, Utils.FlattenCellValues(args).filter((x): x is number => typeof x === 'number')),
+          value: Math.max.apply(0, Utils.FlattenNumbers(args)),
         };
       },
     },
 
     Min: {
-      fn: (...args: any[]): UnionValue => {
+      fn: (...args: number[]): UnionValue => {
         return { 
           type: ValueType.number, 
-          value: Math.min.apply(0, Utils.FlattenUnboxed(args).filter(x => typeof x === 'number')),
+          // value: Math.min.apply(0, Utils.FlattenCellValues(args).filter((x): x is number => typeof x === 'number')),
+          value: Math.min.apply(0, Utils.FlattenNumbers(args)),
         };
       },
     },
@@ -905,15 +905,19 @@ export const BaseFunctionLibrary: FunctionMap = {
 
     SumProduct: {
       description: 'Returns the sum of pairwise products of two or more ranges',
-      fn: (...args: any[]): UnionValue  => {
+      fn: (...args: CellValue[][]): UnionValue  => {
 
-        const flattened = args.map(arg => Utils.FlattenUnboxed(arg));
+        const flattened = args.map(arg => Utils.FlattenCellValues(arg));
         const len = Math.max.apply(0, flattened.map(x => x.length));
 
         let sum = 0;
         for (let i = 0; i < len; i++) {
           sum += flattened.reduce((a, arg) => {
-            return a * (arg[i] || 0);
+            let ai: CellValue = arg[i];
+            if (ai === true) {
+              ai = 1;
+            }
+            return (typeof ai === 'number') ? a * ai : 0;
           }, 1);
         }        
 
@@ -986,9 +990,9 @@ export const BaseFunctionLibrary: FunctionMap = {
       ],
       xlfn: true,
       fn: (
-          lookup_value: any, 
-          lookup_array: any[][], 
-          return_array: any[][],
+          lookup_value: IntrinsicValue, 
+          lookup_array: IntrinsicValue[][], 
+          return_array: IntrinsicValue[][],
           not_found?: UnionValue,
           match_mode = 0,
           search_mode = 1,
@@ -1021,7 +1025,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           return ValueError();
         }
 
-        let transpose = (lookup_array.length === 1);
+        const transpose = (lookup_array.length === 1);
         if (transpose) {
           lookup_array = Utils.TransposeArray(lookup_array);
           return_array = Utils.TransposeArray(return_array);
@@ -1115,11 +1119,11 @@ export const BaseFunctionLibrary: FunctionMap = {
               // wildcard string match. we only handle strings for 
               // this case (see above).
 
-              const pattern = Utils.ParseWildcards(lookup_value);
+              const pattern = Utils.ParseWildcards(lookup_value?.toString() || '');
               const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
 
               for (let i = 0; i < lookup_array.length; i++) {
-                let value = lookup_array[i][0];
+                const value = lookup_array[i][0];
                 if (typeof value === 'string' && regex.exec(value)) {
                   return ReturnIndex(i);
                 }
@@ -1146,68 +1150,6 @@ export const BaseFunctionLibrary: FunctionMap = {
             break;
         }
 
-        /*
-        const flat_lookup = Utils.FlattenUnboxed(lookup_array);
-        const flat_return = Utils.FlattenUnboxed(return_array);
-
-        // maybe reverse... 
-
-        if (search_mode < 0) {
-          flat_lookup.reverse();
-          flat_return.reverse();
-        }
-
-        // if value is not a string, then we can ignore wildcards.
-        // in that case convert to exact match.
-
-        if (match_mode === 2 && typeof lookup_value !== 'string') {
-          match_mode = 0;
-        }
-
-        switch (match_mode) {
-          case 2:
-
-            {
-
-              // wildcard string match. we only handle strings
-              // for wildcard matching (handled above).
-
-              const pattern = Utils.ParseWildcards(lookup_value);
-              const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
-
-              for (let i = 0; i < flat_lookup.length; i++) {
-                let value = flat_lookup[i];
-                if (typeof value === 'string' && regex.exec(value)) {
-                  return Box(flat_return[i]);
-                }
-              }
- 
-
-            }
-
-            break;
-
-          case 0: 
-          
-            // return exact match or NA/default. in this case
-            // "exact" means icase (but not wildcard)
-
-            if (typeof lookup_value === 'string') {
-              lookup_value = lookup_value.toLowerCase();
-            }
-            for (let i = 0; i < flat_lookup.length; i++) {
-              let value = flat_lookup[i];
-              if (typeof value === 'string') {
-                value = value.toLowerCase();
-              }
-              if (value === lookup_value) {
-                return Box(flat_return[i]);
-              }
-            }
-
-            break;
-        }
-        */
 
         // FIXME: if we're expecting to return an array maybe we should
         // pack it up as an array? if it's not already an array? (...)
@@ -1222,7 +1164,7 @@ export const BaseFunctionLibrary: FunctionMap = {
      */
     HLookup: {
       arguments: [...zlookup_arguments],
-      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+      fn: (value: number|boolean|string|undefined, table: (number|boolean|string|undefined)[][], col: number, inexact = true): UnionValue => {
         return ZLookup(value, table, col, inexact, true);
       },
     },
@@ -1233,14 +1175,14 @@ export const BaseFunctionLibrary: FunctionMap = {
      */
     VLookup: {
       arguments: [...zlookup_arguments],
-      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+      fn: (value: number|boolean|string|undefined, table: (number|boolean|string|undefined)[][], col: number, inexact = true): UnionValue => {
         return ZLookup(value, table, col, inexact, false);
       },
     },
 
     Product: {
       arguments: [{boxed: true}],
-      fn: (...args: any[]): UnionValue => {
+      fn: (...args: UnionValue[]): UnionValue => {
 
         let product: Complex = { real: 1, imaginary: 0 };
 
@@ -1269,54 +1211,64 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Log: {
+      arguments: [ { unroll: true }, { unroll: true } ], 
+
       /** default is base 10; allow specific base */
-      fn: Utils.ApplyAsArray2((a: number, base = 10): UnionValue => {
+      fn: (a: number, base = 10): UnionValue => {
         return { type: ValueType.number, value: Math.log(a) / Math.log(base) };
-      }),
+      },
     },
 
     Log10: {
-      fn: Utils.ApplyAsArray((a: number): UnionValue => {
+      arguments: [{ unroll: true }], 
+      fn: (a: number): UnionValue => {
         return { type: ValueType.number, value: Math.log(a) / Math.log(10) };
-      }),
+      },
     },
 
     Ln: {
-      fn: Utils.ApplyAsArray((a: number): UnionValue => {
+      arguments: [{ unroll: true }], 
+      fn: (a: number): UnionValue => {
         return { type: ValueType.number, value: Math.log(a) };
-      }),
+      },
     },
 
     Round: {
-      fn: Utils.ApplyAsArray2((a, digits = 0) => {
+      arguments: [ { unroll: true }, { unroll: true } ], // FIXME: lazy
+
+      fn: (a, digits = 0) => {
         const m = Math.pow(10, digits);
         return { 
           type: ValueType.number, 
           value: Math.round(m * a) / m,
         };
-      }),
+      },
     },
 
     RoundDown: {
-      fn: Utils.ApplyAsArray2((a, digits = 0) => {
+      arguments: [ { unroll: true }, { unroll: true } ], // FIXME: lazy
+
+      fn: (a, digits = 0) => {
         const m = Math.pow(10, digits);
         const positive = a >= 0;
         return { 
           type: ValueType.number, 
           value: positive ? Math.floor(m * a) / m : Math.ceil(m * a) / m,
         };
-      }),
+      },
     },
 
     RoundUp: {
-      fn: Utils.ApplyAsArray2((a, digits = 0) => {
+      arguments: [ { unroll: true }, { unroll: true } ], // FIXME: lazy
+
+      fn: (a, digits = 0) => {
         const m = Math.pow(10, digits);
         const positive = a >= 0;
         return { 
           type: ValueType.number, 
           value: positive ? Math.ceil(m * a) / m : Math.floor(m * a) / m,
         };
-      }),
+      },
     },
 
     /*
@@ -1373,7 +1325,7 @@ export const BaseFunctionLibrary: FunctionMap = {
 
         return { 
           type: ValueType.string, 
-          value: a.value.toString().split('').reverse().join(''),
+          value: (a.value??'').toString().split('').reverse().join(''),
         };
       },
     },
@@ -1383,15 +1335,21 @@ export const BaseFunctionLibrary: FunctionMap = {
      */
     Exp: {
       arguments: [
-        { boxed: true },
+        { boxed: true, unroll: true },
       ],
-      fn: Utils.ApplyAsArray((x: UnionValue) => {
+      fn: (x: UnionValue) => {
+        
         if (x.type === ValueType.complex) {
           const value = ComplexExp(x.value);
           return ComplexOrReal(value);
         }
-        return { type: ValueType.number, value: Math.exp(x.value || 0) };
-      }),
+
+        if (x.type !== ValueType.number) {
+          return ValueError();
+        }
+
+        return { type: ValueType.number, value: Math.exp(x.value) };
+      },
     },
 
     /**
@@ -1400,25 +1358,30 @@ export const BaseFunctionLibrary: FunctionMap = {
      */
     Abs: {
       arguments: [
-        { boxed: true },
+        { boxed: true, unroll: true },
       ],
-      fn: Utils.ApplyAsArray((a: UnionValue) => {
+      fn: (a: UnionValue) => {
         if (a.type === ValueType.complex) {
           return { 
             type: ValueType.number, 
             value: Math.sqrt(a.value.real * a.value.real + a.value.imaginary * a.value.imaginary), 
           };
         }
+
+        if (a.type !== ValueType.number) {
+          return ValueError();
+        }
+
         return { type: ValueType.number, value: Math.abs(a.value || 0) };
-      }),
+      },
     },
 
     Simplify: {
       arguments: [
-        { name: 'value' }, 
-        { name: 'significant digits' },
+        { name: 'value', unroll: true, }, 
+        { name: 'significant digits', unroll: true, },
       ],
-      fn: Utils.ApplyAsArray2((value: number, significant_digits = 2): UnionValue => {
+      fn: (value: number, significant_digits = 2): UnionValue => {
         significant_digits = significant_digits || 2;
         if (value === 0) {
           return { type: ValueType.number, value };
@@ -1430,7 +1393,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           type: ValueType.number,
           value: Math.round(value / x) * x * negative
         };
-      }),
+      },
     },
  
     Erf: {
@@ -1508,9 +1471,9 @@ export const BaseFunctionLibrary: FunctionMap = {
     Sqrt: {
       description: 'Returns the square root of the argument',
       arguments: [
-        {boxed: true},
+        { boxed: true, unroll: true },
       ],
-      fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+      fn: (ref: UnionValue): UnionValue => {
 
         // little bit torn on this. what should sqrt(-1) return? a complex 
         // number, or NaN? or should we control that with a flag? 
@@ -1535,6 +1498,15 @@ export const BaseFunctionLibrary: FunctionMap = {
           }
         }
         */
+        else if (ref.type === ValueType.number) {
+          return { 
+            type: ValueType.number, value: Math.sqrt(ref.value),
+          };
+        }
+
+        return ValueError();
+
+        /*
         else {
           const value = Math.sqrt(ref.value);
           if (isNaN(value)) {
@@ -1542,18 +1514,19 @@ export const BaseFunctionLibrary: FunctionMap = {
           }
           return { type: ValueType.number, value };
         }
-      }),
+        */
+      },
     },
 
     HexToDec: {
-      arguments: [{ description: 'hexadecimal string' }],
+      arguments: [{ description: 'hexadecimal string', unroll: true }],
       fn: (hex: string): UnionValue => {
         return { type: ValueType.number, value: parseInt(hex, 16) };
       },
     },
 
     DecToHex: {
-      arguments: [{ description: 'number' }],
+      arguments: [{ description: 'number', unroll: true }],
       fn: (num: number): UnionValue => {
         return { type: ValueType.string, value: num.toString(16) };
       },
@@ -1608,8 +1581,8 @@ export const BaseFunctionLibrary: FunctionMap = {
 
         if (area.type === ValueType.array) {
 
-          const cols = area.value.length;
-          const rows = area.value[0]?.length;
+          // const cols = area.value.length;
+          // const rows = area.value[0]?.length;
 
           // how is uniqueness defined in this context? (...)
 
@@ -1690,7 +1663,7 @@ export const BaseFunctionLibrary: FunctionMap = {
 
         const tmp = Utils.FlattenBoxed([area]);
 
-        let sum = 0;
+        // let sum = 0;
         let count = 0;
         let min = 0; 
         let max = 0;
@@ -1719,7 +1692,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           min = static_min;
         }
 
-        let range = max - min;
+        const range = max - min;
 
         let rows = 1;
         let columns = 1;
@@ -1838,6 +1811,7 @@ for (const name of Object.getOwnPropertyNames(Math)) {
   case 'function':
     // console.info("MATH FUNC", name);
     BaseFunctionLibrary[name] = {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       fn: (...args: any) => {
         return Box(value(...args));
       },