# Ejercicios tema 1 
Blanca Cano Camarero

ANTES DE COMENZAR LAS PRÁCTCAS, LEED LE README 



```python
# import básicos
from sympy import * 
## declaraciones
x = symbols("x")
```

### Ejercicio 1
1.- Demuestre que la ecuación $x^3+4 x^2=10$ tiene una única raíz en el intervalo $[1,2]$. Aproxime dicha raíz con el método de bisección con al menos 3 cifras decimales exactas. ¿Cuántas iteraciones serán necesarias para conseguir 5 cifras decimales exactas? Aproxime también la raíz con el método de Newton-Raphson partiendo del extremo adecuado hasta que la diferencia en valor absoluto, entre dos aproximaciones consecutivas sea inferior a $10^{-3}$.


```python
# La siguiente función se anula en donde la ecuación tiene solución
f = x**4 + 4*x**2 - 10

print(f'en f(2)={f.evalf(subs={x:2})} y f(1)={f.evalf(subs={x:1})}')

# análisis de la derivada
df = diff(f,x)
print(f'Los puntos donde se anula l aderiva son {solve(df)}')
print(f'en df(-1)={df.evalf(subs={x:-1})} y df(1)={df.evalf(subs={x:1})}')


```

    en f(2)=22.0000000000000 y f(1)=-5.00000000000000
    Los puntos donde se anula l aderiva son [0, -sqrt(2)*I, sqrt(2)*I]
    en df(-1)=-12.0000000000000 y df(1)=12.0000000000000


Por ser f un polinomio (clase infinito) y  puesto que la derivada solo se anula en 0 y toma valores positivos en adelante; deducimos que la función $f$ es creciente a partir de 0. 

Además gracias al teorema de Bolzano sabemos que se anulará en un punto por ser $f(1)<0<f(2)$ continua y creciente en ese intervalo.

#### Consideraciones bisección


```python
import biseccion as bis
# Para tres cifras decimales de precisión el error será (10**(-3))

n3 = bis.calcIterations(1,2,10**(-3))
n5 = bis.calcIterations(1,2,10**(-5))
print(f'El número mínimo de iteraciones para tres cifras es de {n3}')
print(f'El número mínimo de iteraciones para cinco cifras es de {n5}')

def f(x):
    return x**4+ 4*x**2 - 10

## Calculamos el valor de la raíz con bisección 
raiz, ms_salida = bis.bisection(f,1,2,10**(-5))
print(f'La solución buscada es {raiz}')
```

    El número mínimo de iteraciones para tres cifras es de 10.0
    El número mínimo de iteraciones para cinco cifras es de 17.0
    La solución buscada es 1.3197250366210938


#### Consideraciones Newton-Raphson


```python
from newtonRaphson import newtonRaphsonSinInicio
f = x**4 + 4*x**2 - 10
raiz, ms_salida, num_iter = newtonRaphsonSinInicio(f,1,2,10**(-3))

print(f'La solución con newtonRapshon es {raiz}, que se ha alcanzado en {num_iter} iteraciones')
```

    La solución con newtonRapshon es 1.3197190191327715, que se ha alcanzado en 4 iteraciones


## Ejercicio 2

2.- Encuentre una aproximación de la raíz cúbica de 25 con dos decimales exactos, usando el algoritmo de bisección.


```python
#Esta función se anula en la raíz cúbica de 25 
f = x**3 -25


print(f'en f(2)={f.evalf(subs={x:2})} y f(3)={f.evalf(subs={x:3})}')

# análisis de la derivada
df = diff(f,x)
print(f'Los puntos donde se anula la aderiva son {roots(df)}')
print(f'en df(-1)={df.evalf(subs={x:-1})} y df(1)={df.evalf(subs={x:1})}')


```

    en f(2)=-17.0000000000000 y f(3)=2.00000000000000
    Los puntos donde se anula la aderiva son {0: 2}
    en df(-1)=3.00000000000000 y df(1)=3.00000000000000


Por tanto (Como era completamente de esperar) la función es creciente a partir de 0 y gracias a bolzano en la semirecta real positiva existirá una única solución.


