Sitemap
Press enter or click to view image in full size
9 min readMar 11, 2024

--

Introducción

En publicaciones anteriores, modelamos funciones para distintos tipos de bonos y analizamos su teoría y fórmulas. La teoría que aplicaremos en esta publicación para cada tipo de bono la encontrarás en las siguientes ligas respectivamente:

Bono Cupón Cero

Bono Tasa Fija

Bono Tasa Variable.

En esta publicación, desarrollaremos un modelo unificado para todos los tipos de bonos, al cual denominaremos ‘Clase Bono’. Al hablar de clases, nos referimos a algo llamado Programación Orientada a Objetos (POO). La POO nos permite crear plantillas que nos servirán para automatizar el análisis de instrumentos similares.

Python: Programación Orientada a Objetos

Python es un lenguaje de programación de alto nivel cuya simplicidad y versatilidad facilitan el desarrollo en múltiples áreas como ingeniería, finanzas, ciencia de datos e inteligencia artificial. Gracias a su sintaxis clara y su soporte para múltiples paradigmas de programación, incluida la Programación Orientada a Objetos (POO), se ha convertido en una herramienta invaluable.

La Programación Orientada a Objetos (POO) es una manera de organizar el código en programas que se centra en crear ‘objetos’ a partir de ‘clases’. Imagina las clases como plantillas o moldes en una fábrica de juguetes: cada plantilla (clase) se utiliza para moldear varias figuras de juguete (objetos). Nuestro interés se centra en los instrumentos financieros y, bajo este enfoque, supongamos que un grupo de instrumentos financieros comparten ciertas características o atributos; por lo tanto, podemos crear una plantilla para estos.

Primero definimos la clase y sus atributos (Representan las características o datos que los objetos):

Press enter or click to view image in full size
Animación 1. Creación de una clase (Constructor)

Después definimos los métodos (acciones definidas dentro de una clase y se utilizan para definir el comportamiento de los objetos):

Press enter or click to view image in full size
Animación 2. Métodos de una clase

Ya que se define una clase, esta la utilizaremos como plantilla para crear “instancias” (objeto concreto creado a partir de una clase) y sobre estas instancias realizaremos los cálculos definidos en la clase:

Press enter or click to view image in full size
Animación 3. Instancias u Objetos de una clase

Los objetos se comportan de acuerdo a la plantilla o clase que definimos. Cada objeto “hereda” los métodos de la clase y ahora podemos obtener el resultado de cada método y utilizarlo a nuestro gusto.

Este paradigma de programación nos permite automatizar el análisis de muchos instrumentos financieros clasificados de acuerdo a sus características. Veamos el concepto de lo que queremos modelar respecto a Bonos.

Modelación del Bono

Deseamos obtener un solo modelo, por lo tanto debemos conceptualizar el modelo que realizaremos considerando las características de los tres bonos previamente utilizados. Lo primero que definiremos en nuestro modelo es ¿Qué deseamos hacer? es decir el objetivo del modelo.

Objetivo del Modelo

La modelación de Bonos en herramientas como Excel, puede ser tediosa cuando deseamos observar los flujos en el tiempo y calcular las medidas principales de cualquier bono, por lo tanto elaboraremos obtendremos dos arreglos de datos: el calendario de pagos con los flujos correspondientes y las medidas principales del bono tipo resumen. Definiremos entonces dos principales métodos: obtener_calendario_pagos y obtener_medidas:

Press enter or click to view image in full size
Imagen 1. Métodos objetivo de la Clase Bono

En finanzas todo es flujo de efectivo, por lo que el primer método es el de mayor importancia para nuestro modelo. Veamos cómo desarrollamos el modelo basándonos en un nuestro objetivo.

Desarrollo del Modelo

Primero debemos determinar las variables de entrada de nuestro modelo las cuales serán atributos de nuestra clase. Para esto, debemos comprender cómo obtendremos los flujos, los valores presentes y las medidas que deseamos obtener. Vayamos en sentido contrario, del objetivo hacia las necesidades.

Para nuestro método obtener_calendario_pagos, debemos determinar si el bono cuenta con cupones fraccionados, debemos obtener los días en los que estos se pagarán así como obtener los valores presentes brutos, intereses devengados en el tiempo y los valores presentes netos:

Press enter or click to view image in full size
Imagen 2. Métodos internos necesarios para el método final obtener calendario de pagos

