[TP2.pdf](/home/oli/OneDrive/Documents/Documents Personnels/Documents Olivier/Travail/Etudes/IUT/Cours/S2/Méthodes Numériques/TP1/TP2.pdf)

from os import sys
from decimal import Decimal
from math import *
import matplotlib.pyplot as plt

sys.setrecursionlimit(100000)

######################
##### Exercice 2 #####
######################

"""
f: la fonction à afficher.
min: la valeur minimale de l'intervalle.
max: la valeur maximale de l'intervalle.
pas: l'incrément entre chaque valeur de x dans l'intervalle.

Cette fonction permet de visualiser graphiquement le comportement de la fonction donnée dans l'intervalle spécifié.
f(x) correspond à l'ordonnée de la fonction pour une valeur de x donnée.
"""

def affiche(f, min, max, pas):
    x = min
    tabx = []
    taby = []

    while x <= max:
        tabx.append(x)
        taby.append(f(x))
        x += pas

    plt.title("Affichage fonction")
    plt.grid(True)
    plt.plot(tabx, taby, label="f(x)", color="green")
    # plt.plot(tabx,tabx, label="y=x", color="red")
    plt.legend()
    plt.show()

######################
##### Exercice 1 #####
######################

def f(x):
    return x**5 - 3 * x**4 + 2 * x**3 + 5 * x**2 - 7 * x + 2

# affiche(f,-10,10,0.1)
# affiche(f,-1.5,1.8,0.1)

def g(x):
    return x * sin(x)

# affiche(g,-10,10,0.1)
# affiche(g,-100,100,0.1)

def h(x):
    return sin(1 / x)

# affiche(h, -100, 100, 0.1)
# affiche(h, -0.02, 0.02, 0.000001)

# Oscille avec une fréquence de plus en plus élevé en se rapprochant de 0

######################
##### Exercice 3 #####
######################

"""
La fonction zero est une implémentation de la méthode de dichotomie (ou bissection) pour trouver une approximation d'un zéro d'une fonction continue,
c'est-à-dire une valeur x pour laquelle f(x) = 0 dans un intervalle donnée [xmin, xmax].

f = la fonction pour laquelle on cherche un zéro.
xmin = la borne inférieure de l'intervalle.
xmax = la borne supérieure de l'intervalle.
"""

def zero(f, xmin, xmax):
    c = 0
    m = xmin
    while xmax - xmin > 0.000000000000001:
        c += 1
        m = (xmin + xmax) / 2
        if f(m) * f(xmin) > 0:
            xmin = m
        elif f(m) * f(xmin) < 0:
            xmax = m
        else:
            # print(c)
            return m
    # print(c)
    return m

def t(x):
    return x * x - 4

def t2(x):
    return x * x - 2

def t3(x):
    return x**3 - 4 * x - 3

def t4(x):
    return x - cos(x)

def derivee(f, x):
    h = 0.00000001
    return (f(x + h) - f(x)) / h

def cube(x):
    return x * x * x

def test(x):
    return -x * (x - 4)

######################
### Exercice 4 & 5 ###
######################

"""
Calcule une approximation de la dérivée d'une fonction f en un point x donné,
en utilisant la définition de la dérivée comme limite.
Elle utilise une méthode d'approximation numérique connue sous le nom de différence finie.

- `f`: la fonction dont on veut calculer la dérivée.
- `x`: le point où on veut calculer la dérivée.
"""

def derivee(f, x):
    h = 0.00000001
    return (f(x + h) - f(x)) / h

"""
La fonction extre vise à trouver un point où la fonction f atteint un extrême
(soit un minimum, soit un maximum) dans l'intervalle [xmin, xmax].
"""

def extre(f, xmin, xmax):
    def df(x):
        return derivee(f, x)

    abs = zero(df, xmin, xmax)
    ord = f(abs)
    return abs, ord

# affiche(f, -1.5, 1.7, 0.01)

# print(zero(f, -1.5, -1))
# print(zero(f, 0, 0.5))
# print(zero(f, 0.7, 1.2))

# print("extre", extre(f, -1.5, 1.7))
# print("extre", extre(f, 0, 1.5))

# Faire des affichages ( un zoom par défaut, un zoom plus précis )
# en déduire ces croissances et décroissances

# lim ( + inf ) = ...
# lim ( ... ) = ...
# en déduire ses limites

# 3 check sur la fonction zéros
#

# 1 check sur la fonction max

# 1 check sur la fonction min