exprify 1.0.0 → 1.0.1

package/src/core/Exprify.js

@@ -1,70 +1,140 @@
-import { tokenize } from "../parser/tokenizer.js";
-import { infixToPostfix } from "../parser/infixToPostfix.js";
-import { evaluatePostfix } from "../parser/evaluator.js";
-
-import { mathOperations } from "../math/operations.js";
-
-import { internalFunctions } from "../functions/internalFunctions.js";
-import { externalFunctions } from "../functions/externalFunctions.js";
-
-import { variablesDB } from "../variables/variables.js";
-
-import { stringToJS } from "../utils/typeConverter.js";
-
-class ViewPoint {
-
-    constructor() {
-        // Shared state
-        this.variablesDB = variablesDB;
-        this.func_DB_intrnl = internalFunctions;
-        this.func_DB_extrnl = externalFunctions;
-
-        this.operator_precedence = mathOperations.operator_precedence;
-    }
-
-    setVariable(name, value) {
-        this.variablesDB[name] = value;
-    }
-
-    addFunction(name, fn) {
-        this.func_DB_extrnl[name] = fn;
-    }
-
-    stringToJS(str) {
-        return stringToJS.call(this, str, this.variablesDB);
-    }
-
-    evaluate(expr) {
-
-        if (typeof expr !== "string") {
-            throw new Error("Expression must be a string");
-        }
-
-        const context = {
-            variablesDB: this.variablesDB,
-            func_DB_intrnl: this.func_DB_intrnl,
-            func_DB_extrnl: this.func_DB_extrnl,
-            stringToJS: this.stringToJS.bind(this),
-            evaluate: this.evaluate.bind(this)
-        };
-
-        // Step 1: Tokenize
-        const tokens = tokenize(expr, context);
-
-        // Step 2: Infix → Postfix
-        const postfix = infixToPostfix(
-            tokens,
-            this.operator_precedence
-        );
-
-        // Step 3: Evaluate Postfix
-        const result = evaluatePostfix(
-            postfix,
-            mathOperations
-        );
-
-        return result;
-    }
-}
-
-export default ViewPoint;
+import { tokenize } from "../parser/tokenizer.js";
+// import { infixToPostfix } from "../parser/infixToPostfix.js";
+import { evaluateAST } from "../parser/evaluator.js";
+import { createContext } from "./context.js";
+import { mathOperations } from "../math/operations.js";
+
+import { createUnitsStore } from "../utils/store.js";
+import { globalUnits } from "../utils/globalUnits.js";
+
+import { createVarStore } from "../variables/store.js";
+import { createFunctionRegistry } from "../function/registry.js";
+import { internalFunctions } from "../function/internal.js";
+
+import { buildAST } from "../parser/astBuild.js";
+
+
+//
+
+const isComplex = (value) =>
+    value && typeof value === "object" && "re" in value && "im" in value;
+
+const isUnitValue = (value) =>
+    value && typeof value === "object" && "value" in value && "unit" in value;
+
+const isMatrix = (value) =>
+    Array.isArray(value) && value.length > 0 && value.every(Array.isArray);
+
+const formatComplex = (value) => {
+    if (!isComplex(value)) return value;
+
+    const real = value.re;
+    const imaginary = Math.abs(value.im);
+    const sign = value.im < 0 ? "-" : "+";
+
+    if (real === 0) {
+        if (value.im === 1) return "i";
+        if (value.im === -1) return "-i";
+        return `${value.im}i`;
+    }
+
+    const imagPart = imaginary === 1 ? "i" : `${imaginary}i`;
+    return `${real} ${sign} ${imagPart}`;
+};
+
+const formatResult = (value) => {
+    if (isComplex(value)) {
+        return formatComplex(value);
+    }
+
+    if (isUnitValue(value)) {
+        return `${value.value} ${value.unit}`;
+    }
+
+    if (isMatrix(value)) {
+        return value.map((row) => row.join("\t")).join("\n");
+    }
+
+    if (Array.isArray(value)) {
+        return value.join("\n");
+    }
+
+    return value;
+};
+
+class exprify {
+    constructor() {
+        // Shared state
+        this.math = mathOperations;
+        this.units = createUnitsStore(globalUnits);
+        this.functions = createFunctionRegistry(internalFunctions);
+        this.variables = createVarStore();
+        this._cache = new Map();
+    }
+
+    setVariable(name, value) {
+        this.variables.set(name, value);
+    }
+
+    getVariable(name) {
+        return this.variables.get(name);
+    }
+
+    addFunction(name, fn) {
+        this.functions.register(name, fn);
+    }
+
+    _createContext() {
+        return createContext({
+            functions: this.functions,
+            variables: this.variables,
+            units: this.units,
+            evaluate: this.evaluate.bind(this)
+        });
+    }
+
+    tokenize(expr) {
+        if (typeof expr !== "string") {
+            throw new Error("Expression must be a string");
+        }
+        return tokenize(expr, this._createContext());
+    }
+
+    parse(expr) {
+        const tokens = this.tokenize(expr);
+        const ast = buildAST(tokens);
+        return { tokens, ast };
+    }
+
+    evaluate(expr) {
+        const { ast } = this.parse(expr);
+        return formatResult(evaluateAST(
+            ast,
+            this._createContext()
+        ));
+    }
+
+    compile(expr) {
+        if (this._cache.has(expr)) {
+            return this._cache.get(expr);
+        }
+
+        const { ast } = this.parse(expr);
+
+        const compiledFn = (scope = {}) => {
+            const baseContext = this._createContext();
+            const scopedContext = baseContext.withScope(scope);
+            return formatResult(evaluateAST(ast, scopedContext));
+        };
+
+        this._cache.set(expr, compiledFn);
+        return compiledFn;
+    }
+
+    clearCache() {
+        this._cache.clear();
+    }
+
+}
+
+export default exprify;

