Evaluates a mathematical expression and returns the result.

Supports basic operators (+, -, *, /, **, %, ^), mathematical functions (sin, cos, tan, exp, log, log10, sqrt), and constants (pi, e). Uses an AST whitelist for safe execution.

Args: expression: The mathematical expression to evaluate as a string. Examples: "2 + 2", "sin(pi/4)", "sqrt(16) * 2", "log(100, 10)"

Returns: On success: {"result": } On error: {"error": }

Examples: >>> calculate("2 * 3 + 4") {'result': 10} >>> calculate("sin(pi/2)") {'result': 1.0} >>> calculate("sqrt(16)") {'result': 4.0} >>> calculate("(2 + 3)^2") {'result': 25}

Notes: - Use 'x' as the variable (e.g., x2, not x^2) - Multiplication must be explicitly indicated with * (e.g., 2*x, not 2x) - Powers can be represented with ** or ^ (e.g., x2 or x^2)

Solves an algebraic equation for x and returns all solutions.

The equation must contain exactly one equality sign (=) and use a variable x. Can solve polynomial, trigonometric, and other equations supported by SymPy.

Args: equation: The equation to solve as a string. Format: ' = ' Examples: "x**2 - 5x + 6 = 0", "sin(x) = 0.5", "2x + 3 = 7"

Returns: On success: {"solutions": } On error: {"error": }

Examples: >>> solve_equation("x**2 - 5x + 6 = 0") {'solutions': '[2, 3]'} >>> solve_equation("2x + 3 = 7") {'solutions': '[2]'} >>> solve_equation("x = 0") {'solutions': '[0]'}

Notes: - Use 'x' as the variable (e.g., x2, not x^2) - Multiplication must be explicitly indicated with * (e.g., 2*x, not 2x) - Powers can be represented with ** or ^ (e.g., x2 or x^2)

Computes the derivative of a mathematical expression with respect to a variable.

Supports polynomials, trigonometric functions, exponential functions, logarithms, and other functions supported by SymPy.

Args: expression: The mathematical expression to differentiate as a string. Examples: "x**2", "sin(x)", "exp(x)", "log(x)" variable: The variable with respect to which to differentiate. Default is "x". Optionally, other variables can be specified.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> differentiate("x**2") {'result': '2x'} >>> differentiate("sin(x)") {'result': 'cos(x)'} >>> differentiate("xy", "y") {'result': 'x'} >>> differentiate("exp(x)") {'result': 'exp(x)'}

Notes: - Use mathematical notation with explicit operators (* for multiplication) - Powers can be represented with ** or ^ (e.g., x**2 or x^2) - For trigonometric functions, use sin(x), cos(x), etc. - Only support for one variable at a time (implicit differentiation not supported)

Computes the indefinite integral of a mathematical expression with respect to a variable.

Supports polynomials, trigonometric functions, exponential functions, logarithms, and other functions supported by SymPy.

Args: expression: The mathematical expression to integrate as a string. Examples: "x**2", "sin(x)", "exp(x)", "1/x" variable: The variable with respect to which to integrate. Default is "x". Optionally, other variables can be specified.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> integrate("x2") {'result': 'x3/3'} >>> integrate("sin(x)") {'result': '-cos(x)'} >>> integrate("exp(x)") {'result': 'exp(x)'} >>> integrate("1/x") {'result': 'log(x)'} >>> integrate("xy", "y") {'result': 'xy**2/2'}

Notes: - The result is the indefinite integral without the constant of integration - Complex expressions may be returned in simplified form

Computes the mean of a list of numbers.

Args: data: A list of numerical values.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> mean([1, 2, 3, 4]) {'result': 2.5} >>> mean([10, 20, 30]) {'result': 20.0}

Computes the variance of a list of numbers.

Args: data: A list of numerical values.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> variance([1, 2, 3, 4]) {'result': 1.25}

Computes the standard deviation of a list of numbers.

Args: data: A list of numerical values.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> standard_deviation([1, 2, 3, 4]) {'result': 1.118033988749895}

