import math

def evaluate_expression(expression, x):

    """

    Helper function to safely evaluate a mathematical string.

    Replaces '^' with '**' for user convenience.

    Available math functions: sin, cos, tan, exp, sqrt, log.

    """

    # Allow common math functions to be used in the eval context

    safe_dict = {

        'x': x,

        'sin': math.sin,

        'cos': math.cos,

        'tan': math.tan,

        'exp': math.exp,

        'sqrt': math.sqrt,

        'log': math.log,

        'e': math.e,

        'pi': math.pi

    }

    

    # Handle user using '^' for power instead of Python's '**'

    clean_expr = expression.replace('^', '**')

    

    try:

        return eval(clean_expr, {"__builtins__": None}, safe_dict)

    except Exception as e:

        return None

def run_newton_raphson(func_str, deriv_str, x0, N):

    """

    Runs the Newton-Raphson logic based on string inputs.

    """

    x_current = x0

    

    print(f"\nSolving for: f(x) = {func_str}")

    print(f"{'Iter':<5} | {'x_n':<20} | {'Error (|f(x)|)':<20}")

    print("-" * 50)

    # Print initial state (n=0)

    fx_start = evaluate_expression(func_str, x_current)

    if fx_start is None:

        print("Error: Could not evaluate function. Check your syntax.")

        return

    print(f"{0:<5} | {x_current:<20.10f} | {abs(fx_start):<20.10f}")

    for n in range(1, N + 1):

        # Calculate f(x) and f'(x)

        fx = evaluate_expression(func_str, x_current)

        dfx = evaluate_expression(deriv_str, x_current)

        if fx is None or dfx is None:

            print("Error parsing the equation. Please use python syntax (e.g., 3*x instead of 3x).")

            return

        # Check for zero derivative (division by zero risk)

        if dfx == 0:

            print("Derivative is zero. Newton-Raphson fails.")

            return

        # The Newton-Raphson Formula

        x_next = x_current - (fx / dfx)

        

        # Calculate error

        # We evaluate the function at the NEW x to see how close to 0 we are

        error = abs(evaluate_expression(func_str, x_next))

        

        print(f"{n:<5} | {x_next:<20.10f} | {error:<20.10f}")

        

        x_current = x_next

    print("-" * 50)

    print(f"Final Root Approximation: {x_current}\n")

def main():

    # --- PART 1: Run the specific Assignment Question first ---

    print("--- ASSIGNMENT DEFAULT RUN ---")

    print("Function: x^3 - 7x")

    print("Derivative: 3x^2 - 7")

    run_newton_raphson("x**3 - 7*x", "3*x**2 - 7", 1.5, 20)

    # --- PART 2: Interactive Loop ---

    while True:

        choice = input("Do you want to try another function? (y/n): ").strip().lower()

        

        if choice != 'y':

            print("Exiting program. Goodbye!")

            break

        

        print("\n--- CUSTOM INPUT MODE ---")

        print("Instructions:")

        print("1. Use '*' for multiplication (e.g., 3*x, not 3x)")

        print("2. Use '**' or '^' for power (e.g., x^3)")

        

        try:

            # Get User Inputs

            f_input = input("Enter Function f(x): ")

            # Note: We ask for derivative because standard Python cannot do calculus automatically

            df_input = input("Enter Derivative f'(x): ")

            x0_input = float(input("Enter Initial Guess (x0): "))

            N_input = int(input("Enter Number of Iterations (N): "))

            

            run_newton_raphson(f_input, df_input, x0_input, N_input)

            

        except ValueError:

            print("Invalid input! Please enter numbers for x0 and N.")

if __name__ == "__main__":

    main()