package/src/core/context.js

@@ -0,0 +1,30 @@
+export function createContext({ variables, functions, units, evaluate}) {
+    if (!variables) throw new Error("Variable store missing");
+    if (!functions) throw new Error("Function registry missing");
+    if (!units) throw new Error("Units list missing");
+    if (!evaluate) throw new Error("evaluate function missing");
+
+    return {
+        variables: variables,
+        functions: functions,
+        units: units,
+        evaluate,
+        withScope(scope = {}) {
+            const tempVars = {
+                ...variables.all?.(),
+                ...scope
+            };
+            return createContext({
+                functions: functions,
+                evaluate,
+                units,
+                variables: {
+                    get: (k) => tempVars[k],
+                    set: (k, v) => (tempVars[k] = v),
+                    all: () => tempVars
+                }
+            });
+
+        }
+    };
+}

package/src/function/executor.js

@@ -0,0 +1,64 @@
+export function createFunctionExecutor(fnRegistry, options = {}) {
+  if (!fnRegistry) {
+    throw new Error("Function registry is required");
+  }
+
+  const config = {
+    strict: options.strict ?? true
+  };
+
+  /* ================= EXECUTE ================= */
+
+  function execute(name, args = [], context) {
+    const fn = fnRegistry.get(name);
+
+    /* ----- NOT FOUND ----- */
+    if (!fn) {
+      if (config.strict) {
+        throw new Error(`Unknown function: ${name}`);
+      }
+      return undefined;
+    }
+
+    /* ----- VALIDATE ARGS ----- */
+    if (!Array.isArray(args)) {
+      throw new Error(`Arguments for "${name}" must be an array`);
+    }
+
+    /* ----- EXECUTE ----- */
+    try {
+      return fn(...args);
+    } catch (err) {
+      throw new Error(
+        `Error in function "${name}": ${err.message}`
+      );
+    }
+  }
+
+  /* ================= SAFE EXECUTE ================= */
+
+  function safeExecute(name, args = [], context) {
+    try {
+      return execute(name, args, context);
+    } catch (err) {
+      return {
+        error: true,
+        message: err.message
+      };
+    }
+  }
+
+  /* ================= EXISTS ================= */
+
+  function exists(name) {
+    return fnRegistry.has(name);
+  }
+
+  /* ================= API ================= */
+
+  return {
+    execute,
+    safeExecute,
+    exists
+  };
+}

