# Modelo del rendimiento de una cuenta de ahorro



> **¿Tiene el dinero el mismo valor a lo largo del tiempo?** La respuesta es *no*. Todos lo hemos vivido. 

> Dos situaciones básicas:
1. <font color=blue>Inflación</font>: ¿Cuánto dinero necesitabas para comprar unas papas y un refresco hace 10 años? ¿Cuánto necesitas hoy?
2. <font color=blue>Interés</font>: no es lo mismo tener $\$10000$ MXN disponibles hoy a recibir $\$10000$ MXN en un año, pues los primeros pueden ser invertidos en un negocio o una cuenta bancaria para generar *interés*. Por lo tanto los $\$10000$ MXN disponibles hoy valen más que los $\$10000$ MXN que se recibirán en un año.

Referencia:
- Vidaurri Aguirre, Héctor Manuel. *Ingeniería económica básica*, ISBN: 978-607-519-017-4. (Disponible en biblioteca)

Referencias:
- http://www.sympy.org
- http://matplotlib.org
- http://www.numpy.org
- http://ipywidgets.readthedocs.io/en/latest/index.html

___
## Interés
Nos centraremos en como cambia el valor del dinero en el tiempo debido al **interés**. Existen dos tipos:

### Capitalización por interés simple
Este tipo de interés se calcula <font color=red>única y exclusivamente sobre la cantidad original que se invirtió</font>. Como consecuencia, el interés generado no forma parte del dinero que se invierte, es decir, los <font color=blue>intereses no ganan intereses</font>.

Suponga que se tiene un capital inicial $C_0$ y se invierte a un plazo de $k$ periodos (pueden ser meses, trimestres, semestres, años...) a una tasa de **interés simple** por periodo $i$. Al final del primer periodo, el capital $C_1$ que se obtiene es:

$$C_1=C_0+iC_0=C_0(1+i).$$

De la misma manera, como el interés solo se calcula sobre el capital inicial, al final del segundo periodo, el capital $C_2$ que se obtiene es:

$$C_2=C_1+iC_0=C_0+iC_0+iC_0=C_0(1+2i).$$

Así, al final del $k-$ésimo periodo, el capital $C_k$ que se obtiene es:

$$C_k=C_{k-1}+iC_0=C_0+kiC_0=C_0(1+ki).$$

> **Ejemplo.** Suponga que se tiene un capital de \$10000 MXN, el cual se pone en un fondo de inversión que paga una tasa de interés simple del 0.8% mensual. 

> Si se tiene una meta de ahorro de \$11000 MXN sin inversiones adicionales, ¿cuántos meses se debería dejar invertido el dinero?


```python
# Librería para cálculo numérico
import numpy as np
```


```python
# Valores dados en el enunciado
C0 = 10000
i = 0.8 / 100
Meta = 11000
```


```python
# Despejamos k tal que C_k=meta
k = np.ceil((Meta / C0 - 1) / i).astype(int)
```


```python
k
```




    13




```python
(1 + k * i) * C0
```




    11040.000000000002




```python
# Imprimimos respuesta en pantalla
print(f"Para llegar a nuestra meta de $11000, necesitamos {k} meses, con lo que obtenemos"
      f" al final de este periodo ${round((1 + k * i) * C0)}")
```

    Para llegar a nuestra meta de $11000, necesitamos 13 meses, con lo que obtenemos al final de este periodo $11040.0


> <font color=blue>**Actividad.**</font>
> - ¿Qué pasa si el interés no es del 0.8% mensual sino del 1% mensual?
> - ¿Qué pasa si la meta no son $\$11000$ MXN si no $\$12000$ MXN?


```python
# Solución

```

> Una gráfica que nos permite ilustrar la situación anterior se puede realizar de la siguiente manera.


```python
# Librerías para gráficos
from matplotlib import pyplot as plt
# Para que se muestren las gráficas en la misma ventana
%matplotlib inline
# Librería para widgets de python interactivo
from ipywidgets import interact, interact_manual, fixed, widgets
```

