#PINCE DE TELESIEGE
#on commence par importer les bibliothèques pour les fonctions sin et cos et pour pouvoir tracer la fonction étudiée
from math import *
from matplotlib.pyplot import *

#Question 1
xB=280. #longeur xB en mm
zB=33. #longueur zB en mm
lc=541. #longueur lc en mm
lam_min=276. #longueur de lambda minimale en mm

#Question 2
#on doit convertir l'angle en rad
def f(x):
    y=(xB**2.+zB**2.+lc**2.-2.*lc*xB*cos(x/180.*pi)+2.*lc*zB*sin(x/180.*pi))**(0.5)-lam_min
    return y
#on définit la liste des abscisses et clle des ordonnées. Pas suffisamment petit pour un joli tracé
theta_1=[0.1*i for i in range(451)]
f_1=[f(0.1*i) for i in range(451)]
plot(theta_1,f_1)
show()

#Question 3
a=0
b=45
compteur_dicho=0
c=(a+b)/2
while abs(f(c))/lam_min>=1e-8:
    compteur_dicho=compteur_dicho+1
    if f(a)*f(c)<0:
        b=c
    else:
        a=c
    c=(a+b)/2
theta_dicho=c
print('theta_dicho=',theta_dicho,'° compteur_dicho=',compteur_dicho)
#theta_dicho= 7.279343605041504 ° compteur_dicho= 19

#Question 4

#on définit d'abord la dérivéee de f
#attention.quand on dérive...dsin(ax)/dx = acos(ax)
def df(x):
    y=(lc*xB*(pi/180.)*sin(x/180.*pi)+lc*zB*(pi/180.)*cos(x/180.*pi))/(f(x)+lam_min)
    return y

#point de départ à 30°
x=30
compteur_new=0
while abs(f(x))/lam_min>=1e-8:
    compteur_new=compteur_new+1
    x=x-f(x)/df(x)

print('theta_new=',x,'° compteur_new=',compteur_new)
#theta_new= 7.279343977902869 ° compteur_new= 4

#Question 5°
#on définit d'abord la dérivée numérique à 1 pas à droite
def deriv(f,h,x):
    y=(f(x+h)-f(x))/h
    return y

#Question 6
x2=30
h=1
compteur_new2=0
while abs(f(x2))/lam_min>=1e-8:
    compteur_new2=compteur_new2+1
    x2=x2-f(x2)/deriv(f,h,x2)

print('theta_new2=',x2,'° compteur_new2=',compteur_new2)
#theta_new2= 7.2793435464228295 ° compteur_new2= 6

#Question 7
#La corde a pour équation : y = (f(b)-f(a))/(b-a)*(x-a)+f(a). On en déduit que c=(a*f(b)-b*f(a))/(f(b)-f(a))

#Question 8
a=0
b=45
compteur_lag=0
c=(a*f(b)-b*f(a))/(f(b)-f(a))
while abs(f(c))/lam_min>=1e-8:
    compteur_lag=compteur_lag+1
    if f(a)*f(c)>0:
        a=c
    else:
        b=c
    c=(a*f(b)-b*f(a))/(f(b)-f(a))
theta_lag=c
print('theta_lag=',theta_lag,'° compteur_lag=',compteur_lag)
#theta_lag= 7.2793421389696515 ° compteur_lag= 18

#synthèse
#La dichotomie est la plus simple mais c'est celle qui demande le plus d'itérations. Newton est la plus efficace avec la dérivée connue. Un peu moins par dérivation numérique si on ne connait pas la dérivée.