La suma de estos valores son lo que conocemos como precio sucio, intereses devengados y precio limpio, respectivamente. Para poder obtener los valores presentes primero necesitamos obtener el flujo de efectivo que pagará el bono, el cual dependerá de la configuración o tipo de Bono.

Get Modelación Financiera Python’s stories in your inbox

Join Medium for free to get updates from this writer.

El Bono cupón cero paga un solo flujo de efectivo, el bono cupón fijo paga un monto constante y el valor nominal al finalizar, y el variable paga interés que oscila de acuerdo a la tasa asociada y el nominal al final. Será conveniente “dividir” nuestra clase en tres subclases: BonoCero, BonoFijo y BonoVariable ya que cada una tendrá su propio método para obtener los flujos correspondientes:

Press enter or click to view image in full size
Imagen 3. Creación de subclases: BonoCero, BonoFijo y BonoVariable

Una subclase es una clase que hereda de otra clase (super clase o padre) atributos y métodos permitiendo reutilizar el código previamente desarrollado. Las variables de entrada que son atributos de la clase no los hemos definido aun, ya que dependen del flujo y cómo se determinará el valor presente para cada tipo de bono:

Press enter or click to view image in full size
Animación 4. Variables de entrada (atributos) de la Clase Bono

Dado que la subclase BonoVariable es la que más variables necesita para determinar los flujos y los valores presentes, esta será la que defina las variables de entrada o atributos : valor_nominal, tasa_cupon, periodo_cupon, tasa_interes, dias_vencimiento, sobre_tasa, dias_vencimiento y dias_anio. Con esta información podemos conceptualizar la definición del método obtener_calendario_pagos y sus necesidades:

Press enter or click to view image in full size
Imagen 4. Diagrama del método obtener calendario de la Clase Bono

En algunas ocasiones deseamos obtener solo las medidas que caracterizan el análisis de un Bono: precio sucio, interés devengado, precio limpio, duración, duración modificada y convexidad (entre otras). Dado que los cálculos los obtendremos de los métodos previamente definidos, no necesitaremos variables de entrada extra para el método obtener_medidas:

Press enter or click to view image in full size
Imagen 5. Diagrama de la Clase Bono

Para obtener estas medidas definiremos los métodos calcular_precio_sucio, calcular_interés_devengado, calcular_precio_limpio, calcular_duración_macaulay, calcular_duracion_modificada y calcular_convexidad. Dado que estas medidas son características para todos los bonos, le indicaremos a nuestro modelo que estos son atributos del Bono. Ahora procedamos a programar la clase, los atributos y los métodos previamente definidos.

Desarrollo

Desarrollaremos la clase Bono de acuerdo a los siguientes pasos:

  1. Crear la Clase y su constructor
  2. Definir los métodos internos y necesarios de la Clase Bono o Super Clase.
  3. Definir las subclases BonoCero, BonoFijo y BonoVariable junto con sus respectivos métodos internos obtener_flujos
  4. Definir el método obtener_calendario_pagos y llamar los métodos necesarios para presentar el resultado
Press enter or click to view image in full size
Animación 5. Desarrollo de la clase Bono

EL código completo de nuestra clase quedaría entonces:

# Importamos Librerías
from abc import abstractmethod
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

class Bono:
def __init__(
self,
valor_nominal,
tasa_cupon,
tasa_rendimiento,
sobre_tasa,
periodo_cupon,
dias_vencimiento,
dias_por_año,
):
self.valor_nominal = valor_nominal # Valor nominal
self.tasa_cupon = tasa_cupon # Tasa del cupón
self.tasa_rendimiento = tasa_rendimiento # Tasa de interés
self.sobre_tasa = sobre_tasa # Sobretasa
self.periodo_cupon = periodo_cupon if periodo_cupon != 0 else dias_vencimiento # Periodo de cada cupón
self.dias_vencimiento = dias_vencimiento # Días hasta el vencimiento
self.dias_por_año = dias_por_año # Días por año (360, 365, etc.)
self.flujos = None # Se definirá en subclases

def obtener_cupones(self):
# Calcular el número total de cupones (puede incluir decimales)
total_cupones = self.dias_vencimiento / self.periodo_cupon
cupones_completos = int(total_cupones)
es_fraccionado = total_cupones > cupones_completos
fraccion_cupon = total_cupones - cupones_completos if es_fraccionado else 0

return cupones_completos, es_fraccionado, fraccion_cupon

