@trebco/treb 27.5.3 → 27.9.0

package/treb-calculator/src/function-library.ts

@@ -1,24 +1,24 @@
-/*
- * 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-2023 trebco, llc. 
- * info@treb.app
- * 
- */
-
+/*
+ * 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-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
 import type { 
   ExtendedFunctionDescriptor, CompositeFunctionDescriptor,
   FunctionMap, ExtendedFunctionMap } from './descriptors';
@@ -80,9 +80,12 @@ export class FunctionLibrary {
   }
 
   /** get a list, for AC services */
-  public List() {
+  public List(filter_internal = true) {
     const list: ExtendedFunctionMap = {};
     for (const key of Object.keys(this.functions)) {
+      if (filter_internal && this.functions[key].visibility === 'internal') {
+        continue;
+      }
       list[key] = this.functions[key];
     }
     return list;

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

@@ -21,10 +21,10 @@
 
 import type { FunctionMap } from '../descriptors';
 import * as Utils from '../utilities';
-import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError } from '../function-error';
+import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError, NameError } from '../function-error';
 import type { UnionValue, 
          RenderFunctionResult, RenderFunctionOptions, Complex } from 'treb-base-types';
-import { Box, ValueType, GetValueType, ComplexOrReal } from 'treb-base-types';
+import { Box, ValueType, GetValueType, ComplexOrReal, IsComplex } from 'treb-base-types';
 import { Sparkline } from './sparkline';
 import { LotusDate, UnlotusDate } from 'treb-format';
 
@@ -427,7 +427,7 @@ export const BaseFunctionLibrary: FunctionMap = {
       description: 'Counts cells that contain numbers',
       fn: (...args: unknown[]): UnionValue => {
         return Box(Utils.FlattenUnboxed(args).reduce((a: number, b: unknown) => {
-          if (typeof b === 'number') return a + 1;
+          if (typeof b === 'number' || IsComplex(b)) return a + 1;
           return a;
         }, 0));
       },
@@ -456,7 +456,7 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Not: {
-      fn: (...args: unknown[]): UnionValue => {
+      fn: Utils.ApplyAsArray((...args: unknown[]): UnionValue => {
         if (args.length === 0) {
           return ArgumentError();
         }
@@ -464,7 +464,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           return Box(!args[0]);
         }
         return Box(true);
-      }
+      })
     },
 
     If: {
@@ -1126,6 +1126,167 @@ export const BaseFunctionLibrary: FunctionMap = {
       fn: (...args: unknown[]): UnionValue => {
         return { type: ValueType.object, value: args, key: 'sparkline-data' };
       },
+    },
+
+    UniqueValues: {
+      arguments: [
+        { name: 'range', boxed: true },
+      ],
+      visibility: 'internal',
+      fn: (area: UnionValue): UnionValue => {
+
+        if (area.type === ValueType.array) {
+
+          const cols = area.value.length;
+          const rows = area.value[0]?.length;
+
+          // how is uniqueness defined in this context? (...)
+
+          const Normalize = (cell?: UnionValue): string|number|boolean => {
+
+            if (!cell) {
+              return '';
+            }
+            else switch (cell.type) {
+            case ValueType.string:
+            case ValueType.number:
+            case ValueType.boolean:
+              return cell.value;
+
+            case ValueType.undefined:
+              return '';
+
+            default:
+              console.info("check", cell, cell.value)
+              return cell.value?.toString() || '';
+            }
+
+          };
+
+          const set: Set<number|string|boolean> = new Set();
+          const duplicates: Set<number|string|boolean> = new Set();
+
+          for (const column of area.value) {
+            for (const cell of column) {
+              const normalized = Normalize(cell);
+              if (set.has(normalized)) {
+                duplicates.add(normalized);
+              }
+              else {
+                set.add(normalized);
+              }
+            }
+          }
+
+          const result: UnionValue[][] = [];
+          for (const column of area.value) {
+            const column_result: UnionValue[] = [];
+            for (const cell of column) {
+              const value = Normalize(cell);
+              column_result.push({
+                type: ValueType.boolean,
+                value: !duplicates.has(value),
+              });
+            }
+            result.push(column_result);
+          }
+
+          return {
+            type: ValueType.array,
+            value: result,
+          };
+
+        }
+
+        // if it's not an array, by definition it's unique
+
+        return {
+          type: ValueType.boolean,
+          value: true,
+        }
+
+      },
+    },
+
+    Gradient: {
+      arguments: [
+        { name: 'range', boxed: true },
+        { name: 'min', },
+        { name: 'max', },
+      ],
+      visibility: 'internal',
+      fn: (area: UnionValue, static_min?: number, static_max?: number): UnionValue => {
+
+        const tmp = Utils.FlattenBoxed([area]);
+
+        let sum = 0;
+        let count = 0;
+        let min = 0; 
+        let max = 0;
+
+        for (const ref of tmp as UnionValue[]) {
+          if (ref.type === ValueType.error) {
+            return ref;
+          }
+          if (ref.type === ValueType.number) {
+            if (count === 0) {
+              min = ref.value;
+              max = ref.value;
+            }
+            else {
+              min = Math.min(min, ref.value);
+              max = Math.max(max, ref.value);
+            }
+            count++;
+          }
+        }
+
+        if (typeof static_max === 'number') {
+          max = static_max;
+        }
+        if (typeof static_min === 'number') {
+          min = static_min;
+        }
+
+        let range = max - min;
+
+        let rows = 1;
+        let columns = 1;
+
+        if (area.type === ValueType.array) {
+
+          rows = area.value.length;
+          columns = area.value[0]?.length || 0;
+
+          const result: UnionValue[][] = [];
+          for (let r = 0; r < rows; r++) {
+            const row: UnionValue[] = [];
+            for (let c = 0; c < columns; c++) {
+              const src = area.value[r][c];
+              if (src.type === ValueType.number) {
+                let calc = 0;
+                if (range > 0) {
+                  calc = (src.value - min) / range;
+                }
+                row.push({ type: ValueType.number, value: calc });
+              }
+              else {
+                row.push({ type: ValueType.undefined });
+              }
+
+            }
+            result.push(row);
+          }
+  
+          return { type: ValueType.array, value: result };
+  
+
+        }
+        else {
+          return ArgumentError();
+        }
+  
+      },
     }
 
 };