Explicar la siguiente función


```python
# Función de gráficos de interés simple
def interes_simple(C_0, meta, i):
    # Despejamos k
    k = np.ceil((meta / C_0 - 1) / i).astype(int)  # Notar el uso de la función ceil
    C_k = C_0 * (1 + k * i)  # Cálculo del capital al final del periodo k
    C_k = round(C_k, 2)  # Redondeo con dos cifras decimales
    # Vector de periodos
    kk = np.linspace(0, k, k + 1)               
    # Vector de capitales por periodo
    CC = C_0 * (1 + kk * i)
    # Gráfico
    plt.figure(num=1)  # Figura 1
    plt.clf()  # Borrar lo que contenga la figura
    plt.plot(kk, CC,'*',linewidth=3)  # Se grafica la evolución de los capitales
    plt.plot(kk, meta * np.ones(k + 1), '--k')  # Se grafica la meta
    plt.xlabel('k')  # Etiqueta eje x
    plt.ylabel('C_k')  # Etiqueta eje y
    plt.grid()  # Malla en la gráfica
    plt.show()  # Mostrar la figura
    print("El número de periodos que se debe dejar invertido el dinero para llegar a la meta de ", meta," es ", k,
          ". Al final del periodo ", k,", el capital es ", C_k, ".", sep="")
```


