modularized

maths/calculus/calculate_limit.py

@@ -0,0 +1,39 @@
+import sympy
+
+def calculate_limit(expression_str: str, variable_str: str, point_str: str, direction: str = '+-') -> str:
+    """
+    Calculates the limit of an expression as a variable approaches a point.
+
+    Args:
+        expression_str: The mathematical expression as a string (e.g., "sin(x)/x").
+        variable_str: The variable in the expression (e.g., "x").
+        point_str: The point the variable is approaching (e.g., "0", "oo" for infinity).
+        direction: The direction of the limit ('+', '-', or '+-' for both sides).
+
+    Returns:
+        A string representing the limit or an error message.
+    """
+    try:
+        var = sympy.Symbol(variable_str)
+        local_dict = {variable_str: var}
+        expr = sympy.parse_expr(expression_str, local_dict=local_dict, transformations='all')
+
+        if point_str.lower() == 'oo':
+            point = sympy.oo
+        elif point_str.lower() == '-oo':
+            point = -sympy.oo
+        else:
+            point = sympy.sympify(point_str)
+
+        if direction == '+':
+            limit_val = sympy.limit(expr, var, point, dir='+')
+        elif direction == '-':
+            limit_val = sympy.limit(expr, var, point, dir='-')
+        else:
+            limit_val = sympy.limit(expr, var, point)
+
+        return str(limit_val)
+    except (sympy.SympifyError, TypeError, SyntaxError) as e:
+        return f"Error parsing expression or point: {e}. Ensure valid Sympy syntax (e.g. use 'oo' for infinity, ensure variables match)."
+    except Exception as e:
+        return f"An unexpected error occurred: {e}"

maths/calculus/calculus.py

