Impactos de Juros sobre Reservas: Uma Perspectiva Baseada na Teoria de Kessler e Python

A gestão financeira de recursos onerosos de terceiros, notadamente a relação entre reservas de lucros, despesas de juros e empréstimos é crucial para a saúde financeira de uma empresa.

O acompanhamento de perto desses recursos é fundamental para reduzir a dependência e, consequentemente, as despesas com juros.

Envolve também uma gestão eficiente das reservas de lucros como elemento vital para o financiamento de investimentos, para o fortalecimento dos negócios, crescimento e geração de lucros, mas sem a necessidade descontrolada de empréstimos onerosos.

Este artigo, tem como propósito apresentar um script em Python que permita simular e visualizar a relação entre despesas financeiras acumuladas e reservas de lucros restantes ao longo de um período previsto, através da analogia da síndrome de Kessler no impacto financeiro da empresa.

A Teoria de Kessler e as Despesas Financeiras

A Teoria de Kessler ou Síndrome de Kessler foi proposta pelo cientista Donald J. Kessler em 1978 no contexto da astronomia e engenharia espacial, especialmente no campo do lixo de detritos espaciais na orbita terrestre, que dado o acúmulo de objetos resultaria em colisões e destruição de satélites.

Assim como esse conceito está aplicado ao espacial sideral onde eventos isolados podem desencadear uma reação em cadeia elevando o risco de colapso do sistema, também podemos visualizá-lo e compará-lo no contexto da saúde financeira das empresas onde o acúmulo de dívidas ou despesas com juros decorrente do capital oneroso de terceiros, contraídos sem controle, podem levar ao caos e/ou a falência da organização.

Contextualizando o Script no Fenômeno de Kessler

O script desenvolvido tem como objetivo servir como uma ferramenta analítica para identificar o exato ponto de colisão financeira que ocorrerá entre as despesas financeiras acumuladas e as reservas de lucros que restaram, ano após ano, após a dedução daquelas pelo uso indiscriminado de empréstimos onerosos junto a terceiros.

Ou seja, a simulação permitirá visualizar o momento em que as despesas acumuladas com juros se tornam tão significativas que colidem diretamente com as reservas disponíveis e, por conseguinte, diminuindo o capital da empresa a níveis perigosos.

A colisão é demonstrada no ponto de intersecção entre as curvas das linhas representativas das reservas de lucros restantes e as despesas financeiras acumuladas. Isto é, essa intersecção é o ponto crítico que marca o início de uma possível reação destruidora da capacidade financeira da empresa de honrar seus compromissos

Analogia da Gestão Financeira com o Fenômeno de Kessler

A analogia principal entre o fenômeno Kessler e o equilíbrio entre as reservas de lucros e as despesas financeiras se dá pela correlação da seguinte forma:

a) Na teoria de Kessler o espaço orbital é o ambiente onde se situam os satélites e outros objetos espaciais. Na gestão dos recursos, as reservas de lucros são equivalentes a esse espaço.

b) As despesas e juros, por sua vez, são os satélites e outros “detritos” ocupando o espaço das reservas financeiras. Assim, como prevê aquela teoria em que o volume crescente e elevado desses detritos provocará, em algum momento, uma colisão entre eles, o mesmo poderá ocorrer com as despesas financeiras, colidindo umas com as outras, no “espaço” das reservas restantes acumuladas.

c) O momento de colisão dos detritos é, por sua vez, o “momento” em que no gráfico ocorre a intersecção das despesas com as reservas. É o ponto crítico inicial que sinaliza um provável risco de insolvência da empresa.

O ponto de interseção é o principal indicador inspirado no script utilizado para medir o impacto dessa relação entre as despesas e as reservas ao longo do período previsto.

Fonte - O Autor

O Modelo Matemático por Trás do Ponto de Colisão

O papel da simulação proposta no script é calcular e exibir de forma gráfica como as despesas financeiras crescem ao longo do tempo e impactam as reservas de lucros.

A tomada indiscriminada de empréstimos junto a terceiros sem controle do volume do que já se tem contratado, com o script, poderá ser visualizado, fornecendo insights valiosos para prevenir essa situação.

A matemática do ponto de colisão (a intersecção das duas curvas) se dará pelo ajuste das despesas, calculadas como a soma total das despesas ao longo do período dividido por dois (representando os dois principais componentes de custos: juros de empréstimos existentes e novos empréstimos). As reservas de lucros , por sua vez, serão obtidas subtraindo as despesas ajustadas do valor inicial das reservas.

A interseção das linhas azul e vermelha no gráfico simboliza a colisão financeira, permitindo uma análise visual clara de como e quando essa situação ocorre.

O Script em Python

A seguir o script desenvolvido e comentado.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter


