src/streamlit_app.py

import streamlit as st
from PIL import Image
import pandas as pd
import numpy as np
import math

st.set_page_config(page_title="Numerical Methods Solver", layout="centered")

# Sidebar navigation
image = Image.open("src/ii.jpg")
st.sidebar.image(image, use_container_width=True)

# Sidebar navigation
st.sidebar.title("Navigation")
page = st.sidebar.radio("Go to", ["Overview", "Tutorial", "Solver"])
if page == "Overview":
    st.image('src/okay-i-will-it.jpg',  width = 600)
    st.title("\U0001F4D8 Numerical Methods Solver")
    st.markdown("""
    #### 👋 Welcome!
    This app helps you understand and solve **ordinary differential equations** (ODEs) using numerical methods.

    ---
    #### 🔍 What You Can Do:
    - Solve **ordinary differential equations (ODEs)** using methods like Euler, Runge-Kutta, Milne, and more
    - Solve **systems of linear equations** using Gauss Elimination, Gauss-Jordan, Gauss-Seidel, Jacobi, and LU Decomposition
    - Visualize **step-by-step calculations**
    - Input your own function, step size, and initial conditions
    - Get results up to 4–5 decimal places

    ---
    #### 📌 Who Is This For?
    - Students studying **Numerical Analysis** or **Linear Algebra**
    - Educators who want a visual teaching tool
    - Anyone learning how numerical methods work under the hood

    ---
    #### 💡 Supported Methods (So Far)
    **ODE Methods:**
    - Euler's Method (Explicit)
    - Euler's Method (Implicit)
    - Heun’s Method (Improved Euler)
    - Runge-Kutta 4th Order (RK4)
    - Taylor Series Method (1st order)
    - Milne's Predictor-Corrector Method

    **Linear Algebraic Methods:**
    - Gauss Elimination Method
    - Gauss-Jordan Method
    - Gauss-Seidel Iterative Method
    - Jacobi Iteration Method
    - LU Decomposition Method

    ---
    #### 🧠 How It Works:
    For ODEs:
    - Provide a function of `x` and `y`
    - Set initial values `x₀`, `y₀`, step size `h`, and number of steps `n`

    For Linear Equations:
    - Provide matrix `A` and vector `b` from your system of equations

    The app will:
    - Compute approximated values step by step
    - Display intermediate and final results
    """)

