slangmath 1.0.0 → 1.0.3

package/package.json

@@ -1,23 +1,23 @@
-{
-  "name": "slangmath",
-  "version": "1.0.0",
-  "description": "🎯 **Advanced Symbolic Mathematics with Comprehensive LaTeX Conversion & Extended Function Support**",
-  "main": "slang-advanced.js",
-  "directories": {
-    "test": "tests"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/SENODROOM/SLaNg.git"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/SENODROOM/SLaNg/issues"
-  },
-  "homepage": "https://github.com/SENODROOM/SLaNg#readme"
-}
+{
+  "name": "slangmath",
+  "version": "1.0.3",
+  "description": "🎯 **Advanced Symbolic Mathematics with Comprehensive LaTeX Conversion & Extended Function Support**",
+  "main": "slang-math.js",
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SENODROOM/SLaNg.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/SENODROOM/SLaNg/issues"
+  },
+  "homepage": "https://github.com/SENODROOM/SLaNg#readme"
+}

package/slang-extended.js

@@ -3,7 +3,7 @@
  * Extends the converter with support for trigonometric, logarithmic, and other functions
  */
 
-import { createTerm, createFraction } from './slang-basic.js';
+import { createTerm, createFraction, multiplyTerms, differentiatePolynomial } from './slang-basic.js';
 import { slangToLatex, latexToSlang } from './slang-convertor.js';
 
 // ============================================================================
@@ -432,6 +432,423 @@ export function getFunctionLatex(name) {
     return info ? info.latex : null;
 }
 
