@trebco/treb 28.11.1 → 28.15.0

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

@@ -88,6 +88,98 @@ const inverse_normal = (q: number): number => {
 
 };
 
+const zlookup_arguments = [
+  {
+    name: "Lookup value",
+  },
+  {
+    name: "Table",
+  },
+  {
+    name: "Result index",
+  },
+  {
+    name: "Inexact",
+    default: true,
+  },
+];
+
+/**
+ * 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 => {
+
+  if (transpose) {
+    table = Utils.TransposeArray(table);
+  }
+
+  col = Math.max(0, col - 1);
+
+  // inexact is the default. this assumes that the data is sorted,
+  // either numerically or alphabetically. it returns the closest
+  // value without going over -- meaning walk the list, and when
+  // you're over return the _previous_ item. except if there's an
+  // exact match, I guess, in that case return the exact match.
+  
+  // FIXME: there's a hint in the docs for XLOOKUP that this might
+  // be using a binary search. not sure why, but that might be 
+  // correct.
+
+  if (inexact) {
+
+    let result: any = table[col][0];
+
+    if (typeof value === 'number') {
+
+      let compare = Number(table[0][0]);
+      if (isNaN(compare) || compare > value) {
+        return NAError();
+      }
+
+      for (let i = 1; i < table[0].length; i++) {
+        compare = Number(table[0][i]);
+        if (isNaN(compare) || compare > value) {
+          break;
+        }
+        result = table[col][i];
+
+      }
+
+    }
+    else {
+
+      value = value.toLowerCase(); // ?
+      let compare: string = (table[0][0] || '').toString().toLowerCase();
+      if (compare.localeCompare(value) > 0) {
+        return NAError();
+      }
+
+      for (let i = 1; i < table[0].length; i++) {
+        compare = (table[0][i] || '').toString().toLowerCase();
+        if (compare.localeCompare(value) > 0) {
+          break;
+        }
+        result = table[col][i];
+
+      }
+
+    }
+
+    return Box(result);
+
+  }
+  else {
+    for (let i = 0; i < table[0].length; i++) {
+      if (table[0][i] == value) { // ==
+        return Box(table[col][i]);
+      }
+    }
+    return NAError();
+  }
+
+};
+
 /**
  * alternate functions. these are used (atm) only for changing complex 
  * behavior.
@@ -241,6 +333,51 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  YearFrac: {
+    description: 'Returns the fraction of a year between two dates',
+    arguments: [
+      { name: 'Start', }, 
+      { name: 'End', },
+      { name: 'Basis', default: 0 },
+    ],
+    fn: (start: number, end: number, basis: number): UnionValue => {
+
+      // is this in the spec? should it not be negative here? (...)
+
+      if (end < start) {
+        const temp = start;
+        start = end;
+        end = temp;
+      }
+
+      const delta = Math.max(0, end - start);
+      let divisor = 360;
+
+      if (basis && basis < 0 || basis > 4) {
+        return ArgumentError();
+      }
+
+      // console.info({start, end, basis, delta});
+
+      switch (basis) {
+        case 1:
+          break;
+        case 2:
+          break;
+        case 3:
+          divisor = 365;
+          break;
+      }
+
+      return {
+        type: ValueType.number,
+        value: delta / divisor,
+      };
+
+      return NAError();
+    },
+  },
+
   Date: {
     description: 'Constructs a Lotus date from parts',
     arguments: [
@@ -299,6 +436,25 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  IsNA: {
+    description: 'Checks if another cell contains a #NA error',
+    arguments: [{ name: 'reference', allow_error: true, boxed: true }],
+    fn: (...args: UnionValue[]): UnionValue => {
+
+      const values = Utils.FlattenBoxed(args);
+      for (const value of values) {
+        if (value.type === ValueType.error) {
+          if (value.value === 'N/A') {
+            return { type: ValueType.boolean, value: true };
+          }
+        }
+      }
+
+      return { type: ValueType.boolean, value: false };
+
+    },
+  },
+
   IsError: {
     description: 'Checks if another cell contains an error',
     arguments: [{ name: 'reference', allow_error: true, boxed: true }],
@@ -739,42 +895,275 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
     */
    
