@trebco/treb 23.6.2 → 25.0.0-rc1

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

@@ -0,0 +1,164 @@
+/*
+ * 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 { RenderFunctionOptions, ClickFunctionOptions, ClickFunctionResult, Style, RenderFunctionResult } from 'treb-base-types';
+
+export const ClickCheckbox = (options: ClickFunctionOptions): ClickFunctionResult => {
+  const { x, y, width, height, cell } = options;
+  const result: ClickFunctionResult = {};
+
+  const offset = 3;
+  const scaled = Math.round(16 * (options.scale || 1));
+
+  // console.info('options', options);
+
+  if (cell && width && height && x && y) {
+
+    const box = {
+      x: offset,
+      y: height - offset - scaled,
+    }
+  
+    if (cell.style) {
+      switch (cell.style.vertical_align) {
+        case Style.VerticalAlign.Top:
+          box.y = offset;
+          break;
+  
+        case Style.VerticalAlign.Middle:
+          box.y = Math.round((height - scaled) / 2);
+          break;
+    
+      }
+  
+      switch (cell.style.horizontal_align) {
+        case Style.HorizontalAlign.Right:
+          box.x = Math.round(width - offset - scaled);
+          break;
+  
+        case Style.HorizontalAlign.Center:
+          box.x = Math.round((width - scaled) / 2);
+          break;
+  
+      }    
+    }
+
+    if (x >= box.x && x <= box.x + scaled && y >= box.y && y <= box.y + scaled) {
+      result.value = `=Checkbox(${cell.calculated ? 'FALSE' : 'TRUE'})`;
+      result.block_selection = true;
+    }
+  }
+
+  return result;
+};
+
+export const RenderCheckbox = (options: RenderFunctionOptions): RenderFunctionResult => {
+
+  const {context, width, height, cell} = options;
+  const scale = options.scale || 1;
+
+  context.lineJoin = 'round';
+  context.lineCap = 'round';
+
+  const offset = 3 * scale;
+  const scaled = 16 * scale;
+
+  let x = offset; 
+  let y = height - offset - scaled; 
+
+  if (cell.style) {
+    switch (cell.style.vertical_align) {
+      case Style.VerticalAlign.Top:
+        y = offset;
+        break;
+
+      case Style.VerticalAlign.Middle:
+        y = // Math.round
+          ((height - scaled) / 2);
+        break;
+  
+    }
+
+    switch (cell.style.horizontal_align) {
+      case Style.HorizontalAlign.Right:
+        x = // Math.round
+          (width - offset - scaled);
+        break;
+
+      case Style.HorizontalAlign.Center:
+        x = // Math.round
+          ((width - scaled) / 2);
+        break;
+
+    }    
+  }
+
+  x = Math.floor(x) + .5;
+  y = Math.floor(y) + .5;
+
+  const x2 = Math.floor(x + scaled) + .5;
+  const y2 = Math.floor(y + scaled) + .5;
+
+  if (cell && cell.calculated) {
+    context.lineWidth = .5;
+    context.fillStyle = context.strokeStyle;
+    context.beginPath();
+
+    context.moveTo(x, y);
+    context.lineTo(x + 16 * scale, y);
+    context.lineTo(x + 16 * scale, y + 16 * scale);
+    context.lineTo(x, y + 16 * scale);
+    context.closePath();
+
+    context.moveTo(x + 15 * scale, y + 4 * scale);
+    for (const point of [
+        [13.59, 2.58],
+        [6, 10.17],
+        [2.41, 6.59],
+        [1, 8],
+        [6, 13],
+      ]) {
+      context.lineTo(x + point[0] * scale, y + point[1] * scale);
+    }
+    context.closePath();
+    context.fill();
+
+  }
+  else {
+
+    context.lineWidth = 1;
+    context.lineJoin = 'round';
+
+    context.beginPath();
+    context.moveTo(x, y);
+    context.lineTo(x2, y);
+    context.lineTo(x2, y2);
+    context.lineTo(x, y2);
+    context.closePath();
+    context.stroke();
+
+    // context.lineWidth = Math.max(2, 2 * scale);
+    // context.strokeRect(x, y, 16 * scale, 16 * scale);
+  }
+
+  return { handled: true }; // painted
+
+};

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

@@ -0,0 +1,253 @@
+/*
+ * 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 { FunctionMap } from '../descriptors';
+import { IsComplex, NumberUnion, UnionValue, ValueType } from 'treb-base-types';
+import * as Utils from '../utilities';
+import { ValueError } from '../function-error';
+import { RectangularToPolar } from '../complex-math';
+
+export const ComplexFunctionLibrary: FunctionMap = {
+
+  IsComplex: {
+    description: 'Returns true if the reference is a complex number',
+    arguments: [{
+      name: 'Reference',
+      metadata: true, /* OK with array metadata */
+    }],
+    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+      return { 
+        type: ValueType.boolean, 
+        value: ref?.value && IsComplex(ref.value.value),
+      };
+    }),
+  },
+
+
+  Real: {
+    description: 'Returns the real part of a complex number',
+    arguments: [
+      { boxed: true },
+    ],
+    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+      if (ref.type === ValueType.number) {
+        return { ...ref };
+      }
+      if (ref.type === ValueType.complex) {
+        return {
+          type: ValueType.number,
+          value: ref.value.real || 0,
+        };
+      }
+      if (ref.type === ValueType.undefined || (ref.type === ValueType.string && ref.value === '')) {
+        return {
+          type: ValueType.number,
+          value: 0,
+        };
+      }
+      return ValueError();
+    }),
+  },
+
+  Imaginary: {
+    description: 'Returns the imaginary part of a complex number (as real)',
+    arguments: [
+      { boxed: true },
+    ],
+    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+      if (ref.type === ValueType.complex) {
+        return {
+          type: ValueType.number,
+          value: ref.value.imaginary || 0,
+        };
+      }
+      if (ref.type === ValueType.number ||
+          ref.type === ValueType.undefined || 
+          (ref.type === ValueType.string && ref.value === '')) {
+        return {
+          type: ValueType.number,
+          value: 0,
+        };
+      }
+      return ValueError();
+    }),
+  },
+
+  Conjugate: {
+    description: 'Returns the conjugate of a complex number',
+    arguments: [
+      { boxed: true },
+    ],
+    fn: Utils.ApplyAsArray((arg: UnionValue): UnionValue => {
+      if (arg.type === ValueType.complex) {
+        return {
+          type: ValueType.complex,
+          value: {
+            real: arg.value.real,
+            imaginary: -arg.value.imaginary,
+          },
+        };
+      }
+      else if (arg.type === ValueType.number || arg.type === ValueType.undefined || !arg.value) {
+        return {
+          type: ValueType.number, value: arg.value || 0,
+        };
+      }
+      else {
+        return ValueError();
+      }
+    }),
+  },
+
+  Arg: {
+    description: 'Returns the principal argument of a complex number (in radians)',
+    arguments: [
+      { boxed: true },
+    ],
+    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+      
+      if (ref.type === ValueType.complex) {
+        return {
+          type: ValueType.number,
+          value: Math.atan2(ref.value.imaginary, ref.value.real),
+        }
+      }
+
+      if (ref.type === ValueType.number ||
+          ref.type === ValueType.undefined || 
+          (ref.type === ValueType.string && ref.value === '')) {
+        return {
+          type: ValueType.number,
+          value: Math.atan2(0, (ref as NumberUnion).value || 0), // this is clumsy now because typing has _improved_
+        }
+      }
+
+      return ValueError();
+    }),
+  },
+
+  Rectangular: {
+    description: 'Converts a complex number in polar form to rectangular form',
+    arguments: [
+      { name: 'r' },
+      { name: 'θ in radians' },
+    ],
+    fn: (r = 0, theta = 0): UnionValue => {
+      return {
+        type: ValueType.complex,
+        value: { 
+          real: r * Math.cos(theta),
+          imaginary: r * Math.sin(theta),
+        },
+      }
+    },
+  },
+
+  Complex: {
+    description: 'Ensures that the given value will be treated as a complex number',
+    arguments: [
+      { boxed: true },
+    ],
+
+    // FIXME: this should use flatten? not sure
+
+    fn: Utils.ApplyAsArray((a: UnionValue): UnionValue => {
+      
+      if (a.type === ValueType.complex) {
+        return a;
+      }
+      
+      if (a.type === ValueType.number || a.type === ValueType.undefined || !a.value) {
+        return { 
+          type: ValueType.complex, 
+          value: {
+            imaginary: 0,
+            real: a.value || 0,
+          },
+        }
+      }
+
+      return ValueError();
+
+    }),
+  },
+
+  /**
+   * unfortunately we can't override the log function because the complex
+   * log function has a different meaning even when applied to reals, i.e.
+   * Log(a + 0i) !== ln(a)
+   * 
+   * note that Log(0) is undefined -- we need to return an error here, but
+   * what error? let's do #VALUE
+   * 
+   */
+  ComplexLog: {
+    description: 'Returns the principal value Log(z) of a complex number z',
+    arguments: [
+      { boxed: true },
+    ],
+    fn: Utils.ApplyAsArray((a: UnionValue): UnionValue => {
+
+      // real -> complex
+      if (a.type === ValueType.number) {
+
+        if (!a.value) {
+          return ValueError();
+        }
+
+        a = {
+          type: ValueType.complex,
+          value: {
+            real: a.value,
+            imaginary: 0,
+          },
+        };
+      }
+
+      // other zero -> complex
+      else if (a.type === ValueType.undefined || (a.type === ValueType.string && a.value === '')) {
+        return ValueError();
+      }
+
+      if (a.type === ValueType.complex) {
+
+        // from polar form, the principal value is 
+        // Log z = ln r + iθ
+
+        const polar = RectangularToPolar(a.value);
+        const value = {
+          real: Math.log(polar.r),
+          imaginary: polar.theta,
+        };
+
+        return (value.imaginary) ?
+          { type: ValueType.complex, value } :
+          { type: ValueType.number, value: value.real };
+
+      }
+      
+      return ValueError();
+
+    }),
+  },
+
+};
+