elif page == "Solver":
    st.title("\U0001F9EE Numerical Methods Solver")

    algebraic_methods = [
        "Gauss Elimination Method",
        "Gauss-Jordan Method",
        "Gauss-Seidel Iterative Method",
        "Jacobi Iteration Method",
        "LU Decomposition Method"
    ]
    ode_methods = [
        "Euler (Explicit)",
        "Euler (Implicit)",
        "Heun’s Method (Improved Euler)",
        "Runge-Kutta 4th Order (RK4)",
        "Taylor Series Method",
        "Milne's Predictor-Corrector Method"
    ]

    method_type = st.radio("Choose a Method Category:", ["ODE Methods", "Algebraic Methods"])

    if method_type == "ODE Methods":
        method = st.selectbox("Choose a Numerical Method:", ode_methods)
        col1, col2 = st.columns(2)

        with col1:
            x0 = st.number_input("Initial x (x₀):", value=0.0, format="%.5f")
            h = st.number_input("Step size (h):", value=0.1, format="%.5f")

        with col2:
            f_str = st.text_input("Enter f(x, y):", "x + y")
            y0 = st.number_input("Initial y (y₀):", value=1.0, format="%.5f")
            n = st.number_input("Number of steps:", value=5, step=1)

        st.markdown("### 🔄 Click below to solve")
        compute = st.button("🔍 Compute Solution")

        if compute:
            try:
                f = lambda x, y: eval(f_str, {"x": x, "y": y, "math": math})
                x_vals = [x0]
                y_vals = [y0]
                x = x0
                y = y0
                results = [{"Step": 0, "x": round(x, 5), "y": round(y, 5)}]

                if method == "Milne's Predictor-Corrector Method":
                    # Generate first 3 points using RK4
                    k1 = h * f(x, y)
                    k2 = h * f(x + h/2, y + k1/2)
                    k3 = h * f(x + h/2, y + k2/2)
                    k4 = h * f(x + h, y + k3)
                    y1 = y + (k1 + 2*k2 + 2*k3 + k4) / 6
                    x1 = x + h

                    k1 = h * f(x1, y1)
                    k2 = h * f(x1 + h/2, y1 + k1/2)
                    k3 = h * f(x1 + h/2, y1 + k2/2)
                    k4 = h * f(x1 + h, y1 + k3)
                    y2 = y1 + (k1 + 2*k2 + 2*k3 + k4) / 6
                    x2 = x1 + h

                    k1 = h * f(x2, y2)
                    k2 = h * f(x2 + h/2, y2 + k1/2)
                    k3 = h * f(x2 + h/2, y2 + k2/2)
                    k4 = h * f(x2 + h, y2 + k3)
                    y3 = y2 + (k1 + 2*k2 + 2*k3 + k4) / 6
                    x3 = x2 + h

                    xs = [x, x1, x2, x3]
                    ys = [y, y1, y2, y3]
                    results = [{"Step": i, "x": round(xs[i], 5), "y": round(ys[i], 5)} for i in range(4)]

                    for i in range(4, int(n) + 1):
                        f_n3 = f(xs[i-3], ys[i-3])
                        f_n2 = f(xs[i-2], ys[i-2])
                        f_n1 = f(xs[i-1], ys[i-1])
                        f_n = f(xs[i-0], ys[i-0])

                        # Predictor
                        y_pred = ys[i-4] + (4*h/3)*(2*f_n2 - f_n1 + 2*f_n)
                        x_new = xs[i-1] + h
                        # Corrector
                        f_pred = f(x_new, y_pred)
                        y_corr = ys[i-2] + (h/3)*(f_n1 + 4*f_n + f_pred)

                        xs.append(x_new)
                        ys.append(y_corr)
                        results.append({"Step": i, "x": round(x_new, 5), "y": round(y_corr, 5)})
                else:
                    for i in range(1, int(n)+1):
                        if method == "Euler (Explicit)":
                            y = y + h * f(x, y)
                            x = x + h
                        elif method == "Euler (Implicit)":
                            y_new = y + h * f(x + h, y)
                            y = y_new
                            x = x + h
                        elif method == "Heun’s Method (Improved Euler)":
                            y_predict = y + h * f(x, y)
                            slope_avg = (f(x, y) + f(x + h, y_predict)) / 2
                            y = y + h * slope_avg
                            x = x + h
                        elif method == "Runge-Kutta 4th Order (RK4)":
                            k1 = h * f(x, y)
                            k2 = h * f(x + h/2, y + k1/2)
                            k3 = h * f(x + h/2, y + k2/2)
                            k4 = h * f(x + h, y + k3)
                            y += (k1 + 2*k2 + 2*k3 + k4) / 6
                            x += h
                        elif method == "Taylor Series Method":
                            y = y + h * f(x, y)
                            x = x + h

                        results.append({"Step": i, "x": round(x, 5), "y": round(y, 5)})
                        x_vals.append(x)
                        y_vals.append(y)

                st.subheader(f"📊 Results using {method}")
                df = pd.DataFrame(results)
                st.dataframe(df)
            except Exception as e:
                st.error(f"⚠️ Error in function input: {e}")

    elif method_type == "Algebraic Methods":
        method = st.selectbox("Choose a Linear Algebra Method:", algebraic_methods)

        st.write("Enter your coefficient matrix A and RHS vector b (1 equation per line).")
        A_str = st.text_area("Enter matrix A (e.g., 2 1 -1\\n-3 -1 2\\n-2 1 2):", "2 1 -1\n-3 -1 2\n-2 1 2")
        b_str = st.text_area("Enter vector b (e.g., 8\\n-11\\n-3):", "8\n-11\n-3")

        if st.button("🔍 Solve System"):
            try:
                A = np.array([list(map(float, row.strip().split())) for row in A_str.strip().split('\n')])
                b = np.array([float(num) for num in b_str.strip().split('\n')])
                n = len(b)

                if method == "Gauss Elimination Method":
                    for i in range(n):
                        for j in range(i + 1, n):
                            factor = A[j][i] / A[i][i]
                            A[j] = A[j] - factor * A[i]
                            b[j] = b[j] - factor * b[i]
                    x_sol = np.zeros(n)
                    for i in range(n - 1, -1, -1):
                        x_sol[i] = (b[i] - np.dot(A[i][i + 1:], x_sol[i + 1:])) / A[i][i]
                elif method == "Gauss-Jordan Method":
                    aug = np.hstack((A, b.reshape(-1,1)))
                    for i in range(n):
                        aug[i] = aug[i] / aug[i][i]
                        for j in range(n):
                            if i != j:
                                aug[j] = aug[j] - aug[j][i] * aug[i]
                    x_sol = aug[:, -1]
                elif method == "Gauss-Seidel Iterative Method":
                    x_sol = np.zeros(n)
                    for _ in range(25):
                        for i in range(n):
                            x_sol[i] = (b[i] - np.dot(A[i, :i], x_sol[:i]) - np.dot(A[i, i+1:], x_sol[i+1:])) / A[i, i]
                elif method == "Jacobi Iteration Method":
                    x_sol = np.zeros(n)
                    for _ in range(25):
                        x_new = np.copy(x_sol)
                        for i in range(n):
                            x_new[i] = (b[i] - np.dot(A[i, :i], x_sol[:i]) - np.dot(A[i, i+1:], x_sol[i+1:])) / A[i, i]
                        x_sol = x_new
                elif method == "LU Decomposition Method":
                    L = np.zeros_like(A)
                    U = np.zeros_like(A)
                    for i in range(n):
                        L[i][i] = 1
                        for j in range(i, n):
                            U[i][j] = A[i][j] - sum(L[i][k] * U[k][j] for k in range(i))
                        for j in range(i + 1, n):
                            L[j][i] = (A[j][i] - sum(L[j][k] * U[k][i] for k in range(i))) / U[i][i]
                    y = np.zeros(n)
                    for i in range(n):
                        y[i] = b[i] - np.dot(L[i, :i], y[:i])
                    x_sol = np.zeros(n)
                    for i in range(n - 1, -1, -1):
                        x_sol[i] = (y[i] - np.dot(U[i, i+1:], x_sol[i+1:])) / U[i][i]

                df_result = pd.DataFrame({"Variable": [f"x{i + 1}" for i in range(n)], "Value": x_sol})
                st.success("✅ System Solved Successfully")
                st.dataframe(df_result)

            except Exception as e:
                st.error(f"⚠️ Error in matrix input: {e}")