```python
#la calculamos por bisección
def f(x):
    return x**3 -25

## Calculamos el valor de la raíz con bisección 
raiz, ms_salida = bis.bisection(f,2,3,10**(-2))
print(f'La solución buscada es {raiz} donde (25^(1/3)= {25**(1/3)}) ')
```

    La solución buscada es 2.9296875 donde (25^(1/3)= 2.924017738212866) 


## Ejercicio 3

3.- Use el método de Newton-Raphson para aproximar las soluciones de las siguientes ecuaciones con precisión $10^{-5}$ , partiendo de
un valor adecuado, próximo a cada una de ellas en cada caso.

i) $x^3-x-1 = 0$  en $[1,2]$.

ii) $3x=2+x^2-e^x$.

iii) $x^2+10 cos x+x=0$.


#### i) $x^3-x-1 = 0$  en $[1,2]$.
$f(x) = x^3-x-1$
Su derivada es $x^2 -1$ positiva en tal intervalo y crecente, por tanto habrá una solucío a lo más. 
$f(1)<0<f(2)$ que por continuidad y bolzano tenemos la certeza de que la solución será única.

La función netonRaphsonSinInicio directamente coloca la semilla en su sitio usando el criterio de la segunda derivada. 


```python
from newtonRaphson import newtonRaphsonSinInicio
f = x**3-x-1
raiz, ms_salida, num_iter = newtonRaphsonSinInicio(f,1,2,10**(-5), 10**(-5))
print(f'La solución buscada es {raiz}')
```

    La solución buscada es 1.3247190494171253


#### ii) $3x=2+x^2-e^x$.

$x^2 -3x +2 =  e^x$

A ojo, casi sin querer se ve que $x^2 -3x +2 = (x-1)(x-2)$
por tanto sabemos que la parábola tomará valores negarivos entre $(1,2)$ y sabemos que la exponencial es estrictamente positiva y de crecimiento mucho más rápido,a partir de uno, antes de eso será aproximadamente 0.  así que de manera intuitiva habrá una solución en $(-\infty,1)$ cercana al uno. 

Puede comprobarse la intuición si representamos la función. 



```python
f = exp(x)-x**2 +  3*x -2
plot(f,ylim=(-10,10), xlim=(-3, 3))

```

Además la segunda derivada de $f=exp(x)-x**2 +  3*x -2$ será $f'' = exp(x) - 2$

Que en es positiva en 1 al igual que la función, así que aplicando el critero de los signos podemos partir de 1 que con el método de newton raphson será convergente. 

Vamos a ellos: 



```python
from newtonRaphson import newtonRaphson
f=exp(x)-x**2 +  3*x -2
raiz, ms_salida, num_iter = newtonRaphsonSinInicio(f,1,10**(-5), 10**(-5))
print(f'La solución buscada es {raiz}, se han realizado {num_iter} iteraciones')
```

    La solución buscada es 0.2575302854263488, se han realizado 4 iteraciones


#### iii) $x^2+10 cos x+x=0$.

En este caso tenemos que tener más cuidado, porque tenemos una parábola $x(x+1)$ y una función periódica, por tanto a lo sumo podemos tener dos soluciones y no queremos dejarnos ninguna. 

Pero vamos a aprovechar las herraminetas gráficas para ver el número de solucionesy su intervalo.


```python
f = x**2 + 10*cos(x) + x
plot(f,ylim=(-10,10), xlim=(-5, 5))
```

Podemos ver que existen dos soluciones, cada respectivamente en $(-4,-3)$ y $(-2, -1)$, así que ya estamos preparados para utilizar nuestra implementación de Newton-Raphson. 


```python
from newtonRaphson import newtonRaphsonSinInicio
f = x**2 + 10*cos(x) + x
raiz, ms_salida, num_iter = newtonRaphsonSinInicio(f,-2,-1,10**(-5), 10**(-5))
print(f'La solución entre (-2,-1)buscada es {raiz},que se ha alcanzado por {ms_salida}, en  {num_iter} iteraciones.')

raiz, ms_salida, num_iter = newtonRaphsonSinInicio(f,-4,-3,10**(-5), 10**(-10))
print(f'La solución entre (-4,-3)buscada es {raiz}  por {ms_salida}, en  {num_iter} iteraciones.')
```

    La solución entre (-2,-1)buscada es -1.6869398658093508,que se ha alcanzado por precision, en  4 iteraciones.
    La solución entre (-4,-3)buscada es -3.5623314972388327  por tolerancia, en  4 iteraciones.


