verbena-complex 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import { Complex } from 'complex.js';
+import { Library } from 'verbena/lib';
+import { vbFunction } from 'verbena/function';
+/**
+ * Library for complex functions.
+ *
+ * Includes complex operations and functions, as well as constants for i, pi and e.
+ */
+export declare const complexLib: Library<Complex>;
+export declare function ComplexFunction(source: string): vbFunction<Complex>;

package/lib/index.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexFunction = exports.complexLib = void 0;
+const complex_js_1 = require("complex.js");
+const lib_1 = require("verbena/lib");
+const lexer_1 = require("verbena/lexer");
+const parser_1 = require("verbena/parser");
+const compileFn_1 = require("verbena/compileFn");
+const token_1 = require("verbena/token");
+/**
+ * Library for complex functions.
+ *
+ * Includes complex operations and functions, as well as constants for i, pi and e.
+ */
+exports.complexLib = {
+    operations: {
+        add: forceComplex((l, r) => l.add(r)),
+        sub: forceComplex((l, r) => l.sub(r)),
+        mul: forceComplex((l, r) => l.mul(r)),
+        div: forceComplex((l, r) => l.div(r)),
+        pow: forceComplex((l, r) => l.pow(r)),
+        neg: forceComplex((z) => z.mul(-1)),
+        mod: forceReal((x, y) => x % y),
+        fac: forceReal(lib_1.standard.functions.fac)
+    },
+    functions: {
+        re: forceComplex((z) => (0, complex_js_1.Complex)(z.re)),
+        im: forceComplex((z) => (0, complex_js_1.Complex)(0, z.im)),
+        abs: forceComplex((z) => (0, complex_js_1.Complex)(z.abs())),
+        acos: forceComplex((z) => z.acos()),
+        acosh: forceComplex((z) => z.acosh()),
+        asin: forceComplex((z) => z.asin()),
+        asinh: forceComplex((z) => z.asinh()),
+        atan: forceComplex((z) => z.atan()),
+        atanh: forceComplex((z) => z.atanh()),
+        cbrt: forceComplex((z) => z.pow(1 / 3)),
+        ceil: forceComplex((z) => z.ceil(0)),
+        cos: forceComplex((z) => z.cos()),
+        cosh: forceComplex((z) => z.cosh()),
+        exp: forceComplex((z) => z.exp()),
+        floor: forceComplex((z) => z.floor(0)),
+        hypot: forceComplex((...zs) => zs.reduce((acc, z) => acc.add(z.pow(2)), (0, complex_js_1.Complex)(0)).sqrt()),
+        log_: forceComplex((z, b = (0, complex_js_1.Complex)(10)) => z.log().div(b.log())),
+        ln: forceComplex((z) => z.log()),
+        max: forceReal(Math.max),
+        min: forceReal(Math.min),
+        pow: forceComplex((z, p) => z.pow(p)),
+        random: () => (0, complex_js_1.Complex)(Math.random()),
+        round: forceComplex((z) => z.round(0)),
+        sign: forceComplex((z) => z.sign()),
+        sin: forceComplex((z) => z.sin()),
+        sinh: forceComplex((z) => z.sinh()),
+        sqrt: forceComplex((z) => z.sqrt()),
+        tan: forceComplex((z) => z.tan()),
+        tanh: forceComplex((z) => z.tanh())
+    },
+    constants: {
+        i: complex_js_1.Complex.I,
+        pi: complex_js_1.Complex.PI,
+        e: complex_js_1.Complex.E,
+    }
+};
+function ComplexFunction(source) {
+    let tokens = (0, lexer_1.scan)(source, exports.complexLib).map(token => {
+        // Little hack to allow implicit of identifiers with i, like ix
+        if (token.type == token_1.TokenType.IDENTIFIER && token.lexeme == 'i') {
+            token.type = token_1.TokenType.CONSTANT;
+        }
+        return token;
+    });
+    let decl = (0, parser_1.parse)(tokens);
+    // Remove function clauses
+    decl.clauses = [];
+    // Compile the function as a real function using the complex library
+    let compiledFn = (0, compileFn_1.compileFn)(decl, exports.complexLib);
+    // Force conversion of function arguments and result to a complex number
+    let complexFn = forceComplex((...args) => (0, complex_js_1.Complex)(compiledFn(...args)));
+    // Copy over the real function's properties to the complex one
+    Object.defineProperties(complexFn, {
+        name: {
+            value: compiledFn.name,
+            writable: false,
+            enumerable: false
+        },
+        ast: {
+            value: compiledFn.ast,
+            writable: false,
+            enumerable: false
+        },
+        paramList: {
+            value: compiledFn.paramList,
+            writable: false,
+            enumerable: false
+        },
+        body: {
+            value: compiledFn.body,
+            writable: false,
+            enumerable: false
+        }
+    });
+    return complexFn;
+}
+exports.ComplexFunction = ComplexFunction;
+/**
+ * Utility function to wrap a complex function, converting all its arguments to a Complex value.
+ *
+ * @param f Complex function
+ * @returns `f` with all its parameters converted to Complex
+ */
+function forceComplex(f) {
+    return (...args) => f(...args.map(z => (0, complex_js_1.Complex)(z)));
+}
+/**
+ * Utility function to wrap a real function, forcing all its arguments to be real numbers.
+ *
+ * @param f Real function
+ * @returns `f`, but will throw an error on any complex arguments
+ */
+function forceReal(f) {
+    return (...args) => {
+        let realArgs = args.map(z => {
+            z = (0, complex_js_1.Complex)(z);
+            if (z.im != 0) {
+                throw Error("complex " + f.name + "is unsupported");
+            }
+            return z.re;
+        });
+        return (0, complex_js_1.Complex)(f(...realArgs));
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "verbena-complex",
+  "version": "0.1.0",
+  "description": "verbena + complex numbers",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "files": [
+    "lib",
+    "README.md"
+  ],
+  "author": "Alfio (https://github.com/p2js)",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/p2js/verbena-complex.git"
+  },
+  "keywords": [
+    "math",
+    "complex",
+    "complex.js",
+    "complex-numbers",
+    "functions",
+    "expressions",
+    "mathjs",
+    "math.js"
+  ],
+  "packageManager": "pnpm@9.14.2+sha512.6e2baf77d06b9362294152c851c4f278ede37ab1eba3a55fda317a4a17b209f4dbb973fb250a77abc463a341fcb1f17f17cfa24091c4eb319cda0d9b84278387",
+  "dependencies": {
+    "complex.js": "^2.4.2",
+    "verbena": "^0.4.0"
+  }
+}

package/readme.md

@@ -0,0 +1,23 @@
+# verbena-complex
+
+This package acts as a complex number extension to the [verbena](https://github.com/p2js/verbena) math function transcompiler to JS.
+
+It uses verbena's standard lexer, parser and compiler, all completely unmodified. The magic happens with the library: All operations are redefined to convert all numbers to complex.js `Complex` numbers, and `i` is treated as a simple constant.
+
+Some additional logic is implemented after lexing and parsing to allow for additional robustness and ergonomics:
+- any identifier `i` will be converted to the constant `i` to allow implicit multiplications of variables by i, such as `ix`.
+- due to the lack of logical operator overloading in verbena, as well as the lack of a natural order on the complex numbers, function clauses are unimplemented and will be removed before compilation.
+
+## Usage
+
+```
+npm install verbena-complex
+```
+
+```js
+import { ComplexFunction } from 'verbena-complex';
+
+const f = ComplexFunction("f(x) = re(x * (3+2i))");
+
+console.log(f(2)); // { re: 6, im: 0 }
+```