changed routing from education level to topics in maths

README.md

@@ -1,146 +1,60 @@
----
-title: Math Tools
-emoji: 🧮
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 5.32.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Mathematics tools for different educational levels
----
+# Math Tools
 
-# Math Education Tools
+## Overview
 
-This web application provides a comprehensive suite of mathematical tools and interactive calculators, categorized by educational levels from elementary school through university. Built with Python and featuring user-friendly Gradio interfaces, it aims to assist with learning and performing a wide array of mathematical operations.
+This application provides a suite of mathematical tools organized by topic (e.g., Algebra, Calculus, Differential Equations) rather than by education level. It's built with Python and Gradio to offer interactive calculators for various mathematical domains.
 
 ## Features
 
-### Text Utils
-
-- Letter Counter: Count occurrences of a specific letter in a word
-
-### Elementary School Math
-
-- Addition: Add two numbers
-- Subtraction: Subtract one number from another
-- Multiplication: Multiply two numbers
-- Division: Divide one number by another
-- Greatest Common Divisor (GCD): Find the GCD of two integers.
-- Least Common Multiple (LCM): Find the LCM of two integers.
-- Prime Number Checker: Check if a number is prime.
-- Array Calculation: Perform basic operations on a list of numbers.
-- Array Calculation with Visualization: Array calculation with a number line plot.
-
-### Middle School Math
-
-- Linear Equation Solver: Solve equations of the form ax = b.
-- Quadratic Expression Evaluator: Calculate the value of ax² + bx + c for a given x.
-- Quadratic Equation Solver: Find roots of ax² + bx + c = 0.
-- Radical Simplifier: Simplify square roots (e.g., √12 to 2√3).
-- Polynomial Operations: Add, subtract, and multiply polynomials.
-
-### High School Math
-
-- Trigonometry Calculator: Calculate sine, cosine, and tangent values for angles in degrees.
-- Inverse Trigonometric Functions: Calculate asin, acos, atan in degrees.
-- Trigonometric Equation Solver: Solve basic trigonometric equations.
-- Trigonometric Identities: Demonstrate common identities like sin²(x) + cos²(x) = 1.
-
-### University Math
-
-#### Calculus
-
-- Polynomial Derivative: Find the derivative of a polynomial function.
-- Polynomial Integration: Find the indefinite integral of a polynomial function.
-- Limits: Calculate the limit of an expression as a variable approaches a point.
-- Series Expansion: Compute Taylor series for functions. Includes examples for Fourier series.
-- Partial Derivatives: Compute partial derivatives of multi-variable expressions.
-- Multiple Integrals: Evaluate definite multiple integrals.
-
-#### Linear Algebra
-
-- Matrix Operations: Addition, subtraction, multiplication.
-- Matrix Analysis: Determinant and inverse of matrices.
-- Vector Operations: Addition, subtraction, dot product, and cross product (for 3D vectors).
-- System Solver: Solve systems of linear equations (Ax = B).
-
-#### Differential Equations
-
-- First-Order ODEs: Solve single or systems of first-order ordinary differential equations with initial conditions.
-- Second-Order ODEs: Solve second-order ordinary differential equations by converting to a system.
-- Solution Plotting: Visualize solutions for ODEs.
+- **Arithmetic**: Addition, Subtraction, Multiplication, Division, Array Calculations (with visualization)
+- **Number Theory**: GCD, LCM, Prime Checker
+- **Algebra**: Expression Evaluation, Radical Simplification, Polynomial Operations
+- **Equations**: Solvers for Linear, Quadratic, Trigonometric, and Linear Systems
+- **Geometry**: Trigonometric Functions, Inverse Trigonometry, Identities
+- **Calculus**: Derivatives, Integrals, Limits, Taylor & Fourier Series, Partial Derivatives, Multiple Integrals
+- **Differential Equations**: First- and Second-Order ODE Solvers
+- **Matrices**: Addition, Subtraction, Multiplication, Determinant, Inverse
+- **Vectors**: Addition, Subtraction, Dot Product, Cross Product
+- **Operations Research**: Branch & Bound, Dual Simplex, Simplex Solver Steps
 
 ## Project Structure
 
+```text
+counting/
+├── app.py                              # Main Gradio application with topic-based tabs   
+├── requirements.txt                    # Python dependencies
+├── README.md                           # Project documentation (this file)
+└── maths/                              # Mathematical modules organized by topic
+    ├── arithmetic/                     # Arithmetic logic & interfaces
+    │   ├── arithmetic.py
+    │   └── arithmetic_interface.py
+    ├── number_theory/                  # Number theory logic & interfaces
+    │   ├── number_theory.py
+    │   └── number_theory_interface.py
+    ├── algebra/                        # Algebra logic & interfaces
+    │   ├── algebra.py
+    │   └── algebra_interface.py
+    ├── equations/                      # Equation solvers & interfaces
+    ���   ├── equations.py
+    │   └── equations_interface.py
+    ├── geometry/                       # Trigonometry & geometry logic & interfaces
+    │   ├── geometry.py
+    │   └── geometry_interface.py
+    ├── calculus/                       # Calculus logic & interfaces
+    │   ├── calculus.py
+    │   └── calculus_interface.py
+    ├── differential_equations/         # ODE solvers & interfaces
+    │   ├── differential_equations.py
+    │   └── differential_equations_interface.py
+    ├── matrices/                       # Matrix operations logic & interfaces
+    │   ├── matrices.py
+    │   └── matrices_interface.py
+    ├── vectors/                        # Vector operations logic & interfaces
+    │   ├── vectors.py
+    │   └── vectors_interface.py
+    └── operations_research/            # Operations research solvers & interfaces
+        ├── operations_research_interface.py
+        ├── BranchAndBoundSolver.py
+        ├── DualSimplexSolver.py
+        └── simplex_solver_with_steps.py
 ```
-├── app.py                    # Main Gradio application file
-├── requirements.txt          # Python package dependencies
-├── maths/                    # Core mathematics modules
-│   ├── __init__.py
-│   ├── elementary/           # Elementary school level functions and interfaces
-│   │   ├── __init__.py
-│   │   ├── arithmetic.py     # Logic for basic arithmetic, GCD, LCM, primes
-│   │   └── arithmetic_interface.py # Gradio interfaces for arithmetic
-│   ├── middleschool/         # Middle school level functions and interfaces
-│   │   ├── __init__.py
-│   │   ├── algebra.py        # Logic for linear/quadratic equations, polynomials
-│   │   └── algebra_interface.py # Gradio interfaces for algebra
-│   ├── highschool/           # High school level functions and interfaces
-│   │   ├── __init__.py
-│   │   ├── trigonometry.py   # Logic for trigonometric functions and equations
-│   │   └── trigonometry_interface.py # Gradio interfaces for trigonometry
-│   └── university/           # University level functions and interfaces
-│       ├── __init__.py
-│       ├── calculus.py       # Logic for calculus (limits, derivatives, integrals, series)
-│       ├── calculus_interface.py # Gradio interfaces for calculus
-│       ├── linear_algebra.py # Logic for matrix/vector operations, linear systems
-│       ├── linear_algebra_interface.py # Gradio interfaces for linear algebra
-│       ├── differential_equations.py # Logic for solving ODEs
-│       ├── differential_equations_interface.py # Gradio interfaces for ODEs
-│       └── tests/              # Unit tests for university level modules
-│           ├── __init__.py
-│           ├── test_linear_algebra.py
-│           └── test_differential_equations.py
-└── utils/                    # Utility functions and interfaces
-    ├── __init__.py
-    ├── text_utils.py         # Logic for text processing utilities
-    └── text_utils_interface.py # Gradio interface for text utils
-```
-
-## Getting Started
-
-1. Install the required packages:
-
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-2. Run the application:
-
-   ```
-   python app.py
-   ```
-
-3. Open your browser and navigate to the displayed URL (typically http://127.0.0.1:7860)
-
-## Extending the Project
-
-To add new mathematical functions or tools:
-
-1. **Create Logic**: Add your mathematical function/logic to an existing Python file in the appropriate `maths/<level>/` directory or create a new `.py` file for it. Ensure your functions have clear inputs, outputs, and docstrings.
-2. **Create Interface**: In the corresponding `maths/<level>/` directory (or a subdirectory like `interfaces` if preferred), create a `_interface.py` file (e.g., `newfeature_interface.py`) or add to an existing one. In this file, import your function(s) and create a Gradio interface for each. Define clear input and output components (e.g., `gr.Textbox()`, `gr.Number()`, `gr.Plot()`, `gr.Image()`).
-3. **Add Tests**: For more complex logic, especially at the university level, add unit tests in a corresponding `maths/<level>/tests/` directory (e.g., `test_newfeature.py`). Use the `unittest` module or `pytest`.
-4. **Update Main App**: Import your new Gradio interface object(s) in the main `app.py` file. Add the interface object(s) to the list of interfaces for the relevant educational level tab (e.g., `university_interfaces_list`) and provide a corresponding name in the tab names list (e.g., `university_tab_names`).
-5. **Update `__init__.py` Files**: Ensure your new modules and interface modules are importable by updating the `__init__.py` files in their respective directories if necessary (e.g., `from . import newfeature`, `from . import newfeature_interface`).
-6. **Update `requirements.txt`**: If your new feature introduces new external dependencies, add them to `requirements.txt`. It's good practice to pin versions (e.g., `new_package==1.2.3`).
-7. **Update README**: Document your new feature in the "Features" section and update the "Project Structure" if you added new files/directories.
-
-## License
-
-MIT
-
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,109 +1,127 @@
 import gradio as gr
-from utils.text_utils_interface import letter_counter_interface
-from maths.elementary.arithmetic_interface import (
+from maths.arithmetic.arithmetic_interface import (
     add_interface, subtract_interface, multiply_interface, divide_interface,
     array_calc_interface, array_calc_vis_interface,
     gcd_interface, lcm_interface, is_prime_interface # Assuming these were added earlier from a subtask
 )
-from maths.middleschool.algebra_interface import (
+from maths.algebra.algebra_interface import (
     solve_linear_equation_interface, evaluate_expression_interface,
     solve_quadratic_interface, simplify_radical_interface, polynomial_interface # Assuming these
 )
-from maths.highschool.trigonometry_interface import (
+from maths.geometry.trigonometry_interface import (
     trig_interface, inverse_trig_interface, solve_trig_equations_interface, trig_identities_interface # Assuming these
 )
-from maths.university.calculus_interface import (
+from maths.calculus.calculus_interface import (
     derivative_interface, integral_interface,
     limit_interface, taylor_series_interface, fourier_series_interface, # Assuming these
     partial_derivative_interface, multiple_integral_interface # Assuming these
 )
-from maths.university.linear_algebra_interface import (
+
+from maths.matrices.matrices_interface import (
     matrix_add_interface, matrix_subtract_interface, matrix_multiply_interface,
-    matrix_determinant_interface, matrix_inverse_interface,
-    vector_add_interface, vector_subtract_interface, vector_dot_product_interface,
-    vector_cross_product_interface, solve_linear_system_interface
+    matrix_determinant_interface, matrix_inverse_interface
+)
+
+from maths.vectors.vectors_interface import (
+    vector_add_interface, vector_subtract_interface,
+    vector_dot_product_interface, vector_cross_product_interface
 )
-from maths.university.differential_equations_interface import (
+
+from maths.differential_equations.differential_equations_interface import (
     first_order_ode_interface, second_order_ode_interface
 )
-from maths.university.operations_research.operations_research_interface import (
+from maths.operations_research.operations_research_interface import (
     branch_and_bound_interface, dual_simplex_interface, simplex_solver_interface
 )
 
-# Group interfaces by education level
-# Note: I'm assuming previous subtasks correctly added GCD, LCM, Polynomial, Quadratic, etc. interfaces to their respective files.
-# If not, this app.py will have import errors for those. I'm focusing on the current task's imports.
-elementary_interfaces_list = [
-    add_interface, subtract_interface, multiply_interface, divide_interface,
-    gcd_interface, lcm_interface, is_prime_interface, # Added from subtask 1
-    array_calc_interface, array_calc_vis_interface
+# Categorize interfaces by topics
+
+arithmetic_interfaces_list = [
+    add_interface, subtract_interface, multiply_interface,
+    divide_interface, array_calc_interface, array_calc_vis_interface
 ]
-elementary_tab_names = [
+arithmetic_tab_names = [
     "Addition", "Subtraction", "Multiplication", "Division",
-    "GCD", "LCM", "Prime Check", # Added from subtask 1
-    "Array Calculation", "Array Calc Viz"
+    "Array Calculation", "Array Calculation Viz"
 ]
 
-middleschool_interfaces_list = [
-    solve_linear_equation_interface, evaluate_expression_interface,
-    solve_quadratic_interface, simplify_radical_interface, polynomial_interface # Added from subtask 2
+number_theory_interfaces_list = [gcd_interface, lcm_interface, is_prime_interface]
+number_theory_tab_names = ["GCD", "LCM", "Prime Check"]
+
+algebra_interfaces_list = [evaluate_expression_interface, simplify_radical_interface, polynomial_interface]
+algebra_tab_names = ["Evaluate Expressions", "Radical Simplifier", "Polynomial Ops"]
+
+equations_interfaces_list = [
+    solve_linear_equation_interface, solve_quadratic_interface,
+    solve_trig_equations_interface
 ]
-middleschool_tab_names = [
-    "Linear Equations", "Evaluate Expressions",
-    "Quadratic Solver", "Radical Simplifier", "Polynomial Ops" # Added from subtask 2
+equations_tab_names = [
+    "Linear Equation Solver", "Quadratic Solver",
+    "Trigonometric Equation Solver"
 ]
 
-highschool_interfaces_list = [
-    trig_interface, inverse_trig_interface,
-    solve_trig_equations_interface, trig_identities_interface # Added from subtask 3
+geometry_interfaces_list = [trig_interface, inverse_trig_interface, trig_identities_interface]
+geometry_tab_names = ["Trig Functions", "Inverse Trig", "Trig Identities"]
+
+calculus_interfaces_list = [
+    derivative_interface, integral_interface, limit_interface,
+    taylor_series_interface, fourier_series_interface,
+    partial_derivative_interface, multiple_integral_interface
 ]
-highschool_tab_names = [
-    "Trig Functions", "Inverse Trig",
-    "Solve Trig Eqs", "Trig Identities" # Added from subtask 3
+calculus_tab_names = [
+    "Derivative", "Integral", "Limits",
+    "Taylor Series", "Fourier Series",
+    "Partial Derivatives", "Multiple Integrals"
 ]
 
-university_interfaces_list = [
-    derivative_interface, integral_interface,
-    limit_interface, taylor_series_interface, fourier_series_interface, # Added from subtask 4
-    partial_derivative_interface, multiple_integral_interface, # Added from subtask 4
-    matrix_add_interface, matrix_subtract_interface, matrix_multiply_interface,
-    matrix_determinant_interface, matrix_inverse_interface,
-    vector_add_interface, vector_subtract_interface, vector_dot_product_interface,
-    vector_cross_product_interface, solve_linear_system_interface,
-    first_order_ode_interface, second_order_ode_interface
-    # OR Tab will be added below
+differential_equations_interfaces_list = [first_order_ode_interface, second_order_ode_interface]
+differential_equations_tab_names = ["First Order ODE", "Second Order ODE"]
+
+matrices_interfaces_list = [
+    matrix_add_interface, matrix_subtract_interface,
+    matrix_multiply_interface, matrix_determinant_interface,
+    matrix_inverse_interface
 ]
-university_tab_names = [
-    "Poly Derivatives", "Poly Integrals",
-    "Limits", "Taylor Series", "Fourier Series", # Added from subtask 4
-    "Partial Derivatives", "Multiple Integrals", # Added from subtask 4
-    "Matrix Add", "Matrix Subtract", "Matrix Multiply",
-    "Matrix Determinant", "Matrix Inverse",
-    "Vector Add", "Vector Subtract", "Vector Dot Product",
-    "Vector Cross Product", "Solve Linear System",
-    "1st Order ODE", "2nd Order ODE"
-    # "Operations Research" will be added below
+matrices_tab_names = [
+    "Matrix Addition", "Matrix Subtraction", "Matrix Multiplication",
+    "Matrix Determinant", "Matrix Inverse"
 ]
 
-# Operations Research Tab
-or_interfaces_list = [branch_and_bound_interface, dual_simplex_interface, simplex_solver_interface]
-or_tab_names = ["Branch & Bound", "Dual Simplex", "Simplex (Steps)"]
-or_tab = gr.TabbedInterface(or_interfaces_list, or_tab_names, title="Operations Research Solvers")
-
-# Add OR tab to University interfaces
-university_interfaces_list.append(or_tab)
-university_tab_names.append("Operations Research")
+vectors_interfaces_list = [
+    vector_add_interface, vector_subtract_interface,
+    vector_dot_product_interface, vector_cross_product_interface
+]
+vectors_tab_names = ["Vector Addition", "Vector Subtraction", "Dot Product", "Cross Product"]
 
+operations_research_interfaces_list = [
+    branch_and_bound_interface, dual_simplex_interface, simplex_solver_interface
+]
+operations_research_tab_names = ["Branch & Bound", "Dual Simplex", "Simplex Steps"]
 
-elementary_tab = gr.TabbedInterface(elementary_interfaces_list, elementary_tab_names, title="Elementary School Math")
-middleschool_tab = gr.TabbedInterface(middleschool_interfaces_list, middleschool_tab_names, title="Middle School Math")
-highschool_tab = gr.TabbedInterface(highschool_interfaces_list, highschool_tab_names, title="High School Math")
-university_tab = gr.TabbedInterface(university_interfaces_list, university_tab_names, title="University Math")
+# Create topic-based tabbed interfaces
+arithmetic_tab = gr.TabbedInterface(arithmetic_interfaces_list, arithmetic_tab_names, title="Arithmetic")
+number_theory_tab = gr.TabbedInterface(number_theory_interfaces_list, number_theory_tab_names, title="Number Theory")
+algebra_tab = gr.TabbedInterface(algebra_interfaces_list, algebra_tab_names, title="Algebra")
+equations_tab = gr.TabbedInterface(equations_interfaces_list, equations_tab_names, title="Equations")
+geometry_tab = gr.TabbedInterface(geometry_interfaces_list, geometry_tab_names, title="Geometry")
+calculus_tab = gr.TabbedInterface(calculus_interfaces_list, calculus_tab_names, title="Calculus")
+differential_equations_tab = gr.TabbedInterface(differential_equations_interfaces_list, differential_equations_tab_names, title="Differential Equations")
+matrices_tab = gr.TabbedInterface(matrices_interfaces_list, matrices_tab_names, title="Matrices")
+vectors_tab = gr.TabbedInterface(vectors_interfaces_list, vectors_tab_names, title="Vectors")
+operations_research_tab = gr.TabbedInterface(operations_research_interfaces_list, operations_research_tab_names, title="Operations Research")
 
-# Main demo with tabs for each education level
+# Main demo with topic tabs
 demo = gr.TabbedInterface(
-    [letter_counter_interface, elementary_tab, middleschool_tab, highschool_tab, university_tab],
-    ["Text Utils", "Elementary", "Middle School", "High School", "University"]
+    [
+        arithmetic_tab, number_theory_tab, algebra_tab,
+        equations_tab, geometry_tab, calculus_tab, differential_equations_tab,
+        matrices_tab, vectors_tab, operations_research_tab
+    ],
+    [
+        "Arithmetic", "Number Theory", "Algebra",
+        "Equations", "Geometry", "Calculus", "Differential Equations",
+        "Matrices", "Vectors", "Operations Research"
+    ]
 )
 
 # Launch the Gradio app

maths/__init__.py

@@ -1,3 +0,0 @@
-"""
-Mathematics tools organized by educational levels.
-"""

maths/{middleschool → algebra}/algebra_interface.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from maths.middleschool.algebra import (
+from maths.algebra.algebra import (
     solve_linear_equation, evaluate_expression, solve_quadratic, 
     simplify_radical, polynomial_operations
 )

maths/{elementary → arithmetic}/arithmetic_interface.py

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

maths/{university → calculus}/calculus_interface.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from maths.university.calculus import (
+from maths.calculus.calculus import (
     derivative_polynomial, integral_polynomial,
     calculate_limit, taylor_series_expansion, fourier_series_example,
     partial_derivative, multiple_integral

maths/{university → differential_equations}/differential_equations_interface.py

@@ -14,7 +14,7 @@ import ast # For safer string literal evaluation if needed for parameters
 import math # To make math functions available in eval scope for ODEs
 
 # Import the solver functions
-from maths.university.differential_equations import solve_first_order_ode, solve_second_order_ode
+from maths.differential_equations.differential_equations import solve_first_order_ode, solve_second_order_ode
 
 # --- Helper Functions ---
 

maths/elementary/__init__.py

@@ -1,3 +0,0 @@
-"""
-Elementary school level mathematics tools.
-"""

maths/{highschool → geometry}/trigonometry_interface.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from maths.highschool.trigonometry import sin_degrees, cos_degrees, tan_degrees, inverse_trig_functions, solve_trig_equations, trig_identities
+from maths.geometry.trigonometry import sin_degrees, cos_degrees, tan_degrees, inverse_trig_functions, solve_trig_equations, trig_identities
 
 # High School Math Tab
 trig_interface = gr.Interface(

maths/highschool/__init__.py

@@ -1,3 +0,0 @@
-"""
-Highschool level mathematics tools.
-"""

maths/matrices/matrices.py

@@ -0,0 +1,40 @@
+"""
+Matrix operations for university level, using NumPy.
+"""
+import numpy as np
+from typing import List, Union
+
+Matrix = Union[List[List[float]], np.ndarray]
+
+def matrix_add(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
+    m1 = np.array(matrix1)
+    m2 = np.array(matrix2)
+    if m1.shape != m2.shape:
+        raise ValueError("Matrices must have the same dimensions for addition.")
+    return np.add(m1, m2)
+
+def matrix_subtract(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
+    m1 = np.array(matrix1)
+    m2 = np.array(matrix2)
+    if m1.shape != m2.shape:
+        raise ValueError("Matrices must have the same dimensions for subtraction.")
+    return np.subtract(m1, m2)
+
+def matrix_multiply(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
+    m1 = np.array(matrix1)
+    m2 = np.array(matrix2)
+    if m1.shape[1] != m2.shape[0]:
+        raise ValueError("Number of columns in the first matrix must equal number of rows in the second for multiplication.")
+    return np.dot(m1, m2)
+
+def matrix_determinant(matrix: Matrix) -> float:
+    m = np.array(matrix)
+    if m.shape[0] != m.shape[1]:
+        raise ValueError("Matrix must be square to compute determinant.")
+    return np.linalg.det(m)
+
+def matrix_inverse(matrix: Matrix) -> np.ndarray:
+    m = np.array(matrix)
+    if m.shape[0] != m.shape[1]:
+        raise ValueError("Matrix must be square to compute inverse.")
+    return np.linalg.inv(m)

maths/{university/linear_algebra_interface.py → matrices/matrices_interface.py}

@@ -1,92 +1,53 @@
 """
-Gradio Interface for Linear Algebra operations.
+Gradio Interface for Matrix operations.
 """
 import gradio as gr
 import numpy as np
-import json # For parsing matrices and vectors easily
+import json
 from typing import Union
-
-from maths.university.linear_algebra import (
+from maths.matrices.matrices import (
     matrix_add, matrix_subtract, matrix_multiply,
-    matrix_determinant, matrix_inverse,
-    vector_add, vector_subtract, vector_dot_product,
-    vector_cross_product, solve_linear_system
+    matrix_determinant, matrix_inverse
 )
 
-# Helper functions to parse inputs
 def parse_matrix(matrix_str: str, allow_empty_rows_cols=False) -> np.ndarray:
-    """Parses a string representation of a matrix (JSON format or comma/semicolon separated) into a NumPy array."""
     try:
-        # Try JSON parsing first for structure like [[1,2],[3,4]]
         m = json.loads(matrix_str)
         arr = np.array(m, dtype=float)
         if not allow_empty_rows_cols and (arr.shape[0] == 0 or (arr.ndim > 1 and arr.shape[1] == 0)):
             raise ValueError("Matrix cannot have zero rows or columns.")
-        if arr.ndim == 1 and arr.shape[0] > 0: # Handles single row matrix like "[1,2,3]"
-             arr = arr.reshape(1, -1)
-        elif arr.ndim == 0 and not allow_empty_rows_cols : # Handles scalar input like "5" if not allowed
+        if arr.ndim == 1 and arr.shape[0] > 0:
+            arr = arr.reshape(1, -1)
+        elif arr.ndim == 0 and not allow_empty_rows_cols:
             raise ValueError("Input is a scalar, not a matrix.")
         return arr
     except (json.JSONDecodeError, TypeError, ValueError) as e_json:
-        # Fallback for simpler comma/semicolon separated format, e.g. "1,2;3,4"
         try:
             rows = [list(map(float, row.split(','))) for row in matrix_str.split(';') if row.strip()]
             if not rows and not allow_empty_rows_cols:
                 raise ValueError("Matrix input is empty.")
-            if not rows and allow_empty_rows_cols: # e.g. for an empty matrix if needed
+            if not rows and allow_empty_rows_cols:
                 return np.array([])
-
-            # Check for consistent row lengths
             if len(rows) > 1:
                 first_row_len = len(rows[0])
                 if not all(len(r) == first_row_len for r in rows):
                     raise ValueError("All rows must have the same number of columns.")
-
             arr = np.array(rows, dtype=float)
             if not allow_empty_rows_cols and (arr.shape[0] == 0 or (arr.ndim > 1 and arr.shape[1] == 0)):
-                 raise ValueError("Matrix cannot have zero rows or columns after parsing.")
+                raise ValueError("Matrix cannot have zero rows or columns after parsing.")
             return arr
-
         except ValueError as e_csv:
             raise gr.Error(f"Invalid matrix format. Use JSON (e.g., [[1,2],[3,4]]) or comma/semicolon (e.g., 1,2;3,4). Error: {e_csv} (Original JSON error: {e_json})")
-        except Exception as e_gen: # Catch any other parsing errors
-            raise gr.Error(f"General error parsing matrix: {e_gen}")
-
-
-def parse_vector(vector_str: str) -> np.ndarray:
-    """Parses a string representation of a vector (JSON or comma-separated) into a NumPy array."""
-    try:
-        # Try JSON parsing for lists like [1,2,3]
-        v = json.loads(vector_str)
-        arr = np.array(v, dtype=float)
-        if arr.ndim != 1:
-            raise ValueError("Vector must be 1-dimensional.")
-        if arr.shape[0] == 0:
-            raise ValueError("Vector cannot be empty.")
-        return arr
-    except (json.JSONDecodeError, TypeError, ValueError) as e_json:
-        # Fallback for simpler comma-separated format e.g. "1,2,3"
-        try:
-            if not vector_str.strip():
-                 raise ValueError("Vector input is empty.")
-            arr = np.array([float(x.strip()) for x in vector_str.split(',') if x.strip()], dtype=float)
-            if arr.shape[0] == 0: # case like "," or " , "
-                 raise ValueError("Vector cannot be empty after parsing.")
-            return arr
-        except ValueError as e_csv:
-            raise gr.Error(f"Invalid vector format. Use JSON (e.g., [1,2,3]) or comma-separated (e.g., 1,2,3). Error: {e_csv} (Original JSON error: {e_json})")
         except Exception as e_gen:
-            raise gr.Error(f"General error parsing vector: {e_gen}")
+            raise gr.Error(f"General error parsing matrix: {e_gen}")
 
 def format_output(data: Union[np.ndarray, float, str]) -> str:
-    """Formats NumPy array or float for display, handling errors."""
     if isinstance(data, np.ndarray):
-        return str(data.tolist()) # Convert to list for cleaner display
+        return str(data.tolist())
     elif isinstance(data, (float, int, str)):
         return str(data)
     return "Output type not recognized."
 
-# --- Matrix Interfaces ---
 matrix_add_interface = gr.Interface(
     fn=lambda m1_str, m2_str: format_output(matrix_add(parse_matrix(m1_str), parse_matrix(m2_str))),
     inputs=[
@@ -135,63 +96,3 @@ matrix_inverse_interface = gr.Interface(
     title="Matrix Inverse",
     description="Calculates the inverse of a square matrix. Matrix must be invertible (non-singular)."
 )
-
-# --- Vector Interfaces ---
-vector_add_interface = gr.Interface(
-    fn=lambda v1_str, v2_str: format_output(vector_add(parse_vector(v1_str), parse_vector(v2_str))),
-    inputs=[
-        gr.Textbox(label="Vector 1 (JSON or CSV format)", placeholder="e.g., [1,2,3] or 1,2,3"),
-        gr.Textbox(label="Vector 2 (JSON or CSV format)", placeholder="e.g., [4,5,6] or 4,5,6")
-    ],
-    outputs=gr.Textbox(label="Resulting Vector"),
-    title="Vector Addition",
-    description="Adds two vectors. Ensure they have the same dimensions."
-)
-
-vector_subtract_interface = gr.Interface(
-    fn=lambda v1_str, v2_str: format_output(vector_subtract(parse_vector(v1_str), parse_vector(v2_str))),
-    inputs=[
-        gr.Textbox(label="Vector 1 (Minuend)", placeholder="e.g., [4,5,6]"),
-        gr.Textbox(label="Vector 2 (Subtrahend)", placeholder="e.g., [1,2,3]")
-    ],
-    outputs=gr.Textbox(label="Resulting Vector"),
-    title="Vector Subtraction",
-    description="Subtracts the second vector from the first. Ensure they have the same dimensions."
-)
-
-vector_dot_product_interface = gr.Interface(
-    fn=lambda v1_str, v2_str: format_output(vector_dot_product(parse_vector(v1_str), parse_vector(v2_str))),
-    inputs=[
-        gr.Textbox(label="Vector 1", placeholder="e.g., [1,2,3]"),
-        gr.Textbox(label="Vector 2", placeholder="e.g., [4,5,6]")
-    ],
-    outputs=gr.Textbox(label="Dot Product (Scalar)"),
-    title="Vector Dot Product",
-    description="Calculates the dot product of two vectors. Ensure they have the same dimensions."
-)
-
-vector_cross_product_interface = gr.Interface(
-    fn=lambda v1_str, v2_str: format_output(vector_cross_product(parse_vector(v1_str), parse_vector(v2_str))),
-    inputs=[
-        gr.Textbox(label="Vector 1 (3D)", placeholder="e.g., [1,2,3]"),
-        gr.Textbox(label="Vector 2 (3D)", placeholder="e.g., [4,5,6]")
-    ],
-    outputs=gr.Textbox(label="Resulting Vector (3D)"),
-    title="Vector Cross Product",
-    description="Calculates the cross product of two 3D vectors."
-)
-
-# --- Solve Linear System Interface ---
-solve_linear_system_interface = gr.Interface(
-    fn=lambda A_str, B_str: format_output(solve_linear_system(parse_matrix(A_str), parse_vector(B_str))),
-    inputs=[
-        gr.Textbox(label="Coefficients Matrix (A)", placeholder="For Ax=B. e.g., [[2,1],[1,1]] for 2x+y, x+y"),
-        gr.Textbox(label="Constants Vector (B)", placeholder="For Ax=B. e.g., [1,1] for =1, =1")
-    ],
-    outputs=gr.Textbox(label="Solution Vector (x)"),
-    title="Linear System Solver (Ax = B)",
-    description="Solves a system of linear equations Ax = B. Matrix A must be square and invertible."
-)
-
-# It might be useful to group these interfaces in a Gradio TabbedInterface or Blocks layout in a main app file.
-# For now, this file just defines the individual interfaces.

maths/middleschool/__init__.py

@@ -1,3 +0,0 @@
-"""
-Middle school level mathematics tools.
-"""

maths/university/__init__.py

@@ -1,9 +0,0 @@
-"""
-University level mathematics tools.
-"""
-
-from . import calculus
-from . import linear_algebra
-from . import linear_algebra_interface
-from . import differential_equations
-from . import differential_equations_interface

maths/university/linear_algebra.py

@@ -1,249 +0,0 @@
-"""
-Linear Algebra operations for university level, using NumPy.
-"""
-import numpy as np
-from typing import List, Union, Tuple
-
-Matrix = Union[List[List[float]], np.ndarray]
-Vector = Union[List[float], np.ndarray]
-
-def matrix_add(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
-    """
-    Adds two matrices.
-
-    Args:
-        matrix1: The first matrix.
-        matrix2: The second matrix.
-
-    Returns:
-        The resulting matrix as a NumPy array.
-    Raises:
-        ValueError: If matrices have incompatible shapes.
-    """
-    m1 = np.array(matrix1)
-    m2 = np.array(matrix2)
-    if m1.shape != m2.shape:
-        raise ValueError("Matrices must have the same dimensions for addition.")
-    return np.add(m1, m2)
-
-def matrix_subtract(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
-    """
-    Subtracts the second matrix from the first.
-
-    Args:
-        matrix1: The first matrix.
-        matrix2: The second matrix.
-
-    Returns:
-        The resulting matrix as a NumPy array.
-    Raises:
-        ValueError: If matrices have incompatible shapes.
-    """
-    m1 = np.array(matrix1)
-    m2 = np.array(matrix2)
-    if m1.shape != m2.shape:
-        raise ValueError("Matrices must have the same dimensions for subtraction.")
-    return np.subtract(m1, m2)
-
-def matrix_multiply(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
-    """
-    Multiplies two matrices.
-
-    Args:
-        matrix1: The first matrix.
-        matrix2: The second matrix.
-
-    Returns:
-        The resulting matrix as a NumPy array.
-    Raises:
-        ValueError: If matrices have incompatible shapes for multiplication.
-    """
-    m1 = np.array(matrix1)
-    m2 = np.array(matrix2)
-    if m1.shape[1] != m2.shape[0]:
-        raise ValueError("Number of columns in the first matrix must equal number of rows in the second for multiplication.")
-    return np.dot(m1, m2)
-
-def matrix_determinant(matrix: Matrix) -> float:
-    """
-    Calculates the determinant of a square matrix.
-
-    Args:
-        matrix: The matrix (must be square).
-
-    Returns:
-        The determinant of the matrix.
-    Raises:
-        ValueError: If the matrix is not square.
-    """
-    m = np.array(matrix)
-    if m.shape[0] != m.shape[1]:
-        raise ValueError("Matrix must be square to calculate its determinant.")
-    return np.linalg.det(m)
-
-def matrix_inverse(matrix: Matrix) -> np.ndarray:
-    """
-    Calculates the inverse of a square matrix.
-
-    Args:
-        matrix: The matrix (must be square and invertible).
-
-    Returns:
-        The inverse of the matrix as a NumPy array.
-    Raises:
-        ValueError: If the matrix is not square.
-        np.linalg.LinAlgError: If the matrix is singular (not invertible).
-    """
-    m = np.array(matrix)
-    if m.shape[0] != m.shape[1]:
-        raise ValueError("Matrix must be square to calculate its inverse.")
-    return np.linalg.inv(m)
-
-def vector_add(vector1: Vector, vector2: Vector) -> np.ndarray:
-    """
-    Adds two vectors.
-
-    Args:
-        vector1: The first vector.
-        vector2: The second vector.
-
-    Returns:
-        The resulting vector as a NumPy array.
-    Raises:
-        ValueError: If vectors have incompatible shapes.
-    """
-    v1 = np.array(vector1)
-    v2 = np.array(vector2)
-    if v1.shape != v2.shape:
-        raise ValueError("Vectors must have the same dimensions for addition.")
-    return np.add(v1, v2)
-
-def vector_subtract(vector1: Vector, vector2: Vector) -> np.ndarray:
-    """
-    Subtracts the second vector from the first.
-
-    Args:
-        vector1: The first vector.
-        vector2: The second vector.
-
-    Returns:
-        The resulting vector as a NumPy array.
-    Raises:
-        ValueError: If vectors have incompatible shapes.
-    """
-    v1 = np.array(vector1)
-    v2 = np.array(vector2)
-    if v1.shape != v2.shape:
-        raise ValueError("Vectors must have the same dimensions for subtraction.")
-    return np.subtract(v1, v2)
-
-def vector_dot_product(vector1: Vector, vector2: Vector) -> float:
-    """
-    Calculates the dot product of two vectors.
-
-    Args:
-        vector1: The first vector.
-        vector2: The second vector.
-
-    Returns:
-        The dot product of the vectors.
-    Raises:
-        ValueError: If vectors have incompatible shapes.
-    """
-    v1 = np.array(vector1)
-    v2 = np.array(vector2)
-    if v1.shape != v2.shape:
-        raise ValueError("Vectors must have the same dimensions for dot product.")
-    return np.dot(v1, v2)
-
-def vector_cross_product(vector1: Vector, vector2: Vector) -> np.ndarray:
-    """
-    Calculates the cross product of two 3D vectors.
-
-    Args:
-        vector1: The first 3D vector.
-        vector2: The second 3D vector.
-
-    Returns:
-        The resulting 3D vector as a NumPy array.
-    Raises:
-        ValueError: If vectors are not 3-dimensional.
-    """
-    v1 = np.array(vector1)
-    v2 = np.array(vector2)
-    if v1.shape != (3,) or v2.shape != (3,):
-        raise ValueError("Cross product is only defined for 3-dimensional vectors.")
-    return np.cross(v1, v2)
-
-def solve_linear_system(coefficients_matrix: Matrix, constants_vector: Vector) -> np.ndarray:
-    """
-    Solves a system of linear equations Ax = B.
-
-    Args:
-        coefficients_matrix (A): The matrix of coefficients.
-        constants_vector (B): The vector of constants.
-
-    Returns:
-        The solution vector (x) as a NumPy array.
-    Raises:
-        ValueError: If the coefficient matrix is not square or dimensions are incompatible.
-        np.linalg.LinAlgError: If the system has no unique solution (e.g., singular matrix).
-    """
-    A = np.array(coefficients_matrix)
-    B = np.array(constants_vector)
-
-    if A.shape[0] != A.shape[1]:
-        raise ValueError("Coefficient matrix must be square.")
-    if A.shape[0] != B.shape[0]:
-        raise ValueError("Number of rows in coefficient matrix must match number of elements in constants vector.")
-
-    return np.linalg.solve(A, B)
-
-# Example Usage (can be removed or commented out for production)
-if __name__ == '__main__':
-    # Matrix examples
-    m_a = [[1, 2], [3, 4]]
-    m_b = [[5, 6], [7, 8]]
-    print("Matrix A+B:", matrix_add(m_a, m_b))
-    print("Matrix A*B:", matrix_multiply(m_a, m_b))
-    m_c = [[1,2,3],[4,5,6],[7,8,9]] # Singular
-    m_d = [[1,2,3],[0,1,4],[5,6,0]]
-    print("Determinant of D:", matrix_determinant(m_d))
-    try:
-        print("Inverse of D:", matrix_inverse(m_d))
-    except np.linalg.LinAlgError as e:
-        print("Error inverting D:", e)
-    try:
-        print("Inverse of C (singular):", matrix_inverse(m_c)) # Should raise error
-    except np.linalg.LinAlgError as e:
-        print("Error inverting C:", e)
-
-
-    # Vector examples
-    v_a = [1, 2, 3]
-    v_b = [4, 5, 6]
-    print("Vector A+B:", vector_add(v_a, v_b))
-    print("Vector A.B (dot):", vector_dot_product(v_a, v_b))
-    print("Vector AxB (cross):", vector_cross_product(v_a, v_b))
-
-    v_c = [1,2]
-    v_d = [3,4]
-    try:
-        print(vector_cross_product(v_c,v_d)) # Should error
-    except ValueError as e:
-        print("Error cross product:", e)
-
-    # Solve linear system example
-    # 2x + y = 1
-    # x + y = 1
-    coeffs = [[2, 1], [1, 1]]
-    consts = [1, 1]
-    print("Solution to 2x+y=1, x+y=1 is:", solve_linear_system(coeffs, consts)) # Expected: [0, 1]
-
-    # Singular system
-    coeffs_singular = [[1, 1], [1, 1]]
-    consts_singular = [1, 2] # No solution
-    try:
-        print("Solution to singular system:", solve_linear_system(coeffs_singular, consts_singular))
-    except np.linalg.LinAlgError as e:
-        print("Error solving singular system:", e)

maths/university/tests/__init__.py

@@ -1,2 +0,0 @@
-# This file makes 'tests' a Python package.
-# It can be empty.

maths/university/tests/test_differential_equations.py

@@ -1,133 +0,0 @@
-import unittest
-import numpy as np
-import math
-from numpy.testing import assert_array_almost_equal
-
-# Adjust import path as necessary
-from maths.university.differential_equations import solve_first_order_ode, solve_second_order_ode
-
-class TestDifferentialEquations(unittest.TestCase):
-
-    def test_solve_simple_first_order_ode_constant_rate(self):
-        """Test dy/dt = k, e.g., dy/dt = 2 with y(0)=1. Solution y(t) = 2t + 1."""
-        k = 2.0
-        y_initial = 1.0
-
-        def ode_func(t, y):
-            # For a system, y is an array. Here, it's a single equation, so y[0]
-            # solve_ivp always passes y as at least a 1-element array.
-            return k
-
-        t_span = (0, 5)
-        t_eval_count = 50
-        y0 = [y_initial] # Initial condition must be a list or 1D array for solve_ivp
-
-        result = solve_first_order_ode(ode_func, t_span, y0, t_eval_count=t_eval_count)
-
-        self.assertTrue(result['success'], msg=f"Solver failed: {result['message']}")
-        self.assertIsInstance(result['t'], np.ndarray)
-        self.assertIsInstance(result['y'], np.ndarray)
-
-        self.assertEqual(result['t'].shape, (t_eval_count,))
-        # solve_ivp returns y with shape (n_equations, n_timepoints)
-        self.assertEqual(result['y'].shape, (1, t_eval_count))
-
-        # Check analytical solution: y(t) = k*t + y0
-        expected_y = k * result['t'] + y_initial
-        assert_array_almost_equal(result['y'][0], expected_y, decimal=5,
-                                  err_msg="Numerical solution does not match analytical solution for dy/dt=k.")
-
-    def test_solve_simple_first_order_ode_exponential_decay(self):
-        """Test dy/dt = -k*y, e.g., dy/dt = -0.5*y with y(0)=10. Solution y(t) = 10*exp(-0.5t)."""
-        k = 0.5
-        y_initial = 10.0
-
-        def ode_func(t, y):
-            return -k * y[0] # y is [y_val]
-
-        t_span = (0, 3)
-        t_eval_count = 30
-        y0 = [y_initial]
-
-        result = solve_first_order_ode(ode_func, t_span, y0, t_eval_count=t_eval_count)
-
-        self.assertTrue(result['success'], msg=f"Solver failed for exponential decay: {result['message']}")
-        self.assertEqual(result['t'].shape, (t_eval_count,))
-        self.assertEqual(result['y'].shape, (1, t_eval_count))
-
-        # Check analytical solution: y(t) = y0 * exp(-k*t)
-        expected_y = y_initial * np.exp(-k * result['t'])
-        assert_array_almost_equal(result['y'][0], expected_y, decimal=5,
-                                  err_msg="Numerical solution does not match analytical for exponential decay.")
-
-
-    def test_solve_simple_second_order_ode_constant_acceleration(self):
-        """Test d²y/dt² = a, e.g., d²y/dt² = 2 with y(0)=1, y'(0)=0.5.
-           Solution y'(t) = a*t + y'(0) => y'(t) = 2t + 0.5
-           Solution y(t) = 0.5*a*t² + y'(0)*t + y(0) => y(t) = t² + 0.5t + 1
-        """
-        accel = 2.0
-        y_initial = 1.0
-        dy_dt_initial = 0.5
-
-        def ode_func_second_order(t, y_val, dy_dt_val):
-            return accel # d²y/dt² = constant
-
-        t_span = (0, 4)
-        t_eval_count = 40
-
-        result = solve_second_order_ode(
-            ode_func_second_order, t_span, y_initial, dy_dt_initial, t_eval_count=t_eval_count
-        )
-
-        self.assertTrue(result['success'], msg=f"Solver failed for 2nd order const accel: {result['message']}")
-        self.assertIsInstance(result['t'], np.ndarray)
-        self.assertIsInstance(result['y'], np.ndarray)
-        self.assertIsInstance(result['dy_dt'], np.ndarray)
-
-        self.assertEqual(result['t'].shape, (t_eval_count,))
-        self.assertEqual(result['y'].shape, (t_eval_count,)) # Output y is 1D array
-        self.assertEqual(result['dy_dt'].shape, (t_eval_count,)) # Output dy_dt is 1D array
-
-        # Check analytical solution for y(t)
-        expected_y = 0.5 * accel * result['t']**2 + dy_dt_initial * result['t'] + y_initial
-        assert_array_almost_equal(result['y'], expected_y, decimal=5,
-                                  err_msg="Numerical y(t) does not match analytical for const accel.")
-
-        # Check analytical solution for dy/dt(t)
-        expected_dy_dt = accel * result['t'] + dy_dt_initial
-        assert_array_almost_equal(result['dy_dt'], expected_dy_dt, decimal=5,
-                                  err_msg="Numerical dy/dt(t) does not match analytical for const accel.")
-
-    def test_solve_damped_oscillator_second_order(self):
-        """Test d²y/dt² = -b*(dy/dt) - k*y (damped harmonic oscillator).
-           This is more complex and won't have a trivial analytical solution form for all parameters,
-           so we mainly check if it runs and produces output of the correct shape.
-        """
-        damping_b = 0.5 # Damping coefficient
-        spring_k = 2.0  # Spring constant (normalized for m=1)
-        y_initial = 1.0
-        dy_dt_initial = 0.0
-
-        def damped_oscillator_func(t, y, dy_dt):
-            return -damping_b * dy_dt - spring_k * y
-
-        t_span = (0, 10)
-        t_eval_count = 100
-
-        result = solve_second_order_ode(
-            damped_oscillator_func, t_span, y_initial, dy_dt_initial, t_eval_count=t_eval_count
-        )
-
-        self.assertTrue(result['success'], msg=f"Solver failed for damped oscillator: {result['message']}")
-        self.assertEqual(result['t'].shape, (t_eval_count,))
-        self.assertEqual(result['y'].shape, (t_eval_count,))
-        self.assertEqual(result['dy_dt'].shape, (t_eval_count,))
-        # For a damped oscillator starting from rest at y=1, y should decrease initially (or oscillate around 0)
-        # This is just a sanity check, not a strict assertion of values.
-        if len(result['y']) > 1:
-            self.assertTrue(result['y'][0] > result['y'][-1] or result['y'][0] < result['y'][-1] or result['y'][0] != result['y'][1])
-
-
-if __name__ == '__main__':
-    unittest.main(argv=['first-arg-is-ignored'], exit=False)

maths/university/tests/test_linear_algebra.py

@@ -1,132 +0,0 @@
-import unittest
-import numpy as np
-from numpy.testing import assert_array_almost_equal, assert_raises
-
-# Adjust the import path based on your project structure if necessary
-# Assuming 'maths' is a top-level directory in PYTHONPATH or current working directory
-from maths.university.linear_algebra import (
-    matrix_add, matrix_subtract, matrix_multiply,
-    matrix_determinant, matrix_inverse,
-    vector_add, vector_subtract, vector_dot_product,
-    vector_cross_product, solve_linear_system
-)
-
-class TestLinearAlgebra(unittest.TestCase):
-
-    def test_matrix_add(self):
-        m1 = np.array([[1, 2], [3, 4]])
-        m2 = np.array([[5, 6], [7, 8]])
-        expected = np.array([[6, 8], [10, 12]])
-        assert_array_almost_equal(matrix_add(m1, m2), expected)
-        assert_array_almost_equal(matrix_add([[1,2],[3,4]], [[5,6],[7,8]]), expected)
-
-    def test_matrix_multiply(self):
-        m1 = np.array([[1, 2], [3, 4]])
-        m2 = np.array([[5, 6], [7, 8]]) # 2x2
-        expected = np.array([[19, 22], [43, 50]]) # (1*5+2*7), (1*6+2*8) etc.
-        assert_array_almost_equal(matrix_multiply(m1, m2), expected)
-
-        m3 = np.array([[1,2,3],[4,5,6]]) # 2x3
-        m4 = np.array([[7,8],[9,10],[11,12]]) # 3x2
-        expected2 = np.array([[58,64],[139,154]])
-        assert_array_almost_equal(matrix_multiply(m3,m4),expected2)
-
-        # Test incompatible shapes
-        with assert_raises(ValueError):
-            matrix_multiply(m1, m3) # 2x2 and 2x3 not compatible like this
-
-    def test_matrix_determinant(self):
-        m1 = np.array([[1, 2], [3, 4]]) # det = 1*4 - 2*3 = 4 - 6 = -2
-        self.assertAlmostEqual(matrix_determinant(m1), -2.0)
-
-        m2 = np.array([[3, 1, 0], [2, 0, 1], [0, 2, 4]])
-        # Det = 3(0-2) - 1(8-0) + 0 = -6 - 8 = -14
-        self.assertAlmostEqual(matrix_determinant(m2), -14.0)
-
-        m_singular = np.array([[1,2],[2,4]]) # det = 0
-        self.assertAlmostEqual(matrix_determinant(m_singular), 0.0)
-
-    def test_matrix_inverse(self):
-        m1 = np.array([[1, 2], [3, 7]]) # det = 7-6 = 1
-        # inv = 1/1 * [[7, -2], [-3, 1]]
-        expected_inv1 = np.array([[7, -2], [-3, 1]])
-        assert_array_almost_equal(matrix_inverse(m1), expected_inv1)
-
-        m_non_square = np.array([[1,2,3],[4,5,6]])
-        with assert_raises(ValueError): # Specific to our implementation if it checks before numpy
-            matrix_inverse(m_non_square)
-
-        m_singular = np.array([[1, 2], [2, 4]]) # Determinant is 0
-        with assert_raises(np.linalg.LinAlgError): # Numpy's error for singular matrix
-            matrix_inverse(m_singular)
-
-    def test_vector_dot_product(self):
-        v1 = np.array([1, 2, 3])
-        v2 = np.array([4, 5, 6])
-        # 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
-        self.assertAlmostEqual(vector_dot_product(v1, v2), 32.0)
-        self.assertAlmostEqual(vector_dot_product([1,0,-1], [1,1,1]), 0.0) # Orthogonal
-
-    def test_vector_cross_product(self):
-        v1 = np.array([1, 0, 0]) # i
-        v2 = np.array([0, 1, 0]) # j
-        expected_ij = np.array([0, 0, 1]) # k
-        assert_array_almost_equal(vector_cross_product(v1, v2), expected_ij)
-
-        v3 = np.array([1, 2, 3])
-        v4 = np.array([4, 5, 6])
-        # (2*6 - 3*5, 3*4 - 1*6, 1*5 - 2*4)
-        # (12 - 15, 12 - 6, 5 - 8)
-        # (-3, 6, -3)
-        expected_v3v4 = np.array([-3, 6, -3])
-        assert_array_almost_equal(vector_cross_product(v3, v4), expected_v3v4)
-
-        # Test non-3D vectors
-        v_2d_1 = [1,2]
-        v_2d_2 = [3,4]
-        with assert_raises(ValueError):
-            vector_cross_product(v_2d_1, v_2d_2)
-        with assert_raises(ValueError):
-            vector_cross_product(v1, v_2d_1) # One 3D, one 2D
-
-    def test_solve_linear_system(self):
-        # System 1:
-        # 2x + y = 5
-        # x - y = 1
-        # Solution: x=2, y=1
-        A1 = np.array([[2, 1], [1, -1]])
-        B1 = np.array([5, 1])
-        expected_X1 = np.array([2, 1])
-        assert_array_almost_equal(solve_linear_system(A1, B1), expected_X1, decimal=6)
-
-        # System 2:
-        # x + y + z = 6
-        #   2y + 5z = -4
-        # 2x + 5y - z = 27
-        # Solution: x=5, y=3, z=-2 (from online calculator)
-        A2 = np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]])
-        B2 = np.array([6, -4, 27])
-        expected_X2 = np.array([5, 3, -2])
-        assert_array_almost_equal(solve_linear_system(A2, B2), expected_X2, decimal=6)
-
-        # Singular system (no unique solution)
-        A_singular = np.array([[1, 1], [2, 2]])
-        B_singular = np.array([1, 3]) # Inconsistent
-        with assert_raises(np.linalg.LinAlgError):
-            solve_linear_system(A_singular, B_singular)
-
-        # Non-square coefficient matrix
-        A_non_square = np.array([[1,1,1],[0,2,5]])
-        B_non_square = np.array([6,-4])
-        with assert_raises(ValueError):
-            solve_linear_system(A_non_square, B_non_square)
-
-        # Incompatible dimensions B vector
-        A_valid = np.array([[1,1],[0,2]])
-        B_invalid_dim = np.array([1,2,3])
-        with assert_raises(ValueError): # Or LinAlgError depending on numpy's internal checks order
-            solve_linear_system(A_valid, B_invalid_dim)
-
-
-if __name__ == '__main__':
-    unittest.main(argv=['first-arg-is-ignored'], exit=False)

maths/university/tests/test_operations_research_interface.py

@@ -1,134 +0,0 @@
-import pytest
-import numpy as np
-import gradio as gr # Import for gr.Error if used in parsing
-
-# Assuming parsing functions and interface wrappers are in the following module
-from maths.university.operations_research.operations_research_interface import (
-    parse_vector, parse_matrix, parse_relations, parse_bounds, # Import parsing functions if you want to test them directly too
-    solve_branch_and_bound_interface,
-    solve_dual_simplex_interface,
-    run_simplex_solver_interface
-)
-
-# Test for Branch and Bound Interface
-def test_bnb_interface_valid_input():
-    # Example from its own interface definition
-    c_str = "5,4"
-    A_str = "1,1;2,0;0,1"
-    b_str = "5,6,3"
-    integer_vars_str = "0,1" # Both vars are integer
-    binary_vars_str = ""    # No specific binary vars beyond integer_vars
-    maximize_bool = True
-
-    solution_str, objective_str, log_str, fig = solve_branch_and_bound_interface(
-        c_str, A_str, b_str, integer_vars_str, binary_vars_str, maximize_bool
-    )
-
-    # Expected solution for this problem is x0=2, x1=3, objective=22
-    assert "2.000, 3.000" in solution_str or "2, 3" in solution_str # Allow for formatting variations
-    assert "22.000" in objective_str or "22.0" in objective_str
-    assert fig is not None # Check that a figure object is returned
-    assert "Branch and bound completed!" in log_str
-    assert "Optimal objective: 22.0" in log_str # More specific check
-
-def test_bnb_interface_parsing_error():
-    # Invalid matrix string (row length mismatch)
-    solution_str, objective_str, log_str, fig = solve_branch_and_bound_interface(
-        "1,2", "1,2;3", "10,12", "", "", True # b_str needs two elements if A has two rows
-    )
-    # The error message comes from parse_matrix via gr.Warning, which is then caught by the wrapper.
-    # The wrapper appends to its own log_messages.
-    assert "Error parsing matrix" in log_str or "Could not parse matrix" in log_str
-    assert fig is None
-
-# Test for Dual Simplex Interface
-def test_dual_simplex_interface_valid_input():
-    # Example from its own interface definition, but made consistent for Dual Simplex properties
-    # Max Z = -2x1 -x2  (originally Min 2x1+x2)
-    # s.t. -x1 -x2 <= -5 (originally x1+x2 >= 5)
-    #      -2x1 -x2 <= -6 (originally 2x1+x2 >= 6)
-    obj_type = "max"
-    c_str = "-2,-1"
-    A_str = "-1,-1;-2,-1"
-    relations_str = "<=,<=" # Correct for typical dual simplex tableau setup
-    b_str = "-5,-6"
-
-    solution_str, objective_str, log_str = solve_dual_simplex_interface(
-        obj_type, c_str, A_str, relations_str, b_str
-    )
-
-    # For Z' = -2x1 -x2 s.t. -x1-x2<=-5, -2x1-x2<=-6. Optimal is x1=1, x2=4, Z'=-6. (Min Z = 6)
-    # The solution string format depends on the solver's _print_results
-    assert "x1: 1.000" in solution_str or "x1=1.000" in solution_str
-    assert "x2: 4.000" in solution_str or "x2=4.000" in solution_str
-    assert "-6.000" in objective_str # Max -Z
-    assert "Optimal Solution Found" in log_str or "Final Solution" in log_str
-
-def test_dual_simplex_interface_dim_mismatch():
-    solution_str, objective_str, log_str = solve_dual_simplex_interface(
-        "max", "1,2", "1,1;2,2", "<=", "10,12" # relations_str has 1 relation, A has 2 rows
-    )
-    assert "Dimension mismatch" in log_str # Check for error message
-
-# Test for Simplex Solver Interface
-def test_simplex_solver_interface_valid_input():
-    # Example from its own interface definition
-    c_str = "3,5"
-    A_str = "1,0;0,2;3,2"
-    b_str = "4,12,18"
-    bounds_str = "0,None;0,None" # Non-negative
-
-    solution_str, objective_str, steps_str = run_simplex_solver_interface(
-        c_str, A_str, b_str, bounds_str
-    )
-
-    # Expected: x1=2, x2=6, Z=36
-    assert "2.000, 6.000" in solution_str or "2, 6" in solution_str
-    assert "36.000" in objective_str or "36.0" in objective_str
-    assert "Simplex Method Complete" in steps_str
-    assert "Initial tableau" in steps_str
-
-def test_simplex_solver_interface_invalid_bounds():
-    solution_str, objective_str, steps_str = run_simplex_solver_interface(
-        "1,2", "1,1;2,1", "10,12", "0,None;0" # Malformed bounds pair
-    )
-    assert "Error parsing var_bounds" in steps_str or "Could not parse bounds" in steps_str
-
-
-# Test parsing functions directly
-def test_parse_matrix_valid():
-    assert np.array_equal(parse_matrix("1,2;3,4"), np.array([[1.0,2.0],[3.0,4.0]]))
-
-def test_parse_matrix_invalid_char():
-    # parse_matrix issues a gr.Warning and returns an empty np.array([])
-    # The test checks if the returned array is empty.
-    # We cannot directly test gr.Warning without a more complex setup.
-    result = parse_matrix("1,2;3,a")
-    assert isinstance(result, np.ndarray)
-    assert result.size == 0
-
-def test_parse_matrix_invalid_row_length():
-    result = parse_matrix("1,2;3,4,5")
-    assert isinstance(result, np.ndarray)
-    assert result.size == 0
-
-def test_parse_vector_valid():
-    assert parse_vector("1,2,3.5") == [1.0, 2.0, 3.5]
-
-def test_parse_vector_invalid():
-    assert parse_vector("1,a,3") == []
-
-def test_parse_relations_valid():
-    assert parse_relations("<=,>=,=") == ["<=", ">=", "="]
-
-def test_parse_relations_invalid():
-    assert parse_relations("<=,>,=") == [] # '>' is invalid
-
-def test_parse_bounds_valid():
-    assert parse_bounds("0,None;10,20.5;None,5") == [(0.0, None), (10.0, 20.5), (None, 5.0)]
-
-def test_parse_bounds_invalid_format():
-    assert parse_bounds("0,None;10,20,30") == [] # middle pair has 3 parts
-
-def test_parse_bounds_invalid_order():
-    assert parse_bounds("10,0") == [] # lower > upper

maths/vectors/vectors.py

@@ -0,0 +1,35 @@
+"""
+Vector operations for university level, using NumPy.
+"""
+import numpy as np
+from typing import List, Union
+
+Vector = Union[List[float], np.ndarray]
+
+def vector_add(vector1: Vector, vector2: Vector) -> np.ndarray:
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != v2.shape:
+        raise ValueError("Vectors must have the same dimensions for addition.")
+    return np.add(v1, v2)
+
+def vector_subtract(vector1: Vector, vector2: Vector) -> np.ndarray:
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != v2.shape:
+        raise ValueError("Vectors must have the same dimensions for subtraction.")
+    return np.subtract(v1, v2)
+
+def vector_dot_product(vector1: Vector, vector2: Vector) -> float:
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != v2.shape:
+        raise ValueError("Vectors must have the same dimensions for dot product.")
+    return np.dot(v1, v2)
+
+def vector_cross_product(vector1: Vector, vector2: Vector) -> np.ndarray:
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != (3,) or v2.shape != (3,):
+        raise ValueError("Both vectors must be 3-dimensional for cross product.")
+    return np.cross(v1, v2)

maths/vectors/vectors_interface.py

@@ -0,0 +1,83 @@
+"""
+Gradio Interface for Vector operations.
+"""
+import gradio as gr
+import numpy as np
+import json
+from typing import Union
+from maths.vectors.vectors import (
+    vector_add, vector_subtract, vector_dot_product, vector_cross_product
+)
+
+def parse_vector(vector_str: str) -> np.ndarray:
+    try:
+        v = json.loads(vector_str)
+        arr = np.array(v, dtype=float)
+        if arr.ndim != 1:
+            raise ValueError("Vector must be 1-dimensional.")
+        if arr.shape[0] == 0:
+            raise ValueError("Vector cannot be empty.")
+        return arr
+    except (json.JSONDecodeError, TypeError, ValueError) as e_json:
+        try:
+            if not vector_str.strip():
+                raise ValueError("Vector input is empty.")
+            arr = np.array([float(x.strip()) for x in vector_str.split(',') if x.strip()], dtype=float)
+            if arr.shape[0] == 0:
+                raise ValueError("Vector cannot be empty after parsing.")
+            return arr
+        except ValueError as e_csv:
+            raise gr.Error(f"Invalid vector format. Use JSON (e.g., [1,2,3]) or comma-separated (e.g., 1,2,3). Error: {e_csv} (Original JSON error: {e_json})")
+        except Exception as e_gen:
+            raise gr.Error(f"General error parsing vector: {e_gen}")
+
+def format_output(data: Union[np.ndarray, float, str]) -> str:
+    if isinstance(data, np.ndarray):
+        return str(data.tolist())
+    elif isinstance(data, (float, int, str)):
+        return str(data)
+    return "Output type not recognized."
+
+vector_add_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_add(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1 (JSON or CSV format)", placeholder="e.g., [1,2,3] or 1,2,3"),
+        gr.Textbox(label="Vector 2 (JSON or CSV format)", placeholder="e.g., [4,5,6] or 4,5,6")
+    ],
+    outputs=gr.Textbox(label="Resulting Vector"),
+    title="Vector Addition",
+    description="Adds two vectors. Ensure they have the same dimensions."
+)
+
+vector_subtract_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_subtract(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1 (Minuend)", placeholder="e.g., [4,5,6]"),
+        gr.Textbox(label="Vector 2 (Subtrahend)", placeholder="e.g., [1,2,3]")
+    ],
+    outputs=gr.Textbox(label="Resulting Vector"),
+    title="Vector Subtraction",
+    description="Subtracts the second vector from the first. Ensure they have the same dimensions."
+)
+
+vector_dot_product_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_dot_product(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1", placeholder="e.g., [1,2,3]"),
+        gr.Textbox(label="Vector 2", placeholder="e.g., [4,5,6]")
+    ],
+    outputs=gr.Textbox(label="Dot Product (Scalar)"),
+    title="Vector Dot Product",
+    description="Calculates the dot product of two vectors. Ensure they have the same dimensions."
+)
+
+vector_cross_product_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_cross_product(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1 (3D)", placeholder="e.g., [1,2,3]"),
+        gr.Textbox(label="Vector 2 (3D)", placeholder="e.g., [4,5,6]")
+    ],
+    outputs=gr.Textbox(label="Resulting Vector (3D)"),
+    title="Vector Cross Product",
+    description="Calculates the cross product of two 3D vectors."
+)

utils/__init__.py

@@ -1,3 +0,0 @@
-"""
-Utility functions for general purposes.
-"""

utils/text_utils.py

@@ -1,7 +0,0 @@
-"""
-Utility functions for text processing.
-"""
-
-def letter_counter(word, letter):
-    """Count the occurrences of a specific letter in a word."""
-    return word.lower().count(letter.lower())

utils/text_utils_interface.py

@@ -1,11 +0,0 @@
-import gradio as gr
-from utils.text_utils import letter_counter
-
-# Text Utils Tab
-letter_counter_interface = gr.Interface(
-    fn=letter_counter,
-    inputs=["text", "text"],
-    outputs="number",
-    title="Letter Counter",
-    description="Count how many times a letter appears in a word"
-)