# EXERCICE 2:

>On considère l'équation : $$ f(x)=x^3+x^2-3x-3=0$$
>1) Dessiner la courbe de $f$ dans l'intervalle $[-2;2]$, puis trouver des intervalles convenables pour appliquer la méthode de >bisection.
>
>2) Utiliser un programme `dicho.m` qui permettra de trouver les solutions de l'équation $f(x)=0$ avec $eps=0.001$.
>
>3) Modifier le programme `dicho.m` pour qu'il donne le nombre d'itération nécessaire pour avoir la solution à $eps$ près.

## La version python de `dicho`


```python
def dicho(a,b,f,tol):
    m=(a+b)/2
    err=abs(b-a)
    while err>tol:
        if f(m)==0 :
            break
        elif f(a)*f(m)<0 :
            b=m
        else :
            a=m
        m=(a+b)/2
        err=abs(b-a)
    return m
    
    
```


```python
f=lambda x: x**3+x**2-3*x-3
x3=dicho(-2,-1.5,f,10)
x10=dicho(-2,-1.5,f,10)
x20=dicho(-2,-1.5,f,20)
print(x3,x10,x20)
#print(x3)
```

    -1.75 -1.75 -1.75



```python
print('f(x10)={},f(x20)={}'.format(f(x10),f(x20)))
```

    f(x10)=-0.046875,f(x20)=-0.046875


### Version tant que qui renvoi la solution avec le nombre d'itération


```python
def dichow (a ,b,f,eps):

    g,d = min (a,b),max(a,b)
    gau,dor = f(g),f(d)
    n = 0
    while d-g > eps :
        n += 1
        m = ( g + d )/2
        valm = f ( m )
        if gau * valm < 0 :
            d = m
            dor = valm
        else :
            g = m
            gau = valm
    
    return (g+d)/2,n
```


```python
dichow(-2,-1.5,f,0.0001)
```


```python
import numpy as np
np.floor(2.3)
np.ceil(2.3)
```




    3.0




```python
import numpy as np
a=-1.5
b=-0.5
p=8 # précision à 10 ^-8 prés
dichow(a,b,f,10**(-p))#à 10^-8
```




    (-0.5000000037252903, 27)




```python
interval=[[-2,-1.5],[-1.5,-0.5],[1.5,2]]
for u in interval:
    print(dichow(u[0],u[1],f,10**(-3)))
################################################   
print(dichow(-2,-1.5,f,10**(-3)))
print(dichow(-1.5,-0.5,f,10**(-3)))
print(dichow(1.5,2,f,10**(-3)))
```

    (-1.73193359375, 9)
    (-0.50048828125, 10)
    (1.73193359375, 9)
    (-1.73193359375, 9)
    (-0.50048828125, 10)
    (1.73193359375, 9)


## Nombre d'étiration

Le nombre d'itération N nécéssaire à la méthode de la dichotomie pour trouver $\alpha$ à $10^{-p}$ prés 

$$N \geq E\left(\dfrac{\ln(b-a)+p\ln(10)}{\ln(2)}\right)+1$$


```python
def itteration(a,b,k):
    return int((np.log(b-a)+k*np.log(10)/np.log(2)))+1
```


```python
itteration(-2,-1.5,5)
```




    16




```python
#alpha 1
dichow(-2,-1.5,f,10**(-5))
#à 10^-8
```




    (-1.7320518493652344, 16)




```python
#alpha 2
dichow(-1.51,-0.5,f,10**(-5))
#à 10^-8
```




    (-1.0000028610229492, 17)



## Méthode graphique pour la recherche de la solution 


```python
import numpy as np 
import matplotlib.pyplot as plt

f=lambda x:x**3+x**2-3*x-3

t=np.linspace(1.7,1.75,100)
plt.subplot(2,2,1)
plt.plot(t,f(t),'r')
plt.grid(True)
#################
t=np.linspace(1.2,1.4,100)
plt.subplot(2,2,2)
plt.plot(t,f(t),'r')
plt.grid(True)
#################
t=np.linspace(1.5,1.8,100)
plt.subplot(2,2,3)
plt.plot(t,f(t),'r')
plt.grid(True)
#################
t=np.linspace(1.365,1.366,100)
plt.subplot(2,2,4)
plt.plot(t,f(t),'r')
plt.grid(True)

```


