#!/usr/bin/env python
# coding: utf-8

# ![En tête general](img/En_tete_general.png)
# 
# 
# *(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*
# 
# <span style="color: #9317B4"> Pour exécuter une saisie Python, sélectionner la cellule et valider avec </span><span style="color: #B317B4"><strong>SHIFT+Entrée</strong></span>.
# 

# # 1. Dérivation <span style="color: red"> (corrigé)</span> 

# <span style="color: #7C39C9">*But de l’activité : Ecrire des fonctions Python permettant le calcul de taux de variation, de nombres dérivés, du coefficient directeur et de l’ordonnée à l’origine d’une tangente à une courbe.*</span>
# 

# On considère la fonction __$f$__ définie sur $\mathbb{R}$ par $f(x)=\frac{1}{4} x^3+x-3$.
# 

# __1. Ecrire une fonction Python f qui :__
# * __reçoit en argument une valeur $x$ ;__
# * __renvoie son image par la fonction $f$.__
# 

# In[1]:


def f(x):
    return 1/4*x**3+x-3


# In[3]:


f(5)


# __2. Ecrire une fonction Python coeff_dir qui :__
# * __reçoit en arguments les coordonnées de deux points $A(x_A;y_A )$ et $B(x_B;y_B )$ (avec $x_A≠x_B$) ;__
# * __renvoie le coefficient directeur de la droite $(AB)$.__
# 

# In[4]:


def coeff_dir(xA,yA,xB,yB):
    return (yB-yA)/(xB-xA)


# In[5]:


coeff_dir(2,5,3,-2)


# __3. A l’aide de la fonction précédente, écrire une fonction Python taux_variation qui :__
# * __reçoit en arguments une fonction $f$ et deux valeurs $a$ et $h$ ;__
# * __renvoie le taux de variation de la fonction $f$ entre $a$ et $a+h$.__
# 

# In[6]:


def taux_variation(f,a,h):
    return coeff_dir(a,f(a),a+h,f(a+h))


# __4. A l’aide de cette fonction, calculer le taux de variation de $f$ entre $3$ et $3,000001$. Conjecturer la valeur du nombre dérivé $f'(3)$, puis effectuer un calcul pour vérifier.__
# 
# 

# In[7]:


taux_variation(f,3,0.000001)


# __5. L’import « from scipy import misc » permet d’utiliser la fonction misc.derivative qui :__
# * __reçoit en arguments une fonction $f$ et une valeur $a$;__
# * __renvoie le nombre dérivé de $f$ en $a$.__
# 
# __Tester cette fonction pour calculer $f'(3)$.__
# 

# In[9]:


from scipy import misc
ec=10**-9

misc.derivative(f,3,ec)


# __6. Ecrire une fonction Python coeff_tang qui :__
# * __reçoit en arguments une fonction $f$ et une valeur $a$ ;__
# * __renvoie le coefficient directeur et l’ordonnée à l’origine de la tangente à $f$ en $a$.__
# 

# In[12]:


def coeff_tang(f,a):
    derive=misc.derivative(f,a,ec)
    return derive , f(a)-derive*a


# __Tester cette fonction pour déterminer l’équation de la tangente à la courbe de $f$ en $2$.__

# In[14]:


coeff_tang(f,2)


# __7. La fonction tab_val ci-dessous permet d’obtenir une liste de valeurs de la fonction $f$.__
# * __Quelle est la valeur initiale de cette liste ? le pas ? le nombre de valeurs obtenues ?__
# * __Adapter cette fonction pour qu’elle reçoive en argument la valeur initiale $x_0$, le pas $p$ et le nombre de valeurs n.__
# 
# 

# In[15]:


#(Tester puis) modifier la fonction
def tab_val(f,x0,p,n):
    t=[]
    x=x0
    for k in range(n):
        t.append(f(x))
        x=x+p
    return t


# In[16]:


# Tester la fonction modifiée
tab_val(f,3,0.5,10)


