Create app.py

app.py

@@ -0,0 +1,140 @@
+import streamlit as st
+import pandas as pd
+
+def divided_differences(x, y):
+    """
+    Calculates the divided differences table for Newton's Divided Difference formula.
+
+    Args:
+        x (list): List of x-values.
+        y (list): List of y-values corresponding to x-values.
+
+    Returns:
+        pandas.DataFrame: Divided differences table.
+    """
+    n = len(y)
+    if n == 0:
+        return pd.DataFrame()
+    dd_table = pd.DataFrame(index=range(n), columns=range(n))
+    dd_table[0] = pd.Series(y)
+    for j in range(1, n):
+        for i in range(n - j):
+            dd_table.loc[i, j] = (dd_table.loc[i+1, j-1] - dd_table.loc[i, j-1]) / (float(x[i+j]) - float(x[i]))
+    return dd_table
+
+def newton_interpolation_steps_latex(x, y, x_interp):
+    """
+    Calculates the interpolated value at x_interp using Newton's Divided Difference formula and provides step-by-step solution in LaTeX.
+
+    Args:
+        x (list): List of x-values.
+        y (list): List of y-values corresponding to x-values.
+        x_interp (float): The x-value to interpolate at.
+
+    Returns:
+        tuple: (interpolated_y, dd_table, steps_latex)
+               interpolated_y (float): The interpolated y-value at x_interp.
+               dd_table (pandas.DataFrame): The divided differences table.
+               steps_latex (list of str): List of LaTeX strings describing each step of the calculation.
+               Returns (None, None, None) if there's an error (e.g., empty input).
+    """
+    n = len(x)
+    if n == 0 or len(y) != n:
+        return None, None, None
+
+    dd_table_df = divided_differences(x, y)
+    if dd_table_df.empty:
+        return None, None, None
+
+    dd_table = dd_table_df.values.tolist()
+
+    y_interp = dd_table[0][0]
+    steps_latex = []
+
+    # Initial step in LaTeX
+    steps_latex.append(f"Initial value: $P(x) = f[x_0] = {y_interp:.4f}$")
+
+    for i in range(1, n):
+        term = 1.0
+        for j in range(i):
+            term *= (x_interp - float(x[j]))
+        current_term_value = dd_table[0][i] * term
+
+        # Construct divided difference notation in LaTeX: f[x_0, ..., x_i]
+        dd_notation_latex = f"f[x_0"
+        for k in range(1, i + 1):
+            dd_notation_latex += f", x_{k}"
+        dd_notation_latex += "]"
+
+        # Construct polynomial term in LaTeX: (x - x_0)(x - x_1)...(x - x_{i-1})
+        polynomial_term_latex = ""
+        for j in range(i):
+            polynomial_term_latex += f"(x - {x[j]})"
+        if not polynomial_term_latex:
+            polynomial_term_latex = "1" # For i=0 case which is handled outside loop, but for consistency
+
+        # Step description in LaTeX
+        step_latex_description = f"Add term {i}: ${dd_notation_latex} \\times {polynomial_term_latex.replace('x', str(x_interp))} = {dd_table[0][i]:.4f} \\times "
+        if i > 0:
+            term_values_latex = " \\times ".join([f"({x_interp} - {x[j]})" for j in range(i)])
+            step_latex_description += term_values_latex
+        else:
+            step_latex_description = f"Initial value: $f[x_0] = {dd_table[0][0]:.4f}$" # Should not happen in loop, but for clarity
+
+        step_latex_description += f" = {current_term_value:.4f}$"
+        steps_latex.append(step_latex_description)
+
+        steps_latex.append(f"Current $P(x) = {y_interp:.4f}$")
+        y_interp += current_term_value
+
+    return y_interp, dd_table_df, steps_latex
+
+
+st.title("Newton's Divided Difference Interpolation")
+st.write("Enter the x and y values as comma-separated lists, and the x value you want to interpolate.")
+
+x_values_input = st.text_area("Enter x values (comma-separated):", "0, 1, 2")
+y_values_input = st.text_area("Enter y values (comma-separated):", "1, 3, 2")
+x_interpolate = st.number_input("Enter x value to interpolate:", value=1.5)
+
+if st.button("Calculate Interpolated Value with Steps (LaTeX)"):
+    try:
+        x_values_str = x_values_input.strip()
+        y_values_str = y_values_input.strip()
+
+        if not x_values_str or not y_values_str:
+            st.error("Please enter both x and y values.")
+        else:
+            x_values = [val.strip() for val in x_values_str.split(',')]
+            y_values = [val.strip() for val in y_values_str.split(',')]
+
+            if len(x_values) != len(y_values):
+                st.error("The number of x values and y values must be the same.")
+            else:
+                try:
+                    x_values_float = [float(x) for x in x_values]
+                    y_values_float = [float(y) for y in y_values]
+
+                    if not all(isinstance(x, (int, float)) for x in x_values_float) or not all(isinstance(y, (int, float)) for y in y_values_float):
+                        st.error("Please ensure all x and y values are numbers.")
+                    else:
+                        interpolated_y, dd_table, steps_latex = newton_interpolation_steps_latex(x_values_float, y_values_float, x_interpolate)
+
+                        if interpolated_y is not None:
+                            st.success(f"The interpolated value at x = {x_interpolate} is: **{interpolated_y:.4f}**")
+
+                            st.subheader("Divided Difference Table:")
+                            st.dataframe(dd_table.fillna(''))
+
+                            st.subheader("Step-by-step Calculation:")
+                            for step_latex in steps_latex:
+                                st.latex(step_latex)
+
+                        else:
+                            st.error("An error occurred during interpolation. Please check your input data.")
+
+                except ValueError:
+                    st.error("Invalid input. Please enter comma-separated numbers for x and y values.")
+
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {e}")