import numpy as np
import matplotlib.pyplot as plt

# exercice 1 :

A = np.array([[4,6,-2,3],[2,-1,0,1],[-7,0,1,12]])
print(A[0,:])
print(A[:,1])

Ac = A.copy().astype(float)
Ac[0:2,:] *= 2
Ac[:,-1] /= 3

B = np.array([[4,5,6],[5,10,15],[1,1,1]])

C = A[:3, :3].copy()

D = np.dot(B,A)
E = B * C

somme_E = np.sum(E)
Y = D.sum(axis=1)

# exercice 2 :

def f(x):
    return x**2 * np.cos(10*x)

xx = np.linspace(-np.pi,np.pi,1000)
plt.plot(xx, f(xx), 'pink')
plt.title("Graph of f")
plt.legend(["f"])
plt.xlabel("x-axis")
plt.ylabel("y-axis")

for n in range(11):
    fn = xx**2 * np.cos(n * xx)
    plt.plot(xx, fn)

plt.title("Famille de fonctions f_n")
plt.xlabel("x-axis")
plt.ylabel("y-axis")

# exercice 3 :
def g(x, y):
    return np.exp(-x**2) * np.sin(np.pi * x - y)

x_vals = np.linspace(-4, 4, 100)
y_vals = np.linspace(-4, 4, 100)

Z = [[g(x, y) for x in x_vals] for y in y_vals]

plt.figure()
plt.contour(x_vals, y_vals, Z, 20, cmap='inferno')
plt.colorbar()
plt.title("Lignes de niveau de g")

# exercice 4 :
N = 100
x = 1.0
suite = [x]

for k in range(N):
    x = x * (1 - x / 2)
    suite.append(x)

suite = np.array(suite)

x_star = suite[-1]

epsilon = 1e-16
erreur = np.abs(suite - x_star)

x = 1.0
suite_2 =[x]

for k in range(N):
    x = x/2 + 1/x
    suite_2.append(x)

suite_2 = np.array(suite_2)

x_star_2 = suite_2[-1]
erreur_2 = np.abs(suite_2 - x_star_2) + epsilon

plt.figure()
plt.semilogy(erreur)
plt.semilogy(erreur_2)
plt.title("Taux de convergence de la suite")
plt.xlabel("Itérations (k)")
plt.ylabel("|| x_k - x* || (échelle log)")

# exercice 5 :
import numpy as np

A = np.array([[4, -1, 1], 
              [-1, 4, -2], 
              [1, -2, 3]])
Ap = A.copy()-4 * np.eye(3)

b = np.array([1, 2, -1]) 

x_star = np.linalg.solve(Ap, b)

valeurs_propres = np.linalg.eigvals(Ap)

print("x* =", x_star)
print("Valeurs propres =", valeurs_propres)

x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)

def f(x,y) :
    return x^4 + y^4 -4*x*y +1

def hessian_g(x, y):
    return np.array([
        [12 * x**2, -4],
        [-4, 12 * y**2]
    ])

valeurs_propres1 = np.linalg.eigvals(hessian_g(0,0))
valeurs_propres2 = np.linalg.eigvals(hessian_g(-1,-1))
valeurs_propres3 = np.linalg.eigvals(hessian_g(1,1))

print("En (0,0) -> Point selle :", valeurs_propres1)
print("En (-1,-1) -> Minimum local :", valeurs_propres2)
print("En (1,1) -> Minimum local :", valeurs_propres3)


# Bonus

import numpy as np
import matplotlib.pyplot as plt

# Définition de la fonction non-linéaire g
def g(x, y):
    return x**4 + y**4 - 4 * x * y + 1

# Définition du domaine [-2, 2]
x_vals = np.linspace(-2, 2, 100)
y_vals = np.linspace(-2, 2, 100)

# Calcul des valeurs de Z sur la grille
Z = [[g(x, y) for x in x_vals] for y in y_vals]

# Tracé des lignes de niveau avec plt.contour[cite: 8]
plt.figure()
plt.contour(x_vals, y_vals, Z, 20, cmap='inferno')
plt.colorbar() # Ajustement de la palette de couleurs[cite: 8]
plt.title("Lignes de niveau de g (Exercice 0.5)")
plt.xlabel("x-axis")
plt.ylabel("y-axis")
plt.show()