# __8. Ecrire une fonction Python cdir_secantes qui :__
# * __reçoit en arguments une fonction $f$, une valeur $x_0$, un pas $p$ et un entier $n$.__
# * __renvoie la liste des $n$ coefficients directeurs des sécantes à la courbe de $f$ à partir de $x_0$ avec un pas en abscisse $p$.__
# 
# 

# In[18]:


# Ecrire la fonction
def cdir_secantes(f,x_0,p,n):
    t=[]
    x=x_0
    for k in range(n):
        x=x+p #Attention: incrément préalable pour éviter une division par 0
        t.append(coeff_dir(x_0,f(x_0),x,f(x)))
    return t 

cdir_secantes(f,3,0.5,10)


# # 2. Méthode de Newton <span style="color: red"> (corrigé)</span> 

# <span style="color: #7C39C9">*Prérequis : Fonctions Python réalisées dans l’activité « Fonctions élémentaires autour de la dérivation »*</span> 
# 
# <span style="color: #7C39C9">*But de l’activité : Approcher la solution d’une équation à l’aide de la méthode de Newton.*</span>
# 

# On considère la fonction __$f$__ définie sur $\mathbb{R}$ par $f(x)=\frac{1}{4} x^3+x-3$.

# __1. Démontrer que $f$ est croissante sur $\mathbb{R}$.__ 
# __On admettra pour la suite que l’équation $f(x)=0$ a une unique solution sur $\mathbb{R}$, notée $α$.__
# 

# __2. Justifier que pour toute abscisse $a$, la tangente $T_a$ à la courbe de $f$ en $a$ coupe l’axe des abscisses en un point $P$.__ 
# 
# __Déterminer l’expression de l’abscisse de $P$ en fonction de $a$, $f'(a)$ et $f(a)$.__
# 
# __Ecrire une fonction Python etap_Newton qui :__
# * __reçoit en argument une fonction $f$ et une valeur $a$__ ;
# * __renvoie l’abscisse du point $P$ correspondant.__
# 
# ![Graphiques Méthode Newton](img/Derivation_Newton_Dichotomie_1.png)
# 

# In[19]:


def etap_Newton(f,a):
    return a-f(a)/misc.derivative(f,a,ec)


# In[21]:


# Tester la fonction
etap_Newton(f,3)


# __3. A partir d’un point de l’axe des abscisses, on peut donc construire une suite de points.
# On admettra ici que la suite des abscisses de ces points a pour limite $α$.__
# 
# __La fonction Python appl_Newton donnée ci-dessous :__
# 
# * __reçoit en arguments une fonction $f$, une valeur $a$ et un entier $n$;__
# * __renvoie une liste de valeurs.__ 
# 
# __Expliquer ce que représentent les termes de la liste renvoyée.__
# 
# 

# In[24]:


def appl_Newton(f,a,n):
    t=[a]
    for k in range(n): 
        a=etap_Newton(f,a)
        t.append(a)     
    return t


# __4. Tester cette fonction appl_Newton pour la fonction $f$ de l’énoncé avec  $a=3$ et $n=10$.__

# In[26]:


appl_Newton(f,3,10)


# __5. Proposer et coder en Python des fonctions polynomiales $g$ et $h$ à coefficients entiers s’annulant respectivement en $\sqrt{5}$ et $\sqrt[3]{7}$.__

# In[27]:


def g(x):
    return x**2-5

def h(x):
    return x**3-7


# __A l’aide des fonctions Python précédentes, proposer des valeurs approchées de ces deux nombres.__

# In[28]:


# Effectuer les saisies nécessaires
appl_Newton(g,3,5) , appl_Newton(h,3,5)


# # 3. Algorithme de Dichotomie <span style="color: red"> (corrigé)</span> 

# <span style="color: #7C39C9">*Prérequis : Aucun, mais les question 1)a)b) peuvent être supprimées si l’activité « Méthode de Newton » a été traitée.*</span>
# 
# <span style="color: #7C39C9">*But de l’activité : Approcher la solution d’une équation à l’aide d’un algorithme de dichotomie (méthode plus lente que la méthode de Newton, mais pour laquelle la précision du résultat est connue).*</span>
# 