package/src/function/internal.js

@@ -0,0 +1,270 @@
+function validateSquareMatrix(matrix) {
+  if (!Array.isArray(matrix) || matrix.length === 0) {
+    throw new Error("det() expects a non-empty matrix");
+  }
+
+  if (!matrix.every(Array.isArray)) {
+    throw new Error("det() expects a 2D matrix");
+  }
+
+  const size = matrix.length;
+  if (!matrix.every((row) => row.length === size)) {
+    throw new Error("det() expects a square matrix");
+  }
+
+  for (const row of matrix) {
+    for (const value of row) {
+      if (typeof value !== "number" && typeof value !== "bigint") {
+        throw new Error("det() matrix values must be numeric");
+      }
+    }
+  }
+}
+
+function determinant(matrix) {
+  validateSquareMatrix(matrix);
+
+  if (matrix.length === 1) {
+    return matrix[0][0];
+  }
+
+  if (matrix.length === 2) {
+    return (matrix[0][0] * matrix[1][1]) - (matrix[0][1] * matrix[1][0]);
+  }
+
+  return matrix[0].reduce((sum, value, columnIndex) => {
+    const minor = matrix.slice(1).map((row) =>
+      row.filter((_, index) => index !== columnIndex)
+    );
+    const cofactor = columnIndex % 2 === 0 ? value : -value;
+    return sum + (cofactor * determinant(minor));
+  }, 0);
+}
+
+function splitTerms(expression) {
+  const normalized = expression.replace(/\s+/g, "");
+  if (!normalized) {
+    return [];
+  }
+
+  return normalized
+    .replace(/-/g, "+-")
+    .split("+")
+    .filter(Boolean);
+}
+
+function parsePolynomial(expression, variable) {
+  const terms = splitTerms(expression);
+  const coefficients = new Map();
+
+  for (const term of terms) {
+    if (term.includes(variable)) {
+      const [rawCoeff, rawPower] = term.split(variable);
+      let coefficient;
+
+      if (rawCoeff === "" || rawCoeff === "+") coefficient = 1;
+      else if (rawCoeff === "-") coefficient = -1;
+      else {
+        const cleaned = rawCoeff.endsWith("*") ? rawCoeff.slice(0, -1) : rawCoeff;
+        coefficient = Number(cleaned);
+      }
+
+      if (!Number.isFinite(coefficient)) {
+        throw new Error("Unsupported algebra term");
+      }
+
+      let power = 1;
+      if (rawPower) {
+        if (!rawPower.startsWith("^")) {
+          throw new Error("Unsupported algebra term");
+        }
+
+        power = Number(rawPower.slice(1));
+      }
+
+      if (!Number.isInteger(power) || power < 0) {
+        throw new Error("Only non-negative integer powers are supported");
+      }
+
+      coefficients.set(power, (coefficients.get(power) || 0) + coefficient);
+    } else {
+      const constant = Number(term);
+      if (!Number.isFinite(constant)) {
+        throw new Error("Unsupported algebra term");
+      }
+      coefficients.set(0, (coefficients.get(0) || 0) + constant);
+    }
+  }
+
+  return coefficients;
+}
+
+function formatPolynomial(coefficients, variable) {
+  const ordered = [...coefficients.entries()]
+    .filter(([, coefficient]) => coefficient !== 0)
+    .sort((a, b) => b[0] - a[0]);
+
+  if (!ordered.length) {
+    return "0";
+  }
+
+  return ordered.map(([power, coefficient], index) => {
+    const negative = coefficient < 0;
+    const absCoeff = Math.abs(coefficient);
+    let body;
+
+    if (power === 0) {
+      body = `${absCoeff}`;
+    } else if (power === 1) {
+      body = absCoeff === 1 ? variable : `${absCoeff} * ${variable}`;
+    } else {
+      body = absCoeff === 1
+        ? `${variable}^${power}`
+        : `${absCoeff} * ${variable}^${power}`;
+    }
+
+    if (index === 0) {
+      return negative ? `-${body}` : body;
+    }
+
+    return negative ? `- ${body}` : `+ ${body}`;
+  }).join(" ");
+}
+
+function simplifyExpression(expression) {
+  const compact = expression.replace(/\s+/g, "");
+  const variableMatch = compact.match(/[a-zA-Z]+/);
+  const variable = variableMatch?.[0] || "x";
+  const coefficients = parsePolynomial(expression, variable);
+  return formatPolynomial(coefficients, variable);
+}
+
+function derivativeExpression(expression, variable) {
+  const coefficients = parsePolynomial(expression, variable);
+  const derived = new Map();
+
+  for (const [power, coefficient] of coefficients.entries()) {
+    if (power === 0) continue;
+    derived.set(power - 1, (derived.get(power - 1) || 0) + (coefficient * power));
+  }
+
+  return formatPolynomial(derived, variable);
+}
+
+export const internalFunctions = {
+  max: (...args) => {
+    if (!args.length) throw new Error("max() requires arguments");
+    return Math.max(...args);
+  },
+
+  min: (...args) => {
+    if (!args.length) throw new Error("min() requires arguments");
+    return Math.min(...args);
+  },
+
+  abs: (x) => Math.abs(x),
+
+  round: (x) => Math.round(x),
+
+  floor: (x) => Math.floor(x),
+
+  ceil: (x) => Math.ceil(x),
+
+  sqrt: (x) => {
+    if (x < 0) throw new Error("sqrt() domain error");
+    return Math.sqrt(x);
+  },
+
+  pow: (a, b) => a ** b,
+  det: (matrix) => determinant(matrix),
+  simplify: (expression) => {
+    if (typeof expression !== "string") {
+      throw new Error("simplify() expects an expression string");
+    }
+    return simplifyExpression(expression);
+  },
+  derivative: (expression, variable = "x") => {
+    if (typeof expression !== "string" || typeof variable !== "string") {
+      throw new Error("derivative() expects expression and variable strings");
+    }
+    return derivativeExpression(expression, variable);
+  },
+
+  /* ================= TRIGONOMETRY ================= */
+
+  sin: (x) => Math.sin(x),
+  cos: (x) => Math.cos(x),
+  tan: (x) => Math.tan(x),
+
+  asin: (x) => Math.asin(x),
+  acos: (x) => Math.acos(x),
+  atan: (x) => Math.atan(x),
+
+  /* ================= LOG / EXP ================= */
+
+  log: (x) => {
+    if (x <= 0) throw new Error("log() domain error");
+    return Math.log(x);
+  },
+
+  log10: (x) => {
+    if (x <= 0) throw new Error("log10() domain error");
+    return Math.log10(x);
+  },
+
+  exp: (x) => Math.exp(x),
+
+  /* ================= RANDOM ================= */
+
+  random: () => Math.random(),
+
+  /* ================= BOOLEAN / LOGIC ================= */
+
+  and: (a, b) => Boolean(a && b),
+
+  or: (a, b) => Boolean(a || b),
+
+  not: (a) => !a,
+  "!": (a) => !a,
+
+  /* ================= COMPARISON ================= */
+
+  eq: (a, b) => a === b,
+
+  neq: (a, b) => a !== b,
+  "notEqual": (a, b) => a !== b,
+
+  gt: (a, b) => a > b,
+  "greaterThan": (a, b) => a > b,
+
+  lt: (a, b) => a < b,
+  "lessThan": (a, b) => a < b,
+
+  gte: (a, b) => a >= b,
+  "greaterThanOrEqual": (a, b) => a >= b,
+
+  lte: (a, b) => a <= b,
+  "lessThanOrEqual": (a, b) => a <= b,
+
+  /* ================= UTILITY ================= */
+
+  clamp: (x, min, max) => {
+    if (min > max) throw new Error("clamp(): min > max");
+    return Math.min(Math.max(x, min), max);
+  },
+
+  if: (condition, a, b) => (condition ? a : b),
+
+  /* ================= TYPE ================= */
+
+  typeof: (x) => typeof x,
+
+  /* ================= STRING ================= */
+
+  length: (x) => {
+    if (typeof x === "string" || Array.isArray(x)) {
+      return x.length;
+    }
+    throw new Error("length() expects string or array");
+  }
+};

