Refactor and expand math tools application with new features and improved documentation

.gitignore

@@ -0,0 +1 @@
+**/__pycache__

README.md

@@ -1,14 +1,99 @@
 ---
-title: Counting
-emoji: 🐨
-colorFrom: red
-colorTo: green
+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: simple counting mcp server
+short_description: Mathematics tools for different educational levels
+---
+
+# Math Education Tools
+
+This web application provides various mathematical tools organized by educational level, from elementary school to university. The application is built using Gradio and provides interactive interfaces for different mathematical operations.
+
+## 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
+
+### 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
+
+### High School Math
+
+- Trigonometry Calculator: Calculate sine, cosine, and tangent values for angles in degrees
+
+### University Math
+
+- Polynomial Derivative: Find the derivative of a polynomial function
+- Polynomial Integration: Find the indefinite integral of a polynomial function
+
+## Project Structure
+
+```
+├── app.py                    # Main application file
+├── maths/                    # Mathematics modules
+│   ├── __init__.py
+│   ├── elementary/           # Elementary school level
+│   │   ├── __init__.py
+│   │   └── arithmetic.py     # Basic operations (add, subtract, multiply, divide)
+│   ├── middleschool/         # Middle school level
+│   │   ├── __init__.py
+│   │   └── algebra.py        # Algebra operations
+│   ├── highschool/           # High school level
+│   │   ├── __init__.py
+│   │   └── trigonometry.py   # Trigonometric functions
+│   └── university/           # University level
+│       ├── __init__.py
+│       └── calculus.py       # Calculus operations
+└── utils/                    # Utility functions
+    ├── __init__.py
+    └── text_utils.py         # Text processing utilities
+```
+
+## Getting Started
+
+1. Install the required packages:
+
+   ```
+   pip install gradio
+   ```
+
+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:
+
+1. Choose the appropriate educational level folder
+2. Add your function to an existing file or create a new module
+3. Import the function in app.py
+4. Create a new Gradio interface for the function
+
+## License
+
+MIT
+
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,18 +1,12 @@
 import gradio as gr
+from utils.text_utils import letter_counter
+from maths.elementary.arithmetic import add, subtract, multiply, divide
+from maths.middleschool.algebra import solve_linear_equation, evaluate_expression
+from maths.highschool.trigonometry import sin_degrees, cos_degrees, tan_degrees
+from maths.university.calculus import derivative_polynomial, integral_polynomial
 