# On considère la fonction __$f$__ définie sur $\mathbb{R}$ par $f(x)=\frac{1}{4} x^3+x-3$.

# __1. Démontrer que $f$ est croissante sur $\mathbb{R}$.__ 
# __On admettra pour la suite que l’équation $f(x)=0$ a une unique solution sur $\mathbb{R}$, notée $α$.__
# 
# __Ecrire une fonction Python $f$ qui:__
# * __reçoit en argument une valeur $x$ ;__
# * __renvoie son image par la fonction $f$.__
# 

# In[29]:


def f(x):
    return 1/4*x**3+x-3


# __Déterminer les images de $0$ et $3$ par $f$, et en déduire que $α∈[0;3]$.__
# 

# In[30]:


f(0) , f(3)


# __2. On considère un intervalle $[a;b]$ contenant $α$ et on pose $m=\frac{a+b}{2}$.__
# 
# __Justifier que :  (*)  si $f(a) \times f(m)<0$ alors $α∈[a;m]$ , et sinon $α∈[m;b]$ .__
# 
# __En utilisant (*), écrire une fonction Python etap_dichoto qui :__
# * __reçoit en arguments une fonction $f$ et les bornes $a$ et $b$ d’un intervalle contenant $α$ ;__
# * __renvoie les bornes $a$ et $b$ d’un nouvel intervalle contenant $α$.__
# 
# ![Graphiques Méthode Newton](img/Derivation_Newton_Dichotomie_2.png)

# In[31]:


def etap_dichoto(f,a,b):
    m=(a+b)/2
    if f(a)*f(m)<0:
        return a,m
    else:
        return m,b


# __A partir de l’intervalle $[a;b]=[0;3]$, obtenir successivement 3 nouveaux intervalles contenant $α$.__
# 

# In[36]:


int1=etap_dichoto(f,0,3)
int2=etap_dichoto(f,*int1)
int3=etap_dichoto(f,*int2)

int1 , int2 , int3


# __Que peut-on dire de la longueur de chaque intervalle obtenu par rapport à la précédente ?__

# __3. Ecrire une fonction Python dichoto_iter qui :__
# * __reçoit en arguments une fonction $f$, les bornes $a$ et $b$ d’un intervalle contenant $α$ et un entier $n$ ;__
# * __renvoie les bornes d’un nouvel intervalle contenant $α$ obtenu en répétant $n$ fois la fonction précédente.__
# 

# In[37]:


def dichoto_iter(f,a,b,n):
    for k in range(n):
        a,b=etap_dichoto(f,a,b)
    return a,b


# __Tester avec la fonction $f$ de l’énoncé en partant de l’intervalle $[0;3]$ et en répétant $10$ fois la méthode.__

# In[38]:


dichoto_iter(f,0,3,10)


# __4. Ecrire une fonction Python dichoto_test qui :__
# * __reçoit en arguments la fonction $f$, les bornes $a$ et $b$ d’un intervalle contenant $α$ et une valeur $h$ ;__
# * __renvoie les bornes du premier intervalle de longueur inférieure à $h$ obtenu avec la méthode décrite précédemment.__
# 

# In[41]:


def dichoto_test(f,a,b,h):
    while b-a>h:
        a,b=etap_dichoto(f,a,b)
    return a,b


# __Tester avec la fonction $f$ de l’énoncé pour obtenir un encadrement de α à $10^{-5}$ près.__
# 

# In[42]:


dichoto_test(f,0,3,10**-5)


# __5. Proposer et coder en Python des fonctions polynomiales $g$ et $h$ à coefficients entiers s’annulant respectivement en $\sqrt{5}$ et $\sqrt[3]{7}$.__

# In[43]:


def g(x):
    return x**2-5

def h(x):
    return x**3-7


# __A l’aide des fonctions Python précédentes, proposer des encadrements de ces deux nombres à $10^{-7}$ près.__

# In[44]:


dichoto_test(g,0,3,10**-7) , dichoto_test(f,0,3,10**-7)


# *(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*
# 

# In[ ]: