{"_id":"@auriel/sympjs","_rev":"5-9d244f90965d275f6f0e4794243dc4e1","name":"@auriel/sympjs","dist-tags":{"latest":"0.0.5"},"versions":{"0.0.1":{"name":"@auriel/sympjs","version":"0.0.1","keywords":["Typescript","Mathematics"],"author":{"name":"Debaditya Malakar"},"license":"MIT","_id":"@auriel/sympjs@0.0.1","maintainers":[{"name":"auriel","email":"debadityamalakar@aol.com"}],"homepage":"https://github.com/uriel-flame-of-god/SympJS#readme","bugs":{"url":"https://github.com/uriel-flame-of-god/SympJS/issues"},"dist":{"shasum":"f63b2cb7c23067335303bc43db4964794755a73f","tarball":"https://registry.npmjs.org/@auriel/sympjs/-/sympjs-0.0.1.tgz","fileCount":9,"integrity":"sha512-rgLn605vHzwsywaz6RhhwEb/8mJdM/dFILLTew8eUnU/JnPPF19BgEB+RdPcV5K9H46bPNbiJa1CeMzc0VGdQQ==","signatures":[{"sig":"MEUCIGbkx4xQYISzgP4dZjzkx/tsExSD8zP2vpqarHBbBF1YAiEAvNvbcHfvPBe6t7xsklI98BFFwOYtWlECEv0IBMb1hK4=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":38811},"main":"src/index.ts","type":"module","scripts":{"dev":"vite","build":"tsc && vite build","preview":"vite preview"},"_npmUser":{"name":"auriel","email":"debadityamalakar@aol.com"},"repository":{"url":"git+https://github.com/uriel-flame-of-god/SympJS.git","type":"git"},"_npmVersion":"10.9.3","description":"A TypeScript library for symbolic mathematics inspired by SymPy, providing symbolic computation, automatic differentiation, and beautiful mathematical rendering.","directories":{},"_nodeVersion":"22.20.0","_hasShrinkwrap":false,"devDependencies":{"vite":"^7.2.4","typescript":"~5.9.3"},"_npmOperationalInternal":{"tmp":"tmp/sympjs_0.0.1_1763810180098_0.5930264373389664","host":"s3://npm-registry-packages-npm-production"}},"0.0.3":{"name":"@auriel/sympjs","version":"0.0.3","keywords":["Typescript","Mathematics"],"author":{"name":"Debaditya Malakar"},"license":"MIT","_id":"@auriel/sympjs@0.0.3","maintainers":[{"name":"auriel","email":"debadityamalakar@aol.com"}],"homepage":"https://github.com/uriel-flame-of-god/SympJS#readme","bugs":{"url":"https://github.com/uriel-flame-of-god/SympJS/issues"},"dist":{"shasum":"286ff2edf1871a98e227dc46e0ea0fd55db13b2f","tarball":"https://registry.npmjs.org/@auriel/sympjs/-/sympjs-0.0.3.tgz","fileCount":10,"integrity":"sha512-6NfvRTiJBqksprdizUXpH7OXa55lw+D+VEp+U3mS0lEDOjPGuvnjHxkD/002LL1EBy+XyHBcAc5NjMqVvXb4OQ==","signatures":[{"sig":"MEUCIDAZk5lDavJixZBrVUvaHOWRHSXieEOsjr2imUzIZlxyAiEAhdwT1+Fe7sGWOrQSL5O7/Qf77Bef196dKIy9sbmPBKM=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":68756},"main":"src/index.ts","type":"module","scripts":{"dev":"vite","build":"tsc && vite build","preview":"vite preview"},"_npmUser":{"name":"auriel","email":"debadityamalakar@aol.com"},"repository":{"url":"git+https://github.com/uriel-flame-of-god/SympJS.git","type":"git"},"_npmVersion":"10.9.3","description":"A TypeScript library for symbolic mathematics inspired by SymPy, providing symbolic computation, automatic differentiation, and beautiful mathematical rendering.","directories":{},"_nodeVersion":"22.20.0","_hasShrinkwrap":false,"devDependencies":{"vite":"^7.2.4","typescript":"~5.9.3"},"_npmOperationalInternal":{"tmp":"tmp/sympjs_0.0.3_1764161076761_0.210994027711634","host":"s3://npm-registry-packages-npm-production"}},"0.0.5":{"name":"@auriel/sympjs","version":"0.0.5","type":"module","scripts":{"dev":"vite","build":"tsc && vite build","preview":"vite preview"},"devDependencies":{"typescript":"~5.9.3","vite":"^7.2.4"},"description":"A TypeScript library for symbolic mathematics inspired by SymPy, providing symbolic computation, automatic differentiation, and beautiful mathematical rendering.","main":"src/index.ts","repository":{"type":"git","url":"git+https://github.com/uriel-flame-of-god/SympJS.git"},"keywords":["Typescript","Mathematics"],"author":{"name":"Debaditya Malakar"},"license":"MIT","bugs":{"url":"https://github.com/uriel-flame-of-god/SympJS/issues"},"homepage":"https://github.com/uriel-flame-of-god/SympJS#readme","_id":"@auriel/sympjs@0.0.5","_nodeVersion":"25.2.0","_npmVersion":"11.6.2","dist":{"integrity":"sha512-LqupSCou52RUboaY9oia++p/ynhBsRb1vszSiIrQPmRUIgpc8Fz2SSox+aBxxJErAFudAfSjbuMNBjsB2Wf/Zg==","shasum":"d54bd9977f7b3811811bfabb05194b6dce6af5ff","tarball":"https://registry.npmjs.org/@auriel/sympjs/-/sympjs-0.0.5.tgz","fileCount":14,"unpackedSize":131339,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEYCIQCuzO087CDeXY8PpzIQW2d/yb6Rr4BUD8zgCz8L8EYYXAIhANSqKbCSzVJsjaEAdIhqTFWuEskvScBN0LZelapZtpG/"}]},"_npmUser":{"name":"auriel","email":"debadityamalakar@aol.com"},"directories":{},"maintainers":[{"name":"auriel","email":"debadityamalakar@aol.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/sympjs_0.0.5_1766660824229_0.8540273680379553"},"_hasShrinkwrap":false}},"time":{"created":"2025-11-22T11:16:19.967Z","modified":"2025-12-25T11:07:04.593Z","0.0.1":"2025-11-22T11:16:20.289Z","0.0.2":"2025-11-25T08:01:47.224Z","0.0.3":"2025-11-26T12:44:36.968Z","0.0.5":"2025-12-25T11:07:04.387Z"},"bugs":{"url":"https://github.com/uriel-flame-of-god/SympJS/issues"},"author":{"name":"Debaditya Malakar"},"license":"MIT","homepage":"https://github.com/uriel-flame-of-god/SympJS#readme","keywords":["Typescript","Mathematics"],"repository":{"type":"git","url":"git+https://github.com/uriel-flame-of-god/SympJS.git"},"description":"A TypeScript library for symbolic mathematics inspired by SymPy, providing symbolic computation, automatic differentiation, and beautiful mathematical rendering.","maintainers":[{"name":"auriel","email":"debadityamalakar@aol.com"}],"readme":"# @auriel/sympjs - Symbolic Mathematics in TypeScript\n\n[![npm version](https://img.shields.io/npm/v/@auriel/sympjs.svg)](https://www.npmjs.com/package/@auriel/sympjs)\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n\nA comprehensive TypeScript library for symbolic mathematics inspired by SymPy, providing symbolic computation, automatic differentiation, algebraic simplification, equation solving, Fourier series, trigonometric functions, integration, and beautiful mathematical rendering.\n\n## 🚀 Features\n\n### Core Symbolic Math\n- **Symbolic Variables**: Create and manipulate mathematical symbols naturally\n- **Operator Overloading**: Intuitive mathematical syntax with `+`, `-`, `*`, `/`, `^` operators\n- **Automatic Differentiation**: Symbolic derivatives using calculus rules (power rule, product rule, quotient rule, chain rule)\n- **Expression Trees**: Build and manipulate complex mathematical expressions with method chaining\n\n### Advanced Algebra\n- **Algebraic Simplification**: Automatically simplifies expressions using mathematical rules\n  - Eliminates zero multiplication: `y*0 → 0`\n  - Removes identity operations: `x + 0 → x`, `1 * x → x`\n  - Simplifies powers: `x^0 → 1`, `x^1 → x`\n  - Combines like terms: `x + x → 2x`\n  - Simplifies constants: `2 + 3 → 5`\n\n- **Equation Solving**:\n  - Linear equations: `ax + b = 0`\n  - Quadratic equations: `ax² + bx + c = 0` (using quadratic formula)\n  - Symbolic coefficient extraction\n\n- **Linear Algebra & Matrices**:\n  - MxN matrix support (not limited to square matrices)\n  - Scalar multiplication & matrix operations\n  - Matrix multiplication: `(MxN) × (NxP) = (MxP)`\n  - Matrix-vector multiplication\n  - Transpose, Determinant, Matrix Inverse\n  - Gaussian elimination for solving linear systems\n  - LU decomposition for efficiency\n\n### Complex Numbers & Series\n- **Complex Number Support**: Full complex arithmetic with imaginary unit `i`\n  - Complex addition, subtraction, multiplication, division\n  - Magnitude and phase calculations\n  - Complex conjugation\n  - Built-in constants: `i`, `0`, `1`\n\n- **Taylor Series Expansion**: Symbolic Taylor series for functions\n  - Expand functions around any point\n  - Configurable number of terms\n  - Built-in expansions for common functions (`e^x`, `sin(x)`, `cos(x)`)\n  - Custom function expansion support\n\n- **Fourier Series Expansion**: Complete Fourier analysis capabilities\n  - Real and complex Fourier series\n  - Common waveforms: square wave, sawtooth wave, triangle wave\n  - Custom function Fourier series computation\n  - Amplitude and phase spectrum analysis\n  - Numerical integration using Simpson's rule\n  - Conversion between real and complex representations\n\n### Calculus Operations\n- **Symbolic Integration**: Basic integration capabilities\n  - Power rule integration\n  - Linearity of integration\n  - Constant multiple rule\n  - Integration by parts (basic)\n  - Definite integrals with bounds\n  - Support for integral notation\n\n- **Trigonometric Functions**: Complete trigonometric system\n  - All six trigonometric functions: `sin`, `cos`, `tan`, `cot`, `sec`, `csc`\n  - Inverse trigonometric functions: `asin`, `acos`, `atan`\n  - Symbolic differentiation of trigonometric functions\n  - Common angle simplification (30°, 45°, 60°, 90°)\n  - Trigonometric identities and simplification\n  - Chain rule support for composite trigonometric functions\n\n### Rendering & Visualization\n- **Beautiful Mathematical Typography**: Professional rendering with proper spacing and symbols\n- **Symbol Support**: Greek letters, operators (∫, ∑, ∂), relations (≤, ≥, ≠), and more\n- **Automatic HTML Integration**: Detects and renders to containers with `app-type=\"math\"`\n- **Multiple Rendering Formats**: Symbolic expressions, LaTeX, HTML, and mathematical text\n- **Responsive Design**: Works seamlessly on desktop and mobile\n\n### Developer Experience\n- **Zero Dependencies**: Lightweight and framework-agnostic\n- **Type-Safe**: Full TypeScript support with comprehensive type definitions\n- **Method Chaining**: Fluent API for building complex expressions\n- **ES6 Modules**: Modern module system ready for bundlers like Vite\n\n## 📦 Installation\n\n```bash\nnpm install @auriel/sympjs\n```\n\n## 🎯 Quick Start\n\n### Basic Usage\n\n```typescript\nimport { symbols, diff, Render } from '@auriel/sympjs';\n\n// Create symbolic variables\nconst [x, y] = symbols('x', 'y');\n\n// Build expressions naturally\nconst expr = x.pow(2).add(y.mul(3));  // x² + 3y\n\n// Compute derivatives symbolically\nconst derivative = diff(expr, x);     // 2x\n\n// Simplify expressions\nconst simplified = Simplifier.simplify(\n  y.pow(2).add(y.mul(3)).add(y.mul(0))\n);  // y² + 3y (eliminates y*0)\n\n// Render beautifully\nconst renderer = new Render();\nrenderer.renderSymbolic(expr, 'math-container');\nrenderer.renderSymbolic(derivative, 'derivative-container');\n```\n\n### HTML Integration\n\n```html\n<!DOCTYPE html>\n<html>\n<head>\n    <title>SympJS Demo</title>\n</head>\n<body>\n    <h1>Mathematical Expressions</h1>\n    \n    <!-- Auto-detected containers -->\n    <div id=\"math-container-1\" app-type=\"math\"></div>\n    <div id=\"math-container-2\" app-type=\"math\"></div>\n    \n    <!-- Custom container -->\n    <div id=\"custom-math\"></div>\n\n    <script type=\"module\">\n        import { symbols, diff, Render, Simplifier } from '@auriel/sympjs';\n        \n        const [x, y] = symbols('x', 'y');\n        const expr = x.pow(2).add(y.mul(3));\n        const derivative = diff(expr, x);\n        \n        const renderer = new Render();\n        renderer.renderSymbolic(expr, 'math-container-1');\n        renderer.renderSymbolic(derivative, 'math-container-2');\n        renderer.render('∫x² dx = x³/3 + C', 'custom-math');\n    </script>\n</body>\n</html>\n```\n\n## 📚 API Reference\n\n### Core Symbols\n\n```typescript\nimport { symbols, Constant, diff } from '@auriel/sympjs';\n\n// Create variables\nconst [x, y, z] = symbols('x', 'y', 'z');\n\n// Arithmetic operations\nconst expr1 = x.add(y);              // x + y\nconst expr2 = x.mul(y);              // x * y  \nconst expr3 = x.pow(2);              // x²\nconst expr4 = x.div(y);              // x / y\nconst expr5 = x.sub(y);              // x - y\n\n// Method chaining\nconst complex = x.pow(3)\n  .add(y.mul(2))\n  .sub(x.div(2));                    // x³ + 2y - x/2\n\n// Constants\nconst five = new Constant(5);\nconst expr6 = x.mul(5);              // 5x\n```\n\n### Differentiation\n\n```typescript\nimport { diff } from '@auriel/sympjs';\n\nconst [x, y] = symbols('x', 'y');\n\n// Function style\nconst d1 = diff(expr, x);            // Derivative with respect to x\n\n// Method style\nconst d2 = expr.diff(x);             // Same result\n\n// Higher-order derivatives\nconst d2dx2 = diff(diff(expr, x), x); // Second derivative\n\n// Examples\ndiff(x.pow(3), x);                   // 3x²\ndiff(x.mul(y), x);                   // y (product rule)\ndiff(x.div(y), x);                   // 1/y (quotient rule)\n```\n\n### Integration\n\n```typescript\nimport { int, symbols, Constant } from '@auriel/sympjs';\n\nconst [x] = symbols('x');\nconst zero = new Constant(0);\nconst one = new Constant(1);\n\n// Basic integration\nint(new Constant(1), x);            // ∫1 dx = x\nint(x, x);                          // ∫x dx = (1/2)x²\nint(x.pow(2), x);                   // ∫x² dx = (1/3)x³\n\n// Definite integrals\nint(x.pow(2), x, zero, one);        // ∫[0,1] x² dx\n\n// Linearity of integration\nconst linearExpr = x.add(x.pow(2));\nint(linearExpr, x);                 // ∫(x + x²) dx = (1/2)x² + (1/3)x³\n\n// Constant multiple rule\nconst constMultipleExpr = new Constant(3).mul(x.pow(2));\nint(constMultipleExpr, x);          // ∫3x² dx = x³\n```\n\n### Trigonometric Functions\n\n```typescript\nimport { sin, cos, tan, cot, sec, csc, asin, acos, atan, simplifyTrig, pi, symbols } from '@auriel/sympjs';\n\nconst [x] = symbols('x');\n\n// Basic trigonometric functions\nconst sinExpr = sin(x);\nconst cosExpr = cos(x);\nconst tanExpr = tan(x);\nconst cotExpr = cot(x);\nconst secExpr = sec(x);\nconst cscExpr = csc(x);\n\n// Inverse trigonometric functions\nconst asinExpr = asin(x);\nconst acosExpr = acos(x);\nconst atanExpr = atan(x);\n\n// Common angle simplification\nconst sin30 = simplifyTrig(sin(pi().div(6)));    // sin(π/6) → 1/2\nconst cos45 = simplifyTrig(cos(pi().div(4)));    // cos(π/4) → √2/2\nconst tan60 = simplifyTrig(tan(pi().div(3)));    // tan(π/3) → √3\n\n// Trigonometric identities\nconst pythagorean = sin(x).pow(2).add(cos(x).pow(2));\nconst simplified = simplifyTrig(pythagorean);    // sin²(x) + cos²(x) → 1\n\n// Derivatives of trig functions\nsinExpr.diff(x);     // cos(x)\ncosExpr.diff(x);     // -sin(x)\ntanExpr.diff(x);     // sec²(x)\nasinExpr.diff(x);    // 1/√(1 - x²)\n\n// Chain rule examples\nsin(x.mul(2)).diff(x);      // 2cos(2x)\ncos(x.pow(2)).diff(x);      // -2x sin(x²)\n```\n\n### Fourier Series\n\n```typescript\nimport { FourierSeries, FourierUtils } from '@auriel/sympjs';\n\n// Common waveforms\nconst squareWave = FourierUtils.squareWave(1, 2 * Math.PI);\nconst sawtoothWave = FourierUtils.sawtoothWave(1, 2 * Math.PI);\nconst triangleWave = FourierUtils.triangleWave(1, 2 * Math.PI);\n\n// Evaluate waveforms\nsquareWave.evaluate(0);           // Value at x=0\nsquareWave.evaluate(Math.PI/4);   // Value at x=π/4\n\n// Get coefficients\nconst coeffs = squareWave.getCoefficients();\nconsole.log(`a0 = ${coeffs.a0}`);\nconsole.log(`First an: ${coeffs.an.slice(0, 3)}`);\nconsole.log(`First bn: ${coeffs.bn.slice(0, 3)}`);\n\n// Create custom Fourier series\nconst customSeries = new FourierSeries(2 * Math.PI);\nconst customFunc = (x: number) => Math.abs(x);  // f(x) = |x|\ncustomSeries.computeCoefficients(customFunc, 5, 1000); // 5 harmonics\n\n// Complex Fourier series\nconst complexSeries = new FourierSeries(2 * Math.PI);\nconst complexFunc = (x: number) => new Complex(Math.cos(x), Math.sin(x)); // e^(ix)\ncomplexSeries.computeComplexCoefficients(complexFunc, 3, 500);\n\n// Get amplitude and phase spectrum\nconst amplitude = complexSeries.getAmplitudeSpectrum();\nconst phase = complexSeries.getPhaseSpectrum();\n\n// Convert real to complex coefficients\nconst complexCoeffs = squareWave.toComplexCoefficients();\nconst complexFromReal = FourierSeries.fromComplexCoefficients(complexCoeffs, 2 * Math.PI);\n```\n\n### Algebraic Simplification\n\n```typescript\nimport { Simplifier } from '@auriel/sympjs';\n\nconst [x, y] = symbols('x', 'y');\n\n// Simplify expressions\nconst expr1 = y.pow(2).add(y.mul(3)).add(y.mul(0));\nconst simplified = Simplifier.simplify(expr1);  // y² + 3y\n\n// More examples\nSimplifier.simplify(x.add(0));                  // x\nSimplifier.simplify(x.mul(1));                  // x\nSimplifier.simplify(x.pow(0));                  // 1\nSimplifier.simplify(x.mul(x));                  // x²\nSimplifier.simplify(x.add(x));                  // 2x\nSimplifier.simplify(x.div(x));                  // 1\n```\n\n### Equation Solving\n\n```typescript\nimport { EquationSolver } from '@auriel/sympjs';\n\nconst [x] = symbols('x');\n\n// Linear equations: ax + b = 0\nconst linear = x.mul(2).add(4);\nconst xLinear = EquationSolver.solveLinear(linear, x);  // -2\n\n// Quadratic equations: ax² + bx + c = 0\nconst quadratic = x.pow(2).sub(x.mul(5)).add(6);\nconst solutions = EquationSolver.solveQuadratic(quadratic, x);  // [3, 2]\n\n// Returns [solution1, solution2] or null if no real solutions\n```\n\n### Matrix Operations\n\n```typescript\nimport { Matrix } from '@auriel/sympjs';\n\n// Create matrices (MxN support)\nconst A = new Matrix([\n  [1, 2, 3],\n  [4, 5, 6]\n]);  // 2x3 matrix\n\nconst B = new Matrix([\n  [1, 2],\n  [3, 4],\n  [5, 6]\n]);  // 3x2 matrix\n\n// Basic operations\nconst C = new Matrix([[1, 2], [3, 4]]);\nconst D = new Matrix([[5, 6], [7, 8]]);\n\nC.add(D);                    // Matrix addition\nC.subtract(D);               // Matrix subtraction\nC.scalarMultiply(2);         // Scalar multiplication\n\n// Matrix multiplication (MxN) × (NxP) = (MxP)\nconst product = A.multiply(B);  // (2x3) × (3x2) = (2x2)\n\n// Vector operations\nconst vector = [1, 2, 3];\nconst result = A.multiplyVector(vector);  // Matrix-vector product\n\n// Matrix properties\nconst C_T = C.transpose();   // Transpose\nconst det = C.determinant(); // Determinant (square only)\nconst inv = C.inverse();     // Inverse (square, invertible only)\nconst [rows, cols] = C.shape(); // Get dimensions\n\n// Solve linear systems Ax = b\nconst augmented = new Matrix([\n  [2, 1, 5],      // 2x + y = 5\n  [1, 3, 4]       // x + 3y = 4\n]);\nconst solution = augmented.gaussianElimination();  // [x, y]\n```\n\n### Complex Numbers\n\n```typescript\nimport { Complex } from '@auriel/sympjs';\n\n// Create complex numbers\nconst z1 = new Complex(3, 4);        // 3 + 4i\nconst z2 = new Complex(1, -2);       // 1 - 2i\n\n// Basic arithmetic\nconst sum = z1.add(z2);              // 4 + 2i\nconst product = z1.multiply(z2);     // 11 - 2i\nconst quotient = z1.divide(z2);      // -1 + 2i\n\n// Properties and functions\nconst magnitude = z1.magnitude();    // 5.0000\nconst phase = z1.phase();            // 0.9273 radians\nconst conjugate = z1.conjugate();    // 3 - 4i\n\n// Built-in constants\nconst i = ComplexConstants.I;                 // 0 + 1i\nconst zero = ComplexConstants.ZERO;           // 0 + 0i\nconst one = ComplexConstants.ONE;             // 1 + 0i\n\n// String representation\nconsole.log(z1.toString());          // \"3 + 4i\"\n```\n\n### Taylor Series\n\n```typescript\nimport { TaylorSeries, symbols } from '@auriel/sympjs';\n\nconst [x] = symbols('x');\n\n// Taylor series for common functions\nconst expSeries = TaylorSeries.exp(x, 0, 6);     // e^x around 0, 6 terms\nconst sinSeries = TaylorSeries.sin(x, 0, 6);     // sin(x) around 0, 6 terms\nconst cosSeries = TaylorSeries.cos(x, 0, 6);     // cos(x) around 0, 6 terms\n\n// Custom function expansion\nconst customFunc = x.pow(2).add(x.mul(3)).add(1);\nconst customSeries = TaylorSeries.expand(customFunc, x, 0, 3);\n\n// Display results\nconsole.log(`e^x ≈ ${expSeries}`);\nconsole.log(`sin(x) ≈ ${sinSeries}`);\nconsole.log(`cos(x) ≈ ${cosSeries}`);\nconsole.log(`Custom function: ${customSeries}`);\n```\n\n### Rendering\n\n```typescript\nimport { Render } from '@auriel/sympjs';\n\nconst renderer = new Render();\n\n// Render symbolic expressions\nrenderer.renderSymbolic(expr, 'container-id');\n\n// Render mathematical text with symbols\nrenderer.render('∫x² dx = x³/3 + C', 'math-container');\nrenderer.render('∑_{i=1}^n i = n(n+1)/2', 'sum-container');\nrenderer.render('∂f/∂x = 2x + 3y', 'partial-container');\n\n// Get container IDs\nconst ids = renderer.getContainerIds();  // ['math-container-1', 'math-container-2', ...]\n\n// Add/remove containers dynamically\nconst newDiv = document.createElement('div');\nrenderer.addContainer(newDiv);\nrenderer.removeContainer('math-container-1');\n\n// Clear all containers\nrenderer.clearAll();\n```\n\n## 🎨 Mathematical Notation Support\n\n### Supported Symbols\n- **Greek letters**: `α, β, γ, δ, θ, π` (using HTML entities)\n- **Operators**: `∫` (integral), `∑` (summation), `∂` (partial), `∇` (nabla), `√` (root), `∞` (infinity), `±`, `×`, `÷`\n- **Relations**: `≤, ≥, ≠, ≈, ∝`\n- **Primes**: `′, ″`\n- **Complex numbers**: `i` (imaginary unit)\n\n### Beautiful Formatting\n- **Superscripts**: `x^2` → x², `x^{n+1}` → xⁿ⁺¹\n- **Subscripts**: `x_n` → xₙ, `x_{n+1}` → xₙ₊₁  \n- **Fractions**: `a/b` → ½, `\\frac{a}{b}` → ½\n- **Variables**: Automatic italic styling with color coding\n- **Parentheses**: Smart sizing with `\\left(` and `\\right)`\n- **Numbers**: Color-coded for distinction\n- **Operators**: Properly spaced and styled\n\n## 🔧 Advanced Examples\n\n### Calculus Examples\n\n```typescript\nimport { symbols, diff, int, Simplifier, Render } from '@auriel/sympjs';\n\nconst [x, y] = symbols('x', 'y');\nconst renderer = new Render();\n\n// Power rule: d/dx[x⁵] = 5x⁴\nconst powerExpr = x.pow(5);\nconst powerDeriv = diff(powerExpr, x);\nrenderer.renderSymbolic(powerDeriv, 'power-rule');\n\n// Product rule: d/dx[x(x + 1)] = 2x + 1\nconst productExpr = x.mul(x.add(1));\nconst productDeriv = diff(productExpr, x);\nrenderer.renderSymbolic(productDeriv, 'product-rule');\n\n// Quotient rule: d/dx[x/(x + 1)] = 1/(x + 1)²\nconst quotientExpr = x.div(x.add(1));\nconst quotientDeriv = diff(quotientExpr, x);\nrenderer.renderSymbolic(quotientDeriv, 'quotient-rule');\n\n// Integration examples\nconst integral1 = int(x.pow(3), x);  // (1/4)x⁴\nconst integral2 = int(sin(x), x);    // -cos(x)\nrenderer.renderSymbolic(integral1, 'integral-1');\nrenderer.renderSymbolic(integral2, 'integral-2');\n```\n\n### Fourier Series Examples\n\n```typescript\nimport { FourierSeries, FourierUtils, Render } from '@auriel/sympjs';\n\nconst renderer = new Render();\n\n// Square wave analysis\nconst squareWave = FourierUtils.squareWave(1, 2 * Math.PI);\nconsole.log(`Square wave has ${squareWave.getNumHarmonics()} harmonics`);\nconsole.log(`Period: ${squareWave.getPeriod()}`);\n\n// Evaluate at different points\nconst points = [0, Math.PI/4, Math.PI/2, Math.PI];\npoints.forEach(x => {\n    const value = squareWave.evaluate(x);\n    console.log(`f(${x.toFixed(2)}) = ${value.toFixed(4)}`);\n});\n\n// Custom function Fourier series\nconst customSeries = new FourierSeries(Math.PI);\nconst triangleFunc = (x: number) => Math.abs(x);  // Triangle wave\ncustomSeries.computeCoefficients(triangleFunc, 5, 1000);\n\n// Complex Fourier series\nconst complexSeries = new FourierSeries(2 * Math.PI);\nconst complexFunc = (x: number) => new Complex(Math.cos(x), Math.sin(x));\ncomplexSeries.computeComplexCoefficients(complexFunc, 3, 500);\n\n// Get frequency spectrum\nconst amplitudes = complexSeries.getAmplitudeSpectrum();\nconst phases = complexSeries.getPhaseSpectrum();\nconsole.log('Amplitude spectrum:', amplitudes.map(a => a.toFixed(4)));\n```\n\n### Trigonometric Examples\n\n```typescript\nimport { symbols, sin, cos, tan, simplifyTrig, pi, diff, Render } from '@auriel/sympjs';\n\nconst [x] = symbols('x');\nconst renderer = new Render();\n\n// Common angle simplification\nconst angles = {\n    'π/6': pi().div(6),\n    'π/4': pi().div(4), \n    'π/3': pi().div(3),\n    'π/2': pi().div(2)\n};\n\nObject.entries(angles).forEach(([name, angle]) => {\n    const sinVal = simplifyTrig(sin(angle));\n    const cosVal = simplifyTrig(cos(angle));\n    const tanVal = simplifyTrig(tan(angle));\n    \n    console.log(`${name}: sin = ${sinVal}, cos = ${cosVal}, tan = ${tanVal}`);\n    renderer.renderSymbolic(sinVal, `sin-${name}`);\n    renderer.renderSymbolic(cosVal, `cos-${name}`);\n    renderer.renderSymbolic(tanVal, `tan-${name}`);\n});\n\n// Trigonometric differentiation chain rule\nconst compositeFunc = sin(x.pow(2).add(1));\nconst derivative = compositeFunc.diff(x);\nconsole.log(`d/dx[sin(x² + 1)] = ${derivative}`);\nrenderer.renderSymbolic(derivative, 'trig-derivative');\n\n// Trigonometric identities\nconst identity1 = sin(x).pow(2).add(cos(x).pow(2));\nconst simplifiedId = simplifyTrig(identity1);\nconsole.log(`sin²(x) + cos²(x) = ${simplifiedId}`);\n```\n\n### Linear Algebra Examples\n\n```typescript\nimport { Matrix, EquationSolver } from '@auriel/sympjs';\n\n// 2x2 System\nconst system2x2 = new Matrix([\n  [2, 1, 5],   // 2x + y = 5\n  [1, 3, 4]    // x + 3y = 4\n]);\nconst sol2 = system2x2.gaussianElimination();\nconsole.log(`Solution: x = ${sol2[0]}, y = ${sol2[1]}`);\n\n// 3x3 System\nconst system3x3 = new Matrix([\n  [3, 2, 1, 11],    // 3x + 2y + z = 11\n  [1, 1, 1, 6],     // x + y + z = 6\n  [2, 1, -1, 3]     // 2x + y - z = 3\n]);\nconst sol3 = system3x3.gaussianElimination();\nconsole.log(`Solution: x = ${sol3[0]}, y = ${sol3[1]}, z = ${sol3[2]}`);\n\n// Matrix properties\nconst A = new Matrix([[1, 2], [3, 4]]);\nconsole.log(`Determinant: ${A.determinant()}`);     // -2\nconsole.log(`Inverse:`, A.inverse());\nconsole.log(`Transpose:`, A.transpose());\n```\n\n### Complex Number & Taylor Series Examples\n\n```typescript\nimport { Complex, TaylorSeries, symbols, Render } from '@auriel/sympjs';\n\nconst [x] = symbols('x');\nconst renderer = new Render();\n\n// Complex number operations\nconst z1 = new Complex(3, 4);\nconst z2 = new Complex(1, -2);\n\nconsole.log(`z1 = ${z1}`);\nconsole.log(`z2 = ${z2}`);\nconsole.log(`Magnitude of z1: ${z1.magnitude().toFixed(4)}`);\nconsole.log(`Phase of z1: ${z1.phase().toFixed(4)} radians`);\n\nconst zSum = z1.add(z2);\nconsole.log(`\\nz1 + z2 = ${zSum}`);\n\nconst zProduct = z1.multiply(z2);\nconsole.log(`z1 * z2 = ${zProduct}`);\n\nconst zQuotient = z1.divide(z2);\nconsole.log(`z1 / z2 = ${zQuotient}`);\n\nconst zConjugate = z1.conjugate();\nconsole.log(`Conjugate of z1: ${zConjugate}`);\n\nconsole.log(`\\nComplex constants:`);\nconsole.log(`i = ${ComplexConstants.I}`);\nconsole.log(`0 = ${ComplexConstants.ZERO}`);\nconsole.log(`1 = ${ComplexConstants.ONE}`);\n\n// Taylor series expansions\nconst expApprox = TaylorSeries.exp(x, 0, 6);\nconst sinApprox = TaylorSeries.sin(x, 0, 6);\nconst cosApprox = TaylorSeries.cos(x, 0, 6);\n\nrenderer.renderSymbolic(expApprox, 'taylor-exp');\nrenderer.renderSymbolic(sinApprox, 'taylor-sin');\nrenderer.renderSymbolic(cosApprox, 'taylor-cos');\n\nconsole.log(`\\ne^x ≈ ${expApprox}`);\nconsole.log(`sin(x) ≈ ${sinApprox}`);\nconsole.log(`cos(x) ≈ ${cosApprox}`);\n```\n\n### Educational Tool\n\n```typescript\nimport { symbols, diff, int, Simplifier, Render, TaylorSeries, FourierUtils } from '@auriel/sympjs';\n\nconst [x] = symbols('x');\nconst renderer = new Render();\n\n// Demonstrate calculus rules\nconst functions = [\n  { name: 'Power', expr: x.pow(2) },\n  { name: 'Product', expr: x.mul(x.add(1)) },\n  { name: 'Quotient', expr: x.div(x.add(1)) },\n  { name: 'Complex', expr: x.pow(3).add(x.mul(2)) }\n];\n\nfunctions.forEach((fn, i) => {\n  const derivative = Simplifier.simplify(diff(fn.expr, x));\n  const integral = int(fn.expr, x);\n  const taylor = TaylorSeries.expand(fn.expr, x, 0, 4);\n  \n  renderer.renderSymbolic(fn.expr, `func-${i}`);\n  renderer.renderSymbolic(derivative, `deriv-${i}`);\n  renderer.renderSymbolic(integral, `integral-${i}`);\n  renderer.renderSymbolic(taylor, `taylor-${i}`);\n  \n  console.log(`${fn.name}: ${fn.expr} → d/dx: ${derivative}, ∫: ${integral}`);\n});\n\n// Fourier analysis demo\nconst squareWave = FourierUtils.squareWave(1, 2 * Math.PI);\nconst triangleWave = FourierUtils.triangleWave(1, 2 * Math.PI);\nconst sawtoothWave = FourierUtils.sawtoothWave(1, 2 * Math.PI);\n\nconst waveforms = [\n  { name: 'Square Wave', wave: squareWave },\n  { name: 'Triangle Wave', wave: triangleWave },\n  { name: 'Sawtooth Wave', wave: sawtoothWave }\n];\n\nwaveforms.forEach((wf, i) => {\n  console.log(`${wf.name}:`);\n  console.log(`  Harmonics: ${wf.wave.getNumHarmonics()}`);\n  console.log(`  Period: ${wf.wave.getPeriod()}`);\n  \n  const testPoint = Math.PI / 2;\n  const value = wf.wave.evaluate(testPoint);\n  console.log(`  f(π/2) = ${value.toFixed(4)}`);\n});\n```\n\n## 🛠️ Development\n\n### Project Structure\n```\nsrc/\n├── types/\n│   ├── symbols.ts           # Core symbol classes & differentiation\n│   ├── complex.ts           # Complex number implementation\n│   └── trigonometry.ts      # Trigonometric functions and identities\n├── lib/\n│   ├── algebra.ts           # Simplification, equations, matrices\n│   ├── taylor.ts            # Taylor series expansion\n│   ├── fourier.ts           # Fourier series expansion\n│   └── render.ts            # Beautiful math renderer\n├── index.ts                 # Main exports\n└── main.ts                  # Usage examples\n```\n\n### Building from Source\n\n```bash\ngit clone https://github.com/uriel-flame-of-god/SympJS\ncd SympJS\nnpm install\nnpm run dev      # Start development server\nnpm run build    # Build for production\nnpm run test     # Run tests\n```\n\n### Directory Overview\n- `src/types/symbols.ts` - Symbolic computation engine with differentiation and integration rules\n- `src/types/complex.ts` - Complex number arithmetic and operations\n- `src/types/trigonometry.ts` - Trigonometric functions, identities, and simplification\n- `src/lib/algebra.ts` - Advanced algebra: simplification, equation solving, linear algebra\n- `src/lib/taylor.ts` - Taylor series expansion for functions\n- `src/lib/fourier.ts` - Fourier series analysis and synthesis\n- `src/lib/render.ts` - Mathematical expression rendering with beautiful typography\n- `index.html` - Demo page with math containers\n- `src/main.ts` - Comprehensive test suite demonstrating all features\n\n## ✅ Tested Features\n\n### Simplification ✓\n- Identity elimination (0, 1 operations)\n- Zero multiplication removal\n- Power simplification (x^0, x^1)\n- Like term combination\n- Constant computation\n- Complex nested expression simplification\n\n### Equation Solving ✓\n- Linear equations with correct solutions\n- Quadratic equations with quadratic formula\n- Multiple root detection\n- No real solution handling\n\n### Matrix Operations ✓\n- MxN matrix support (tested: 2x3, 3x2, 2x2, 3x3)\n- Scalar multiplication\n- Matrix addition & subtraction\n- Matrix multiplication with dimension validation\n- Matrix-vector multiplication\n- Transpose (MxN → NxM)\n- Determinant calculation (2x2, 3x3)\n- Matrix inverse with identity verification\n- Gaussian elimination for system solving (2x2, 3x3)\n\n### Complex Numbers ✓\n- Complex arithmetic (addition, subtraction, multiplication, division)\n- Magnitude and phase calculations\n- Complex conjugation\n- Built-in constants (i, 0, 1)\n- String representation\n\n### Taylor Series ✓\n- Exponential function expansion (e^x)\n- Trigonometric function expansion (sin(x), cos(x))\n- Custom function expansion\n- Configurable expansion point and number of terms\n- Symbolic polynomial generation\n\n### Fourier Series ✓\n- Real Fourier series computation\n- Complex Fourier series computation\n- Common waveform generation (square, sawtooth, triangle)\n- Numerical integration with Simpson's rule\n- Amplitude and phase spectrum analysis\n- Real-to-complex coefficient conversion\n\n### Trigonometric Functions ✓\n- All six trigonometric functions (sin, cos, tan, cot, sec, csc)\n- Inverse trigonometric functions (asin, acos, atan)\n- Common angle simplification (30°, 45°, 60°, 90°)\n- Symbolic differentiation with chain rule\n- Trigonometric identity application\n- Exact value computation for special angles\n\n### Integration ✓\n- Basic power rule integration\n- Linearity and constant multiple rules\n- Definite integrals with bounds\n- Integration by parts (basic)\n- Integral expression representation\n\n### Rendering ✓\n- Auto-container detection with `app-type=\"math\"`\n- Symbolic expression rendering\n- Mathematical symbol support\n- Responsive design\n- Dark mode support\n\n## 🎯 Roadmap\n\n- [x] Algebraic simplification engine\n- [x] Equation solving system\n- [x] Matrix operations and linear algebra\n- [x] Complex number support\n- [x] Series expansion (Taylor)\n- [x] Symbolic integration capabilities\n- [ ] LaTeX import/export\n- [ ] Limit computation\n- [x] Fourier series expansion\n- [ ] 3D mathematical plotting\n- [ ] Polynomial factorization\n- [x] Trigonometric simplification\n- [ ] Graph theory integration\n- [ ] Statistics and probability functions\n\n## 🤝 Contributing\n\nWe welcome contributions! Please feel free to:\n\n1. Fork the repository\n2. Create a feature branch (`git checkout -b feature/amazing-feature`)\n3. Commit your changes (`git commit -m 'Add amazing feature'`)\n4. Push to the branch (`git push origin feature/amazing-feature`)\n5. Open a Pull Request\n6. Report bugs or suggest features in [GitHub Issues](https://github.com/uriel-flame-of-god/SympJS/issues)\n\n## 📄 License\n\nMIT License - see [LICENSE](https://github.com/uriel-flame-of-god/SympJS/blob/main/LICENSE) file for details.\n\n## 🔗 Links\n\n- **NPM Package**: [@auriel/sympjs](https://www.npmjs.com/package/@auriel/sympjs)\n- **GitHub Repository**: [SympJS](https://github.com/uriel-flame-of-god/SympJS)\n- **Issues & Bugs**: [GitHub Issues](https://github.com/uriel-flame-of-god/SympJS/issues)\n- **Author**: [Debaditya Malakar](https://github.com/uriel-flame-of-god)\n\n## 🙏 Acknowledgments\n\nInspired by SymPy and other computer algebra systems. Mathematical rendering uses professional typography with support for STIX, Cambria Math, and Latin Modern Math fonts.\n\n---\n\n**@auriel/sympjs** - Bringing the elegance of symbolic mathematics to TypeScript! 🧮✨\n\n*Making advanced mathematics accessible and beautiful on the web.*\n","readmeFilename":"README.md"}