# Função para formatar entrada do usuário
def parse_float(value):
  try:
      return float(value)  # Tenta converter a entrada em um número de ponto flutuante
  except ValueError:
      print("Entrada inválida! Por favor, insira um valor numérico.")  # Caso a entrada não seja numérica
      exit()


# Função para formatar valores como moeda brasileira
def format_currency(value):
  return f"R$ {value:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")


# Função para simular as despesas acumuladas e reservas ao longo dos anos
def simulate_expenses_vs_reserves(initial_reserves, total_expense, years_to_predict):
  reserves = [initial_reserves]  # Lista para armazenar reservas ao longo dos anos
  expenses = []  # Lista para armazenar despesas acumuladas


  for year in range(years_to_predict + 1):
      if year == 0:
          expenses.append(0)  # No início, despesas acumuladas são zero
      else:
          expenses.append(total_expense * year)  # Calcula despesas acumuladas
      remaining_reserves = max(reserves[-1] - total_expense, 0)  # Reduz as reservas pelas despesas
      reserves.append(remaining_reserves)  # Adiciona o saldo de reservas


  return pd.DataFrame({
      "Year": list(range(years_to_predict + 1)),  # Lista de anos (0 até anos previstos)
      "Remaining Reserves": reserves[:years_to_predict + 1],  # Reservas para cada ano
      "Cumulative Expenses": expenses  # Despesas acumuladas
  })


# Função para calcular o ponto de interseção baseado nas fórmulas fornecidas
def calculate_intersection_point(df, initial_reserves, years_to_predict):
  cumulative_expenses_total = df.loc[years_to_predict, "Cumulative Expenses"]  # Soma das despesas no último ano
  intersection_expenses = cumulative_expenses_total / 2  # Divide o total de despesas por 2
  intersection_reserves = initial_reserves - intersection_expenses  # Calcula as reservas ajustadas
  return intersection_reserves, intersection_expenses  # Retorna os valores ajustados


# Função para gerar o gráfico de Reservas vs Despesas
def generate_expenses_vs_reserves_graph(df, initial_reserves, years_to_predict):
  fig, ax1 = plt.subplots()


  years = df["Year"]  # Eixo X com os anos
  reserves = df["Remaining Reserves"]  # Eixo Y1 com reservas
  expenses = df["Cumulative Expenses"]  # Eixo Y2 com despesas acumuladas


  # Configurar o eixo das Reservas (azul)
  ax1.yaxis.set_major_formatter(FuncFormatter(lambda x, _: format_currency(x)))  # Formata os valores como moeda
  ax1.plot(years, reserves, 'b-o', label="Reservas Restantes (R$)")  # Plota as reservas
  ax1.set_xlabel("Ano")  # Rótulo do eixo X
  ax1.set_ylabel("Reservas Restantes (R$)", color="blue")  # Rótulo do eixo Y
  ax1.tick_params(axis='y', labelcolor="blue")  # Define cor dos rótulos para azul
  ax1.set_xticks(years)  # Define os valores do eixo X


  # Configurar o eixo das Despesas (vermelho)
  ax2 = ax1.twinx()  # Segundo eixo Y
  ax2.yaxis.set_major_formatter(FuncFormatter(lambda x, _: format_currency(x)))  # Formata como moeda
  ax2.plot(years, expenses, 'r--x', label="Despesas Acumuladas (R$)")  # Plota as despesas acumuladas
  ax2.set_ylabel("Despesas Acumuladas (R$)", color="red")  # Rótulo do eixo Y
  ax2.tick_params(axis='y', labelcolor="red")  # Define cor dos rótulos para vermelho


  # Calcular o ponto de interseção
  intersection_reserves, intersection_expenses = calculate_intersection_point(df, initial_reserves, years_to_predict)


  # Exibir os valores calculados no terminal
  print(f"\nValores calculados para o ponto de interseção:")
  print(f"Reservas Ajustadas: {format_currency(intersection_reserves)}")
  print(f"Despesas Ajustadas: {format_currency(intersection_expenses)}\n")


  # Adicionar anotação no gráfico próximo à intersecção
  ax1.annotate(
      f"Reservas: {format_currency(intersection_reserves)}\nDespesas: {format_currency(intersection_expenses)}",
      xy=(years_to_predict / 2, intersection_reserves),  # Coordenadas do ponto de interseção
      xytext=(years_to_predict / 2 + 0.5, intersection_reserves - (intersection_reserves * 0.05)),  # Ajuste para o texto
      arrowprops=dict(facecolor='black', arrowstyle="->", lw=0.5),  # Configuração da seta
      fontsize=8,  # Tamanho da fonte
      color="black",
      alpha=0.8  # Transparência para melhor visualização
  )


  plt.title("Simulação de Reservas Lucros vs Despesas Financeiras")  # Título do gráfico
  plt.tight_layout()  # Ajuste do layout para evitar sobreposição
  plt.show()  # Exibir o gráfico