def obtener_intereses_devengados(self):
cupones_completos, es_fraccionado, fraccion_cupon = self.obtener_cupones()
longitud = cupones_completos + 1 if es_fraccionado else cupones_completos
intereses_devengados = np.zeros(longitud)
if es_fraccionado:
intereses_devengados[0] = (
(1 - fraccion_cupon)
* (self.periodo_cupon)
* self.valor_nominal
* self.tasa_cupon
/ self.dias_por_año
)

return intereses_devengados

def obtener_factores(self):
cupones_completos, es_fraccionado, fraccion_cupon = self.obtener_cupones()
longitud = cupones_completos + (1 if es_fraccionado else 0)
factores = np.zeros(longitud)

if es_fraccionado:
factores = np.arange(start=fraccion_cupon, stop=fraccion_cupon + longitud)
else:
factores = np.arange(start=1, stop=longitud + 1)

return factores

def obtener_valores_presentes(self, tasa_rendimiento=None):
if tasa_rendimiento is None:
tasa_rendimiento = self.tasa_rendimiento
if self.flujos is None:
self.definir_flujos() # Asegura que self.flujos esté definido

factores = self.obtener_factores()
descuento = (
1
+ (tasa_rendimiento + self.sobre_tasa)
* self.periodo_cupon
/ self.dias_por_año
) ** -factores
valores_presentes = self.flujos * descuento

return valores_presentes

def obtener_calendario_pagos(self):
factores = self.obtener_factores()
dias_flujo = factores * self.periodo_cupon
flujo_efectivo = self.definir_flujos()
valor_presente_bruto = self.obtener_valores_presentes()
interes_devengado = self.obtener_intereses_devengados()
valor_presente_neto = valor_presente_bruto - interes_devengado

df = {
"Días Flujo": dias_flujo,
"Flujo": flujo_efectivo,
"Valor Presente Bruto": valor_presente_bruto,
"Interés Devengado": interes_devengado,
"Valor Presente Neto": valor_presente_neto,
}

# Convertimos al formato DataFrame con pandas

calendario_pagos = pd.DataFrame(df)
calendario_pagos.loc["Total"] = [
dias_flujo[-1],
flujo_efectivo.sum(),
valor_presente_bruto.sum(),
interes_devengado.sum(),
valor_presente_neto.sum(),
]
return calendario_pagos

def obtener_medidas(self):
precio_sucio = self.precio_sucio
interes_devengado = self.interes_devengado
precio_limpio = self.precio_limpio
duracion_macaulay = self.duracion_macaulay
duracion_modificada = self.duracion_modificada
convexidad = self.convexidad

datos = {
"Concepto": [
"Precio Sucio",
"Interés Devengado",
"Precio Limpio",
"Duración Macaulay",
"Duración Modificada",
"Convexidad",
],
"Dato": [
precio_sucio,
interes_devengado,
precio_limpio,
duracion_macaulay,
duracion_modificada,
convexidad,
],
}

medidas = pd.DataFrame(datos)
medidas.set_index("Concepto", inplace=True)

return medidas

def calcular_precio_sucio_cambio(self, tasa_rendimiento=None):
if tasa_rendimiento is None:
tasa_rendimiento = self.tasa_rendimiento
valor_presente_bruto = self.obtener_valores_presentes(
tasa_rendimiento=tasa_rendimiento
)
precio_sucio = valor_presente_bruto.sum()

return precio_sucio

@property
def precio_sucio(self):
valor_presente_bruto = self.obtener_valores_presentes()
precio_sucio = valor_presente_bruto.sum()

return precio_sucio

@property
def interes_devengado(self):
intereses_devengados = self.obtener_intereses_devengados()
interes_devengado = intereses_devengados.sum()

return interes_devengado

@property
def precio_limpio(self):
precio_sucio = self.precio_sucio
interes_devengado = self.interes_devengado
precio_limpio = precio_sucio - interes_devengado

return precio_limpio

@property
def duracion_macaulay(self):
valor_presente_bruto = self.obtener_valores_presentes()
factores = self.obtener_factores()
proporcion = valor_presente_bruto / self.precio_sucio
tiempo_proporcion = proporcion * factores
duracion_macaulay = (
tiempo_proporcion.sum() * self.periodo_cupon / self.dias_por_año
)

return duracion_macaulay

@property
def duracion_modificada(self):
duracion_macaulay = self.duracion_macaulay
duración_modificada = duracion_macaulay / (
1
+ (self.tasa_rendimiento + self.sobre_tasa)
* self.periodo_cupon
/ self.dias_por_año
)
return duración_modificada

