Cálculo Aproximado de la Tasa Interna de Retorno (TIR)

CBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderemos a aproximar la Tasa Interna de Retorno (TIR) utilizando un programa en C. Empezaremos leyendo los flujos de efectivo, que representan el dinero invertido o recibido en diferentes periodos de tiempo de una inversión. Luego, utilizaremos un enfoque iterativo para encontrar la tasa donde el Valor Actual Neto (VAN) es aproximadamente cero, lo que nos da la TIR estimada. Finalmente, imprimiremos la TIR calculada. El laboratorio cubre conceptos clave de matemáticas financieras y demuestra su implementación en programación C.

Lectura de Flujos de Efectivo

En este paso, aprenderemos a leer y almacenar flujos de efectivo para calcular la Tasa Interna de Retorno (TIR) en un programa en C. Los flujos de efectivo representan el dinero invertido o recibido en diferentes periodos de tiempo de una inversión.

Primero, creemos un archivo C para implementar la funcionalidad de lectura de flujos de efectivo:

cd ~/project
nano irr_calculation.c

Ahora, escribamos el código inicial para leer los flujos de efectivo:

#include <stdio.h>
#define MAX_FLUJOS_EFECTIVO 10

int main() {
    double flujos_efectivo[MAX_FLUJOS_EFECTIVO];
    int num_flujos_efectivo;

    printf("Ingrese el número de flujos de efectivo (máximo %d): ", MAX_FLUJOS_EFECTIVO);
    scanf("%d", &num_flujos_efectivo);

    printf("Ingrese los flujos de efectivo (negativo para inversiones, positivo para retornos):\n");
    for (int i = 0; i < num_flujos_efectivo; i++) {
        printf("Flujo de efectivo %d: ", i);
        scanf("%lf", &flujos_efectivo[i]);
    }

    // Imprimir los flujos de efectivo ingresados para verificación
    printf("\nFlujos de efectivo Ingresados:\n");
    for (int i = 0; i < num_flujos_efectivo; i++) {
        printf("Flujo de efectivo %d: %.2f\n", i, flujos_efectivo[i]);
    }

    return 0;
}

Compilar y ejecutar el programa:

gcc irr_calculation.c -o irr_calculation
./irr_calculation

Ejemplo de salida:

Ingrese el número de flujos de efectivo (máximo 10): 4
Ingrese los flujos de efectivo (negativo para inversiones, positivo para retornos):
Flujo de efectivo 0: -1000
Flujo de efectivo 1: 300
Flujo de efectivo 2: 400
Flujo de efectivo 3: 500

Flujos de efectivo Ingresados:
Flujo de efectivo 0: -1000.00
Flujo de efectivo 1: 300.00
Flujo de efectivo 2: 400.00
Flujo de efectivo 3: 500.00
Explicación
  • Definimos un número máximo de flujos de efectivo (MAX_FLUJOS_EFECTIVO) para evitar un uso excesivo de memoria.
  • El programa primero solicita al usuario que ingrese el número de flujos de efectivo.
  • Luego, solicita al usuario que ingrese cada valor de flujo de efectivo.
  • Los valores negativos representan inversiones iniciales.
  • Los valores positivos representan retornos o ingresos.
  • El programa imprime los flujos de efectivo ingresados para verificación.

Usar Iteración para Encontrar la Tasa Donde VAN≈0

En este paso, extenderemos nuestro programa anterior de flujos de efectivo para calcular la Tasa Interna de Retorno (TIR) utilizando un método numérico iterativo.

Primero, modifiquemos nuestro archivo C existente:

cd ~/project
nano irr_calculation.c

Ahora, implementemos la lógica de cálculo de VAN y TIR:

#include <stdio.h>
#include <math.h>
#define MAX_FLUJOS_EFECTIVO 10
#define EPSILON 0.0001

double calculate_npv(double cash_flows[], int num_cash_flows, double rate) {
    double npv = 0.0;
    for (int i = 0; i < num_cash_flows; i++) {
        npv += cash_flows[i] / pow(1 + rate, i);
    }
    return npv;
}

double find_irr(double cash_flows[], int num_cash_flows) {
    double rate_low = -0.9;
    double rate_high = 10.0;
    double rate = 0.1;

    while ((rate_high - rate_low) > EPSILON) {
        double npv = calculate_npv(cash_flows, num_cash_flows, rate);

        if (fabs(npv) < EPSILON) {
            return rate;
        }

        if (npv > 0) {
            rate_low = rate;
        } else {
            rate_high = rate;
        }

        rate = (rate_low + rate_high) / 2.0;
    }

    return rate;
}

int main() {
    double cash_flows[MAX_FLUJOS_EFECTIVO];
    int num_cash_flows;

    printf("Ingrese el número de flujos de efectivo (máximo %d): ", MAX_FLUJOS_EFECTIVO);
    scanf("%d", &num_cash_flows);

    printf("Ingrese los flujos de efectivo (negativo para inversiones, positivo para retornos):\n");
    for (int i = 0; i < num_cash_flows; i++) {
        printf("Flujo de efectivo %d: ", i);
        scanf("%lf", &cash_flows[i]);
    }

    double tir = find_irr(cash_flows, num_cash_flows);
    printf("\nTasa Interna de Retorno (TIR) aproximada: %.4f o %.2f%%\n", tir, tir * 100);

    return 0;
}

Compilar el programa con la biblioteca matemática:

gcc irr_calculation.c -o irr_calculation -lm

Ejecutar el programa con flujos de efectivo de muestra:

./irr_calculation

Ejemplo de salida:

Ingrese el número de flujos de efectivo (máximo 10): 4
Ingrese los flujos de efectivo (negativo para inversiones, positivo para retornos):
Flujo de efectivo 0: -1000
Flujo de efectivo 1: 300
Flujo de efectivo 2: 400
Flujo de efectivo 3: 500

Tasa Interna de Retorno (TIR) aproximada: 0.2154 o 21.54%
Explicación
  • calculate_npv() calcula el Valor Actual Neto (VAN) para una tasa de interés dada.
  • find_irr() utiliza el método de bisección para encontrar la tasa donde VAN ≈ 0.
  • Usamos EPSILON para definir la precisión de convergencia.
  • El algoritmo reduce iterativamente el rango de TIR.
  • La TIR final se calcula y muestra como decimal y porcentaje.

Imprimir TIR Estimada

En este paso final, mejoraremos nuestro programa de cálculo de TIR para proporcionar una salida más detallada y demostrar diferentes escenarios de inversión.

Modifiquemos nuestro archivo C existente para agregar un análisis de TIR más completo:

cd ~/project
nano irr_calculation.c

Actualicemos el código con una salida y análisis adicionales:

#include <stdio.h>
#include <math.h>
#define MAX_FLUJOS_EFECTIVO 10
#define EPSILON 0.0001

double calculate_npv(double cash_flows[], int num_cash_flows, double rate) {
    double npv = 0.0;
    for (int i = 0; i < num_cash_flows; i++) {
        npv += cash_flows[i] / pow(1 + rate, i);
    }
    return npv;
}

double find_irr(double cash_flows[], int num_cash_flows) {
    double rate_low = -0.9;
    double rate_high = 10.0;
    double rate = 0.1;

    while ((rate_high - rate_low) > EPSILON) {
        double npv = calculate_npv(cash_flows, num_cash_flows, rate);

        if (fabs(npv) < EPSILON) {
            return rate;
        }

        if (npv > 0) {
            rate_low = rate;
        } else {
            rate_high = rate;
        }

        rate = (rate_low + rate_high) / 2.0;
    }

    return rate;
}

void print_investment_analysis(double cash_flows[], int num_cash_flows, double irr) {
    double total_investment = 0;
    double total_returns = 0;

    printf("\n--- Análisis de Inversión ---\n");

    // Desglose detallado de los flujos de efectivo
    for (int i = 0; i < num_cash_flows; i++) {
        printf("Periodo %d: $%.2f\n", i, cash_flows[i]);

        if (cash_flows[i] < 0) {
            total_investment += fabs(cash_flows[i]);
        } else {
            total_returns += cash_flows[i];
        }
    }

    // Resumen de la inversión
    printf("\nInversión Total: $%.2f\n", total_investment);
    printf("Retornos Totales: $%.2f\n", total_returns);
    printf("Beneficio Neto: $%.2f\n", total_returns - total_investment);

    // Detalles de la TIR
    printf("\nTasa Interna de Retorno (TIR):\n");
    printf("Decimal: %.4f\n", irr);
    printf("Porcentaje: %.2f%%\n", irr * 100);

    // Interpretación del rendimiento de la inversión
    if (irr > 0.15) {
        printf("\nRendimiento de la Inversión: Excelente\n");
    } else if (irr > 0.10) {
        printf("\nRendimiento de la Inversión: Bueno\n");
    } else if (irr > 0) {
        printf("\nRendimiento de la Inversión: Moderado\n");
    } else {
        printf("\nRendimiento de la Inversión: Deficiente\n");
    }
}

int main() {
    double cash_flows[MAX_FLUJOS_EFECTIVO];
    int num_cash_flows;

    printf("Ingrese el número de flujos de efectivo (máximo %d): ", MAX_FLUJOS_EFECTIVO);
    scanf("%d", &num_cash_flows);

    printf("Ingrese los flujos de efectivo (negativo para inversiones, positivo para retornos):\n");
    for (int i = 0; i < num_cash_flows; i++) {
        printf("Flujo de efectivo %d: ", i);
        scanf("%lf", &cash_flows[i]);
    }

    double tir = find_irr(cash_flows, num_cash_flows);
    print_investment_analysis(cash_flows, num_cash_flows, tir);

    return 0;
}

Compilar el programa:

gcc irr_calculation.c -o irr_calculation -lm

Ejecutar el programa con un escenario de inversión de muestra:

./irr_calculation

Ejemplo de salida:

... (Salida similar al ejemplo original)
Explicación
  • Se agregó la función print_investment_analysis() para proporcionar una salida completa.
  • Calcula la inversión total, los retornos y el beneficio neto.
  • Interpreta el rendimiento de la TIR con categorías descriptivas.
  • Proporciona un desglose detallado de los flujos de efectivo y las métricas de inversión.

Resumen

En este laboratorio, aprendimos primero cómo leer y almacenar flujos de efectivo para calcular la Tasa Interna de Retorno (TIR) en un programa en C. Los flujos de efectivo representan el dinero invertido o recibido en diferentes períodos de tiempo de una inversión. Luego, exploramos el uso de la iteración para encontrar la tasa donde el Valor Actual Neto (VAN) es aproximadamente cero, que es la TIR. Finalmente, aprendimos cómo imprimir la TIR estimada. Los puntos clave del aprendizaje son comprender las estructuras de datos de flujo de efectivo, implementar algoritmos iterativos para encontrar la TIR y presentar el resultado final.