package/src/function/registry.js

@@ -0,0 +1,68 @@
+export function createFunctionRegistry(initial = {}) {
+  const store = Object.create(null);
+
+  for (const key in initial) {
+    if (typeof initial[key] === "function") {
+      store[key] = initial[key];
+    }
+  }
+
+  return {
+    getAllFunctionsName() {
+      return Object.keys(store);
+    },
+    // register new formula
+    register(name, fn) {
+      if (typeof name !== "string" || !name) {
+        throw new Error("Formula name must be a non-empty string");
+      }
+
+      if (typeof fn !== "function") {
+        throw new Error(`Formula "${name}" must be callable`);
+      }
+
+      store[name] = fn;
+    },
+
+    // get formula
+    get(name) {
+      return store[name];
+    },
+
+    // check existence
+    has(name) {
+      return Object.prototype.hasOwnProperty.call(store, name);
+    },
+
+    // remove formula
+    remove(name) {
+      delete store[name];
+    },
+
+    // list all
+    all() {
+      return { ...store };
+    },
+
+    // clear registry
+    clear() {
+      for (const key in store) {
+        delete store[key];
+      }
+    },
+
+    // extend multiple
+    extend(formulas = {}) {
+      for (const name in formulas) {
+        if (typeof formulas[name] === "function") {
+          store[name] = formulas[name];
+        }
+      }
+    },
+
+    // clone (for scoped instances)
+    clone() {
+      return createFormulaRegistry(store);
+    }
+  };
+}