package/treb-calculator/src/index.ts

@@ -19,9 +19,9 @@
  * 
  */
 
-export * from './calculator';
-// export * from './pack-results';
-
-// for annotations that have dependencies
-
-export {LeafVertex} from './dag/leaf_vertex';
+export * from './calculator';
+// export * from './pack-results';
+
+// for annotations that have dependencies
+
+export type { LeafVertex } from './dag/graph';

package/treb-calculator/src/notifier-types.ts

@@ -19,7 +19,7 @@
  * 
  */
 
-import type { LeafVertex } from './dag/leaf_vertex';
+import type { LeafVertex } from './dag/graph';
 import type { Area } from 'treb-base-types';
 
 export interface NotifierType {

package/treb-calculator/src/utilities.ts

@@ -180,10 +180,10 @@ export const UndefinedToEmptyString = (args: any[]): any[] => {
 export const ApplyArrayFunc = (base: (...args: any[]) => any) => {
   return (a: any) => {
     if (Array.isArray(a)) {
-      const tmp = [];
+      const tmp: any[] = [];
       const rows = a[0].length;
       for (let c = 0; c < a.length; c++) {
-        const col = [];
+        const col: any[] = [];
         for (let r = 0; r < rows; r++) col[r] = base(a[c][r]);
         tmp.push(col);
       }

package/treb-charts/src/util.ts

@@ -38,7 +38,7 @@ export class Util {
    * given a passed range, find the best scale range. count is just a
    * suggestion -- we try to get as close as possible.
    */
-  public static Scale(min: number, max: number, count = 6.5): RangeScale {
+  public static Scale(min: number, max: number, count = 6.5, limit_count?: boolean, discrete?: boolean): RangeScale {
 
     /*
     const range = max - min;
@@ -71,7 +71,7 @@ export class Util {
 
     return { scale, step, count, min, max };
     */
-    return Scale(min, max, count);
+    return Scale(min, max, count, limit_count, discrete);
     
   }