@@ -1,265 +0,0 @@
-"""
-Calculus operations for university level.
-"""
-import sympy
-from sympy.parsing.mathematica import parse_mathematica # For robust expression parsing
-import numpy as np # For numerical integration if needed
-from typing import Callable, Union, List, Tuple
-
-# Define common symbols for Sympy expressions
-x, y, z, n = sympy.symbols('x y z n')
-
-def derivative_polynomial(coefficients):
-    """
-    Calculate the derivative of a polynomial function.
-    
-    Args:
-        coefficients (list): List of coefficients from highest to lowest degree
-        
-    Returns:
-        list: Coefficients of the derivative polynomial
-    """
-    if len(coefficients) <= 1:
-        return [0]
-    
-    result = []
-    for i, coef in enumerate(coefficients[:-1]):
-        power = len(coefficients) - i - 1
-        result.append(coef * power)
-    
-    return result
-
-def integral_polynomial(coefficients, c=0):
-    """
-    Calculate the indefinite integral of a polynomial function.
-    
-    Args:
-        coefficients (list): List of coefficients from highest to lowest degree
-        c (float): Integration constant
-        
-    Returns:
-        list: Coefficients of the integral polynomial including constant term
-    """
-    result = []
-    for i, coef in enumerate(coefficients):
-        power = len(coefficients) - i
-        result.append(coef / power)
-    
-    result.append(c)  # Add integration constant
-    return result
-
-
-def calculate_limit(expression_str: str, variable_str: str, point_str: str, direction: str = '+-') -> str:
-    """
-    Calculates the limit of an expression as a variable approaches a point.
-
-    Args:
-        expression_str: The mathematical expression as a string (e.g., "sin(x)/x").
-        variable_str: The variable in the expression (e.g., "x").
-        point_str: The point the variable is approaching (e.g., "0", "oo" for infinity).
-        direction: The direction of the limit ('+', '-', or '+-' for both sides).
-
-    Returns:
-        A string representing the limit or an error message.
-    """
-    try:
-        var = sympy.Symbol(variable_str)
-        # Using parse_mathematica for more robust parsing than sympify alone
-        # It handles expressions like "x^2" or "sin(x)" more reliably.
-        # We need to ensure the variable is available in the parsing context.
-        local_dict = {variable_str: var}
-        expr = sympy.parse_expr(expression_str, local_dict=local_dict, transformations='all')
-
-
-        if point_str.lower() == 'oo':
-            point = sympy.oo
-        elif point_str.lower() == '-oo':
-            point = -sympy.oo
-        else:
-            point = sympy.sympify(point_str) # Can handle numbers or symbolic constants like pi
-
-        if direction == '+':
-            limit_val = sympy.limit(expr, var, point, dir='+')
-        elif direction == '-':
-            limit_val = sympy.limit(expr, var, point, dir='-')
-        else: # '+-' default
-            limit_val = sympy.limit(expr, var, point)
-
-        return str(limit_val)
-    except (sympy.SympifyError, TypeError, SyntaxError) as e:
-        return f"Error parsing expression or point: {e}. Ensure valid Sympy syntax (e.g. use 'oo' for infinity, ensure variables match)."
-    except Exception as e:
-        return f"An unexpected error occurred: {e}"
-
-
-def taylor_series_expansion(expression_str: str, variable_str: str = 'x', point: float = 0, order: int = 5) -> str:
-    """
-    Computes the Taylor series expansion of an expression around a point.
-
-    Args:
-        expression_str: The mathematical expression (e.g., "exp(x)").
-        variable_str: The variable (default 'x').
-        point: The point around which to expand (default 0).
-        order: The order of the Taylor polynomial (default 5).
-
-    Returns:
-        String representation of the Taylor series or an error message.
-    """
-    try:
-        var = sympy.Symbol(variable_str)
-        expr = sympy.parse_expr(expression_str, local_dict={variable_str: var}, transformations='all')
-
-        series = expr.series(var, x0=point, n=order).removeO() # removeO() removes the O(x^n) term
-        return str(series)
-    except Exception as e:
-        return f"Error calculating Taylor series: {e}"
-
-
-def fourier_series_example(function_type: str = "sawtooth", n_terms: int = 5) -> str:
-    """
-    Provides an example of a Fourier series for a predefined function.
-
-    Args:
-        function_type: "sawtooth" or "square" wave.
-        n_terms: Number of terms to compute in the series.
-
-    Returns:
-        String representation of the Fourier series.
-    """
-    try:
-        L = sympy.pi  # Periodicity, assuming 2L = 2*pi for standard examples
-        x = sympy.Symbol('x')
-
-        if function_type == "sawtooth":
-            # Sawtooth wave: f(x) = x for -pi < x < pi
-            # a0 = 0
-            # an = 0
-            # bn = 2/L * integral(x*sin(n*pi*x/L), (x, 0, L))
-            #    = 2/pi * integral(x*sin(nx), (x, 0, pi))
-            #    = 2/pi * [-x*cos(nx)/n + sin(nx)/n^2]_0^pi
-            #    = 2/pi * [-pi*cos(n*pi)/n] = -2*(-1)^n / n
-            series = sympy.S(0) # Start with zero, as a0 is 0
-            for i in range(1, n_terms + 1):
-                bn_coeff = -2 * ((-1)**i) / i
-                series += bn_coeff * sympy.sin(i * x)
-            return f"Fourier series for sawtooth wave (f(x)=x on [-pi,pi]): {str(series)}"
-
-        elif function_type == "square":
-            # Square wave: f(x) = -1 for -pi < x < 0, f(x) = 1 for 0 < x < pi
-            # a0 = 0
-            # an = 0
-            # bn = 2/L * integral(f(x)*sin(n*pi*x/L), (x, 0, L)) where f(x)=1 for (0,L)
-            #    = 2/pi * integral(sin(nx), (x, 0, pi))
-            #    = 2/pi * [-cos(nx)/n]_0^pi
-            #    = 2/(n*pi) * (1 - cos(n*pi)) = 2/(n*pi) * (1 - (-1)^n)
-            # This means bn is 4/(n*pi) if n is odd, and 0 if n is even.
-            series = sympy.S(0)
-            for i in range(1, n_terms + 1):
-                if i % 2 != 0: # n is odd
-                    bn_coeff = 4 / (i * sympy.pi)
-                    series += bn_coeff * sympy.sin(i * x)
-            return f"Fourier series for square wave (f(x)=1 on [0,pi], -1 on [-pi,0]): {str(series)}"
-        else:
-            return "Error: Unknown function type for Fourier series. Choose 'sawtooth' or 'square'."
-    except Exception as e:
-        return f"Error generating Fourier series: {e}"
-
-
-def partial_derivative(expression_str: str, variables_str: List[str]) -> str:
-    """
-    Computes partial derivatives of an expression with respect to specified variables.
-    Example: expression_str="x**2*y**3", variables_str=["x", "y"] will compute d/dx then d/dy.
-    If you want d^2f/dx^2, use variables_str=["x", "x"].
-
-    Args:
-        expression_str: The mathematical expression (e.g., "x**2*y + y*z**2").
-        variables_str: A list of variable names (strings) to differentiate by, in order.
-                       (e.g., ["x", "y"] for d/dy(d/dx(expr)) ).
-
-    Returns:
-        String representation of the partial derivative or an error message.
-    """
-    try:
-        # Create symbols for all variables that might appear in the expression
-        # For simplicity, we'll assume 'x', 'y', 'z' are common, but user must specify which to derive by.
-        # A more robust way would be to parse expression_str to find all symbols.
-        symbols_in_expr = {s.name: s for s in sympy.parse_expr(expression_str, transformations='all').free_symbols}
-
-        # Ensure variables to differentiate by are symbols
-        diff_vars_symbols = []
-        for var_name in variables_str:
-            if var_name in symbols_in_expr:
-                diff_vars_symbols.append(symbols_in_expr[var_name])
-            else:
-                # If a variable to differentiate by is not in free_symbols, it might be an error
-                # or the expression doesn't depend on it. Sympy handles differentiation by non-present vars as 0.
-                # We'll create the symbol anyway to pass to diff.
-                diff_vars_symbols.append(sympy.Symbol(var_name))
-
-        if not diff_vars_symbols:
-             return "Error: No variables specified for differentiation."
-
-        expr = sympy.parse_expr(expression_str, local_dict=symbols_in_expr, transformations='all')
-
-        # Compute partial derivatives iteratively
-        current_expr = expr
-        for var_sym in diff_vars_symbols:
-            current_expr = sympy.diff(current_expr, var_sym)
-
-        return str(current_expr)
-    except (sympy.SympifyError, TypeError, SyntaxError) as e:
-        return f"Error parsing expression or variables: {e}"
-    except Exception as e:
-        return f"An unexpected error occurred: {e}"
-
-
-def multiple_integral(expression_str: str, integration_vars: List[Tuple[str, Union[str, float], Union[str, float]]]) -> str:
-    """
-    Computes definite multiple integrals.
-
-    Args:
-        expression_str: The mathematical expression (e.g., "x*y**2").
-        integration_vars: A list of tuples, where each tuple contains:
-                          (variable_name_str, lower_bound_str_or_float, upper_bound_str_or_float).
-                          Example: [("x", "0", "1"), ("y", "0", "x")] for integral from 0 to 1 dx of integral from 0 to x dy of (x*y**2).
-                          The order in the list is the order of integration (inner to outer).
-
-    Returns:
-        String representation of the integral result or an error message.
-    """
-    try:
-        # Create symbols for all variables that might appear in the expression
-        # and in integration bounds.
-        # A more robust approach might involve parsing the expression and bounds to identify all symbols.
-        # For now, we'll default to x, y, z if not explicitly mentioned.
-        present_symbols = {sym.name: sym for sym in sympy.parse_expr(expression_str, transformations='all').free_symbols}
-
-        integration_params_sympy = []
-        for var_name, lower_bound, upper_bound in integration_vars:
-            var_sym = present_symbols.get(var_name, sympy.Symbol(var_name))
-            if var_sym.name not in present_symbols: # Add if it wasn't in expression but is an integration var
-                present_symbols[var_sym.name] = var_sym
-
-            # Bounds can be numbers or expressions involving other variables
-            # We need to ensure these other variables are available in the context for sympify
-            lower_s = sympy.sympify(lower_bound, locals=present_symbols)
-            upper_s = sympy.sympify(upper_bound, locals=present_symbols)
-            integration_params_sympy.append((var_sym, lower_s, upper_s))
-
-        if not integration_params_sympy:
-            return "Error: No integration variables specified."
-
-        expr = sympy.parse_expr(expression_str, local_dict=present_symbols, transformations='all')
-
-        # Compute integral iteratively (from inner to outer)
-        # Sympy's integrate function takes tuples like (x, 0, 1)
-        # The order of integration_params_sympy should be from inner-most integral to outer-most.
-        # For sympy.integrate, the order of variables in the list is outer to inner. So we reverse.
-
-        integral_val = sympy.integrate(expr, *integration_params_sympy)
-
-        return str(integral_val)
-    except (sympy.SympifyError, TypeError, SyntaxError) as e:
-        return f"Error parsing expression, bounds, or variables: {e}. Ensure bounds are numbers or valid expressions."
-    except Exception as e:
-        return f"An unexpected error occurred during integration: {e}"