-def letter_counter(word, letter):
-    """Count the occurrences of a specific letter in a word.
-    
-    Args:
-        word: The word or phrase to analyze
-        letter: The letter to count occurrences of
-        
-    Returns:
-        The number of times the letter appears in the word
-    """
-    return word.lower().count(letter.lower())
-
-demo = gr.Interface(
+# Text Utils Tab
+letter_counter_interface = gr.Interface(
     fn=letter_counter,
     inputs=["text", "text"],
     outputs="number",
@@ -20,4 +14,131 @@ demo = gr.Interface(
     description="Count how many times a letter appears in a word"
 )
 
-demo.launch(mcp_server=True)
+# Elementary Math Tab
+add_interface = gr.Interface(
+    fn=add,
+    inputs=[gr.Number(label="A"), gr.Number(label="B")],
+    outputs="number",
+    title="Addition",
+    description="Add two numbers"
+)
+
+subtract_interface = gr.Interface(
+    fn=subtract,
+    inputs=[gr.Number(label="A"), gr.Number(label="B")],
+    outputs="number",
+    title="Subtraction",
+    description="Subtract two numbers"
+)
+
+multiply_interface = gr.Interface(
+    fn=multiply,
+    inputs=[gr.Number(label="A"), gr.Number(label="B")],
+    outputs="number",
+    title="Multiplication",
+    description="Multiply two numbers"
+)
+
+divide_interface = gr.Interface(
+    fn=divide,
+    inputs=[gr.Number(label="A"), gr.Number(label="B")],
+    outputs="text",
+    title="Division",
+    description="Divide two numbers"
+)
+
+# Middle School Math Tab
+solve_linear_equation_interface = gr.Interface(
+    fn=solve_linear_equation,
+    inputs=[
+        gr.Number(label="Coefficient (a)"),
+        gr.Number(label="Constant (b)")
+    ],
+    outputs="text",
+    title="Linear Equation Solver",
+    description="Solve the equation ax = b for x"
+)
+
+evaluate_expression_interface = gr.Interface(
+    fn=evaluate_expression,
+    inputs=[
+        gr.Number(label="a (coefficient of x²)"),
+        gr.Number(label="b (coefficient of x)"),
+        gr.Number(label="c (constant)"),
+        gr.Number(label="x (value)")
+    ],
+    outputs="number",
+    title="Quadratic Expression Evaluator",
+    description="Evaluate ax² + bx + c for a given value of x"
+)
+
+# High School Math Tab
+trig_interface = gr.Interface(
+    fn=lambda angle, function: {
+        "sin": sin_degrees(angle),
+        "cos": cos_degrees(angle),
+        "tan": tan_degrees(angle)
+    }[function],
+    inputs=[
+        gr.Number(label="Angle (degrees)"),
+        gr.Radio(["sin", "cos", "tan"], label="Trigonometric Function")
+    ],
+    outputs="number",
+    title="Trigonometry Calculator",
+    description="Calculate trigonometric functions for angles in degrees"
+)
+
+# University Math Tab
+derivative_interface = gr.Interface(
+    fn=lambda coefficients: derivative_polynomial([float(c) for c in coefficients.split(',')]),
+    inputs=gr.Textbox(label="Polynomial Coefficients (comma-separated, highest degree first)"),
+    outputs="json",
+    title="Polynomial Derivative",
+    description="Find the derivative of a polynomial function"
+)
+
+integral_interface = gr.Interface(
+    fn=lambda coefficients, c: integral_polynomial([float(x) for x in coefficients.split(',')], float(c)),
+    inputs=[
+        gr.Textbox(label="Polynomial Coefficients (comma-separated, highest degree first)"),
+        gr.Number(label="Integration Constant (c)", value=0)
+    ],
+    outputs="json",
+    title="Polynomial Integration",
+    description="Find the indefinite integral of a polynomial function"
+)
+
+# Group interfaces by education level
+elementary_tab = gr.TabbedInterface(
+    [add_interface, subtract_interface, multiply_interface, divide_interface],
+    ["Addition", "Subtraction", "Multiplication", "Division"],
+    title="Elementary School Math"
+)
+
+middleschool_tab = gr.TabbedInterface(
+    [solve_linear_equation_interface, evaluate_expression_interface],
+    ["Linear Equations", "Evaluate Expressions"],
+    title="Middle School Math"
+)
+
+highschool_tab = gr.TabbedInterface(
+    [trig_interface],
+    ["Trigonometry"],
+    title="High School Math"
+)
+
+university_tab = gr.TabbedInterface(
+    [derivative_interface, integral_interface],
+    ["Derivatives", "Integrals"],
+    title="University Math"
+)
+
+# Main demo with tabs for each education level
+demo = gr.TabbedInterface(
+    [letter_counter_interface, elementary_tab, middleschool_tab, highschool_tab, university_tab],
+    ["Text Utils", "Elementary", "Middle School", "High School", "University"]
+)
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

maths/__init__.py

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

maths/elementary/__init__.py

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

maths/elementary/arithmetic.py

@@ -0,0 +1,131 @@
+"""
+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

maths/highschool/__init__.py

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

maths/highschool/trigonometry.py

@@ -0,0 +1,16 @@
+"""
+Trigonometry operations for high school level.
+"""
+import math
+
+def sin_degrees(angle):
+    """Calculate the sine of an angle in degrees."""
+    return math.sin(math.radians(angle))
+
+def cos_degrees(angle):
+    """Calculate the cosine of an angle in degrees."""
+    return math.cos(math.radians(angle))
+
+def tan_degrees(angle):
+    """Calculate the tangent of an angle in degrees."""
+    return math.tan(math.radians(angle))

maths/middleschool/__init__.py

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

maths/middleschool/algebra.py

@@ -0,0 +1,20 @@
+"""
+Basic algebra operations for middle school level.
+"""
+
+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

maths/university/__init__.py

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

maths/university/calculus.py

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

utils/__init__.py

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

utils/text_utils.py

@@ -0,0 +1,7 @@
+"""
+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())