import numpy as np

def newton(F, dF, x0, delta=1e-4, epsilon=1e-4, maxIter=100):
    """
    Algoritmul lui Newton pentru găsirea rădăcinilor funcției F: R^n -> R^n.

    Parametri:
    - F: Funcția pentru care căutăm rădăcina.
    - dF: Derivata primei funcții (jacobianul) a funcției F.
    - x0: Valoarea de pornire (punctul inițial).
    - delta: Exactitatea pentru criteriul de întrerupere ||F(x^k)||_2 < delta.
    - epsilon: Exactitatea pentru criteriul de întrerupere ||x^(k+1) - x^k||_2 < epsilon.
    - maxIter: Numărul maxim de iterații.

    Returnează:
    - x: Aproximarea rădăcinii găsite.
    - iter_count: Numărul de iterații efectuate.
    """
    x = x0
    iter_count = 0

    while iter_count < maxIter:
        F_value = F(x)
        JF_value = dF(x)

        # Verificăm criteriul de întrerupere
        if np.linalg.norm(F_value, 2) < delta:
            print(f"Convergență atinsă: ||F(x^{iter_count})||_2 < {delta}")
            return x, iter_count

        # Calculăm direcția de ajustare folosind formula lui Newton-Raphson
        delta_x = np.linalg.solve(JF_value, -F_value)

        # Actualizăm valoarea aproximativă
        x = x + delta_x

        # Verificăm criteriul de întrerupere pentru diferența dintre două iterații consecutive
        if np.linalg.norm(delta_x, 2) < epsilon:
            print(f"Convergență atinsă: ||x^{iter_count+1} - x^{iter_count}||_2 < {epsilon}")
            return x, iter_count + 1

        iter_count += 1
    print(f"Număr maxim de iterații atins: {maxIter}")
    return x, iter_count

# Exemplu de utilizare:
# Definim funcția și derivata primei funcții (jacobianul)
def F(x):
    return np.array([x[0]**2 + x[1]**2 - 1, x[0] - x[1]])

def dF(x):
    return np.array([[2*x[0], 2*x[1]], [1, -1]])

# Setăm valoarea de pornire
x0 = np.array([1.0, 1.0])

# Apelăm funcția newton
result, iterations = newton(F, dF, x0)

print(f"\nRezultatul final: {result}")
print(f"Numărul de iterații: {iterations}")