## Ejercicio 4

4.- Para la función  $ f(x)= 3 x^2+e^x-1$, 

i) encuentre, mediante el método de bisección una aproximación de la raíz en $[0,1]$ con, al menos, cuatro decimales exactos, y determine el número de iteraciones realizadas;

ii) encuentre, mediante el método de Newton-Raphson, una aproximación de la raíz en $[0,1]$ con una tolerancia de $10^{-4}$,
partiendo de $x_0=0$, y determine el número de iteraciones realizadas.  

### Solución



```python

# BISECCIÓN
import biseccion as bis
# Para cuatro cifras decimales de precisión el error será (10**(-4))
n4 = bis.calcIterations(0,1,10**(-4))
print('Bisección')
print(f'El número mínimo de iteraciones en bisección para cuaro cifras será de {n3}')


def f(x):
    return 3* x**2 + exp(x)-1

## Calculamos el valor de la raíz con bisección 
raiz, ms_salida = bis.bisection(f,0,1,10**(-4))
print(f'La solución a priori con bisección es {raiz}')


## NEWTON-RAPHSON
from newtonRaphson import newtonRaphson
f  = 3* x**2 + exp(x)-1
raiz, ms_salida, num_iter = newtonRaphson(f,0,10**(-4), 10**(-4))
print(f'NEWTON-RAPHSON: La solución buscada es {raiz} con {num_iter} iteraciones.')
```

    Bisección
    El número mínimo de iteraciones en bisección para cuaro cifras será de 10.0
    La solución a priori con bisección es 6.103515625e-05
    NEWTON-RAPHSON: La solución buscada es 0.0 con 1 iteraciones.


## Ejercicio 5
5.- Utilice las órdenes apropiadas de Python para aproximar todos los puntos donde se anulan las funciones siguientes (si es necesario, represéntelas gráficamente):

i) $f(x)=x^7-x^4+2$ ,

ii) $f(x)=x^7+\cos  x-3$.
### caso i


```python
fi = x**7 - x**4 +2

print(f'Las soluciones reales y complejas de {fi} son:')
complexN = solve(fi, x)
for i in complexN:
    print(N(i))
 

```

    Las soluciones reales y complejas de x**7 - x**4 + 2 son:
    -1.00000000000000
    -0.713102145851293 - 0.98823188827156*I
    -0.713102145851293 + 0.98823188827156*I
    1.06110281046036 - 0.376384046559108*I
    1.06110281046036 + 0.376384046559108*I
    0.151999335390936 - 1.01945594669063*I
    0.151999335390936 + 1.01945594669063*I


### caso ii
Hemos representado esta función en el intervalo $[-2.5,2.5]$ para valores fuera de ese intervalo no existe ninguna solución, pues el coseno tiene una amplitud de 1 y en para valores $N < -2.5$ se tiene que $N^7 -3 < -1 <-cos(N)$ y apara $N> 2.5$ se tiene que $N^7>4 > - cos(N) + 3$ 

Además la solución estará próxima a 1, un dato ideal para utilzar `nsolve`.


```python
# segunda
fii = x**7 + cos(x) -3
plot(fii, xlim=(-2.5,2.5), ylim=(-10, 10) )
# Por tanto calcula la única solución 
sol = nsolve(fii, 1)

print(f'La raíz para {fii} es {sol}')
```

## Ejercicio 6
 6.- Aplicar los métodos de aceleración de la convergencia de Aitken y Steffensen a las sucesiones obtenidas para los distintos métodos
programados en esta práctica y comparar los resultados. Para aplicar el método de aceleración de Steffensen, recuerde que para transformar cualquier ecuación de la forma  $ f(x)=0 $  en un problema de puntos fijos  $ g(x)=x $, la forma más simple puede ser definir  $g(x)=x \pm f(x)$.

### Resolución

OJO CUIDADO, algunos resultados no convergen a la solución, y es que el método de aceleración de convergencia no te aseguran de ello, si no que el cocienente de la sucesión de errores se vaya a cero.