elif page == "Tutorial":
    st.title("📘 How to Use This Solver")
    st.markdown("")
    st.markdown("---")
    st.markdown("")
    st.markdown("### 🔢 ODE Methods Input")
    st.markdown("""
    These methods solve differential equations like dy/dx = f(x, y).

    **Required Inputs:**
    - `f(x, y)` — The function to solve (e.g., `x + y`, `x * y`, `math.exp(x)`)
    - `Initial x₀` — Starting x-value (e.g., 0)
    - `Initial y₀` — Starting y-value (e.g., 1)
    - `Step size (h)` — E.g., 0.1
    - `Number of steps (n)` — How many iterations (e.g., 5)

    **Function Rules:**
    - You can use basic operators: `+`, `-`, `*`, `/`, `**`
    - You can use math functions like `math.sin(x)`, `math.exp(x)` — include `math.` prefix!
    """)

    st.markdown("")
    st.markdown("---")
    st.markdown("")

    st.markdown("### 🧮 Algebraic Methods Input")
    st.markdown("""
    These methods solve systems like Ax = b.

    **Required Inputs:**
    - **Matrix A** — Coefficients of your equations  
      Example:  
      ```
      2 1 -1  
      -3 -1 2  
      -2 1 2
      ```
    - **Vector b** — Right-hand side values  
      Example:  
      ```
      8  
      -11  
      -3
      ```

    This represents:  
    ```
    2x₁ + 1x₂ - 1x₃ = 8  
    -3x₁ - 1x₂ + 2x₃ = -11  
    -2x₁ + 1x₂ + 2x₃ = -3
    ```

    ✅ Avoid extra spaces. Match the number of rows in A and b.
    """)

    st.markdown("---")
    st.info("Make sure matrix A is square and matches vector b in dimensions for algebraic methods.")
    st.success("You're all set! Head to the Solver tab to try it out.")

st.markdown("---")
st.markdown("<h8 style='text-align: LEFT; font-family:montserrat'>Numerical Method Solver built with ❤️ by Datapsalm</h8>", unsafe_allow_html=True)