```python
import math
import numpy as np
from sympy import *
t, s, k = symbols('t, s, k')
```


```python
# Defino los métodos de suma de rectángulos - izquierda
def _Riemman_izq(Func, limA, limB, numI):
    """ Método de la Bisección para encontrar raíces en un intervalo.

        ## Parámetros:
            Func (function) : función que depende de una variable.
            limA (function) : derivada de la función.
            limB (int)      : semilla de la solución.
            numI (int)      : número máximo de iteraciones.
        
        ## Devoluciones:
            Area (float)       : valor de area encontrado.
    """
    Δx = (limB - limA) / numI
    Alturas = 0
    for i in range(numI):
        Alturas += Func(limA + i * Δx)

    Area = Δx * Alturas
    return Area

# Defino los métodos de suma de rectángulos - izquierda
def _Riemman_der(Func, limA, limB, numI):
    """ Método de la Bisección para encontrar raíces en un intervalo.

        ## Parámetros:
            Func (function) : función que depende de una variable.
            limA (function) : derivada de la función.
            limB (int)      : semilla de la solución.
            numI (int)      : número máximo de iteraciones.
        
        ## Devoluciones:
            Area (float)       : valor de area encontrado.
    """
    Δx = (limB - limA) / numI
    Alturas = 0
    for i in range(numI):
        Alturas += Func(limB - i * Δx)

    Area = Δx * Alturas
    return Area

# Defino los métodos de suma de rectángulos - izquierda
def _Riemman_med(Func, limA, limB, numI):
    """ Método de la Bisección para encontrar raíces en un intervalo.

        ## Parámetros:
            Func (function) : función que depende de una variable.
            limA (function) : derivada de la función.
            limB (int)      : semilla de la solución.
            numI (int)      : número máximo de iteraciones.
        
        ## Devoluciones:
            Area (float)       : valor de area encontrado.
    """
    Δx = (limB - limA) / numI
    Alturas = 0
    for i in range(numI):
        Alturas += Func(limA + (2*i + 1)/2 * Δx)

    Area = Δx * Alturas
    return Area

# Defino el métodos del trapecio
def _trapecio(Func, limA, limB, numI):
    """ Método de la Bisección para encontrar raíces en un intervalo.

        ## Parámetros:
            Func (function) : función que depende de una variable.
            limA (function) : derivada de la función.
            limB (int)      : semilla de la solución.
            numI (int)      : número máximo de iteraciones.
        
        ## Devoluciones:
            Area (float)       : valor de area encontrado.
    """
    Δx = (limB - limA) / numI
    Bases = 0
    for i in range(numI):
        Bases += Func(limA + i * Δx) + Func(limA + Δx + i * Δx)

    Area = Δx/2 * Bases
    return Area

# Defino el métodos de la regla simpson
def _simpson(Func, limA, limB, numI):
    """ Método de la Bisección para encontrar raíces en un intervalo.

        ## Parámetros:
            Func (function) : función que depende de una variable.
            limA (function) : derivada de la función.
            limB (int)      : semilla de la solución.
            numI (int)      : número máximo de iteraciones.
        
        ## Devoluciones:
            Area (float)       : valor de area encontrado.
    """
    Δx = (limB - limA) / numI
    Bases = 0
    for i in range(numI):
        Bases += Func(limA + i * Δx) + 4 * Func(limA + (2*i + 1)/2 * Δx) + Func(limA + Δx + i * Δx)

    Area = Δx/6 * Bases
    return Area
```


```python
# 2
una_lista = [[1,2,3,[0,]], [4,5,6,0], [7,8,9,(0,1)]]
una_lista[1:][1][3][1]

```




    1




```python
# 3
A = [(1,  2),  (-3,  4)]
b = [14,  18]
M11 = 4
detA = np.linalg.det(A)
Zt = Integral(s, (s, t, M11))
funtion_Zt = Zt.doit()
Zt1 = detA * funtion_Zt.subs(t, 1)
display(Zt, funtion_Zt, Zt1)

# math.floor(Z11)
```


$\displaystyle \int\limits_{t}^{4} s\, ds$



$\displaystyle 8 - \frac{t^{2}}{2}$



$\displaystyle 75.0$



```python
# 4 
A = [(1, 3), (0, 3)]
b = [14, 21]
x = np.matmul(np.linalg.inv(A), np.transpose(b))
x1 = x[0]
x2 = x[1]
ft = 2*t
Ft = Integral(ft, t)
Ft_ab = Integral(ft, (t, x2, x1))

# Evaluar la integral
Rt = Ft.doit()
Rt_ab = Ft_ab.doit()
display(Eq(Ft, Rt))
display(Ft_ab, Rt_ab)

```


$\displaystyle \int 2 t\, dt = t^{2}$



$\displaystyle \int\limits_{7.0}^{-7.0} 2 t\, dt$



$\displaystyle 0$



```python
# 5
F2 = lambda x: (x**2 + 3)**3
Va = _Riemman_der(F2, 4, 0, 7)
print(Va)
print(-3000 - Va)
print(-4000 - Va)
```

    -3150.264595777026
    150.264595777026
    -849.735404222974



```python
# 8
F4 = lambda k: math.e**(k)/k
va_1 = _trapecio(F4, 2, 4, 4)
va_2 = _simpson(F4, 2, 4, 4)
print(f"{va_1:7.5f}")
print(f"{va_2:7.5f}")

```

    14.85088
    14.67678



```python
# 9
F3 = lambda k: math.e**(2*k)
vr = Integral(math.e**(2*k), (k, 0, 3)).doit()
va = _Riemman_med(F3, 0, 3, 3)
er = 100 * abs(vr-va)/va
print(vr, va, er)
```

    201.214396746367 171.21697785422327 17.5201193643801


3589c485d8fff0b396bae7f724f65edac80cbed7
ipynb
Jupyter Notebook
Jupyter/55_Solucion_taller_4.ipynb
GiancarloBenavides/Metodos-Numericos
c35eb538d33b8dd58eacccf9e8b9b59c605d7dba
MIT
2020-10-29T19:13:39.000Z
2020-10-29T19:13:39.000Z
Jupyter/55_Solucion_taller_4.ipynb
GiancarloBenavides/Metodos-Numericos
c35eb538d33b8dd58eacccf9e8b9b59c605d7dba
MIT
Jupyter/55_Solucion_taller_4.ipynb
GiancarloBenavides/Metodos-Numericos
c35eb538d33b8dd58eacccf9e8b9b59c605d7dba
MIT
2020-11-12T20:22:40.000Z
2020-11-12T20:22:40.000Z
Qwen/Qwen-72B
1. YES
2. YES