También influye cómo se haya obtenido $g$, es decir cómo se ha despejado la x para que quede sola y eso lo reflejo en que de una ecuación verá varios despejes distintos. 


```python
# cada tupla contiene la función f de cada ejercicio, la semilla inicial 
import aceleracionConvergencia as ac

#Dejo comentado todos las funciones posibles porque de otra forma esto es muy pesado de meter y yo diría que la idea se entiende.
#f=[(x**4 + 4*x**2 - 10,1),(x**3 -25,2),(x**3-x-1,1),(exp(x)-x**2 +  3*x -2,0),
 #(x**2 + 10*cos(x) + x,-2),(1,3* x**2 + exp(x)-1), (x**7 - x**4 +2,0),(x**7 + cos(x) -3,-1)]
    
f =[x**4 + 4*x**2 - 10,exp(x)-x**2 +  3*x -2, x**3 -25, x**3 -25, exp(x)-x**2 +  3*x -2,exp(x)-x**2 +  3*x -2, x**2 + 10*cos(x) + x ]

for i in range(len(f)):
    gaux=[(10/(x*(x+4)),1),((x**2+2-exp(x))/3,1.4),(x**3+x-25,2.93), (25/x**2, 2.9),
    (exp(x)-x**2 + x+ 3*x -2,0.25), (1/3*(-exp(x)+x**2 + x +2),0.25), (-(x**2 + 10*cos(x)),-3.55), 
         ] #(3* x**2 + x+ exp(x)-1 ,0.1)]
    def g(y):
        return gaux[i][0].evalf(subs={x:y})
    print(f'La aceleración de {f[i]} con semilla {gaux[i][1]} en {gaux[i][0]}:')
    ac.tablasAceleracion(g,gaux[i][1])

```

    La aceleración de x**4 + 4*x**2 - 10 con semilla 1 en 10/(x*(x + 4)):
    Xn                        | Aitken                 |Stepheson 
    1                         |                        | 
    2.00000000000000          |                        | 
    0.833333333333333         | 1.46153846153846       | 
    2.48275862068966          | 1.51666666666667       | 
    0.621306146572104         | 1.37815034468775       | 1.37815034468775
    3.48280861316797          | 1.34654507131928       | 1.34654507131928
    0.383712328149617         | 1.41935299784799       | 1.41935299784799
    5.94500467589520          | 1.29391242913432       | 1.29391242913432
    0.169138629713219         | 1.59554139423208       | 1.59554139423208
    14.1811305766207          | 1.04384454082576       | 1.04384454082576
    0.0387853985175662        | 2.35352259823629       | 2.35352259823629
    63.8382487052382          | -0.974754625444874     | -0.974754625444874
    0.00230910886112447       | 5.88011667047837       | 5.88011667047837
    La aceleración de -x**2 + 3*x + exp(x) - 2 con semilla 1.4 en x**2/3 - exp(x)/3 + 2/3:
    Xn                        | Aitken                 |Stepheson 
    1.4                       |                        | 
    -0.0317333222815582       |                        | 
    0.344080702698839         | 0.265943783305879      | 
    0.235899684121873         | 0.260079958147681      | 
    0.263200453939663         | 0.256071638322854      | 0.256071638322854
    0.256062326008391         | 0.257530717992165      | 0.257530717992165
    0.257911558186928         | 0.257530268398944      | 0.257530268398944
    0.257431340610680         | 0.257530285669833      | 0.257530285669833
    0.257555968396257         | 0.257530285435571      | 0.257530285435571
    0.257523619331349         | 0.257530285439935      | 0.257530285439935
    0.257532015678931         | 0.257530285439859      | 0.257530285439859
    0.257529836344885         | 0.257530285439861      | 0.257530285439861
    0.257530402005542         | 0.257530285439861      | 0.257530285439861
    La aceleración de x**3 - 25 con semilla 2.93 en x**3 + x - 25:
    Xn                        | Aitken                 |Stepheson 
    2.93                      |                        | 
    3.08375700000000          |                        | 
    7.40892069048313          | 2.92433255570526       | 
    389.100179080503          | 3.03418434042021       | 
    58909722.4089418          | 2.92150143189044       | 2.92150143189044
    2.04437672938503E+23      | 4.65717060612217       | 4.65717060612217
    8.54442390811763E+69      | 0                      | 0
    6.23804293586468E+209     | nan                    | nan
    2.42742085550551E+629     | nan                    | nan
    1.43032667048473E+1888    | nan                    | nan
    2.92621148325892E+5664    | nan                    | nan
    2.50563109951439E+16993   | nan                    | nan
    1.57308211140660E+50980   | nan                    | nan
    La aceleración de x**3 - 25 con semilla 2.9 en 25/x**2:
    Xn                        | Aitken                 |Stepheson 
    2.9                       |                        | 
    2.97265160523187          |                        | 
    2.82912400000000          | 2.92441611166700       | 
    3.12346067761173          | 2.92560466792560       | 
    2.56252389048675          | 2.92402638779294       | 2.92402638779294
    3.80718659474958          | 2.92394574212361       | 2.92394574212361
    1.72477196110407          | 2.92455767849169       | 2.92455767849169
    8.40381806645469          | 2.91880646378207       | 2.91880646378207
    0.353986520684614         | 2.95840919148536       | 2.95840919148536
    199.510868259849          | 2.21686496195687       | 2.21686496195687
    0.000628068324895442      | 4.62750182697734       | 4.62750182697734
    63376204.4287542          | -1055.80776950707      | -1055.80776950707
    6.22425757889018E-15      | 99.8438526019454       | 99.8438526019454
    La aceleración de -x**2 + 3*x + exp(x) - 2 con semilla 0.25 en -x**2 + 4*x + exp(x) - 2:
    Xn                        | Aitken                 |Stepheson 
    0.25                      |                        | 
    0.221525416687741         |                        | 
    0.0850071238216746        | 0.257504387790415      | 
    -0.578472893261474        | 0.256892775322289      | 
    -4.08776841696098         | 0.257526937369315      | 0.257526937369315
    -35.0441476682879         | 0.257732604822869      | 0.257732604822869
    -1370.26887646992         | 0.287528863010341      | 0.287528863010341
    -1883119.86932801         | 0.247735480396528      | 0.247735480396528
    -3546147974739.43         | -2.62847312700751      | -2.62847312700751
    -1.25751654587628E+25     | -34.0968756675720      | -34.0968756675720
    -1.58134786315260E+50     | 1073741481.68260       | 1073741481.68260
    -2.50066106429729E+100    | 0                      | 0
    -6.25330575849244E+200    | nan                    | nan
    La aceleración de -x**2 + 3*x + exp(x) - 2 con semilla 0.25 en 0.333333333333333*x**2 + 0.333333333333333*x - 0.333333333333333*exp(x) + 0.666666666666667:
    Xn                        | Aitken                 |Stepheson 
    0.25                      |                        | 
    0.342824861104086         |                        | 
    0.350477254406297         | 0.351164790235221      | 
    0.351188864597114         | 0.351261823088331      | 
    0.351255617399848         | 0.351262532505594      | 0.351262532505594
    0.351261884184793         | 0.351262533522134      | 0.351262533522134
    0.351262472557723         | 0.351262533522904      | 0.351262533522904
    0.351262527798990         | 0.351262533522905      | 0.351262533522905
    0.351262532985496         | 0.351262533522905      | 0.351262533522905
    0.351262533472448         | 0.351262533522904      | 0.351262533522904
    0.351262533518167         | 0.351262533522904      | 0.351262533522904
    0.351262533522460         | 0.351262533522904      | 0.351262533522904
    0.351262533522863         | 0.351262533522904      | 0.351262533522904
    La aceleración de x**2 + x + 10*cos(x) con semilla -3.55 en -x**2 - 10*cos(x):
    Xn                        | Aitken                 |Stepheson 
    -3.55                     |                        | 
    -3.42495494033724         |                        | 
    -2.12910813554661         | -3.56335517905669      | 
    0.764449677143187         | -4.47597038254420      | 
    -7.80201698008086         | -3.77208967876199      | -3.77208967876199
    -61.3908816588683         | -17.7134524671622      | -17.7134524671622
    -3770.13495617214         | -0.308949401778629     | -0.308949401778629
    -14213927.3384249         | 4.40737816363196       | 4.40737816363196
    -202035730382025          | -6.23603888153457      | -6.23603888153457
    -4.08184363509983E+28     | -1899.79022616796      | -1899.79022616796
    -1.66614474614050E+57     | 0                      | 0
    -2.77603831509158E+114    | nan                    | nan
    -7.70638872685652E+228    | nan                    | nan


