verbena-complex 0.1.0 → 0.2.0

package/lib/index.d.ts

@@ -1,10 +1,4 @@
 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 * from './lib';
 export declare function ComplexFunction(source: string): vbFunction<Complex>;

package/lib/index.js

@@ -1,130 +1,52 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 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");
+exports.ComplexFunction = ComplexFunction;
+const function_1 = require("verbena/function");
 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,
-    }
-};
+const lib_1 = require("./lib");
+__exportStar(require("./lib"), exports);
 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 (0, function_1.Function)(source, {
+        lib: lib_1.complexLib,
+        scanner: (source, lib) => (0, lexer_1.scan)(source, lib).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;
+        }),
+        compiler: (decl, lib) => {
+            // Error if clauses
+            if (decl.clauses.length > 0) {
+                throw Error("Function clauses are not allowed in complex functions");
+            }
+            // Compile the function as a real function using the complex library
+            let compiledFn = (0, compileFn_1.compileFn)(decl, lib);
+            // Force conversion of function arguments and result to a complex number
+            let complexFn = (0, lib_1.forceComplex)((...args) => compiledFn(...args));
+            // Copy over the real function's properties to the complex one
+            Object.defineProperties(complexFn, Object.fromEntries(Reflect.ownKeys(compiledFn).map(prop => [prop, {
+                    value: compiledFn[prop],
+                    writable: false,
+                    enumerable: false
+                }])));
+            return complexFn;
         }
     });
-    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/lib/lib.d.ts

@@ -0,0 +1,22 @@
+import { Complex } from 'complex.js';
+import { Library } from 'verbena/lib';
+/**
+ * Library for complex functions.
+ *
+ * Includes complex operations and functions, as well as constants for i, pi and e.
+ */
+export declare const complexLib: Library<Complex>;
+/**
+ * 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
+ */
+export declare function forceComplex(f: (...args: Complex[]) => Complex | number): (...args: Complex[]) => Complex;
+/**
+ * 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
+ */
+export declare function forceReal(f: (...args: number[]) => number): (...args: Complex[]) => Complex;

package/lib/lib.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.complexLib = void 0;
+exports.forceComplex = forceComplex;
+exports.forceReal = forceReal;
+const complex_js_1 = require("complex.js");
+const lib_1 = require("verbena/lib");
+/**
+ * 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) => z.re),
+        im: forceComplex((z) => z.im),
+        abs: forceComplex((z) => 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,
+    }
+};
+/**
+ * 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) => (0, complex_js_1.Complex)(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

@@ -1,13 +1,9 @@
 {
   "name": "verbena-complex",
-  "version": "0.1.0",
+  "version": "0.2.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"
@@ -28,9 +24,12 @@
     "mathjs",
     "math.js"
   ],
-  "packageManager": "pnpm@9.14.2+sha512.6e2baf77d06b9362294152c851c4f278ede37ab1eba3a55fda317a4a17b209f4dbb973fb250a77abc463a341fcb1f17f17cfa24091c4eb319cda0d9b84278387",
   "dependencies": {
     "complex.js": "^2.4.2",
     "verbena": "^0.4.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
   }
 }

package/readme.md

@@ -1,23 +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 }
+# 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 adding them to a function definition will cause an error.
+
+## 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 }
 ```