maths/calculus/calculus_interface.py

@@ -1,9 +1,11 @@
 import gradio as gr
-from maths.calculus.calculus import (
-    derivative_polynomial, integral_polynomial,
-    calculate_limit, taylor_series_expansion, fourier_series_example,
-    partial_derivative, multiple_integral
-)
+from maths.calculus.derivative_polynomial import derivative_polynomial
+from maths.calculus.integral_polynomial import integral_polynomial
+from maths.calculus.calculate_limit import calculate_limit
+from maths.calculus.taylor_series_expansion import taylor_series_expansion
+from maths.calculus.fourier_series_example import fourier_series_example
+from maths.calculus.partial_derivative import partial_derivative
+from maths.calculus.multiple_integral import multiple_integral
 import json # For parsing list of tuples for multiple integrals
 
 # University Math Tab

maths/calculus/derivative_polynomial.py

@@ -0,0 +1,21 @@
+import sympy
+
+def derivative_polynomial(coefficients):
+    """
+    Calculate the derivative of a polynomial function.
+    
+    Args:
+        coefficients (list): List of coefficients from highest to lowest degree
+        
+    Returns:
+        list: Coefficients of the derivative polynomial
+    """
+    if len(coefficients) <= 1:
+        return [0]
+    
+    result = []
+    for i, coef in enumerate(coefficients[:-1]):
+        power = len(coefficients) - i - 1
+        result.append(coef * power)
+    
+    return result