## Ejercicio 7
 7.- Programar el método de Newton-Raphson acelerado para el caso de una raíz múltiple de una ecuación y comparar los resultados
con los que se obtienen mediante el empleo de los métodos de aceleración anteriores.

### Solución

Lo que relentiza el método de convergencia Newton-Raphson para $f(x)$ son sus raíces múltiples, pero la función $\mu(x) = f(x)/f'(x)$ tiene las misma raíces y ninguna múltiple,  así que será tan sencillo como aplicarle Newton-Raphson a esa función. 


```python
import  newtonRaphson as nr

f = (x-2)*(x-2)

#método sin acelerar 
raiz,mensaje, iteraciones = nr.newtonRaphson(f,100,max_iter=4)

print(f'Para el método tradicional la solución es {raiz}, tras {iteraciones} iteraciones')

df = 2*(x-2)
m = simplify(f/df)

raiz,mensaje, iteraciones = nr.newtonRaphson(m,100, max_iter=4)

print(f'Para el método acelerado la solución es {raiz}, tras {iteraciones} iteraciones')
```

    Para el método tradicional la solución es 14.25, tras 4 iteraciones
    Para el método acelerado la solución es 2.0, tras 4 iteraciones


## Ejercicio 8 

 8.- Programar el conocido algoritmo de Horner para la evaluación de un polinomio y emplearlo de forma reiterativa para el cálculo del