```python
def f ( x ):
    return x **3+ x**2- 3*x - 3
x=np.linspace ( -2 ,2)
y=f(x)
plt.title("solution dans [-2,2]");
plt.xlabel("x")
plt.ylabel("f(x)")
plt.grid(True)
plt.plot (x,y)
plt.axhline()
plt.show()
```

# EXERCICE 3:
>On considère l'équation : $$ f(x)=x^3+4x^2-10=0$$
>1) Dessiner la courbe de $f$ dans l'intervalle $[1;2]$, puis trouver une valeur approché de la solution à 0.001 près (En >utilisant la fonction zoom du graphique).
>
>2) Vérifier que cette équation est équivalente aux 3 schéma du point fixe suivant:
>
>a) $g_1(x)=\frac{1}{2}\sqrt{10-x^3}=x$.
>
>b) $g_2(x)=\sqrt{\displaystyle\frac{10}{4+x}}=x$.
>
>c) $g_3(x)=x-x^3-4x^2+10=x$.
>
>3) Ecrire puis appliquer  une fonction Matlab que l'on appellera  `pointfixe.m` aux trois schémas précédents en prenant >`x0=1.5;eps=0.001`.
>
>4) Quelle est la fonction (parmi $g_1, g_2$ et $g_3$) qui donne la convergence la plus rapide?
>

## Calcul symbolique de la dérivée


```python
from sympy import *
import numpy as np
x, y, z = symbols('x y z')
init_printing(use_unicode=True)
g1=lambda x: 1/2*sqrt(10-x**3)
```


```python
dg1=lambdify(x,diff(g1(x),x,1))
dg1(1.365)
```

### => Le dérive est < 1, donc la fonction converge localement

## Etude de la convergences de g2 et g3


```python
def pt_fixe(f,x_0,e,n):
    a=x_0
    for i in range(n):
        x=a
        a=f(x)
        err=abs(a-x)
        print(a)
        if err<e:
            return a,i
    return "Divergence :( "
```


```python
import numpy as np
x, y, z = symbols('x y z')
init_printing(use_unicode=True)
g1=lambda x: 1/2*sqrt(10-x**3)
g2=lambda x: sqrt(10/(x+4))
g3=lambda x: x-x**3-4*x**2+10
```


```python
pt_fixe(g1,1.5,0.001,50)
```


```python
pt_fixe(g2,1.5,0.001,50)
```


```python
pt_fixe(g3,1.5,0.001,30)
```

### => G2 a convergé plus rapidements avec un nombre d'itérations = 3

# EXERCICE 4:
>1) On considère la fonction $f(x)=e^{-x}-x$. Ecrire puis appliquer  une fonction Matlab que l'on appellera `newton.m` à la >fonction $f$, en prenant $x0=0$, $eps=0.001$ .
>
>2) Montrer que l'équation $f(x)=0$ admet une solution unique que l'on peut obtenir en utilisant la méthode de Newton à partir >de $x0=1$.

### Solution Python


```python
def newtonn(f,fprime,a,eps):
    x1=a
    x2=x1-f(x1)/fprime(x1)
    while abs(x1-x2)>eps :
        x1=x2
        x2=x1-f(x1)/fprime(x1)
    return x2
```


```python
import math
from sympy import *
from sympy.abc import x

f=lambda x: math.exp(-x)-x
fprime=lambda x: -math.exp(-x)-1
newtonn(f,fprime,0,0.001)
```


```python

```

842eb1346fd25fa97c1b7c815c0183453518c4c0
ipynb
Jupyter Notebook
TP1/TP1_2DNI.ipynb
MohamedAmineBoufares/TP_Analyse_Num
29727f4486930cdde6f4276d0cd9a4793decbe24
MIT
2021-09-09T15:27:52.000Z
2021-09-09T15:27:52.000Z
TP1/TP1_2DNI.ipynb
MohamedAmineBoufares/TP_Analyse_Num
29727f4486930cdde6f4276d0cd9a4793decbe24
MIT
2021-06-09T10:57:17.000Z
2021-06-09T10:57:17.000Z
TP1/TP1_2DNI.ipynb
MohamedAmineBoufares/TP_Analyse_Num
29727f4486930cdde6f4276d0cd9a4793decbe24
MIT
2020-10-22T07:18:46.000Z
2021-12-20T17:06:43.000Z
Qwen/Qwen-72B
1. YES
2. YES