Refactor unit conversion and matrix utility functions; add extensive linear algebra tests

- Updated globalUnits.js to improve structure and comments for length and radiation units.
- Enhanced matrix.js with JSDoc annotations for better type checking and clarity.
- Refined store.js and variables/store.js with improved documentation and type annotations.
- Removed outdated notepad.html file to streamline project structure.
- Introduced a new lint configuration file for consistent code formatting and linting.
- Added comprehensive tests for linear algebra operations including matrix arithmetic, vector operations, and advanced decompositions.

Author: hemanta-gayen

.husky/pre-commit

@@ -1 +1 @@
-npx lint-staged
+npx lint-staged --config lint.config.js

.npmignore

@@ -1,16 +1,23 @@
 .github/
+.husky/
+
 docs/
-node_modules/
 test/
+node_modules/
 
-.gitattributes
 .gitignore
+.npmignore
+.prettierrc
+.gitattributes
+.prettierignore
+.editorconfig
+
 CHANGELOG.md
+
+tsconfig.json
 package-lock.json
-rollup.config.js
 
-.prettierrc
-.prettierignore
+lint.config.js
+rollup.config.js
 eslint.config.js
-tsconfig.json
-.husky/
+

README.md

@@ -1,8 +1,6 @@
-# Exprify
-
 [![Exprify Social Banner](https://raw.githubusercontent.com/code-hemu/Exprify/refs/heads/main/docs/assets/capture.jpg)](https://github.com/code-hemu/Exprify)
 
-Exprify is a JavaScript expression parser and evaluator for math-heavy apps. It supports arithmetic, variables, custom functions, unit conversion, matrices, complex numbers, symbolic helpers, and a growing set of linear algebra utilities.
+Exprify is a JavaScript expression parser and evaluator. It is made for math applications, scientific computing, and complex workflows in the browser and Node.js. It supports basic arithmetic, variables, and defined functions. Exprify also covers advanced mathematical areas like unit conversion, matrix operations, complex number arithmetic, and symbolic manipulation.
 
 [![Version](https://img.shields.io/npm/v/exprify)](https://www.npmjs.com/package/exprify)
 [![Downloads](https://img.shields.io/npm/dt/exprify)](https://www.npmjs.com/package/exprify)
@@ -18,6 +16,17 @@ Exprify is a JavaScript expression parser and evaluator for math-heavy apps. It
 [![Github Sponsor](https://img.shields.io/github/sponsors/code-hemu)](https://github.com/sponsors/code-hemu)
 
 
+## Features
+
+- Math expression parsing and evaluation
+- Variables, functions, and lambdas
+- Unit conversion support
+- Matrix and linear algebra operations
+- Complex numbers
+- Symbolic math utilities
+- Calculus and statistics tools
+
+
 ## Installation
 
 ```bash
@@ -196,9 +205,142 @@ expr.evaluate("a to inch");
 // "4 inch"
 ```
 
+### Constants
+
+```js
+expr.evaluate("PHI");
+// 1.6180...
+
+expr.evaluate("TAU");
+// 6.2832...
+
+expr.evaluate("INFINITY > 1e308");
+// true
+
+expr.evaluate("isNaN(NaN)");
+// true
+```
+
+### Range Operator
+
+```js
+expr.evaluate("1:5");
+// [1,2,3,4,5]
+
+expr.evaluate("r = 3:7");
+// [3,4,5,6,7]
+
+expr.evaluate("sum(1:10)");
+// 55
+```
+
+### Lambda Expressions
+
+```js
+expr.evaluate("sq = x -> x^2");
+// function
+
+expr.evaluate('map([1, 2, 3], x -> x^2)');
+// [1,4,9]
+```
+
+### Compound Assignment
+
+```js
+expr.evaluate("a = 10");
+expr.evaluate("a += 5");
+// 15
+
+expr.evaluate("a *= 2");
+// 30
+```
+
+### Spread Operator
+
+```js
+expr.evaluate("max(...[1, 5, 3])");
+// 5
+
+expr.evaluate("max(10, ...[1, 5, 3], 7)");
+// 10
+```
+
+### String Utilities
+
+```js
+expr.evaluate('split("a,b,c", ",")');
+// ["a","b","c"]
+
+expr.evaluate('join(["a", "b", "c"], ", ")');
+// "a, b, c"
+
+expr.evaluate('upper("hello")');
+// "HELLO"
+
+expr.evaluate('lower("HELLO")');
+// "hello"
+
+expr.evaluate('trim("  hi  ")');
+// "hi"
+
+expr.evaluate('replace("hello world", "world", "there")');
+// "hello there"
+
+expr.evaluate('substring("hello", 1, 4)');
+// "ell"
+```
+
+### Array Utilities
+
+```js
+expr.evaluate('map([1, 4, 9], "sqrt")');
+// [1,2,3]
+
+expr.evaluate('filter([1, 2, 3, 4, 5], "isPrime")');
+// [2,3,5]
+```
+
+### Calculus
+
+```js
+expr.evaluate('integral("x^2", 0, 1)');
+// 0.333... (Simpson's rule)
+
+expr.evaluate('sigma("n", 1, 10, "n")');
+// 55
+
+expr.evaluate('sigma("n", 1, 5, "n^2")');
+// 55
+
+expr.evaluate('pi("n", 1, 5, "n")');
+// 120
+
+expr.evaluate('substitute("x + 1", "x", 5)');
+// 6
+
+expr.evaluate('limit("1/x", "x", 1000000, "right")');
+// ~0
+```
+
+### Symbolic Helpers
+
+```js
+expr.evaluate('expand("(x+1)^2")');
+// "x^2 + 2x + 1"
+
+expr.evaluate('factor("x^2 - 5x + 6")');
+// "(x - 2)(x - 3)"
+
+expr.evaluate('solve("x^2 - 4 = 0")');
+// [-2,2]
+
+expr.evaluate('solve("2x - 8 = 0")');
+// [4]
+```
+
 ### Matrices
 
-Exprify supports matrix literals with `;` as row separators.
+Exprify supports matrix literals with `;` as row separators, and matrix arithmetic (addition, subtraction, multiplication, scalar multiplication, integer power).
 
 ```js
 expr.evaluate("a = [1, 2, 3; 4, 5, 6]");
@@ -215,6 +357,18 @@ expr.evaluate("a[3, 1:3] = [7, 8, 9]");
 
 expr.evaluate("det([-1, 2; 3, 1])");
 // -7
+
+expr.evaluate("[[1, 2], [3, 4]] + [[5, 6], [7, 8]]");
+// "6\t8\n10\t12"
+
+expr.evaluate("[[1, 2], [3, 4]] * [[5, 6], [7, 8]]");
+// "19\t22\n43\t50"
+
+expr.evaluate("3 * [[1, 2], [3, 4]]");
+// "3\t6\n9\t12"
+
+expr.evaluate("[[1, 1], [1, 0]] ^ 3");
+// "3\t2\n2\t1"
 ```
 
 ### Linear Algebra Helpers
@@ -315,6 +469,25 @@ expr.evaluate('leafCount(parse("{a: 22/7, b: 10^(1/2)}"))');
 | `lyap` | Solve Lyapunov equation | `lyap([[-2,0];[1,-4]], [[3,1];[1,3]])` | matrix JSON |
 | `qr` | QR decomposition | `qr([[1,-1,4];[1,4,-2];[1,4,2];[1,-1,0]])` | matrix JSON |
 | `polynomialRoot` | Find polynomial roots | `polynomialRoot(-6, 11, -6, 1)` | `[1,3,2]` |
+| `transpose` | Matrix transpose | `transpose([[1,2];[3,4]])` | matrix JSON |
+| `inverse` | Matrix inverse | `inverse([[1,2];[3,4]])` | matrix JSON |
+| `trace` | Sum of diagonal elements | `trace([[1,2];[3,4]])` | `5` |
+| `rank` | Matrix rank | `rank([[1,2];[3,4]])` | `2` |
+| `rref` | Reduced row echelon form | `rref([[1,2,3];[4,5,6]])` | matrix JSON |
+| `minor` | Matrix minor (submatrix det) | `minor([[1,2];[3,4]], 0, 0)` | `4` |
+| `cofactor` | Matrix cofactor | `cofactor([[1,2];[3,4]], 0, 1)` | `-3` |
+| `cross` | 3D cross product | `cross([1,0,0], [0,1,0])` | `[0,0,1]` |
+| `normalize` | Unit vector | `normalize([3,4])` | `[0.6,0.8]` |
+| `angle` | Angle between vectors | `angle([1,0], [0,1])` | `1.5708` |
+| `projection` | Scalar projection | `projection([3,4], [1,0])` | `3` |
+| `identity` | Identity matrix (n×n) | `identity(3)` | matrix JSON |
+| `eye` | Identity matrix alias | `eye(2)` | matrix JSON |
+| `zeros` | Zero matrix (n×m) | `zeros(2, 3)` | matrix JSON |
+| `ones` | Ones matrix (n×m) | `ones(2, 2)` | matrix JSON |
+| `diag` | Diagonal matrix from array | `diag([1,2,3])` | matrix JSON |
+| `cholesky` | Cholesky decomposition | `cholesky([[4,2];[2,3]])` | matrix JSON |
+| `eig` | Eigenvalues & vectors (2×2) | `eig([[1,2];[2,1]])` | JSON |
+| `svd` | SVD (2×2) | `svd([[1,0];[0,2]])` | JSON |
 | `simplify` | Simplify polynomial | `simplify("x^2 + 2x^2")` | `3 * x^2` |
 | `derivative` | Differentiate polynomial | `derivative("x^3")` | `3 * x^2` |
 | `rationalize` | Rationalize expression | `rationalize("1/x + 1/(x+1)")` | `(2x + 1)/(x^2 + x)` |
@@ -324,6 +497,23 @@ expr.evaluate('leafCount(parse("{a: 22/7, b: 10^(1/2)}"))');
 | `random` | Random number (0, 1) | `random()` | e.g. `0.374` |
 | `leafCount` | Count expression leaves | `leafCount("e^(i*pi)-1")` | `4` |
 | `parse` | Return expression string | `parse("a + b")` | `"a + b"` |
+| `split` | Split string by separator | `split("a,b,c", ",")` | `["a","b","c"]` |
+| `join` | Join array with separator | `join(["a","b"], ",")` | `"a,b"` |
+| `upper` | Uppercase string | `upper("hi")` | `"HI"` |
+| `lower` | Lowercase string | `lower("HI")` | `"hi"` |
+| `trim` | Trim whitespace | `trim(" hi ")` | `"hi"` |
+| `replace` | Replace substring | `replace("hi","i","o")` | `"ho"` |
+| `substring` | Extract substring | `substring("hello",1,4)` | `"ell"` |
+| `map` | Apply function to array | `map([1,4,9],"sqrt")` | `[1,2,3]` |
+| `filter` | Filter array by predicate | `filter([1,2,3,4,5],"isPrime")` | `[2,3,5]` |
+| `integral` | Numeric integral (Simpson) | `integral("x^2",0,1)` | `~0.333` |
+| `sigma` | Summation notation | `sigma("n",1,10,"n")` | `55` |
+| `pi` | Product notation | `pi("n",1,5,"n")` | `120` |
+| `limit` | Numeric limit | `limit("1/x","x",1e6,"right")` | `~0` |
+| `substitute` | Replace variable with value | `substitute("x+1","x",5)` | `6` |
+| `expand` | Expand polynomial expression | `expand("(x+1)^2")` | `"x^2 + 2x + 1"` |
+| `factor` | Factor polynomial | `factor("x^2-5x+6")` | `"(x-2)(x-3)"` |
+| `solve` | Solve polynomial equation | `solve("x^2-4=0")` | `[-2,2]` |
 
 ## Return Types
 
@@ -335,6 +525,8 @@ Depending on the expression, `evaluate()` may return:
 - formatted complex strings like `"3 + 2i"`
 - matrix wrapper JSON strings such as `{"exprify":"DenseMatrix",...}`
 - JSON strings for structured helper outputs like `lup()` or `rationalize(..., true)`
+- native JavaScript functions for lambda expressions (`evaluate("x -> x^2")` returns a `function`)
+- arrays for range expressions like `[1,2,3,4,5]`
 
 ## Manual Build