+// ============================================================================
+// ADVANCED MATHEMATICAL FUNCTIONS
+// ============================================================================
+
+/**
+ * Calculate gradient of a multivariable function
+ * @param {Object} func - Function object
+ * @param {Array} variables - Array of variable names ['x', 'y', 'z', ...]
+ * @returns {Object} Gradient object with partial derivatives
+ */
+export function gradient(func, variables) {
+    const grad = {};
+    
+    for (const variable of variables) {
+        if (func.type === 'function') {
+            grad[variable] = differentiateFunction(func, variable);
+        } else {
+            // Handle polynomial differentiation
+            grad[variable] = differentiatePolynomial(func, variable);
+        }
+    }
+    
+    return grad;
+}
+
+/**
+ * Calculate Hessian matrix (second partial derivatives)
+ * @param {Object} func - Function object
+ * @param {Array} variables - Array of variable names
+ * @returns {Object} Hessian matrix
+ */
+export function hessian(func, variables) {
+    const hess = {};
+    
+    for (const var1 of variables) {
+        hess[var1] = {};
+        for (const var2 of variables) {
+            let firstDeriv;
+            
+            if (func.type === 'function') {
+                firstDeriv = differentiateFunction(func, var1);
+            } else {
+                firstDeriv = differentiatePolynomial(func, var1);
+            }
+            
+            // Now differentiate the first derivative with respect to var2
+            if (firstDeriv.type === 'function') {
+                hess[var1][var2] = differentiateFunction(firstDeriv, var2);
+            } else {
+                hess[var1][var2] = differentiatePolynomial(firstDeriv, var2);
+            }
+        }
+    }
+    
+    return hess;
+}
+
+/**
+ * Find tangent plane to surface z = f(x,y) at point (x0, y0)
+ * @param {Object} func - Function object representing f(x,y)
+ * @param {number} x0 - x-coordinate of point
+ * @param {number} y0 - y-coordinate of point
+ * @returns {Object} Tangent plane equation
+ */
+export function tangentPlane(func, x0, y0) {
+    // Calculate partial derivatives at (x0, y0)
+    let fx, fy;
+    
+    if (func.type === 'function') {
+        fx = differentiateFunction(func, 'x');
+        fy = differentiateFunction(func, 'y');
+    } else {
+        // Handle polynomial differentiation
+        fx = differentiatePolynomial(func, 'x');
+        fy = differentiatePolynomial(func, 'y');
+    }
+    
+    // Evaluate function and derivatives at point
+    const z0 = evaluateFunction(func, { x: x0, y: y0 });
+    const fx0 = evaluateFunction(fx, { x: x0, y: y0 });
+    const fy0 = evaluateFunction(fy, { x: x0, y: y0 });
+    
+    // Tangent plane: z = z0 + fx0*(x - x0) + fy0*(y - y0)
+    const plane = {
+        type: 'plane',
+        point: { x: x0, y: y0, z: z0 },
+        normal: { x: -fx0, y: -fy0, z: 1 },
+        equation: {
+            z: createTerm(z0),
+            x: createTerm(fx0, { x: 1 }),
+            y: createTerm(fy0, { y: 1 }),
+            constant: createTerm(-fx0 * x0 - fy0 * y0 + z0)
+        }
+    };
+    
+    return plane;
+}
+
+/**
+ * Find tangent line to curve y = f(x) at point x0
+ * @param {Object} func - Function object
+ * @param {number} x0 - x-coordinate of point
+ * @returns {Object} Tangent line equation
+ */
+export function tangentLine(func, x0) {
+    let derivative;
+    
+    if (func.type === 'function') {
+        derivative = differentiateFunction(func, 'x');
+    } else {
+        // Handle polynomial differentiation
+        derivative = differentiatePolynomial(func, 'x');
+    }
+    
+    const y0 = evaluateFunction(func, { x: x0 });
+    const slope = evaluateFunction(derivative, { x: x0 });
+    
+    // Tangent line: y = y0 + slope*(x - x0)
+    const line = {
+        type: 'line',
+        point: { x: x0, y: y0 },
+        slope: slope,
+        equation: {
+            y: createTerm(slope, { x: 1 }),
+            constant: createTerm(y0 - slope * x0)
+        }
+    };
+    
+    return line;
+}
+
+/**
+ * Find normal vector to surface at point
+ * @param {Object} func - Function object F(x,y,z) = 0
+ * @param {Object} point - Point {x, y, z}
+ * @returns {Object} Normal vector
+ */
+export function surfaceNormal(func, point) {
+    const grad = gradient(func, ['x', 'y', 'z']);
+    const normal = {
+        x: evaluateFunction(grad.x, point),
+        y: evaluateFunction(grad.y, point),
+        z: evaluateFunction(grad.z, point)
+    };
+    
+    // Normalize vector
+    const magnitude = Math.sqrt(normal.x ** 2 + normal.y ** 2 + normal.z ** 2);
+    return {
+        x: normal.x / magnitude,
+        y: normal.y / magnitude,
+        z: normal.z / magnitude
+    };
+}
+
+/**
+ * Find critical points of a multivariable function
+ * @param {Object} func - Function object
+ * @param {Array} variables - Array of variable names
+ * @returns {Array} Array of critical points
+ */
+export function findCriticalPoints(func, variables) {
+    const grad = gradient(func, variables);
+    const criticalPoints = [];
+    
+    // For simplicity, this is a basic implementation
+    // In practice, you'd solve the system of equations grad = 0
+    // This would require a numerical solver or symbolic equation solver
+    
+    if (variables.length === 1) {
+        // Single variable case: solve f'(x) = 0
+        const derivative = grad[variables[0]];
+        // This is a placeholder - actual implementation would need root finding
+        criticalPoints.push({
+            type: 'critical_point',
+            variables: { [variables[0]]: 0 }, // Placeholder
+            value: evaluateFunction(func, { [variables[0]]: 0 })
+        });
+    } else if (variables.length === 2) {
+        // Two variable case: solve fx = 0, fy = 0
+        // Placeholder implementation
+        criticalPoints.push({
+            type: 'critical_point',
+            variables: { x: 0, y: 0 }, // Placeholder
+            value: evaluateFunction(func, { x: 0, y: 0 })
+        });
+    }
+    
+    return criticalPoints;
+}
+
+/**
+ * Classify critical points using Hessian matrix
+ * @param {Object} func - Function object
+ * @param {Object} point - Critical point
+ * @returns {string} Classification: 'minimum', 'maximum', 'saddle', 'degenerate'
+ */
+export function classifyCriticalPoint(func, point) {
+    const hess = hessian(func, Object.keys(point));
+    const variables = Object.keys(point);
+    
+    if (variables.length === 1) {
+        // Single variable: use second derivative test
+        let secondDeriv;
+        
+        if (func.type === 'function') {
+            const firstDeriv = differentiateFunction(func, variables[0]);
+            secondDeriv = differentiateFunction(firstDeriv, variables[0]);
+        } else {
+            const firstDeriv = differentiatePolynomial(func, variables[0]);
+            secondDeriv = differentiatePolynomial(firstDeriv, variables[0]);
+        }
+        
+        const d2 = evaluateFunction(secondDeriv, point);
+        
+        if (d2 > 0) return 'minimum';
+        if (d2 < 0) return 'maximum';
+        return 'degenerate';
+    } else if (variables.length === 2) {
+        // Two variables: use Hessian determinant test
+        const fxx = evaluateFunction(hess[variables[0]][variables[0]], point);
+        const fyy = evaluateFunction(hess[variables[1]][variables[1]], point);
+        const fxy = evaluateFunction(hess[variables[0]][variables[1]], point);
+        
+        const D = fxx * fyy - fxy * fxy;
+        
+        if (D > 0 && fxx > 0) return 'minimum';
+        if (D > 0 && fxx < 0) return 'maximum';
+        if (D < 0) return 'saddle';
+        return 'degenerate';
+    }
+    
+    return 'unknown';
+}
+
+/**
+ * Find local maxima and minima of a function
+ * @param {Object} func - Function object
+ * @param {Array} variables - Array of variable names
+ * @param {Object} bounds - Optional bounds for search {x: [min, max], y: [min, max]}
+ * @returns {Object} Object with maxima and minima arrays
+ */
+export function findExtrema(func, variables, bounds = {}) {
+    const criticalPoints = findCriticalPoints(func, variables);
+    const maxima = [];
+    const minima = [];
+    
+    for (const point of criticalPoints) {
+        const classification = classifyCriticalPoint(func, point.variables);
+        
+        if (classification === 'maximum') {
+            maxima.push(point);
+        } else if (classification === 'minimum') {
+            minima.push(point);
+        }
+    }
+    
+    // Check boundaries if provided
+    if (Object.keys(bounds).length > 0) {
+        // This would require evaluating the function on boundary
+        // Placeholder implementation
+    }
+    
+    return {
+        maxima,
+        minima,
+        critical_points: criticalPoints
+    };
+}
+
+/**
+ * Find global maximum and minimum in a region
+ * @param {Object} func - Function object
+ * @param {Array} variables - Array of variable names
+ * @param {Object} bounds - Bounds for each variable
+ * @returns {Object} Global extrema
+ */
+export function findGlobalExtrema(func, variables, bounds) {
+    const localExtrema = findExtrema(func, variables, bounds);
+    
+    let globalMax = null;
+    let globalMin = null;
+    
+    // Check local extrema
+    for (const max of localExtrema.maxima) {
+        if (!globalMax || max.value > globalMax.value) {
+            globalMax = max;
+        }
+    }
+    
+    for (const min of localExtrema.minima) {
+        if (!globalMin || min.value < globalMin.value) {
+            globalMin = min;
+        }
+    }
+    
+    // Check boundaries (simplified)
+    // In practice, you'd need to evaluate on all boundary combinations
+    
+    return {
+        global_maximum: globalMax,
+        global_minimum: globalMin,
+        local_extrema: localExtrema
+    };
+}
+
+/**
+ * Find extrema subject to constraints using Lagrange multipliers
+ * @param {Object} func - Objective function
+ * @param {Array} constraints - Array of constraint functions
+ * @param {Array} variables - Array of variable names
+ * @returns {Array} Array of constrained extrema
+ */
+export function lagrangeMultipliers(func, constraints, variables) {
+    const constrainedExtrema = [];
+    
+    // For each constraint, create Lagrangian: L = f - λ*g
+    // Then solve ∇L = 0
+    // This is a placeholder - actual implementation would require solving systems
+    
+    for (let i = 0; i < constraints.length; i++) {
+        const constraint = constraints[i];
+        
+        // Placeholder solution
+        constrainedExtrema.push({
+            type: 'constrained_extremum',
+            constraint_index: i,
+            variables: variables.reduce((obj, v) => ({ ...obj, [v]: 0 }), {}),
+            value: evaluateFunction(func, variables.reduce((obj, v) => ({ ...obj, [v]: 0 }), {})),
+            multiplier: 0 // λ
+        });
+    }
+    
+    return constrainedExtrema;
+}
+
+/**
+ * Calculate directional derivative
+ * @param {Object} func - Function object
+ * @param {Object} point - Point of evaluation
+ * @param {Object} direction - Direction vector (not necessarily unit)
+ * @returns {number} Directional derivative
+ */
+export function directionalDerivative(func, point, direction) {
+    const variables = Object.keys(point);
+    const grad = gradient(func, variables);
+    
+    // Calculate magnitude of direction vector
+    const dirMag = Math.sqrt(Object.values(direction).reduce((sum, val) => sum + val ** 2, 0));
+    
+    // Normalize direction vector
+    const unitDir = {};
+    for (const [varName, val] of Object.entries(direction)) {
+        unitDir[varName] = val / dirMag;
+    }
+    
+    // Calculate dot product of gradient and unit direction
+    let dotProduct = 0;
+    for (const varName of variables) {
+        const gradVal = evaluateFunction(grad[varName], point);
+        dotProduct += gradVal * unitDir[varName];
+    }
+    
+    return dotProduct;
+}
+
+/**
+ * Find direction of steepest ascent/descent
+ * @param {Object} func - Function object
+ * @param {Object} point - Point of evaluation
+ * @returns {Object} Directions of steepest ascent and descent
+ */
+export function steepestDirections(func, point) {
+    const variables = Object.keys(point);
+    const grad = gradient(func, variables);
+    
+    // Gradient points in direction of steepest ascent
+    const ascent = {};
+    const descent = {};
+    
+    for (const varName of variables) {
+        const gradVal = evaluateFunction(grad[varName], point);
+        ascent[varName] = gradVal;
+        descent[varName] = -gradVal;
+    }
+    
+    return {
+        steepest_ascent: ascent,
+        steepest_descent: descent,
+        gradient_magnitude: Math.sqrt(Object.values(ascent).reduce((sum, val) => sum + val ** 2, 0))
+    };
+}
+
+/**
+ * Convert tangent plane/line to LaTeX
+ * @param {Object} tangent - Tangent object from tangentPlane or tangentLine
+ * @returns {string} LaTeX representation
+ */
+export function tangentToLatex(tangent) {
+    if (tangent.type === 'plane') {
+        const { equation } = tangent;
+        const zTerm = slangToLatex(equation.z);
+        const xTerm = slangToLatex(equation.x);
+        const yTerm = slangToLatex(equation.y);
+        const constTerm = slangToLatex(equation.constant);
+        
+        return `z = ${zTerm} + ${xTerm} + ${yTerm} + ${constTerm}`;
+    } else if (tangent.type === 'line') {
+        const { equation } = tangent;
+        const yTerm = slangToLatex(equation.y);
+        const constTerm = slangToLatex(equation.constant);
+        
+        return `y = ${yTerm} + ${constTerm}`;
+    }
+    
+    return '';
+}
+
 // ============================================================================
 // EXAMPLES AND DEMO
 // ============================================================================
@@ -496,6 +913,21 @@ export default {
     getFunctionLatex,
     SUPPORTED_FUNCTIONS,
     
+    // Advanced Mathematical Functions
+    gradient,
+    hessian,
+    tangentPlane,
+    tangentLine,
+    surfaceNormal,
+    findCriticalPoints,
+    classifyCriticalPoint,
+    findExtrema,
+    findGlobalExtrema,
+    lagrangeMultipliers,
+    directionalDerivative,
+    steepestDirections,
+    tangentToLatex,
+    
     // Demo
     demoExtendedFunctions
 };

package/slang-math.js

@@ -1,3 +1,11 @@
-export * from "./slang-basic.js";
-export * from "./slang-advanced.js";
-export * from "./slang-helpers.js";
+/**
+ * SLaNg Math Module
+ * Central export point for all SLaNg mathematical functions
+ */
+
+// Export all functions from other modules
+export * from "./slang-basic.js";
+export * from "./slang-advanced.js";
+export * from "./slang-helpers.js";
+export * from "./slang-convertor.js";
+export * from "./slang-extended.js";