```python
interact_manual(interes_simple, 
                C_0=fixed(10000),
                meta=(10000, 20000, 100),
                i=widgets.FloatSlider(value=0.008,min=0.005,max=0.015,step=0.001,readout_format='.3f'))
```


    interactive(children=(IntSlider(value=15000, description='meta', max=20000, min=10000, step=100), FloatSlider(…





    <function __main__.interes_simple(C_0, meta, i)>



Como se esperaba, el capital en el $k-$ésimo periodo $C_k=C_0(1+ki)$ crece linealmente con $k$.

### Capitalización por interés compuesto
El capital que genera el interés simple permanece constante todo el tiempo de duración de la inversión. En cambio, el que produce el interés compuesto en un periodo se <font color=red>convierte en capital en el siguiente periodo</font>. Esto es, el interés generado al final de un periodo <font color=blue>se reinvierte para el siguiente periodo para también producir interés</font>.

Suponga que se tiene un capital inicial $C_0$, y se va a ceder el uso de este capital por un periodo de tiempo determinado a una tasa de interés $i$. El capital que se obtiene al final del primer periodo $C_1$ se puede calcular por

$$C_1=C_0(1+i).$$ 

Si la anterior suma se vuelve a ceder a la misma tasa de interés, al final del periodo dos el capital $C_2$ es 

$$C_2=C_1(1+i)=C_0(1+i)^2.$$

Si se repite el anterior proceso $k$ veces, el capital al final del $k-$ésimo periodo $C_k$ es 

$$C_k=C_{k-1}(1+i)=C_0(1+i)^k.$$

**Referencia**:
- https://es.wikipedia.org/wiki/Inter%C3%A9s_compuesto.

> **Ejemplo.** Suponga que se tiene un capital de \$10000 MXN, el cual se pone en un fondo de inversión que paga una tasa de interés del 0.8% mensual. 

> Si se tiene una meta de ahorro de \$11000 MXN sin inversiones adicionales, ¿cuántos meses se debería dejar invertido el dinero?

> Muestre una gráfica que ilustre la situación.


```python
def interes_compuesto(C_0, meta, i):
    # Despejamos k
    k = np.ceil(np.log(meta / C_0) / np.log(1 + i)).astype(int)
    C_k = C_0 * (1 + i)**k  # Cálculo del capital al final del periodo k
    C_k = round(C_k, 2)  # Redondeo con dos cifras decimales
    # Vector de periodos
    kk = np.linspace(0, k, k + 1)
    # Vector de capitales por periodo
    CC = C_0 * (1 + i)**kk
    # Gráfico
    plt.figure(num=1)  # Figura 1
    plt.clf()  # Borrar lo que contenga la figura
    plt.plot(kk, CC, '*', linewidth=3)  # Se grafica la evolución de los capitales
    plt.plot(kk, meta * np.ones(k + 1), '--k')  # Se grafica la meta
    plt.xlabel('k')  # Etiqueta eje x
    plt.ylabel('C_k')  # Etiqueta eje y
    plt.grid()  # Malla en la gráfica
    plt.show()  # Mostrar la figura
    print("El número de periodos que se debe dejar invertido el dinero para llegar a la meta de ", meta," es ", k,
          ". Al final del periodo ", k,", el capital es ", C_k, ".", sep="")
```


```python
interact_manual(interes_compuesto, 
                C_0=fixed(10000), 
                meta=(10000, 100000, 100), 
                i=fixed(0.008))
```


    interactive(children=(IntSlider(value=55000, description='meta', max=100000, min=10000, step=100), Button(desc…





    <function __main__.interes_compuesto(C_0, meta, i)>



El capital en el $k-$ésimo periodo $C_k=C_0(1+i)^k$ crece de manera exponencial con $k$.

> <font color=blue>**Actividad.**</font>
> - Modificar el código anterior para dejar fija la meta de ahorro y variar la tasa de interés compuesta.


```python

```

### Capitalización continua de intereses
La capitalización continua se considera un tipo de capitalización compuesta, en la que a cada instante de tiempo $t$ se se capitalizan los intereses. Es decir, la frecuencia de capitalización es infinita (o, equivalentemente, el periodo de capitalización tiende a cero).

Suponga que se tiene un capital inicial $C_0$, y que el capital acumulado en el tiempo $t$ es $C(t)$. Queremos saber cuanto será el capital pasado un periodo de tiempo $\Delta t$, dado que la tasa de interés efectiva para este periodo de tiempo es $i$. De acuerdo a lo anterior tenemos

$$C(t+\Delta t)=C(t)(1+i)=C(t)(1+r\Delta t),$$

donde $r=\frac{i}{\Delta t}$ es la tasa de interés instantánea. Manipulando la anterior expresión, obtenemos

$$\frac{C(t+\Delta t)-C(t)}{\Delta t}=r\; C(t).$$

Haciendo $\Delta t\to 0$, obtenemos la siguiente ecuación diferencial 

$$\frac{d C(t)}{dt}=r\; C(t),$$

sujeta a la condición inicial (monto o capital inicial) $C(0)=C_0$.

La anterior, es una ecuación diferencial lineal de primer orden, para la cual se puede calcular la *solución analítica*.


```python
# Librería de cálculo simbólico
import sympy as sym

# Para imprimir en formato TeX
sym.init_printing(use_latex="mathjax")
```


```python
# Símbolos t(para el tiempo) y r(para el interés instantáneo)
sym.var("t r")

# Función de capital
C = sym.Function("C")
```


```python
# Ecuación diferencial
ode = sym.Eq(sym.Derivative(C(t), t) - r * C(t), 0)
# Mostrar ecuación
display(ode)
```


$\displaystyle - r C{\left(t \right)} + \frac{d}{d t} C{\left(t \right)} = 0$



```python
# Resolver
sym.dsolve(ode, C(t))
```




$\displaystyle C{\left(t \right)} = C_{1} e^{r t}$



con $C_1=C_0$.

La equivalencia entre la tasa de interés compuesta $i$ y la tasa de interés instantánea $r$ viene dada por

$$e^r=1+i.$$

___
¿Cómo podemos calcular la *solución numérica*?

> **Ejemplo.** Suponga que se tiene un capital de \$10000 MXN, el cual se pone en un fondo de inversión que paga una tasa de interés del 0.8% mensual. 

> Si se tiene una meta de ahorro de \$11000 MXN sin inversiones adicionales, ¿cuánto tiempo se debe dejar invertido el dinero?

> Muestre una gráfica que ilustre la situación.


```python
# Librerías para integración numérica
from scipy.integrate import odeint
```


```python
help(odeint)
```

    Help on function odeint in module scipy.integrate.odepack:
    
    odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)
        Integrate a system of ordinary differential equations.
        
        .. note:: For new code, use `scipy.integrate.solve_ivp` to solve a
                  differential equation.
        
        Solve a system of ordinary differential equations using lsoda from the
        FORTRAN library odepack.
        
        Solves the initial value problem for stiff or non-stiff systems
        of first order ode-s::
        
            dy/dt = func(y, t, ...)  [or func(t, y, ...)]
        
        where y can be a vector.
        
        .. note:: By default, the required order of the first two arguments of
                  `func` are in the opposite order of the arguments in the system
                  definition function used by the `scipy.integrate.ode` class and
                  the function `scipy.integrate.solve_ivp`.  To use a function with
                  the signature ``func(t, y, ...)``, the argument `tfirst` must be
                  set to ``True``.
        
        Parameters
        ----------
        func : callable(y, t, ...) or callable(t, y, ...)
            Computes the derivative of y at t.
            If the signature is ``callable(t, y, ...)``, then the argument
            `tfirst` must be set ``True``.
        y0 : array
            Initial condition on y (can be a vector).
        t : array
            A sequence of time points for which to solve for y.  The initial
            value point should be the first element of this sequence.
            This sequence must be monotonically increasing or monotonically
            decreasing; repeated values are allowed.
        args : tuple, optional
            Extra arguments to pass to function.
        Dfun : callable(y, t, ...) or callable(t, y, ...)
            Gradient (Jacobian) of `func`.
            If the signature is ``callable(t, y, ...)``, then the argument
            `tfirst` must be set ``True``.
        col_deriv : bool, optional
            True if `Dfun` defines derivatives down columns (faster),
            otherwise `Dfun` should define derivatives across rows.
        full_output : bool, optional
            True if to return a dictionary of optional outputs as the second output
        printmessg : bool, optional
            Whether to print the convergence message
        tfirst: bool, optional
            If True, the first two arguments of `func` (and `Dfun`, if given)
            must ``t, y`` instead of the default ``y, t``.
        
            .. versionadded:: 1.1.0
        
        Returns
        -------
        y : array, shape (len(t), len(y0))
            Array containing the value of y for each desired time in t,
            with the initial value `y0` in the first row.
        infodict : dict, only returned if full_output == True
            Dictionary containing additional output information
        
            =======  ============================================================
            key      meaning
            =======  ============================================================
            'hu'     vector of step sizes successfully used for each time step.
            'tcur'   vector with the value of t reached for each time step.
                     (will always be at least as large as the input times).
            'tolsf'  vector of tolerance scale factors, greater than 1.0,
                     computed when a request for too much accuracy was detected.
            'tsw'    value of t at the time of the last method switch
                     (given for each time step)
            'nst'    cumulative number of time steps
            'nfe'    cumulative number of function evaluations for each time step
            'nje'    cumulative number of jacobian evaluations for each time step
            'nqu'    a vector of method orders for each successful step.
            'imxer'  index of the component of largest magnitude in the
                     weighted local error vector (e / ewt) on an error return, -1
                     otherwise.
            'lenrw'  the length of the double work array required.
            'leniw'  the length of integer work array required.
            'mused'  a vector of method indicators for each successful time step:
                     1: adams (nonstiff), 2: bdf (stiff)
            =======  ============================================================
        
        Other Parameters
        ----------------
        ml, mu : int, optional
            If either of these are not None or non-negative, then the
            Jacobian is assumed to be banded.  These give the number of
            lower and upper non-zero diagonals in this banded matrix.
            For the banded case, `Dfun` should return a matrix whose
            rows contain the non-zero bands (starting with the lowest diagonal).
            Thus, the return matrix `jac` from `Dfun` should have shape
            ``(ml + mu + 1, len(y0))`` when ``ml >=0`` or ``mu >=0``.
            The data in `jac` must be stored such that ``jac[i - j + mu, j]``
            holds the derivative of the `i`th equation with respect to the `j`th
            state variable.  If `col_deriv` is True, the transpose of this
            `jac` must be returned.
        rtol, atol : float, optional
            The input parameters `rtol` and `atol` determine the error
            control performed by the solver.  The solver will control the
            vector, e, of estimated local errors in y, according to an
            inequality of the form ``max-norm of (e / ewt) <= 1``,
            where ewt is a vector of positive error weights computed as
            ``ewt = rtol * abs(y) + atol``.
            rtol and atol can be either vectors the same length as y or scalars.
            Defaults to 1.49012e-8.
        tcrit : ndarray, optional
            Vector of critical points (e.g. singularities) where integration
            care should be taken.
        h0 : float, (0: solver-determined), optional
            The step size to be attempted on the first step.
        hmax : float, (0: solver-determined), optional
            The maximum absolute step size allowed.
        hmin : float, (0: solver-determined), optional
            The minimum absolute step size allowed.
        ixpr : bool, optional
            Whether to generate extra printing at method switches.
        mxstep : int, (0: solver-determined), optional
            Maximum number of (internally defined) steps allowed for each
            integration point in t.
        mxhnil : int, (0: solver-determined), optional
            Maximum number of messages printed.
        mxordn : int, (0: solver-determined), optional
            Maximum order to be allowed for the non-stiff (Adams) method.
        mxords : int, (0: solver-determined), optional
            Maximum order to be allowed for the stiff (BDF) method.
        
        See Also
        --------
        solve_ivp : Solve an initial value problem for a system of ODEs.
        ode : a more object-oriented integrator based on VODE.
        quad : for finding the area under a curve.
        
        Examples
        --------
        The second order differential equation for the angle `theta` of a
        pendulum acted on by gravity with friction can be written::
        
            theta''(t) + b*theta'(t) + c*sin(theta(t)) = 0
        
        where `b` and `c` are positive constants, and a prime (') denotes a
        derivative.  To solve this equation with `odeint`, we must first convert
        it to a system of first order equations.  By defining the angular
        velocity ``omega(t) = theta'(t)``, we obtain the system::
        
            theta'(t) = omega(t)
            omega'(t) = -b*omega(t) - c*sin(theta(t))
        
        Let `y` be the vector [`theta`, `omega`].  We implement this system
        in python as:
        
        >>> def pend(y, t, b, c):
        ...     theta, omega = y
        ...     dydt = [omega, -b*omega - c*np.sin(theta)]
        ...     return dydt
        ...
        
        We assume the constants are `b` = 0.25 and `c` = 5.0:
        
        >>> b = 0.25
        >>> c = 5.0
        
        For initial conditions, we assume the pendulum is nearly vertical
        with `theta(0)` = `pi` - 0.1, and is initially at rest, so
        `omega(0)` = 0.  Then the vector of initial conditions is
        
        >>> y0 = [np.pi - 0.1, 0.0]
        
        We will generate a solution at 101 evenly spaced samples in the interval
        0 <= `t` <= 10.  So our array of times is:
        
        >>> t = np.linspace(0, 10, 101)
        
        Call `odeint` to generate the solution.  To pass the parameters
        `b` and `c` to `pend`, we give them to `odeint` using the `args`
        argument.
        
        >>> from scipy.integrate import odeint
        >>> sol = odeint(pend, y0, t, args=(b, c))
        
        The solution is an array with shape (101, 2).  The first column
        is `theta(t)`, and the second is `omega(t)`.  The following code
        plots both components.
        
        >>> import matplotlib.pyplot as plt
        >>> plt.plot(t, sol[:, 0], 'b', label='theta(t)')
        >>> plt.plot(t, sol[:, 1], 'g', label='omega(t)')
        >>> plt.legend(loc='best')
        >>> plt.xlabel('t')
        >>> plt.grid()
        >>> plt.show()
    



```python
# Modelo de capitalización continua
def cap_continua(C, t, r):
    return r * C
```


```python
def interes_continuo(C_0, meta, r):
    # Despejamos t
    t = np.log(meta / C_0) / r
    # Vector de periodos
    tt = np.linspace(0, t, 100)
    # Vector de capitales por periodo
    CC = odeint(cap_continua, C_0, tt, args = (r,))
    # Gráfico
    plt.figure(num=1)  # Figura 1
    plt.clf()  # Borrar lo que contenga
    plt.plot(tt, CC, '-', linewidth=3)  # Se grafica la evolución de los capitales
    plt.plot(tt,meta*np.ones(len(tt)),'--k')  # Se grafica la meta
    plt.xlabel('t')  # Etiqueta eje x
    plt.ylabel('C(t)')  # Etiqueta eje y
    plt.grid()  # Malla en la gráfica
    plt.show()  # Mostrar la figura
    print("El tiempo que se debe dejar invertido el dinero para llegar a la meta de ", meta," es ", t, " meses.", sep="")
```


```python
interact_manual(interes_continuo,
                C_0=fixed(10000),
                meta=(10000,100000,100),
                r=fixed(np.log(1+0.008)));
```


    interactive(children=(IntSlider(value=55000, description='meta', max=100000, min=10000, step=100), Button(desc…


### Actividad. 
1. Resolver simbólicamente y numéricamente la siguiente ecuación diferencial:
$$\frac{dx}{dt}=\frac{x}{t+1}; \quad x(0) = 1$$


```python
# Símbolos t(para el tiempo) y r(para el interés instantáneo)

# Función de capital

# Ecuacion diferencial

```


```python
# Resolver

```

Despejamos la constante usando la condición inicial:

$$
1=x(0)=C_1(0 + 1)=C_1
$$

Finalmente, la solución es:

$$
x(t) = t + 1
$$

2. Obtener la solución numérica.


```python
# Funcion a integrar

```


```python

```


```python
# Condicion inicial

# Vector de tiempo

```


```python

```


```python
# Solucion numerica

```


```python

```


```python

```


```python
# Grafica x vs.t

```

3. Comparar.


```python
# Grafica x vs.t

```

___
## Tabla de abonos
Como aplicación importante del concepto de interés compuesto se encuentra la creación de un modelo de cuenta de ahorro.

Referencia:
- Vidaurri Aguirre, Héctor Manuel. *Ingeniería económica básica*, ISBN: 978-607-519-017-4. (Disponible en biblioteca)
- http://pbpython.com/amortization-model.html


```python
# Librería de análisis de datos
import pandas as pd
# Librería para manipulación de fechas
from datetime import date
```


```python
# Datos para la cuenta de ahorro
Tasa_interes = 0.08  # 8% anual
Anos = 30
Abonos_ano = 12
Inicial = 50000
Meta = 100000
fecha_inicio = date(2021, 7, 1)

# Tasa interés por periodo
i = Tasa_interes / Abonos_ano  # Tasa de interés mensual
# Total de periodos
T = Anos * Abonos_ano  # 

# Cálculo de abonos mensuales iguales para llegar a la meta de ahorro en el tiempo deseado
Abono = 1000# i * (Meta - Inicial * (1 + i)**T) / ((1 + i)**T - 1)

# Rango de fechas en la tabla
rng = pd.date_range(fecha_inicio, periods=T, freq='MS')
rng.name = "Fecha del abono"

# Columnas de abonos y extracto de cuenta en las fechas respectivas
df = pd.DataFrame(index=rng, columns=['Abono', 'Balance'], dtype='float')

# Para poner el indice con los periodos y no con las fechas
df.reset_index(inplace=True)
df.index += 1
df.index.name = "Periodo"  # Columna correspondiente al periodo

# Los abonos son iguales
df["Abono"] = Abono

# Vector indizador de los periodos de los abonos
index_vector = np.arange(1,len(rng)+1)
# Extracto de la cuenta mes a mes
df["Balance"] = Inicial * (1 + i)**index_vector + Abono * (((1 + i)**index_vector - 1) / i)

# Redondear con dos cifras decimales
df = df.round(2)
df

# La siguiente solución es también válida. Sin embargo, evitar el uso de 'for'

#df.loc[1, "Balance"] = Inicial*(1+Tasa_interes/Abonos_ano)**1 + df.loc[1, "Abono"]

#for i in range(2, len(df)+1):
#    # Get the previous balance as well as current payments
#    prev_balance = df.loc[i-1, "Balance"]

#    df.loc[i, "Balance"] = prev_balance*(1+Tasa_interes/Abonos_ano)**1 + df.loc[i, "Abono"]
```




<div>
<style scoped>
    .dataframe tbody tr th:only-of-type {
        vertical-align: middle;
    }

    .dataframe tbody tr th {
        vertical-align: top;
    }

    .dataframe thead th {
        text-align: right;
    }
</style>
<table border="1" class="dataframe">
  <thead>
    <tr style="text-align: right;">
      <th></th>
      <th>Fecha del abono</th>
      <th>Abono</th>
      <th>Balance</th>
    </tr>
    <tr>
      <th>Periodo</th>
      <th></th>
      <th></th>
      <th></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>1</th>
      <td>2021-07-01</td>
      <td>1000</td>
      <td>51333.33</td>
    </tr>
    <tr>
      <th>2</th>
      <td>2021-08-01</td>
      <td>1000</td>
      <td>52675.56</td>
    </tr>
    <tr>
      <th>3</th>
      <td>2021-09-01</td>
      <td>1000</td>
      <td>54026.73</td>
    </tr>
    <tr>
      <th>4</th>
      <td>2021-10-01</td>
      <td>1000</td>
      <td>55386.90</td>
    </tr>
    <tr>
      <th>5</th>
      <td>2021-11-01</td>
      <td>1000</td>
      <td>56756.15</td>
    </tr>
    <tr>
      <th>...</th>
      <td>...</td>
      <td>...</td>
      <td>...</td>
    </tr>
    <tr>
      <th>356</th>
      <td>2051-02-01</td>
      <td>1000</td>
      <td>1979781.29</td>
    </tr>
    <tr>
      <th>357</th>
      <td>2051-03-01</td>
      <td>1000</td>
      <td>1993979.84</td>
    </tr>
    <tr>
      <th>358</th>
      <td>2051-04-01</td>
      <td>1000</td>
      <td>2008273.03</td>
    </tr>
    <tr>
      <th>359</th>
      <td>2051-05-01</td>
      <td>1000</td>
      <td>2022661.52</td>
    </tr>
    <tr>
      <th>360</th>
      <td>2051-06-01</td>
      <td>1000</td>
      <td>2037145.93</td>
    </tr>
  </tbody>
</table>
<p>360 rows × 3 columns</p>
</div>




```python
df['Abono'].sum() + Inicial
```




$\displaystyle 70829.0$




```python
df['Balance'].plot();
```

> <font color=blue>**Tarea.**</font>
> - Averiguar tasas de interés reales en algún banco y proyectar un ahorro mensual para que al terminar su carrera tengan $50000 MXN en su cuenta.
> - Hacer esto en un nuevo archivo, llamarlo Tarea6_ApellidoNombre.ipynb y subirlo a moodle.
> - Plazo: Lunes 5 de Julio.



<footer id="attribution" style="float:right; color:#808080; background:#fff;">
Created with Jupyter by Esteban Jiménez Rodríguez.
</footer>

3a865f2509e7d142a0c87463a7df71b47970075d
ipynb
Jupyter Notebook
Modulo3/Clase13_ModeloAhorro.ipynb
Damaris02/simmatv2021
cfd3b49a50c543293b30cc797739ecdf7725d886
MIT
Modulo3/Clase13_ModeloAhorro.ipynb
Damaris02/simmatv2021
cfd3b49a50c543293b30cc797739ecdf7725d886
MIT
Modulo3/Clase13_ModeloAhorro.ipynb
Damaris02/simmatv2021
cfd3b49a50c543293b30cc797739ecdf7725d886
MIT
2021-05-25T21:51:37.000Z
2021-06-15T00:44:51.000Z
Qwen/Qwen-72B
1. YES
2. YES