algebra & arithmetic modularized

maths/algebra/algebra.py

@@ -1,213 +0,0 @@
-"""
-Basic algebra operations for middle school level.
-"""
-import cmath
-from fractions import Fraction
-
-def solve_linear_equation(a, b):
-    """
-    Solve the equation ax = b for x.
-    Returns the value of x.
-    """
-    if a == 0:
-        if b == 0:
-            return "Infinite solutions"
-        return "No solution"
-    return b / a
-
-def evaluate_expression(a, b, c, x):
-    """
-    Evaluate the expression ax² + bx + c for a given value of x.
-    """
-    return a * (x ** 2) + b * x + c
-
-
-def solve_quadratic(a: float, b: float, c: float, return_format: str = "string"):
-    """
-    Solve the quadratic equation ax^2 + bx + c = 0.
-
-    Args:
-        a: Coefficient of x^2.
-        b: Coefficient of x.
-        c: Constant term.
-        return_format: Format of return value - "string" for human-readable string
-                      or "dict" for dictionary with roots and vertex.
-
-    Returns:
-        Either a string representing the solutions or a dictionary with roots and vertex.
-    """
-    if a == 0:
-        if b == 0:
-            result = "Not a valid equation (a and b cannot both be zero)." if c != 0 else "Infinite solutions (0 = 0)"
-            return result if return_format == "string" else {"error": result}
-        # Linear equation: bx + c = 0 -> x = -c/b
-        root = -c/b
-        if return_format == "string":
-            return f"Linear equation: x = {root}"
-        else:
-            return {"roots": (root, None), "vertex": None}
-
-    # Calculate vertex
-    vertex_x = -b / (2 * a)
-    vertex_y = c - (b**2 / (4 * a))
-    vertex = (vertex_x, vertex_y)
-    
-    # Calculate discriminant and roots
-    delta = b**2 - 4*a*c
-    
-    if return_format == "dict":
-        # Use cmath for complex roots
-        discriminant = cmath.sqrt(b**2 - 4*a*c)
-        root1 = (-b + discriminant) / (2 * a)
-        root2 = (-b - discriminant) / (2 * a)
-        
-        # Convert to fraction if possible
-        if root1.imag == 0 and root2.imag == 0:
-            root1 = Fraction(root1.real).limit_denominator()
-            root2 = Fraction(root2.real).limit_denominator()
-        
-        return {"roots": (root1, root2), "vertex": vertex}
-    
-    # For string format, handle different cases
-    if delta > 0:
-        x1 = (-b + delta**0.5) / (2*a)
-        x2 = (-b - delta**0.5) / (2*a)
-        # Try to convert to fractions for cleaner display
-        try:
-            x1_frac = Fraction(x1).limit_denominator()
-            x2_frac = Fraction(x2).limit_denominator()
-            return f"Two distinct real roots: x1 = {x1_frac}, x2 = {x2_frac}\nVertex at: {vertex}"
-        except:
-            return f"Two distinct real roots: x1 = {x1}, x2 = {x2}\nVertex at: {vertex}"
-    elif delta == 0:
-        x1 = -b / (2*a)
-        try:
-            x1_frac = Fraction(x1).limit_denominator()
-            return f"One real root (repeated): x = {x1_frac}\nVertex at: {vertex}"
-        except:
-            return f"One real root (repeated): x = {x1}\nVertex at: {vertex}"
-    else: # delta < 0
-        real_part = -b / (2*a)
-        imag_part = (-delta)**0.5 / (2*a)
-        return f"Two complex roots: x1 = {real_part} + {imag_part}i, x2 = {real_part} - {imag_part}i\nVertex at: {vertex}"
-
-
-def simplify_radical(number: int) -> str:
-    """
-    Simplifies a radical (square root) to its simplest form (e.g., sqrt(12) -> 2*sqrt(3)).
-
-    Args:
-        number: The number under the radical.
-
-    Returns:
-        A string representing the simplified radical.
-    """
-    if not isinstance(number, int):
-        return "Input must be an integer."
-    if number < 0:
-        return "Cannot simplify the square root of a negative number with this function."
-    if number == 0:
-        return "0"
-
-    i = 2
-    factor = 1
-    remaining = number
-    while i * i <= remaining:
-        if remaining % (i * i) == 0:
-            factor *= i
-            remaining //= (i*i)
-            # Restart checking with the same i in case of factors like i^4, i^6 etc.
-            continue
-        i += 1
-
-    if factor == 1:
-        return f"sqrt({remaining})"
-    if remaining == 1:
-        return str(factor)
-    return f"{factor}*sqrt({remaining})"
-
-
-def polynomial_operations(poly1_coeffs: list[float], poly2_coeffs: list[float], operation: str) -> str:
-    """
-    Performs addition, subtraction, or multiplication of two polynomials.
-    Polynomials are represented by lists of coefficients in descending order of power.
-    Example: [1, -2, 3] represents x^2 - 2x + 3.
-
-    Args:
-        poly1_coeffs: Coefficients of the first polynomial.
-        poly2_coeffs: Coefficients of the second polynomial.
-        operation: "add", "subtract", or "multiply".
-
-    Returns:
-        A string representing the resulting polynomial or an error message.
-    """
-    if not all(isinstance(c, (int, float)) for c in poly1_coeffs) or \
-       not all(isinstance(c, (int, float)) for c in poly2_coeffs):
-        return "Error: All coefficients must be numbers."
-
-    if not poly1_coeffs:
-        poly1_coeffs = [0]
-    if not poly2_coeffs:
-        poly2_coeffs = [0]
-
-    op = operation.lower()
-
-    if op == "add":
-        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
-        max_len = max(len1, len2)
-        p1 = [0]*(max_len - len1) + poly1_coeffs
-        p2 = [0]*(max_len - len2) + poly2_coeffs
-        result_coeffs = [p1[i] + p2[i] for i in range(max_len)]
-    elif op == "subtract":
-        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
-        max_len = max(len1, len2)
-        p1 = [0]*(max_len - len1) + poly1_coeffs
-        p2 = [0]*(max_len - len2) + poly2_coeffs
-        result_coeffs = [p1[i] - p2[i] for i in range(max_len)]
-    elif op == "multiply":
-        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
-        result_coeffs = [0] * (len1 + len2 - 1)
-        for i in range(len1):
-            for j in range(len2):
-                result_coeffs[i+j] += poly1_coeffs[i] * poly2_coeffs[j]
-    else:
-        return "Error: Invalid operation. Choose 'add', 'subtract', or 'multiply'."
-
-    # Format the result string
-    if not result_coeffs or all(c == 0 for c in result_coeffs):
-        return "0"
-
-    terms = []
-    degree = len(result_coeffs) - 1
-    for i, coeff in enumerate(result_coeffs):
-        power = degree - i
-        if coeff == 0:
-            continue
-
-        term_coeff = ""
-        if coeff == 1 and power != 0:
-            term_coeff = ""
-        elif coeff == -1 and power != 0:
-            term_coeff = "-"
-        else:
-            term_coeff = str(coeff)
-            if isinstance(coeff, float) and coeff.is_integer():
-                term_coeff = str(int(coeff))
-
-
-        if power == 0:
-            terms.append(term_coeff)
-        elif power == 1:
-            terms.append(f"{term_coeff}x")
-        else:
-            terms.append(f"{term_coeff}x^{power}")
-
-    # Join terms, handling signs
-    result_str = terms[0]
-    for term in terms[1:]:
-        if term.startswith("-"):
-            result_str += f" - {term[1:]}"
-        else:
-            result_str += f" + {term}"
-
-    return result_str