@property
def convexidad(self):
tasa_original = self.tasa_rendimiento
precio_mas = self.calcular_precio_sucio_cambio(tasa_rendimiento=tasa_original + 0.0001)
precio_menos = self.calcular_precio_sucio_cambio(tasa_rendimiento=tasa_original - 0.0001)
precio_base = self.precio_sucio

convexidad = (precio_menos + precio_mas - (2 * precio_base)) / (
(0.0001**2) * precio_base
)

return convexidad

@abstractmethod
def definir_flujos(self):
pass

class CuponCero(Bono):
def definir_flujos(self):
factores = self.obtener_factores()
self.flujos = np.zeros(len(factores))
self.flujos[-1] = (
self.valor_nominal
) # Solo hay un flujo, el valor nominal al final

return self.flujos

class CuponFijo(Bono):
def definir_flujos(self):
factores = self.obtener_factores()
cupones = np.full(
len(factores) - 1,
self.valor_nominal
* self.tasa_cupon
* self.periodo_cupon
/ self.dias_por_año,
)
self.flujos = np.append(
cupones, [self.valor_nominal + cupones[-1]]
) # Añadir el valor nominal al final

return self.flujos

class CuponVariable(Bono):
def definir_flujos(self):
factores = self.obtener_factores()
cupones = np.full(
len(factores) - 1,
self.valor_nominal
* self.tasa_rendimiento
* self.periodo_cupon
/ self.dias_por_año,
)
cupones[0] = (
self.valor_nominal
* self.tasa_cupon
* self.periodo_cupon
/ self.dias_por_año
)

self.flujos = np.append(
cupones, [self.valor_nominal + cupones[-1]]
) # Añadir el valor nominal al final

return self.flujos

Procedemos a la utilización de la clase con ejemplos reales.

Utilización

Utilizaremos los siguientes tres Bonos para crear nuestros objetos:

Press enter or click to view image in full size
Imagen 6. Ejemplos obtenidos de Valmer

Los datos mostrados nos permiten crear los objetos:

BI_CETES_240321 = CuponCero(10, 0, 0.1115, 0,0, 16, 360)
M_BONOS_270304 = CuponFijo(100, 0.05,0.1007, 0, 182, 366, 360)
IQ_BPAG91_250102 = CuponVariable(100, 0.1138, 0.11355-0.00085,0.00085,91,303,360)

Una vez creados, estos al heredar los métodos, podemos utilizar el nombre del objeto y usar los métodos que se requiera:

medidas_cete = BI_CETES_240321.obtener_medidas()
calendario_cete = BI_CETES_240321.obtener_calendario_pagos()

medidas_bonom = M_BONOS_270304.obtener_medidas()
calendario_bonom = M_BONOS_270304.obtener_calendario_pagos()

medidas_bpag = IQ_BPAG91_250102.obtener_medidas()
calendario_bpag = IQ_BPAG91_250102.obtener_calendario_pagos()

Desplegamos los resultados:

print("BI_CETES_240321")
display(calendario_cete)
display(medidas_cete)

print("M_BONOS_270304")
display(calendario_bonom)
display(medidas_bonom)

print("IQ_BPAG91_250102")
display(calendario_bpag)
display(medidas_bpag)

Y nuestro resultado lo mostrará para cada uno de ellos con sus respectivas medidas y calendario de flujos:

Press enter or click to view image in full size
Animación 6. Comparativo de resultados

Encontrarás el código en la siguiente liga de Colab: https://colab.research.google.com/drive/1bHrLehihGDvQRBSqbbiTEUpKY9u0mMoE?usp=sharing

La creación de clases, nos permite automatizar nuestro análisis y agrupar los tipos de instrumentos de acuerdo a sus características y su medición específica. Las siguientes publicaciones nos enfocaremos en crear clases como: Clase Acción, Clase Derivado, Clase Portafolio, entre otras.

La razón de utilizar Python en la modelación financiera se justifica con la creación de clases.

Próximas Publicaciones

Las publicaciones programadas posteriores a esta son:

  1. Modelación de Acciones: Mediciones principales de las acciones
  2. La clase “Acción”

--

--

Modelación Financiera Python
Modelación Financiera Python

Written by Modelación Financiera Python

Proyecto dedicado a la creación de contenido educativo relacionado a Finanzas y Programación en Python en Español