desarrollo de Taylor de orden $ n$ de un polinomio cualquiera. Aprovecharlo también para programar una versión especial del método de Newton-Raphson para polinomios, evaluando tanto  $ p(x_k ) $ como $ p'(x_k)$ mediante el citado algoritmo.

### Solución

  El algoritmo de Horner se basa en sacar factor común $x$ para ahorrarse multiplicaciones, es decir si nuestro polinomio es de la forma $p = \sum_{i=0}^n \alpha_i x^i$ entonces el algoritmo de Horner sería, definimos $H(\alpha_i) = \alpha_i + x H(\alpha_{i+1})$, con $H(\alpha_n)=\alpha_n x$ sería $p =H(\alpha_0)$. 
  
 Si ahora queremos calcular la derivada $d$ del polinomio expresado;
 
 
 para todo $i \geq d$
Definimos $H_d(\alpha_i) = \frac{i!}{(i-d)!} \alpha_i + x H_d(\alpha_{i+1})$,  con 
 $H_d(\alpha_n)=\frac{n!}{(n-d)!}\alpha_n x$ y sería $p =H_d(\alpha_d)$. 


```python
n=4
a = list(symbols('a0:'+ str(n)))
def horner(x,coef, d = 0):
    
    n = len(coef)
    salida = 0
    for i in range(n,d,-1):
        salida = factorial(i-1)/factorial(i-d-1)*coef[i-1] + x*salida

        
    return salida

for i in range(n+1):
    print(f' derivada {i}: {horner(x,a,i)}')

```

     derivada 0: a0 + x*(a1 + x*(a2 + a3*x))
     derivada 1: a1 + x*(2*a2 + 3*a3*x)
     derivada 2: 2*a2 + 6*a3*x
     derivada 3: 6*a3
     derivada 4: 0


#### Newton con horner
Puede encontrar la implementación al final del fichero `newtonRaphson.py`



```python

```

9f192668fee0169f83813a221e1ff4362ca7a8ed
ipynb
Jupyter Notebook
practica1-evaluacion_y_raices/EJERCICIOS.ipynb
BlancaCC/metodosNumericosII
73fd6d8bc202a34af0d95d9ac17a3b671895314d
MIT
practica1-evaluacion_y_raices/EJERCICIOS.ipynb
BlancaCC/metodosNumericosII
73fd6d8bc202a34af0d95d9ac17a3b671895314d
MIT
practica1-evaluacion_y_raices/EJERCICIOS.ipynb
BlancaCC/metodosNumericosII
73fd6d8bc202a34af0d95d9ac17a3b671895314d
MIT
Qwen/Qwen-72B
1. YES
2. YES