maths/algebra/algebra_interface.py

@@ -1,8 +1,9 @@
 import gradio as gr
-from maths.algebra.algebra import (
-    solve_linear_equation, evaluate_expression, solve_quadratic, 
-    simplify_radical, polynomial_operations
-)
+from maths.algebra.solve_linear_equation import solve_linear_equation
+from maths.algebra.evaluate_expression import evaluate_expression
+from maths.algebra.solve_quadratic import solve_quadratic
+from maths.algebra.simplify_radical import simplify_radical
+from maths.algebra.polynomial_operations import polynomial_operations
 
 # Middle School Math Tab
 solve_linear_equation_interface = gr.Interface(

maths/algebra/evaluate_expression.py

@@ -0,0 +1,5 @@
+"""
+Evaluate the expression ax² + bx + c for a given value of x.
+"""
+def evaluate_expression(a, b, c, x):
+    return a * (x ** 2) + b * x + c

maths/algebra/polynomial_operations.py

@@ -0,0 +1,64 @@
+"""
+Performs addition, subtraction, or multiplication of two polynomials.
+Polynomials are represented by lists of coefficients in descending order of power.
+Example: [1, -2, 3] represents x^2 - 2x + 3.
+"""
+def polynomial_operations(poly1_coeffs: list[float], poly2_coeffs: list[float], operation: str) -> str:
+    if not all(isinstance(c, (int, float)) for c in poly1_coeffs) or \
+       not all(isinstance(c, (int, float)) for c in poly2_coeffs):
+        return "Error: All coefficients must be numbers."
+    if not poly1_coeffs:
+        poly1_coeffs = [0]
+    if not poly2_coeffs:
+        poly2_coeffs = [0]
+    op = operation.lower()
+    if op == "add":
+        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
+        max_len = max(len1, len2)
+        p1 = [0]*(max_len - len1) + poly1_coeffs
+        p2 = [0]*(max_len - len2) + poly2_coeffs
+        result_coeffs = [p1[i] + p2[i] for i in range(max_len)]
+    elif op == "subtract":
+        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
+        max_len = max(len1, len2)
+        p1 = [0]*(max_len - len1) + poly1_coeffs
+        p2 = [0]*(max_len - len2) + poly2_coeffs
+        result_coeffs = [p1[i] - p2[i] for i in range(max_len)]
+    elif op == "multiply":
+        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
+        result_coeffs = [0] * (len1 + len2 - 1)
+        for i in range(len1):
+            for j in range(len2):
+                result_coeffs[i+j] += poly1_coeffs[i] * poly2_coeffs[j]
+    else:
+        return "Error: Invalid operation. Choose 'add', 'subtract', or 'multiply'."
+    if not result_coeffs or all(c == 0 for c in result_coeffs):
+        return "0"
+    terms = []
+    degree = len(result_coeffs) - 1
+    for i, coeff in enumerate(result_coeffs):
+        power = degree - i
+        if coeff == 0:
+            continue
+        term_coeff = ""
+        if coeff == 1 and power != 0:
+            term_coeff = ""
+        elif coeff == -1 and power != 0:
+            term_coeff = "-"
+        else:
+            term_coeff = str(coeff)
+            if isinstance(coeff, float) and coeff.is_integer():
+                term_coeff = str(int(coeff))
+        if power == 0:
+            terms.append(term_coeff)
+        elif power == 1:
+            terms.append(f"{term_coeff}x")
+        else:
+            terms.append(f"{term_coeff}x^{power}")
+    result_str = terms[0]
+    for term in terms[1:]:
+        if term.startswith("-"):
+            result_str += f" - {term[1:]}"
+        else:
+            result_str += f" + {term}"
+    return result_str

maths/algebra/simplify_radical.py

@@ -0,0 +1,24 @@
+"""
+Simplifies a radical (square root) to its simplest form (e.g., sqrt(12) -> 2*sqrt(3)).
+"""
+def simplify_radical(number: int) -> str:
+    if not isinstance(number, int):
+        return "Input must be an integer."
+    if number < 0:
+        return "Cannot simplify the square root of a negative number with this function."
+    if number == 0:
+        return "0"
+    i = 2
+    factor = 1
+    remaining = number
+    while i * i <= remaining:
+        if remaining % (i * i) == 0:
+            factor *= i
+            remaining //= (i*i)
+            continue
+        i += 1
+    if factor == 1:
+        return f"sqrt({remaining})"
+    if remaining == 1:
+        return str(factor)
+    return f"{factor}*sqrt({remaining})"

maths/algebra/solve_linear_equation.py

@@ -0,0 +1,9 @@
+"""
+Solve the equation ax = b for x.
+"""
+def solve_linear_equation(a, b):
+    if a == 0:
+        if b == 0:
+            return "Infinite solutions"
+        return "No solution"
+    return b / a

maths/algebra/solve_quadratic.py

@@ -0,0 +1,48 @@
+"""
+Solve the quadratic equation ax^2 + bx + c = 0.
+"""
+import cmath
+from fractions import Fraction
+
+def solve_quadratic(a: float, b: float, c: float, return_format: str = "string"):
+    if a == 0:
+        if b == 0:
+            result = "Not a valid equation (a and b cannot both be zero)." if c != 0 else "Infinite solutions (0 = 0)"
+            return result if return_format == "string" else {"error": result}
+        root = -c/b
+        if return_format == "string":
+            return f"Linear equation: x = {root}"
+        else:
+            return {"roots": (root, None), "vertex": None}
+    vertex_x = -b / (2 * a)
+    vertex_y = c - (b**2 / (4 * a))
+    vertex = (vertex_x, vertex_y)
+    delta = b**2 - 4*a*c
+    if return_format == "dict":
+        discriminant = cmath.sqrt(b**2 - 4*a*c)
+        root1 = (-b + discriminant) / (2 * a)
+        root2 = (-b - discriminant) / (2 * a)
+        if root1.imag == 0 and root2.imag == 0:
+            root1 = Fraction(root1.real).limit_denominator()
+            root2 = Fraction(root2.real).limit_denominator()
+        return {"roots": (root1, root2), "vertex": vertex}
+    if delta > 0:
+        x1 = (-b + delta**0.5) / (2*a)
+        x2 = (-b - delta**0.5) / (2*a)
+        try:
+            x1_frac = Fraction(x1).limit_denominator()
+            x2_frac = Fraction(x2).limit_denominator()
+            return f"Two distinct real roots: x1 = {x1_frac}, x2 = {x2_frac}\nVertex at: {vertex}"
+        except:
+            return f"Two distinct real roots: x1 = {x1}, x2 = {x2}\nVertex at: {vertex}"
+    elif delta == 0:
+        x1 = -b / (2*a)
+        try:
+            x1_frac = Fraction(x1).limit_denominator()
+            return f"One real root (repeated): x = {x1_frac}\nVertex at: {vertex}"
+        except:
+            return f"One real root (repeated): x = {x1}\nVertex at: {vertex}"
+    else:
+        real_part = -b / (2*a)
+        imag_part = (-delta)**0.5 / (2*a)
+        return f"Two complex roots: x1 = {real_part} + {imag_part}i, x2 = {real_part} - {imag_part}i\nVertex at: {vertex}"

maths/arithmetic/add.py

@@ -0,0 +1,9 @@
+import numpy as np
+from typing import Union
+
+def add(a: float, b: float) -> float:
+    """Add two numbers."""
+    try:
+        return float(a) + float(b)
+    except (ValueError, TypeError):
+        raise ValueError("Both inputs must be valid numbers")

maths/arithmetic/arithmetic.py

@@ -1,244 +0,0 @@
-"""
-Enhanced arithmetic operations for elementary level with visualization capabilities.
-"""
-import numpy as np
-import matplotlib.pyplot as plt
-from typing import Union, Tuple, Any
-
-def add(a: float, b: float) -> float:
-    """Add two numbers."""
-    try:
-        return float(a) + float(b)
-    except (ValueError, TypeError):
-        raise ValueError("Both inputs must be valid numbers")
-
-def subtract(a: float, b: float) -> float:
-    """Subtract b from a."""
-    try:
-        return float(a) - float(b)
-    except (ValueError, TypeError):
-        raise ValueError("Both inputs must be valid numbers")
-
-def multiply(a: float, b: float) -> float:
-    """Multiply two numbers."""
-    try:
-        return float(a) * float(b)
-    except (ValueError, TypeError):
-        raise ValueError("Both inputs must be valid numbers")
-
-def divide(a: float, b: float) -> Union[float, str]:
-    """Divide a by b."""
-    try:
-        a, b = float(a), float(b)
-        if b == 0:
-            return "Error: Division by zero"
-        return a / b
-    except (ValueError, TypeError):
-        return "Error: Both inputs must be valid numbers"
-
-def create_number_line_visualization(numbers: list, operation: str, result: float) -> plt.Figure:
-    """Create a number line visualization for arithmetic operations."""
-    fig, ax = plt.subplots(figsize=(10, 4))
-    
-    # Determine range for number line
-    all_nums = numbers + [result]
-    min_val = min(all_nums) - 2
-    max_val = max(all_nums) + 2
-    
-    # Draw number line
-    ax.axhline(y=0, color='black', linewidth=2)
-    ax.set_xlim(min_val, max_val)
-    ax.set_ylim(-1, 1)
-    
-    # Add tick marks and labels
-    tick_range = np.arange(int(min_val), int(max_val) + 1)
-    ax.set_xticks(tick_range)
-    for tick in tick_range:
-        ax.axvline(x=tick, ymin=0.4, ymax=0.6, color='black', linewidth=1)
-    
-    # Highlight the numbers involved in the operation
-    colors = ['red', 'blue', 'green']
-    for i, num in enumerate(numbers):
-        ax.plot(num, 0, 'o', markersize=10, color=colors[i % len(colors)], 
-                label=f'Number {i+1}: {num}')
-    
-    # Highlight the result
-    ax.plot(result, 0, 's', markersize=12, color='purple', label=f'Result: {result}')
-    
-    # Add operation description
-    if len(numbers) == 2:
-        op_symbol = {'add': '+', 'subtract': '-', 'multiply': '×', 'divide': '÷'}.get(operation, '?')
-        title = f"{numbers[0]} {op_symbol} {numbers[1]} = {result}"
-    else:
-        title = f"Result: {result}"
-    
-    ax.set_title(title, fontsize=14, fontweight='bold')
-    ax.legend(loc='upper right')
-    ax.set_ylabel('')
-    ax.set_xlabel('Number Line')
-    ax.grid(True, alpha=0.3)
-    
-    return fig
-
-def arithmetic_with_visualization(a: float, b: float, operation: str) -> Tuple[Any, plt.Figure]:
-    """Perform arithmetic operation and return result with visualization."""
-    try:
-        a, b = float(a), float(b)
-        
-        if operation == 'add':
-            result = add(a, b)
-        elif operation == 'subtract':
-            result = subtract(a, b)
-        elif operation == 'multiply':
-            result = multiply(a, b)
-        elif operation == 'divide':
-            result = divide(a, b)
-            if isinstance(result, str):  # Error case
-                return result, None
-        else:
-            return "Error: Unknown operation", None
-        
-        # Create visualization
-        fig = create_number_line_visualization([a, b], operation, result)
-        
-        return result, fig
-        
-    except Exception as e:
-        return f"Error: {str(e)}", None
-
-def create_multiplication_table(number: int, max_multiplier: int = 12) -> plt.Figure:
-    """Create a visual multiplication table."""
-    fig, ax = plt.subplots(figsize=(8, 6))
-    
-    multipliers = np.arange(1, max_multiplier + 1)
-    results = number * multipliers
-    
-    # Create bar chart
-    bars = ax.bar(multipliers, results, color='skyblue', alpha=0.7, edgecolor='navy')
-    
-    # Add value labels on bars
-    for bar, result in zip(bars, results):
-        height = bar.get_height()
-        ax.text(bar.get_x() + bar.get_width()/2., height + max(results) * 0.01,
-                f'{result}', ha='center', va='bottom', fontweight='bold')
-    
-    ax.set_xlabel('Multiplier', fontsize=12)
-    ax.set_ylabel('Result', fontsize=12)
-    ax.set_title(f'Multiplication Table for {number}', fontsize=14, fontweight='bold')
-    ax.grid(True, alpha=0.3)
-    ax.set_xticks(multipliers)
-    
-    return fig
-
-def calculate_array(numbers: list, operations: list) -> float:
-    """
-    Perform a sequence of arithmetic operations on an array of numbers.
-    Example: numbers=[2, 3, 4], operations=['add', 'multiply'] means (2 + 3) * 4
-    Supported operations: 'add', 'subtract', 'multiply', 'divide'
-    """
-    if not numbers or not operations:
-        raise ValueError("Both numbers and operations must be provided and non-empty.")
-    if len(operations) != len(numbers) - 1:
-        raise ValueError("Number of operations must be one less than number of numbers.")
-    
-    result = float(numbers[0])
-    for i, op in enumerate(operations):
-        num = float(numbers[i+1])
-        if op == 'add':
-            result = add(result, num)
-        elif op == 'subtract':
-            result = subtract(result, num)
-        elif op == 'multiply':
-            result = multiply(result, num)
-        elif op == 'divide':
-            result = divide(result, num)
-            if isinstance(result, str):  # Error case
-                return result
-        else:
-            raise ValueError(f"Unsupported operation: {op}")
-    return result
-
-
-def calculate_array_with_visualization(numbers: list, operations: list) -> tuple:
-    """
-    Perform a sequence of arithmetic operations on an array of numbers and return result with visualization.
-    Visualization shows the step-by-step calculation on a number line.
-    """
-    if not numbers or not operations:
-        return "Error: Both numbers and operations must be provided and non-empty.", None
-    if len(operations) != len(numbers) - 1:
-        return "Error: Number of operations must be one less than number of numbers.", None
-    
-    step_results = [float(numbers[0])]
-    result = float(numbers[0])
-    for i, op in enumerate(operations):
-        num = float(numbers[i+1])
-        if op == 'add':
-            result = add(result, num)
-        elif op == 'subtract':
-            result = subtract(result, num)
-        elif op == 'multiply':
-            result = multiply(result, num)
-        elif op == 'divide':
-            result = divide(result, num)
-            if isinstance(result, str):  # Error case
-                return result, None
-        else:
-            return f"Error: Unsupported operation: {op}", None
-        step_results.append(result)
-    # Visualization: show all intermediate results on the number line
-    fig = create_number_line_visualization(numbers, ' -> '.join(operations), result)
-    return result, fig
-
-
-def gcd(a: int, b: int) -> int:
-    """Compute the greatest common divisor of two integers.
-
-    Args:
-        a: The first integer.
-        b: The second integer.
-
-    Returns:
-        The greatest common divisor of a and b.
-    """
-    while b:
-        a, b = b, a % b
-    return abs(a)
-
-
-def lcm(a: int, b: int) -> int:
-    """Compute the least common multiple of two integers.
-
-    Args:
-        a: The first integer.
-        b: The second integer.
-
-    Returns:
-        The least common multiple of a and b.
-    """
-    if a == 0 or b == 0:
-        return 0
-    return abs(a * b) // gcd(a, b)
-
-
-def is_prime(n: int) -> bool:
-    """Check if a number is a prime number.
-
-    Args:
-        n: The number to check.
-
-    Returns:
-        True if n is prime, False otherwise.
-    """
-    if n <= 1:
-        return False
-    if n <= 3:
-        return True
-    if n % 2 == 0 or n % 3 == 0:
-        return False
-    i = 5
-    while i * i <= n:
-        if n % i == 0 or n % (i + 2) == 0:
-            return False
-        i += 6
-    return True

maths/arithmetic/arithmetic_interface.py

@@ -1,5 +1,13 @@
 import gradio as gr
-from maths.arithmetic.arithmetic import add, subtract, multiply, divide, calculate_array, calculate_array_with_visualization, gcd, lcm, is_prime
+from .add import add
+from .subtract import subtract
+from .multiply import multiply
+from .divide import divide
+from .calculate_array import calculate_array
+from .calculate_array_with_visualization import calculate_array_with_visualization
+from .gcd import gcd
+from .lcm import lcm
+from .is_prime import is_prime
 
 # Elementary Math Tab
 add_interface = gr.Interface(

maths/arithmetic/arithmetic_with_visualization.py

@@ -0,0 +1,28 @@
+import matplotlib.pyplot as plt
+from typing import Any, Tuple
+from .add import add
+from .subtract import subtract
+from .multiply import multiply
+from .divide import divide
+from .number_line_visualization import create_number_line_visualization
+
+def arithmetic_with_visualization(a: float, b: float, operation: str) -> Tuple[Any, plt.Figure]:
+    """Perform arithmetic operation and return result with visualization."""
+    try:
+        a, b = float(a), float(b)
+        if operation == 'add':
+            result = add(a, b)
+        elif operation == 'subtract':
+            result = subtract(a, b)
+        elif operation == 'multiply':
+            result = multiply(a, b)
+        elif operation == 'divide':
+            result = divide(a, b)
+            if isinstance(result, str):
+                return result, None
+        else:
+            return "Error: Unknown operation", None
+        fig = create_number_line_visualization([a, b], operation, result)
+        return result, fig
+    except Exception as e:
+        return f"Error: {str(e)}", None

maths/arithmetic/calculate_array.py

@@ -0,0 +1,31 @@
+from .add import add
+from .subtract import subtract
+from .multiply import multiply
+from .divide import divide
+
+def calculate_array(numbers: list, operations: list) -> float:
+    """
+    Perform a sequence of arithmetic operations on an array of numbers.
+    Example: numbers=[2, 3, 4], operations=['add', 'multiply'] means (2 + 3) * 4
+    Supported operations: 'add', 'subtract', 'multiply', 'divide'
+    """
+    if not numbers or not operations:
+        raise ValueError("Both numbers and operations must be provided and non-empty.")
+    if len(operations) != len(numbers) - 1:
+        raise ValueError("Number of operations must be one less than number of numbers.")
+    result = float(numbers[0])
+    for i, op in enumerate(operations):
+        num = float(numbers[i+1])
+        if op == 'add':
+            result = add(result, num)
+        elif op == 'subtract':
+            result = subtract(result, num)
+        elif op == 'multiply':
+            result = multiply(result, num)
+        elif op == 'divide':
+            result = divide(result, num)
+            if isinstance(result, str):
+                return result
+        else:
+            raise ValueError(f"Unsupported operation: {op}")
+    return result

maths/arithmetic/calculate_array_with_visualization.py

@@ -0,0 +1,35 @@
+import matplotlib.pyplot as plt
+from .add import add
+from .subtract import subtract
+from .multiply import multiply
+from .divide import divide
+from .number_line_visualization import create_number_line_visualization
+
+def calculate_array_with_visualization(numbers: list, operations: list) -> tuple:
+    """
+    Perform a sequence of arithmetic operations on an array of numbers and return result with visualization.
+    Visualization shows the step-by-step calculation on a number line.
+    """
+    if not numbers or not operations:
+        return "Error: Both numbers and operations must be provided and non-empty.", None
+    if len(operations) != len(numbers) - 1:
+        return "Error: Number of operations must be one less than number of numbers.", None
+    step_results = [float(numbers[0])]
+    result = float(numbers[0])
+    for i, op in enumerate(operations):
+        num = float(numbers[i+1])
+        if op == 'add':
+            result = add(result, num)
+        elif op == 'subtract':
+            result = subtract(result, num)
+        elif op == 'multiply':
+            result = multiply(result, num)
+        elif op == 'divide':
+            result = divide(result, num)
+            if isinstance(result, str):
+                return result, None
+        else:
+            return f"Error: Unsupported operation: {op}", None
+        step_results.append(result)
+    fig = create_number_line_visualization(numbers, ' -> '.join(operations), result)
+    return result, fig

maths/arithmetic/divide.py

@@ -0,0 +1,11 @@
+from typing import Union
+
+def divide(a: float, b: float) -> Union[float, str]:
+    """Divide a by b."""
+    try:
+        a, b = float(a), float(b)
+        if b == 0:
+            return "Error: Division by zero"
+        return a / b
+    except (ValueError, TypeError):
+        return "Error: Both inputs must be valid numbers"

maths/arithmetic/gcd.py

@@ -0,0 +1,5 @@
+def gcd(a: int, b: int) -> int:
+    """Compute the greatest common divisor of two integers."""
+    while b:
+        a, b = b, a % b
+    return abs(a)

maths/arithmetic/is_prime.py

@@ -0,0 +1,14 @@
+def is_prime(n: int) -> bool:
+    """Check if a number is a prime number."""
+    if n <= 1:
+        return False
+    if n <= 3:
+        return True
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return False
+        i += 6
+    return True

maths/arithmetic/lcm.py

@@ -0,0 +1,7 @@
+from .gcd import gcd
+
+def lcm(a: int, b: int) -> int:
+    """Compute the least common multiple of two integers."""
+    if a == 0 or b == 0:
+        return 0
+    return abs(a * b) // gcd(a, b)

maths/arithmetic/multiplication_table.py

@@ -0,0 +1,19 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def create_multiplication_table(number: int, max_multiplier: int = 12) -> plt.Figure:
+    """Create a visual multiplication table."""
+    fig, ax = plt.subplots(figsize=(8, 6))
+    multipliers = np.arange(1, max_multiplier + 1)
+    results = number * multipliers
+    bars = ax.bar(multipliers, results, color='skyblue', alpha=0.7, edgecolor='navy')
+    for bar, result in zip(bars, results):
+        height = bar.get_height()
+        ax.text(bar.get_x() + bar.get_width()/2., height + max(results) * 0.01,
+                f'{result}', ha='center', va='bottom', fontweight='bold')
+    ax.set_xlabel('Multiplier', fontsize=12)
+    ax.set_ylabel('Result', fontsize=12)
+    ax.set_title(f'Multiplication Table for {number}', fontsize=14, fontweight='bold')
+    ax.grid(True, alpha=0.3)
+    ax.set_xticks(multipliers)
+    return fig

maths/arithmetic/multiply.py

@@ -0,0 +1,9 @@
+import numpy as np
+from typing import Union
+
+def multiply(a: float, b: float) -> float:
+    """Multiply two numbers."""
+    try:
+        return float(a) * float(b)
+    except (ValueError, TypeError):
+        raise ValueError("Both inputs must be valid numbers")

maths/arithmetic/number_line_visualization.py

@@ -0,0 +1,32 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def create_number_line_visualization(numbers: list, operation: str, result: float) -> plt.Figure:
+    """Create a number line visualization for arithmetic operations."""
+    fig, ax = plt.subplots(figsize=(10, 4))
+    all_nums = numbers + [result]
+    min_val = min(all_nums) - 2
+    max_val = max(all_nums) + 2
+    ax.axhline(y=0, color='black', linewidth=2)
+    ax.set_xlim(min_val, max_val)
+    ax.set_ylim(-1, 1)
+    tick_range = np.arange(int(min_val), int(max_val) + 1)
+    ax.set_xticks(tick_range)
+    for tick in tick_range:
+        ax.axvline(x=tick, ymin=0.4, ymax=0.6, color='black', linewidth=1)
+    colors = ['red', 'blue', 'green']
+    for i, num in enumerate(numbers):
+        ax.plot(num, 0, 'o', markersize=10, color=colors[i % len(colors)], 
+                label=f'Number {i+1}: {num}')
+    ax.plot(result, 0, 's', markersize=12, color='purple', label=f'Result: {result}')
+    if len(numbers) == 2:
+        op_symbol = {'add': '+', 'subtract': '-', 'multiply': '×', 'divide': '÷'}.get(operation, '?')
+        title = f"{numbers[0]} {op_symbol} {numbers[1]} = {result}"
+    else:
+        title = f"Result: {result}"
+    ax.set_title(title, fontsize=14, fontweight='bold')
+    ax.legend(loc='upper right')
+    ax.set_ylabel('')
+    ax.set_xlabel('Number Line')
+    ax.grid(True, alpha=0.3)
+    return fig

maths/arithmetic/subtract.py

@@ -0,0 +1,9 @@
+import numpy as np
+from typing import Union
+
+def subtract(a: float, b: float) -> float:
+    """Subtract b from a."""
+    try:
+        return float(a) - float(b)
+    except (ValueError, TypeError):
+        raise ValueError("Both inputs must be valid numbers")