maths/calculus/fourier_series_example.py

@@ -0,0 +1,33 @@
+import sympy
+
+def fourier_series_example(function_type: str = "sawtooth", n_terms: int = 5) -> str:
+    """
+    Provides an example of a Fourier series for a predefined function.
+
+    Args:
+        function_type: "sawtooth" or "square" wave.
+        n_terms: Number of terms to compute in the series.
+
+    Returns:
+        String representation of the Fourier series.
+    """
+    try:
+        L = sympy.pi
+        x = sympy.Symbol('x')
+        if function_type == "sawtooth":
+            series = sympy.S(0)
+            for i in range(1, n_terms + 1):
+                bn_coeff = -2 * ((-1)**i) / i
+                series += bn_coeff * sympy.sin(i * x)
+            return f"Fourier series for sawtooth wave (f(x)=x on [-pi,pi]): {str(series)}"
+        elif function_type == "square":
+            series = sympy.S(0)
+            for i in range(1, n_terms + 1):
+                if i % 2 != 0:
+                    bn_coeff = 4 / (i * sympy.pi)
+                    series += bn_coeff * sympy.sin(i * x)
+            return f"Fourier series for square wave (f(x)=1 on [0,pi], -1 on [-pi,0]): {str(series)}"
+        else:
+            return "Error: Unknown function type for Fourier series. Choose 'sawtooth' or 'square'."
+    except Exception as e:
+        return f"Error generating Fourier series: {e}"

maths/calculus/integral_polynomial.py

@@ -0,0 +1,20 @@
+import sympy
+
+def integral_polynomial(coefficients, c=0):
+    """
+    Calculate the indefinite integral of a polynomial function.
+    
+    Args:
+        coefficients (list): List of coefficients from highest to lowest degree
+        c (float): Integration constant
+        
+    Returns:
+        list: Coefficients of the integral polynomial including constant term
+    """
+    result = []
+    for i, coef in enumerate(coefficients):
+        power = len(coefficients) - i
+        result.append(coef / power)
+    
+    result.append(c)  # Add integration constant
+    return result

maths/calculus/multiple_integral.py