Computes the median of a list of numbers.

Args: data: A list of numerical values.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> median([1, 2, 3, 4]) {'result': 2.5}

Computes the mode of a list of numbers.

Args: data: A list of numerical values.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> mode([1, 2, 2, 3]) {'result': 2.0} >>> mode([1, 1, 2, 2]) {'result': 1.0} >>> mode([]) {'error': 'Cannot compute mode of empty array'}

Computes the Pearson correlation coefficient between two lists of numbers.

Args: data_x: The first list of numerical values. data_y: The second list of numerical values.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> correlation_coefficient([1, 2, 3], [4, 5, 6]) {'result': 1.0}

Performs linear regression on a set of points and returns the slope and intercept.

Args: data: A list of tuples, where each tuple contains (x, y) coordinates.

Returns: On success: {"slope": , "intercept": } On error: {"error": }

Examples: >>> linear_regression([(1, 2), (2, 3), (3, 5)]) {'slope': 1.5, 'intercept': 0.3333333333333335}

Computes the confidence interval for the mean of a dataset.

Args: data: A list of numerical values. confidence: The confidence level (default is 0.95).

Returns: On success: {"confidence_interval": <(lower_bound, upper_bound)>} On error: {"error": }

Examples: >>> import numpy as np >>> np.random.seed(42) # For reproducible results >>> confidence_interval([1, 2, 3, 4]) # doctest: +ELLIPSIS {'confidence_interval': (0.445739743239..., 4.554260256760...)}

Adds two matrices.

Args: matrix_a: The first matrix as a list of lists. matrix_b: The second matrix as a list of lists.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> matrix_addition([[1, 2], [3, 4]], [[5, 6], [7, 8]]) {'result': [[6, 8], [10, 12]]}

Multiplies two matrices.

Args: matrix_a: The first matrix as a list of lists. matrix_b: The second matrix as a list of lists.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> matrix_multiplication([[1, 2], [3, 4]], [[5, 6], [7, 8]]) {'result': [[19, 22], [43, 50]]}

Transposes a matrix.

Args: matrix: The matrix to transpose as a list of lists.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> matrix_transpose([[1, 2], [3, 4]]) {'result': [[1, 3], [2, 4]]}

Computes the determinant of a square matrix.

Args: matrix: A square matrix as a list of rows.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> matrix_determinant([[1, 2], [3, 4]]) {'result': -2.0}

Computes the dot product of two equal-length vectors.

Args: vector_a: The first vector as a list of numbers. vector_b: The second vector as a list of numbers.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> vector_dot_product([1, 2], [7, 8]) {'result': 23}

Computes the cross product of two 2D or 3D vectors.

Args: vector_a: The first vector as a list of numbers. vector_b: The second vector as a list of numbers.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> vector_cross_product([1, 2, 3], [4, 5, 6]) {'result': [-3, 6, -3]}

Computes the magnitude of a vector.

Args: vector: A vector as a list of numbers.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> vector_magnitude([1, 2, 3]) {'result': 3.7416573867739413}

Plots a graph of y = f(x).

Args: expression: The function expression as a string. start: The first x value to plot. end: The final x value to plot. step: The number of x samples to render.

Returns: On success: {"result": "Plot generated successfully.", "format": "png", ...} On error: {"error": }

Notes: - Use 'x' as the variable (e.g., x2, not x^2) - Multiplication must be explicitly indicated with * (e.g., 2*x, not 2x) - Powers can be represented with ** or ^ (e.g., x2 or x^2)

Calculates the summation of a function from start to end.

Args: expression: The expression of function x as a string. start: The starting value of the summation. end: The ending value of the summation.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> summation("x**2", 0, 10) {'result': 385}

Expands an expression.

Args: expression: The expression to expand as a string.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> expand("(x + 1)2") {'result': 'x2 + 2*x + 1'}

Factorizes an expression.

Args: expression: The expression to factorize as a string.

Returns: On success: {"result": } On error: {"error": }

Examples: >>> factorize("x**2 + 2*x + 1") {'result': '(x + 1)**2'}