-    /**
-     * FIXME: does not implement inexact matching (what's the algo for
-     * that, anyway? nearest? price is right style? what about ties?)
+    /*
+     * unsaid anywhere (that I can locate) aboud XLOOKUP is that lookup 
+     * array must be one-dimensional. it can be either a row or a column,
+     * but one dimension must be one. that simplifies things quite a bit.
+     * 
+     * there's a note in the docs about binary search over the data -- 
+     * that might explain how inexact VLOOKUP works as well. seems an odd
+     * choice but maybe back in the day it made sense
      */
-    VLookup: {
-      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+    XLOOKUP: {
+      arguments: [
+        { name: 'Lookup value', },
+        { name: 'Lookup array',  },
+        { name: 'Return array',  },
+        { name: 'Not found', boxed: true },
+        { name: 'Match mode', default: 0, },
+        { name: 'Search mode', default: 1, },
+      ],
+      xlfn: true,
+      fn: (
+          lookup_value: any, 
+          lookup_array: any[][], 
+          return_array: any[][],
+          not_found?: UnionValue,
+          match_mode = 0,
+          search_mode = 1,
+          ): UnionValue => {
+
+        // FIXME: we could I suppose be more graceful about single values
+        // if passed instead of arrays
+        
+        if (!Array.isArray(lookup_array)) {
+          console.info("lookup is not an array");
+          return ValueError();
+        }
+
+        const first = lookup_array[0];
+        if (!Array.isArray(first)) {
+          console.info("lookip is not a 2d array");
+          return ValueError();
+        }
+
+        if (lookup_array.length !== 1 && first.length !== 1) {
+          console.info("lookup array has invalid dimensions");
+          return ValueError();
+        }
+
+        // FIXME: is it required that the return array be (at least) the 
+        // same size? we can return undefineds, but maybe we should error
 
-        col = Math.max(0, col - 1);
+        if (!Array.isArray(return_array)) {
+          console.info("return array is not an array");
+          return ValueError();
+        }
+
+        let transpose = (lookup_array.length === 1);
+        if (transpose) {
+          lookup_array = Utils.TransposeArray(lookup_array);
+          return_array = Utils.TransposeArray(return_array);
+        }
 
-        if (inexact) {
+        // maybe reverse...
 
-          let min = Math.abs(value - table[0][0]);
-          let result: any = table[col][0];
+        if (search_mode < 0) {
+          lookup_array.reverse();
+          return_array.reverse();
+        }
 
-          for (let i = 1; i < table[0].length; i++) {
+        //
+        // return value at index, transpose if necessary, and return
+        // an array. we might prefer to return a scalar if there's only 
+        // one value, not sure what's the intended behavior
+        // 
+        const ReturnIndex = (index: number): UnionValue => {
 
-            const abs = Math.abs(table[0][i] - value);
+          const values = return_array[index];
 
-            if (abs < min) { // implies first match
-              min = abs;
-              result = table[col][i];
-            }
+          if (!values) {
+            return { type: ValueType.undefined };
+          }
+          
+          if (!Array.isArray(values)) {
+            return Box(values);
+          }
+
+          let boxes = [values.map(value => Box(value))];
+          
+          if (transpose) {
+            boxes = Utils.TransposeArray(boxes);
+          }
+
+          return {
+            type: ValueType.array,
+            value: boxes,
           }
 
-          return Box(result);
+        };
+      
+        // 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;
         }
-        else {
-          for (let i = 1; i < table[0].length; i++) {
-            if (table[0][i] == value) { // ==
-              return table[col][i];
+
+        // what does inexact matching mean in this case if the lookup
+        // value is a string or boolean? (...)
+
+        if ((match_mode === 1 || match_mode === -1) && typeof lookup_value === 'number') {
+
+          let min_delta = 0;
+          let index = -1;
+
+          for (let i = 0; i < lookup_array.length; i++) {
+            const value = lookup_array[i][0];
+           
+
+            if (typeof value === 'number') {
+
+              // check for exact match first, just in case
+              if (value === lookup_value) {
+                return ReturnIndex(i); 
+              }
+
+              const delta = Math.abs(value - lookup_value);
+
+              if ((match_mode === 1 && value > lookup_value) || (match_mode === -1 && value < lookup_value)){
+                if (index < 0 || delta < min_delta) {
+                  min_delta = delta;
+                  index = i;
+                }
+              }
+
             }
           }
-          return NAError();
+
+          if (index >= 0) {
+            return ReturnIndex(index);
+          }
+
+        }
+        
+        switch (match_mode) {
+
+          case 2:
+            {
+              // wildcard string match. we only handle strings for 
+              // this case (see above).
+
+              const pattern = Utils.ParseWildcards(lookup_value);
+              const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
+
+              for (let i = 0; i < lookup_array.length; i++) {
+                let value = lookup_array[i][0];
+                if (typeof value === 'string' && regex.exec(value)) {
+                  return ReturnIndex(i);
+                }
+              }
+
+            }
+            break;
+
+          case 0:
+            if (typeof lookup_value === 'string') {
+              lookup_value = lookup_value.toLowerCase();
+            }
+            for (let i = 0; i < lookup_array.length; i++) {
+              let value = lookup_array[i][0];
+ 
+              if (typeof value === 'string') {
+                value = value.toLowerCase();
+              }
+              if (value === lookup_value) {
+                return ReturnIndex(i);
+              }
+            }
+
+            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? (...)
+
+        return (not_found && not_found.type !== ValueType.undefined) ? not_found : NAError();
+
+      },
+    },
+
+    /**
+     * copied from HLOOKUP, fix that one first
+     */
+    HLookup: {
+      arguments: [...zlookup_arguments],
+      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        return ZLookup(value, table, col, inexact, true);
+      },
+    },
+
+    /**
+     * FIXME: does not implement inexact matching (what's the algo for
+     * that, anyway? nearest? price is right style? what about ties?)
+     */
+    VLookup: {
+      arguments: [...zlookup_arguments],
+      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        return ZLookup(value, table, col, inexact, false);
       },
     },
 

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

@@ -26,60 +26,6 @@ import { Localization, ValueType } from 'treb-base-types';
 import * as Utils from '../utilities';
 import { ArgumentError, ValueError } from '../function-error';
 
-/**
- * parse a string with wildcards into a regex pattern
- * 
- * from
- * https://exceljet.net/glossary/wildcard
- * 
- * Excel has 3 wildcards you can use in your formulas:
- *
- * Asterisk (*) - zero or more characters
- * Question mark (?) - any one character
- * Tilde (~) - escape for literal character (~*) a literal question mark (~?), or a literal tilde (~~)
- * 
- * they're pretty liberal with escaping, nothing is an error, just roll with it
- * 
- */
-const ParseWildcards = (text: string): string => {
-
-  const result: string[] = [];
-  const length = text.length;
-
-  const escaped_chars = '[\\^$.|?*+()';
-
-  for (let i = 0; i < length; i++) {
-    let char = text[i];
-    switch (char) {
-
-      case '*':
-        result.push('.', '*');
-        break;
-
-      case '?':
-        result.push('.');
-        break;
-
-      case '~':
-        char = text[++i] || '';
-      
-      // eslint-disable-next-line no-fallthrough
-      default:
-        for (let j = 0; j < escaped_chars.length; j++) {
-          if (char === escaped_chars[j]) {
-            result.push('\\');
-            break;
-          }
-        }
-        result.push(char);
-        break;
-
-    }
-  }
-
-  return result.join('');
-
-};
 
 export const TextFunctionLibrary: FunctionMap = {
 
@@ -129,6 +75,50 @@ export const TextFunctionLibrary: FunctionMap = {
     category: ['text'],
   },
 
+  WildcardMatch: {
+    visibility: 'internal',
+    arguments: [
+      { name: 'text', },
+      { name: 'text', },
+
+      // the invert parameter is optional, defaults to false. we add this
+      // so we can invert wirhout requiring an extra function call.
+
+      { name: 'invert' }, 
+    ],
+    fn: Utils.ApplyAsArray2((a: any, b: any, invert = false) => {
+
+      if (typeof a === 'string' && typeof b === 'string') {
+        const pattern = Utils.ParseWildcards(b);
+        const match = new RegExp('^' + pattern + '$', 'i').exec(a);
+
+        return {
+          type: ValueType.boolean,
+          value: invert ? !match : !!match,
+        };
+      }
+
+      return {
+        type: ValueType.boolean,
+        value: (a === b || a?.toString() === b?.toString()),
+      }
+    }),
+  },
+
+  Exact: {
+    arguments: [
+      { name: 'text', boxed: true, },
+      { name: 'text', boxed: true, },
+    ],
+    category: ['text'],
+    fn: Utils.ApplyAsArray2((a: UnionValue, b: UnionValue): UnionValue => {
+      return {
+        type: ValueType.boolean,
+        value: (a?.value?.toString()) === (b?.value?.toString()),
+      };
+    }),
+  },
+
   Left: {
     arguments: [
       { name: 'string' },
@@ -225,7 +215,7 @@ export const TextFunctionLibrary: FunctionMap = {
         // can we get by with regexes? should we have some sort of cache
         // for common patterns?
 
-        const pattern = ParseWildcards(needle);
+        const pattern = Utils.ParseWildcards(needle);
         // console.info('n', needle, 'p', pattern);
         const match = new RegExp(pattern, 'i').exec(haystack.substr(start - 1));
 

package/treb-calculator/src/primitives.ts

@@ -309,6 +309,17 @@ export const Equals = (a: UnionValue, b: UnionValue): UnionValue => {
 
   }
 
+  // this is standard (icase) string equality. we might also need
+  // to handle wildcard string matching, although it's not the 
+  // default case for = operators.
+
+  if (a.type === ValueType.string && b.type === ValueType.string) {
+    return { 
+      type: ValueType.boolean, 
+      value: a.value.toLowerCase() === b.value.toLowerCase(),
+    };
+  }
+
   return { type: ValueType.boolean, value: a.value == b.value }; // note ==
 };
 

package/treb-calculator/src/utilities.ts

@@ -302,3 +302,58 @@ export const ApplyAsArray2 = (base: (a: any, b: any, ...rest: any[]) => UnionVal
   }
 };
 
+
+/**
+ * parse a string with wildcards into a regex pattern
+ * 
+ * from
+ * https://exceljet.net/glossary/wildcard
+ * 
+ * Excel has 3 wildcards you can use in your formulas:
+ *
+ * Asterisk (*) - zero or more characters
+ * Question mark (?) - any one character
+ * Tilde (~) - escape for literal character (~*) a literal question mark (~?), or a literal tilde (~~)
+ * 
+ * they're pretty liberal with escaping, nothing is an error, just roll with it
+ * 
+ */
+export const ParseWildcards = (text: string): string => {
+
+  const result: string[] = [];
+  const length = text.length;
+
+  const escaped_chars = '[\\^$.|?*+()';
+
+  for (let i = 0; i < length; i++) {
+    let char = text[i];
+    switch (char) {
+
+      case '*':
+        result.push('.', '*');
+        break;
+
+      case '?':
+        result.push('.');
+        break;
+
+      case '~':
+        char = text[++i] || '';
+      
+      // eslint-disable-next-line no-fallthrough
+      default:
+        for (let j = 0; j < escaped_chars.length; j++) {
+          if (char === escaped_chars[j]) {
+            result.push('\\');
+            break;
+          }
+        }
+        result.push(char);
+        break;
+
+    }
+  }
+
+  return result.join('');
+
+};