s1Eva_IT2011_T1_MN Fondo de inversión

Ejercicio: 1Eva_IT2011_T1_MN Fondo de inversión

Se desarrolla para la función:

C(t)=Ate^{-t/3}

siguiento las instrucciones por partes, se obtienen los siguientes resultados:
los valores resultantes:

derivada de la función: 
-x*exp(-x/3)/3 + exp(-x/3)
valor maximo en : 
3.0000001192092896
A para un millon: 
906093.94282
el valor de t para la meta es: 
11.0779035867

las instrucciones en python para observar la función son:

# 1ra Evaluación I Término 2011
# Tema 1. Fondo de Inversion
import numpy as np
import matplotlib.pyplot as plt

ft = lambda t: t*np.exp(-t/3)

a=0
b=20
tolera = 0.000001
muestras = 101
meta = 0.25
# PROCEDIMIENTO
# Observar la función entre [a,b]
ti = np.linspace(a,b,muestras)
fti = ft(ti)

# Salida
# Gráfica
plt.plot(ti,fti, label='f(t)')
plt.axhline(meta, color = 'r')
plt.axhline(0, color = 'k')
plt.legend()
plt.show()


Para desarrollar el literal a), donde se busca el valor máximo, usando la derivada de la función cuando existe el cruce por cero.
Para la derivada se usa la forma simbólica de la función, que se convierte a forma numérica lambda para evaluarla de forma más fácil.

# Literal a) usando derivada simbólica
import sympy as sp
x = sp.Symbol('x')
fxs = x*sp.exp(-x/3)
dfxs = fxs.diff(x,1)

# convierte la expresión a lambda
dfxn = sp.utilities.lambdify(x,dfxs,'numpy')
dfxni = dfxn(ti)
print('derivada de la función: ')
print(dfxs)
# Gráfica de la derivada.
plt.plot(ti,dfxni, label='df(t)/dt')
plt.axhline(0, color = 'k')
plt.legend()
plt.show()

derivada de la función: 
-x*exp(-x/3)/3 + exp(-x/3)

Se busca la raiz con algún método, por ejemplo bisección.

# Busca el máximo en dfxni
def biseccion(funcionx,a,b,tolera):
    fa = funcionx(a)
    fb = funcionx(b)
    tramo = np.abs(b-a)
    while (tramo>=tolera):
        c = (a+b)/2
        fc = funcionx(c)
        cambia = np.sign(fa)*np.sign(fc)
        if (cambia<0):
            b = c
            fb = fc
        else:
            a = c
            fa = fc
        tramo = np.abs(b-a)
    return(c)

# usa función para encontrar el máximo
raizmax = biseccion(dfxn, a, b, tolera)
verifica =  dfxn(raizmax)
print('valor maximo en : ')
print(raizmax)

# que el máximo sea un millon
tmax = raizmax
A = (1000000)/ft(tmax)
print('A para un millon: ')
print(A)
valor maximo en : 3.0000001192092896
A para un millon: 906093.94282

Para el literal b, se busca la laiz usando el metodo de Newton-Raphson como se indica en el enunciado.
En la función nueva se usa el valor de A encontrado, y la meta establecida.
Se obtiene la misa derivada del problema anterio multiplicada por A, por ser solo un factor que multiplica a la función original. El valor de meta es una constante, que se convierte en cero al derivar.

# literal b), buscar cumplir meta de 0.25 millones
def newtonraphson(funcionx, fxderiva, c, tolera):
    tramo = abs(2*tolera)
    while (tramo>=tolera):
        xnuevo = c - funcionx(c)/fxderiva(c)
        tramo = abs(xnuevo-c)
        c = xnuevo
    return(c)

ft1 = lambda t: A*t*np.exp(-t/3) - 250000
# usar método de newton,
# puede usar la misma derivada multiplicada por A
dft1s = A*(fxs.diff(x,1))
dft1 = sp.utilities.lambdify(x,dft1s,'numpy')
c = 10

raiz4 = newtonraphson(ft1, dft1, c, tolera)
ft1i = ft1(ti)

print('el valor de t para la meta es: ')
print(raiz4)

# Gráfica
plt.plot(ti,ft1i, label = 'f(t) con A>1')
plt.axhline(meta, color = 'r')
plt.axhline(0, color = 'k')
plt.axvline(raiz4, color = 'm')
plt.legend()
plt.show()

el valor de t para la meta es: 11.0779035867