@@ -0,0 +1,36 @@
+import sympy
+from typing import List, Tuple, Union
+
+def multiple_integral(expression_str: str, integration_vars: List[Tuple[str, Union[str, float], Union[str, float]]]) -> str:
+    """
+    Computes definite multiple integrals.
+
+    Args:
+        expression_str: The mathematical expression (e.g., "x*y**2").
+        integration_vars: A list of tuples, where each tuple contains:
+                          (variable_name_str, lower_bound_str_or_float, upper_bound_str_or_float).
+                          Example: [("x", "0", "1"), ("y", "0", "x")] for integral from 0 to 1 dx of integral from 0 to x dy of (x*y**2).
+                          The order in the list is the order of integration (inner to outer).
+
+    Returns:
+        String representation of the integral result or an error message.
+    """
+    try:
+        present_symbols = {sym.name: sym for sym in sympy.parse_expr(expression_str, transformations='all').free_symbols}
+        integration_params_sympy = []
+        for var_name, lower_bound, upper_bound in integration_vars:
+            var_sym = present_symbols.get(var_name, sympy.Symbol(var_name))
+            if var_sym.name not in present_symbols:
+                present_symbols[var_sym.name] = var_sym
+            lower_s = sympy.sympify(lower_bound, locals=present_symbols)
+            upper_s = sympy.sympify(upper_bound, locals=present_symbols)
+            integration_params_sympy.append((var_sym, lower_s, upper_s))
+        if not integration_params_sympy:
+            return "Error: No integration variables specified."
+        expr = sympy.parse_expr(expression_str, local_dict=present_symbols, transformations='all')
+        integral_val = sympy.integrate(expr, *integration_params_sympy)
+        return str(integral_val)
+    except (sympy.SympifyError, TypeError, SyntaxError) as e:
+        return f"Error parsing expression, bounds, or variables: {e}. Ensure bounds are numbers or valid expressions."
+    except Exception as e:
+        return f"An unexpected error occurred during integration: {e}"

maths/calculus/partial_derivative.py

@@ -0,0 +1,36 @@
+import sympy
+from typing import List
+
+def partial_derivative(expression_str: str, variables_str: List[str]) -> str:
+    """
+    Computes partial derivatives of an expression with respect to specified variables.
+    Example: expression_str="x**2*y**3", variables_str=["x", "y"] will compute d/dx then d/dy.
+    If you want d^2f/dx^2, use variables_str=["x", "x"].
+
+    Args:
+        expression_str: The mathematical expression (e.g., "x**2*y + y*z**2").
+        variables_str: A list of variable names (strings) to differentiate by, in order.
+                       (e.g., ["x", "y"] for d/dy(d/dx(expr)) ).
+
+    Returns:
+        String representation of the partial derivative or an error message.
+    """
+    try:
+        symbols_in_expr = {s.name: s for s in sympy.parse_expr(expression_str, transformations='all').free_symbols}
+        diff_vars_symbols = []
+        for var_name in variables_str:
+            if var_name in symbols_in_expr:
+                diff_vars_symbols.append(symbols_in_expr[var_name])
+            else:
+                diff_vars_symbols.append(sympy.Symbol(var_name))
+        if not diff_vars_symbols:
+             return "Error: No variables specified for differentiation."
+        expr = sympy.parse_expr(expression_str, local_dict=symbols_in_expr, transformations='all')
+        current_expr = expr
+        for var_sym in diff_vars_symbols:
+            current_expr = sympy.diff(current_expr, var_sym)
+        return str(current_expr)
+    except (sympy.SympifyError, TypeError, SyntaxError) as e:
+        return f"Error parsing expression or variables: {e}"
+    except Exception as e:
+        return f"An unexpected error occurred: {e}"

maths/calculus/taylor_series_expansion.py

@@ -0,0 +1,22 @@
+import sympy
+
+def taylor_series_expansion(expression_str: str, variable_str: str = 'x', point: float = 0, order: int = 5) -> str:
+    """
+    Computes the Taylor series expansion of an expression around a point.
+
+    Args:
+        expression_str: The mathematical expression (e.g., "exp(x)").
+        variable_str: The variable (default 'x').
+        point: The point around which to expand (default 0).
+        order: The order of the Taylor polynomial (default 5).
+
+    Returns:
+        String representation of the Taylor series or an error message.
+    """
+    try:
+        var = sympy.Symbol(variable_str)
+        expr = sympy.parse_expr(expression_str, local_dict={variable_str: var}, transformations='all')
+        series = expr.series(var, x0=point, n=order).removeO()
+        return str(series)
+    except Exception as e:
+        return f"Error calculating Taylor series: {e}"