# Função principal que inicia o script
def main():
  print("Simulação de Reservas vs Despesas\n")


  # Entrada de dados pelo usuário
  initial_reserves = parse_float(input("Digite o valor das Reservas Iniciais (em R$): "))
  existing_loans = parse_float(input("Digite o saldo devedor de empréstimos existentes (em R$): "))
  existing_rate = parse_float(input("Digite a taxa de juros existente (% ao ano): "))
  new_loan = parse_float(input("Digite o valor do novo empréstimo (em R$): "))
  new_rate = parse_float(input("Digite a taxa de juros do novo empréstimo (% ao ano): "))
  years_to_predict = int(input("Digite o número de anos para previsão: "))


  # Cálculo do total de despesas financeiras
  total_expense = (existing_loans * existing_rate / 100) + (new_loan * new_rate / 100)


  # Simular os valores de despesas e reservas
  df = simulate_expenses_vs_reserves(initial_reserves, total_expense, years_to_predict)


  # Formatar os valores para exibição
  df["Remaining Reserves Formatted"] = df["Remaining Reserves"].apply(format_currency)
  df["Cumulative Expenses Formatted"] = df["Cumulative Expenses"].apply(format_currency)


  # Exibir a tabela formatada no terminal
  print(df[["Year", "Remaining Reserves Formatted", "Cumulative Expenses Formatted"]])


  # Gerar o gráfico
  generate_expenses_vs_reserves_graph(df, initial_reserves, years_to_predict)


# Executar o script
if __name__ == "__main__":
  main()

Entendendo o Funcionamento do Script

O script desenvolvido inicia solicitando informações fundamentais ao usuário, como o valor inicial das reservas, empréstimos existentes e novos, taxas de juros, e o horizonte de previsão em anos.

Essas entradas alimentam as funções matemáticas que calculam, ano a ano, as despesas acumuladas e o saldo das reservas. 

O cálculo das despesas totais é baseado na soma dos encargos gerados pelos empréstimos existentes e novos, multiplicados pelas suas respectivas taxas de juros. A cada iteração no horizonte temporal, o script subtrai essas despesas das reservas iniciais, enquanto acumula o valor das despesas ao longo do tempo, simulando assim o comportamento financeiro em cenários distintos.

Um ponto-chave do script é a identificação do "ponto de colisão", que ocorre quando as despesas acumuladas se tornam iguais ou superiores às reservas restantes. Para isso, o script utiliza fórmulas específicas: calcula o total das despesas acumuladas no último ano da previsão, divide-o por dois para representar as fontes de despesas (empréstimos existentes e novos), e ajusta as reservas subtraindo esse valor. Esse ponto é representado graficamente como a intersecção das curvas de despesas e reservas.

A visualização é feita por meio de um gráfico bidimensional, onde a linha azul representa as reservas e a linha vermelha, as despesas acumuladas. O ponto de intersecção é destacado com uma anotação que exibe os valores calculados, proporcionando uma análise clara e visual da situação financeira simulada. A formatação dos eixos segue o padrão de moeda brasileira, garantindo uma leitura adequada ao contexto. 

Por fim, o script permite uma compreensão prática da relação entre despesas financeiras e reservas, demonstrando como decisões relacionadas a empréstimos podem impactar diretamente a saúde financeira de uma empresa, auxiliando na tomada de decisões estratégicas.

Fonte - O Autor

Fonte - O Autor

Conclusão

O artigo teve como objetivo apresentar um script em Python modelado matematicamente para simular e visualizar a relação entre as reservas acumuladas e despesas financeiras ao longo de um período informado pelo usuário, resultando num gráfico onde o ponto de intersecção entre as duas curvas é exibido.

Após sua execução e entrada de dados, verificou-se que o script atendeu ao seu propósito, exibindo a intersecção entre as duas linhas, representando o ponto de colisão entre as mesmas e o início de uma provável situação catastrófica à frente.

O script é composto de várias funções, cada uma desempenhando uma tarefa específica, iniciando com a lógica do cálculo do valor total das despesas acumuladas no último ano, dividido por dois, que são os empréstimos existentes e novos empréstimos, com a subtração desse valor das reservas iniciais para se obter as reservas ajustadas e o ponto de intersecção.

Um script de programação, seja em Python ou outra linguagem, quando bem idealizado, torna-se uma ferramenta crucial para a gestão financeira eficiente das reservas de lucros em relação às despesas financeiras. Ele oferece ao administrador uma visão clara e a capacidade de simular cenários complexos, permitindo tomadas de decisão mais assertivas.

Tradicionalmente, a gestão financeira dependia de planilhas e cálculos manuais, processos propensos a erros e limitados em sua capacidade de simulação. Um script, por outro lado, automatiza cálculos, processa grandes volumes de dados rapidamente e permite a criação de modelos preditivos.

www.linkedin.com/in/izairton-oliveira-de-vasconcelos-a1916351

https://github.com/IOVASCON