Add advanced math tools

README.md

@@ -1,10 +1,93 @@
 ---
-title: Code2MCP Sympy
-emoji: 👁
+title: Code2MCP Sympy - Advanced Mathematical Computing
+emoji: 🧮
 colorFrom: purple
 colorTo: yellow
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Code2MCP Sympy - Advanced Mathematical Computing Service
+
+A powerful MCP (Model Context Protocol) service based on SymPy, providing advanced symbolic mathematics and numerical computing capabilities.
+
+## 🚀 Key Features
+
+### Basic Mathematical Operations
+- Symbolic expression creation and manipulation
+- Expression expansion and simplification
+- Equation solving (linear and nonlinear)
+- Differentiation and integration
+- Polynomial factorization
+
+### Advanced Numerical Computing
+- **Riemann Sum** - Riemann sum calculation (left, right, midpoint, trapezoid methods)
+- **Darboux Sum** - Darboux sum calculation (upper and lower integrals)
+- **Limit Calculation** - Support for finite and infinite limits
+- **Area Calculation** - Area under curves (trapezoid method)
+- **Volume Calculation** - Volume of revolution around x-axis (disk method)
+
+### Transform Calculations
+- **Fourier Transform** - Fourier transform (numerical approximation)
+- **Laplace Transform** - Laplace transform (numerical approximation)
+- **Z Transform** - Z transform (discrete-time systems)
+
+### Financial Mathematics
+- Compound interest calculation
+- Present value calculation
+- Net present value (NPV) calculation
+- Logarithmic and exponential functions
+
+## 🛠️ Technical Features
+
+- Built on FastMCP framework
+- SymPy symbolic computing support
+- Integrated NumPy and SciPy numerical computing
+- Comprehensive error handling
+- Unified API response format
+
+## 📦 Dependencies
+
+- fastapi
+- fastmcp >= 2.12.0
+- sympy >= 1.12
+- numpy >= 1.24.0
+- scipy >= 1.10.0
+- mpmath >= 1.3.0
+
+## 🔧 Usage
+
+The service provides the following MCP tools:
+
+### Basic Tools
+- `create_symbol` - Create symbolic variables
+- `expand_expression` - Expand expressions
+- `simplify_expression` - Simplify expressions
+- `solve_equation` - Solve equations
+- `differentiate` - Calculate derivatives
+- `integrate_expression` - Calculate integrals
+
+### Advanced Computing Tools
+- `riemann_sum` - Riemann sum calculation
+- `darboux_sum` - Darboux sum calculation
+- `calculate_limit` - Limit calculation
+- `calculate_area` - Area calculation
+- `calculate_volume` - Volume calculation
+- `fourier_transform` - Fourier transform
+- `laplace_transform` - Laplace transform
+- `z_transform` - Z transform
+
+### Financial Tools
+- `compound_interest` - Compound interest calculation
+- `present_value` - Present value calculation
+- `npv` - Net present value calculation
+- `logarithm` - Logarithmic calculation
+- `exponential` - Exponential calculation
+
+## 🚀 Deployment
+
+This service is configured to run on Hugging Face Spaces using Docker containerization.
+
+---
+
+Built with [SymPy](https://www.sympy.org/) and [FastMCP](https://github.com/pydantic/fastmcp).

sympy/mcp_output/mcp_plugin/mcp_service.py

@@ -12,8 +12,13 @@ from sympy.simplify import simplify
 from sympy.solvers import solve, linsolve
 from sympy.integrals import integrate
 from sympy.polys import Poly, factor
-from sympy.functions import sin, cos, exp
-from sympy import sympify
+from sympy.functions import sin, cos, exp, log
+from sympy import sympify, limit, oo
+from sympy.calculus.util import continuous_domain
+import numpy as np
+from scipy import integrate as scipy_integrate
+from scipy.fft import fft, ifft
+from scipy.signal import lti
 mcp = FastMCP("sympy_service")
 
 def _ser(x):
@@ -29,6 +34,9 @@ def _ser(x):
 
 @mcp.tool(name="create_symbol")
 def create_symbol(name: str):
+    """
+    Create a symbolic variable
+    """
     try:
         res = symbols(name)
         return {"success": True, "result": _ser(res), "error": None}
@@ -37,6 +45,9 @@ def create_symbol(name: str):
 
 @mcp.tool(name="expand_expression")
 def expand_expression(expr: str):
+    """
+    Expand mathematical expression
+    """
     try:
         res = expand(sympify(expr))
         return {"success": True, "result": _ser(res), "error": None}
@@ -45,6 +56,9 @@ def expand_expression(expr: str):
 
 @mcp.tool(name="simplify_expression")
 def simplify_expression(expr: str):
+    """
+    Simplify mathematical expression
+    """
     try:
         res = simplify(sympify(expr))
         return {"success": True, "result": _ser(res), "error": None}
@@ -53,14 +67,22 @@ def simplify_expression(expr: str):
 
 @mcp.tool(name="solve_equation")
 def solve_equation(equation: str, variable: str):
+    """
+    Solve equation for variable
+    """
     try:
-        res = solve(sympify(equation), symbols(variable))
+        expr = sympify(equation)
+        var = symbols(variable)
+        res = solve(expr, var)
         return {"success": True, "result": _ser(res), "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
 @mcp.tool(name="solve_linear_system")
 def solve_linear_system(system: list, variables: list):
+    """
+    Solve system of linear equations
+    """
     try:
         eqs = [sympify(e) for e in system]
         vars_sym = [symbols(v) for v in variables]
@@ -71,38 +93,63 @@ def solve_linear_system(system: list, variables: list):
 
 @mcp.tool(name="differentiate")
 def differentiate(expr: str, variable: str):
+    """
+    Calculate derivative of expression with respect to variable
+    """
     try:
-        res = diff(sympify(expr), symbols(variable))
+        expr_sym = sympify(expr)
+        var = symbols(variable)
+        res = diff(expr_sym, var)
         return {"success": True, "result": _ser(res), "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
 @mcp.tool(name="integrate_expression")
 def integrate_expression(expr: str, variable: str):
+    """
+    Calculate integral of expression with respect to variable
+    """
     try:
-        res = integrate(sympify(expr), symbols(variable))
+        expr_sym = sympify(expr)
+        var = symbols(variable)
+        res = integrate(expr_sym, var)
         return {"success": True, "result": _ser(res), "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
 @mcp.tool(name="create_polynomial")
-def create_polynomial(coeffs: list, variable: str):
+def create_polynomial(expr: str, variable: str = None):
+    """
+    Create polynomial from expression
+    """
     try:
-        res = Poly(coeffs, symbols(variable))
+        expr_sym = sympify(expr)
+        if variable:
+            var = symbols(variable)
+            res = Poly(expr_sym, var)
+        else:
+            res = Poly(expr_sym)
         return {"success": True, "result": _ser(res), "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
 @mcp.tool(name="factor_polynomial")
 def factor_polynomial(poly: str):
+    """
+    Factor polynomial expression
+    """
     try:
-        res = factor(sympify(poly))
+        poly_sym = sympify(poly)
+        res = factor(poly_sym)
         return {"success": True, "result": _ser(res), "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
 @mcp.tool(name="calculate_sin")
 def calculate_sin(angle: str):
+    """
+    Calculate sine of angle
+    """
     try:
         res = sin(sympify(angle))
         return {"success": True, "result": _ser(res), "error": None}
@@ -111,6 +158,9 @@ def calculate_sin(angle: str):
 
 @mcp.tool(name="calculate_cos")
 def calculate_cos(angle: str):
+    """
+    Calculate cosine of angle
+    """
     try:
         res = cos(sympify(angle))
         return {"success": True, "result": _ser(res), "error": None}
@@ -119,12 +169,287 @@ def calculate_cos(angle: str):
 
 @mcp.tool(name="calculate_exp")
 def calculate_exp(value: str):
+    """
+    Calculate exponential function e^x
+    """
     try:
         res = exp(sympify(value))
         return {"success": True, "result": _ser(res), "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
+@mcp.tool(name="riemann_sum")
+def riemann_sum(expression: str, variable: str, a: float, b: float, n: int, method: str = "midpoint"):
+    """
+    Calculate Riemann sum of a function
+    method: 'left', 'right', 'midpoint', 'trapezoid'
+    """
+    try:
+        # Parse expression
+        expr = sympify(expression)
+        var = symbols(variable)
+        
+        # Calculate step size
+        delta_x = (b - a) / n
+        sum_result = 0
+        
+        if method == "left":
+            for i in range(n):
+                x_val = a + i * delta_x
+                sum_result += float(expr.subs(var, x_val)) * delta_x
+        elif method == "right":
+            for i in range(1, n + 1):
+                x_val = a + i * delta_x
+                sum_result += float(expr.subs(var, x_val)) * delta_x
+        elif method == "midpoint":
+            for i in range(n):
+                x_val = a + (i + 0.5) * delta_x
+                sum_result += float(expr.subs(var, x_val)) * delta_x
+        elif method == "trapezoid":
+            for i in range(n + 1):
+                x_val = a + i * delta_x
+                weight = 0.5 if (i == 0 or i == n) else 1.0
+                sum_result += weight * float(expr.subs(var, x_val)) * delta_x
+        else:
+            return {"success": False, "result": None, "error": "Invalid method. Use 'left', 'right', 'midpoint', or 'trapezoid'"}
+        
+        return {"success": True, "result": sum_result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="darboux_sum")
+def darboux_sum(expression: str, variable: str, a: float, b: float, n: int, sum_type: str = "upper"):
+    """
+    Calculate Darboux sum (upper or lower integral)
+    sum_type: 'upper' or 'lower'
+    """
+    try:
+        expr = sympify(expression)
+        var = symbols(variable)
+        
+        delta_x = (b - a) / n
+        sum_result = 0
+        
+        for i in range(n):
+            x1 = a + i * delta_x
+            x2 = x1 + delta_x
+            y1 = float(expr.subs(var, x1))
+            y2 = float(expr.subs(var, x2))
+            
+            if sum_type == "upper":
+                value = max(y1, y2)
+            else:  # lower
+                value = min(y1, y2)
+            
+            sum_result += value * delta_x
+        
+        return {"success": True, "result": sum_result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="calculate_limit")
+def calculate_limit(expression: str, variable: str, approach: str):
+    """
+    Calculate function limit
+    approach: can be a number or 'oo' (infinity) or '-oo' (negative infinity)
+    """
+    try:
+        expr = sympify(expression)
+        var = symbols(variable)
+        
+        if approach == 'oo':
+            approach_val = oo
+        elif approach == '-oo':
+            approach_val = -oo
+        else:
+            approach_val = float(approach)
+        
+        res = limit(expr, var, approach_val)
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="calculate_area")
+def calculate_area(expression: str, start: float, end: float, n: int = 1000):
+    """
+    Calculate area under curve (using trapezoid method)
+    """
+    try:
+        expr = sympify(expression)
+        var = symbols('x')
+        
+        # Calculate area using trapezoid method
+        delta_x = (end - start) / n
+        area = 0
+        
+        for i in range(n + 1):
+            x_val = start + i * delta_x
+            weight = 0.5 if (i == 0 or i == n) else 1.0
+            area += weight * float(expr.subs(var, x_val)) * delta_x
+        
+        return {"success": True, "result": area, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="calculate_volume")
+def calculate_volume(expression: str, start: float, end: float, n: int = 1000):
+    """
+    Calculate volume of revolution around x-axis (disk method)
+    """
+    try:
+        expr = sympify(expression)
+        var = symbols('x')
+        
+        delta_x = (end - start) / n
+        volume = 0
+        
+        for i in range(n):
+            x_val = start + i * delta_x
+            y_val = float(expr.subs(var, x_val))
+            volume += np.pi * y_val * y_val * delta_x
+        
+        return {"success": True, "result": volume, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="fourier_transform")
+def fourier_transform(expression: str, time_var: str, freq_var: str):
+    """
+    Calculate Fourier transform (numerical approximation)
+    """
+    try:
+        expr = sympify(expression)
+        t = symbols(time_var)
+        omega = symbols(freq_var)
+        
+        # Use numerical integration to approximate Fourier transform
+        def integrand(t_val):
+            return float(expr.subs(t, t_val))
+        
+        # Define integration range and frequency range
+        t_range = (-50, 50)  # Time range
+        omega_vals = np.linspace(-10, 10, 100)  # Frequency range
+        
+        result = []
+        for omega_val in omega_vals:
+            def f(t_val):
+                return integrand(t_val) * np.exp(-1j * omega_val * t_val)
+            
+            # Use numerical integration
+            integral_result, _ = scipy_integrate.quad(f, t_range[0], t_range[1], limit=100)
+            result.append(complex(integral_result))
+        
+        return {"success": True, "result": [str(complex(r)) for r in result], "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="laplace_transform")
+def laplace_transform(expression: str, time_var: str, laplace_var: str):
+    """
+    Calculate Laplace transform (numerical approximation)
+    """
+    try:
+        expr = sympify(expression)
+        t = symbols(time_var)
+        s = symbols(laplace_var)
+        
+        def integrand(t_val):
+            return float(expr.subs(t, t_val))
+        
+        # Define integration range and Laplace variable range
+        t_range = (0, 100)  # Time range
+        s_vals = np.linspace(0.1, 10, 50)  # Laplace variable range
+        
+        result = []
+        for s_val in s_vals:
+            def f(t_val):
+                return integrand(t_val) * np.exp(-s_val * t_val)
+            
+            # Use numerical integration
+            integral_result, _ = scipy_integrate.quad(f, t_range[0], t_range[1], limit=100)
+            result.append(complex(integral_result))
+        
+        return {"success": True, "result": [str(complex(r)) for r in result], "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="z_transform")
+def z_transform(expression: str, time_var: str, z_var: str, limit: int = 100):
+    """
+    Calculate Z transform
+    """
+    try:
+        expr = sympify(expression)
+        n = symbols(time_var)
+        z = symbols(z_var)
+        
+        result = 0
+        for k in range(limit + 1):
+            term = expr.subs(n, k) * (z ** (-k))
+            result += term
+        
+        return {"success": True, "result": _ser(result), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="compound_interest")
+def compound_interest(principal: float, rate: float, time: float, compounds: int = 12):
+    """
+    Calculate compound interest
+    """
+    try:
+        result = principal * (1 + rate / compounds) ** (compounds * time)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="present_value")
+def present_value(future_value: float, rate: float, time: float):
+    """
+    Calculate present value
+    """
+    try:
+        result = future_value / (1 + rate) ** time
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="npv")
+def npv(cash_flows: list, rate: float):
+    """
+    Calculate net present value
+    """
+    try:
+        result = sum(cf / (1 + rate) ** t for t, cf in enumerate(cash_flows))
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="logarithm")
+def logarithm(value: float, base: float = None):
+    """
+    Calculate logarithm
+    """
+    try:
+        if base is None:
+            result = np.log(value)
+        else:
+            result = np.log(value) / np.log(base)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="exponential")
+def exponential(power: float):
+    """
+    Calculate exponential function e^x
+    """
+    try:
+        result = np.exp(power)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
 
 
 def create_app():