package/src/index.js

@@ -1,38 +1,2 @@
-/**
- * Exprify — Math Expression Parser & Evaluator
- *
- * A lightweight JavaScript library for parsing and evaluating mathematical expressions
- * with runtime data-type checking.
- *
- * Author: Nirmal Paul (N Paul)
- * GitHub: https://github.com/nirmalpaul383
- *
- * License: GNU General Public License v3.0 (GPLv3)
- *
- * Note:
- * This project is licensed under GPLv3. While not legally required,
- * attribution is highly appreciated. If you use, modify, or distribute
- * this project, please give credit to the original author.
- *
- * This library has been carefully designed with clean, structured, and
- * maintainable code. Acknowledgment of the original work is encouraged.
- *
- * Resources:
- * GitHub Repository: https://github.com/nirmalpaul383/ViewPoint
- * YouTube Channel:   https://www.youtube.com/channel/UCY6JY8bTlR7hZEvhy6Pldxg/
- * Facebook Page:    https://www.facebook.com/a.New.Way.Technical/
- */
-
-import Exprify from "./core/Exprify.js";
-import { mathOperations } from "./math/operations.js";
-import { internalFunctions } from "./functions/internalFunctions.js";
-import { externalFunctions } from "./functions/externalFunctions.js";
-import { variablesDB } from "./variables/variables.js";
-
-export {
-  Exprify,
-  mathOperations,
-  internalFunctions,
-  externalFunctions,
-  variablesDB
-};
+import Exprify from "./core/Exprify.js";
+export default Exprify;