Jonas Liebl

jonasliebl@outlook.com
(41) 99974-0533

O que é o Software R
O R é um software livre para computação estatística e gráficos. Além de ser amplamente utilizado para cálculos estatísticos no meio acadêmico, vem ganhando
notoriedade em mineração de dados, tornando-se uma das ferramentas mais usadas por profissionais conhecidos como “cientistas de dados”. A principal
página na Internet através da qual se pode baixar o software e iniciar o seu aprendizado é a https://www.r-project.org.

O software R se destaca como uma ferramenta estatística e esse estigma já é suficiente para desestimular o seu uso por profissionais de outras áreas. Ocorre
que os seus comandos e a elevada capacidade de processamento podem facilitar a execução de atividades completamente distintas do segmento estatístico,
sendo úteis inclusive para uso no ambiente doméstico de uma família. Uma das possibilidades que se mostraram excelentes é no campo da matemática
financeira, em especial com sistemas de amortização e planos de capitalização. Além de realizar os cálculos, pode-se emitir planilhas de evolução, também
conhecidas como “extratos”, e gravar arquivos muito úteis para inserção como anexos em contratos, por exemplo. Isso tudo é possível combinando-se funções
e sintaxes de forma personalizada e gravando scripts para serem executados pelo R sempre que for necessário.
O que é um sistema de amortização
Sistema de amortização é um método de cálculo que tem por objetivo pagar uma dívida ou financiamento no prazo contratado, remunerando-o à taxa pactuada.
O mais conhecido é o “Sistema Francês de Amortização”, também chamado de “Tabela Price”. É esse sistema que se encontra residente na famosa calculadora
financeira HP 12C. A sua principal característica é que apresenta prestações (ou parcelas) iguais. Alguns conceitos importantes:

PV (present value): valor presente, que corresponde ao valor da dívida ou do financiamento que deverá ser quitado no prazo contratado.

PMT (payment): pagamento, que é o valor da prestação a ser paga em cada período para amortizar a dívida ou financiamento e remunerá-lo pelos juros
pactuados.

i (interest): taxa percentual de juros destinada a remunerar a dívida ou financiamento. Deve ser expressa na mesma periodicidade das prestações, ou seja,
se forem exigidas prestações mensais, a taxa percentual de juros também deverá ser equivalente a mês.

n (número de períodos): quantidade de prestações para amortizar a dívida ou financiamento.

modo antecipado: ocorre quando a primeira prestação é paga no momento em que a dívida é contraída. É muito comum no comércio, quando se adquire
determinado bem e a primeira prestação é dada como entrada no ato da compra.

modo postecipado: a prestação é paga no final do primeiro período, ou seja, se o prazo do financiamento for mensal, esse pagamento acontece um mês
após a contratação e os demais, sequencialmente, a cada mês.

modo diferido: o início do pagamento das prestações ocorre após um período de carência. Por exemplo, uma compra no comércio realizada em novembro
com primeira prestação a ser paga somente após o carnaval.

Usando o R para cálculos relativos ao Sistema Francês de Amortização

Foram desenvolvidas algumas funcionalidades, consideradas as mais importantes, e gravadas num script denominado CALCULADORA FINANCEIRA.R.
Sempre que precisar fazer algum cálculo desse tipo, basta abrir o R e executar Arquivo / Interpretar código fonte R, localizando o script já salvo no
computador. O console do R apresentará as orientações básicas, as quais poderão ser recuperadas a qualquer momento através da função help(), ou, mais
especificamente quanto ao “Sistema Francês de Amortização”, a help.sfa().

Carga do script
source("http://www.angelfire.com/un/cde/CALCULADORA_FINANCEIRA.R")
Calculando uma prestação
Determinada pessoa pretende obter um empréstimo de R$ 5.000,00 a ser quitado em 6 prestações mensais de igual valor, a primeira ocorrendo um mês após
a contratação. Considerando que a taxa de juros é de 2% ao mês, vamos calcular o valor da prestação. Trata-se de um exemplo típico de cálculo pelo “Sistema
Francês de Amortização” no modo postecipado. Conforme orientações fornecidas pelo script, deve-se comandar sfa() informando, entre os parênteses e entre
vírgulas, o valor presente (valor do empréstimo), a taxa percentual mensal de juros, a quantidade de prestações mensais e o parâmetro de modo que, no caso
do postecipado, é 0 (zero).

Note que o script do R não apenas calcula o valor da prestação, como também demonstra a evolução da dívida mês a mês. O saldo final negativo de R$ 0.01
ocorreu porque os cálculos foram arredondados para duas casas decimais. Sem esse arredondamento, o saldo seria zerado. Deve-se observar que o R adota
o ponto como separador de decimais, que é a convenção utilizada em países de cultura inglesa.

Outro benefício desse script é que o R gravou um arquivo denominado “EXTRATO.CSV” na mesma pasta que está definida para realizar os processamentos.
Esse arquivo poderá ser aberto e formatado para inserção como anexo em contratos, para demonstrar a evolução da dívida.

Calculando uma taxa de juros

Trata-se de um cálculo muito útil como subsídio para uma decisão. Por exemplo, uma pessoa pretende comprar uma geladeira de R$ 1.500,00 e a loja oferece
duas opções de pagamento. A primeira é dividindo o valor em 3 parcelas mensais “sem juros”, com a primeira sendo paga no ato da compra. A segunda é o
pagamento total à vista com um desconto de 10%. Como o comprador possui esse valor num investimento remunerado a 5% ao mês, deseja saber se vale a
pena abrir mão do investimento para obter o desconto.

Intuitivamente, algumas pessoas dividem o 10% do desconto pelo número de parcelas e imaginam que a taxa mensal de juros embutida na operação é de
3,33%. Esse cálculo é equivocado porque não considera a antecipação do primeiro pagamento, nem a amortização mensal das parcelas subsequentes. No
cálculo financeiro, devemos informar como valor presente aquele que seria pago na opção à vista: R$ 1.500,00 menos 10% de desconto, que é igual a R$
1.350,00. As prestações são aquelas da opção a prazo, ou seja, R$ 1.500,00 dividido por 3, que corresponde a R$ 500,00. Finalmente, como o modo é
antecipado, o parâmetro a ser utilizado é de -1 (menos um). Essas informações serão comandadas em isfa().

No presente caso, perder o desconto que seria obtido na compra à vista para pagar a geladeira em 3 vezes “sem juros” representa uma taxa interna de juros
na ordem de 11,5544% ao mês. Como a remuneração mensal do investimento é de 5%, ou seja, inferior a essa taxa interna de juros, a melhor opção é a de
resgatar os R$ 1.350,00 do investimento e adquirir a geladeira à vista.

Não existe uma fórmula para calcular a taxa de juros de maneira direta. O seu cálculo é obtido por um processo iterativo. Note que o R informou que realizou
1002 cálculos para chegar ao resultado com quatro casas decimais, mas nós nem notamos isso porque ocorreu em fração de segundo. Se necessitarmos de
mais casas decimais, precisaremos editar o script para aumentar o processo iterativo, mas isso só vale a pena quando os valores envolvidos são muito grandes.
Calculando o valor presente
É usual os bancos estipularem um limite de crédito pela capacidade de pagamento em função da renda mensal do tomador. Supondo que essa capacidade
está delimitada a 30% da renda de R$ 5.000,00 de uma pessoa, a prestação total mensal não pode passar de R$ 1.500,00. Considerando ainda a existência
de encargos acessórios no valor de R$ 100,00 a título de seguro e taxa de administração, a prestação mensal, destinada a amortização e juros, fica limitada a
R$ 1.400,00. Vamos calcular qual seria o valor do empréstimo nessas condições, a ser resgatado em 6 prestações mensais iguais com 3 meses de carência,
sendo a taxa de juros de 2,5% ao mês. As informações serão comandadas em psfa().

O valor do empréstimo possível considerando a capacidade de pagamento e as regras do negócio é de R$ 7.160,78. Como se trata de um empréstimo com
carência, durante os três primeiros meses só há incorporação de juros. O pagamento das prestações começa no quarto mês e a sua quitação ocorre no nono.
O que é um plano de capitalização
Plano de capitalização é um método de cálculo que tem por objetivo formar um capital ou obter um montante, a partir de depósitos periódicos consecutivos
remunerados a uma determinada taxa. O melhor exemplo de capitalização é um plano de previdência em que, durante muitos anos, é feito um depósito mensal
de determinado valor com o objetivo de, a partir de determinada data, receber um benefício a título de aposentadoria.

Usando o R para cálculos relativos a planos de capitalização

Também foram desenvolvidas algumas funcionalidades, tidas como as mais importantes, e gravadas nesse script denominado CALCULADORA
FINANCEIRA.R. O console do R apresentará as orientações básicas, as quais poderão ser recuperadas a qualquer momento através da função help(), ou,
mais especificamente quanto a capitalizações e montantes, a help.cap().

Calculando o valor do depósito mensal

Vamos supor que uma pessoa deseja comprar um notebook de R$ 3.000,00 daqui a 6 meses e que, para isso, pretende economizar uma parcela fixa do seu
salário depositando-a mensalmente numa aplicação que rende 2% ao mês. Faremos uso do comando cap(), informando, entre os parênteses e entre vírgulas,
o valor do montante desejado, a taxa percentual mensal de juros e a quantidade de depósitos mensais.

O valor a ser economizado e depositado mensalmente é de R$ 475,58. Ao realizar o sexto depósito e computando os juros calculados sobre as parcelas
precedentes, o valor de R$ 3.000,00 estará disponível para adquirir o pretendido notebook.
Calculando a quantidade de depósitos mensais
Imaginando que essa mesma pessoa tenha condições de economizar um pouco mais, elevando o depósito mensal para R$ 700,00, vamos calcular em quantos
meses terá o montante disponível para a compra desejada. O comando a ser utilizado é o ncap().

Cabe esclarecer que o desenvolvimento do script não prevê períodos fracionários. No exemplo em pauta, são depósitos mensais de igual valor efetuados
sempre a cada mês. Percebemos que, no quarto mês, o valor está bem próximo do montante desejado. Com o quinto depósito, o montante já é mais do que
suficiente para adquirir o notebook. Se o comprador deseja juntar exatamente os R$ 3.000,00, poderá ampliar o quarto depósito para o valor de R$ 814,87
(3.000,00 – 2.885,13 + 700,00) ou reduzir o quinto para R$ 57,17 (700,00 – 642,83). Assim, o montante exato será atingido com a parcela 4 ou 5,
respectivamente.

Calculando o montante
Essa funcionalidade tem o objetivo de calcular o montante obtido com os depósitos periódicos de igual valor e inclui a possibilidade de interromper a fase de
depósitos, continuando apenas com a remuneração de juros sobre os saldos precedentes.

Aproveitando o exemplo anterior de depósitos de R$ 700,00, vamos interromper a sequência após a quarta parcela e deixar o saldo sendo remunerado por
mais 6 meses. O comando é o mont(), cujas orientações constam no help.cap().
O montante parcial obtido no momento do quarto depósito continuou sendo remunerado a 2% ao mês por mais 6 meses, elevando o valor de R$ 2.885,13 para
R$ 3.249,12. Percebe-se também que o valor necessário para a compra do notebook seria atingido dois meses após a interrupção dos depósitos.

Considerações finais
O script CALCULADORA FINANCEIRA.R poderá ser baixado e usado tanto para os cálculos a que se propõe, quanto para conhecimento das sintaxes
utilizadas para produzir esses resultados. Evidentemente, trata-se apenas de uma pequena incursão no mundo da matemática financeira para demonstrar que
o R não está restrito à Estatística. As potencialidades do software podem nos ajudar em outras atividades profissionais ou acadêmicas. Como diria Goethe:
“ouse fazer e o poder lhe será dado”.

O script CALCULADORA FINANCEIRA.R

O script para efetuar os cálculos mencionados neste capítulo pode ser obtido através do link:
http://www.angelfire.com/un/cde/CALCULADORA_FINANCEIRA.R

A inserção no R se dá através do comando Arquivo / Novo script, o qual abre uma janela de edição possibilitando colar o conteúdo previamente copiado da
página do link. Na sequência, comanda-se Arquivo / Salvar como, selecionando-se a pasta onde se deseja salvá-lo e atribuindo-se o nome de
CALCULADORA FINANCEIRA. A extensão R será assumida automaticamente. O comando Arquivo / Fechar script retorna ao console.
A execução do script se dá através do comando Arquivo / Interpretar código fonte R, selecionando-se a CALCULADORA FINANCEIRA.R. O console
mostrará as orientações contidas nas ajudas, as quais poderão ser resgatadas a qualquer tempo por help(), help.sfa() e help.cap().

Uma questão importante que merece a nossa atenção é a informação que aparece no console assim que ele é aberto: o “R é um software livre e vem sem
GARANTIA ALGUMA”. Obviamente, essa garantia não existe porque o R é fruto de um ambiente colaborativo e é totalmente gratuito para o usuário. A hipótese
de eventual bug não pode ser descartada, entretanto, dependendo do aplicativo que está sendo processado, é possível estabelecer um controle de qualidade
que assegura total confiabilidade. É o caso dos sistemas de amortização. Ao visualizarmos uma planilha de evolução, o saldo ao final do prazo tende a zero.
Eventual resíduo de pequena monta é decorrente do arredondamento do cálculo da prestação e dos juros. Já um saldo ao final do prazo incompatível com
essa expectativa pode ser decorrente de erros no desenvolvimento do script ou, até mesmo, de um bug no software.

Esse controle de qualidade também é possível em cálculos de capitalização. Se o cálculo tem o objetivo de obter o valor do depósito para compor determinado
montante, o processamento estará correto se esse montante for atingido no prazo desejado. Outros tipos de cálculo de capitalização podem ter o controle de
qualidade através de “engenharia reversa”. Por exemplo, no exercício em que foram realizados 4 depósitos de R$ 700,00 e submetidos a mais 6 meses de
rendimentos de juros à taxa percentual de 2% ao mês, chegou-se ao montante de R$ 3.249,12. A “engenharia reversa” desse cálculo é tomar o valor de R$
3.249,12 como valor presente e submetê-lo ao Sistema Francês de Amortização com 4 prestações e 6 meses de carência, à taxa percentual de juros de 2%
ao mês. O saldo final no décimo mês deve tender a zero. Isso confirma que a rotina para cálculo desse montante está correta.

Devemos ter sempre em mente que nenhum software elimina o conhecimento humano. Aquilo que a tecnologia automatiza facilitando o nosso trabalho precisa
de validação. Esse processo depende do conhecimento acadêmico e profissional na área que ensejou a demanda pelo desenvolvimento do aplicativo.
 O SOFTWARE R COMO FERRAMENTA PARA GESTÃO FINANCEIRA

Segundo Eric Gorgens, “o R não é só um software, nem se resume a uma linguagem. O R é um estilo de pesquisar, estudar e ensinar. Através dos seus
códigos e scripts você entrará num mundo sem limites, aberto à experimentação e à troca de experiência.”

No artigo “Usando o R como calculadora financeira”, demonstramos algumas funcionalidades interessantes da matemática financeira geralmente tratadas pela
calculadora HP 12C. Vimos que o script do R não somente executa o cálculo, como também fornece planilhas de evolução ou extratos.

Neste ensaio, vamos tratar do cálculo da taxa interna de retorno, muito útil para análise da viabilidade econômica de investimentos, tema recorrente em
disciplinas de Administração Financeira. Muito embora o R se destaque como uma ferramenta estatística, nada impede que utilizemos as suas potencialidades
para outras áreas do conhecimento. Como bem disse Bill Venables, “não pergunte se o R é capaz de fazer algo! Pergunte como ele faz!”

Para este exercício, vamos nos apoiar num exemplo encontrado no livro “Matemática Financeira – Aplicações à Análise de Investimentos”, de Carlos Patricio
Samanez (São Paulo: Makron Books, 1994):

A taxa interna de retorno ou taxa interna de rentabilidade, de sigla TIR, em inglês IRR (Internal Rate of Return), é uma taxa de desconto hipotética que,
quando aplicada a um fluxo de caixa, faz com que os valores das despesas, trazidos ao valor presente, seja igual aos valores dos retornos dos investimentos,
também trazidos ao valor presente (https://pt.wikipedia.org/wiki/Taxa_interna_de_retorno). Ela permite obter a equivalência do valor do dinheiro no tempo, cujo
fluxo costuma ser representado graficamente dessa maneira:
No exemplo em pauta, a taxa interna de retorno é obtida pelo resultado da equação:

Não existe uma fórmula para calcular o resultado da taxa unitária “i” de maneira direta, isolando o “i”. Esse resultado é conseguido através de um processo
iterativo, por tentativa e erro. Algumas poucas linhas de comando são suficientes para o R obter a solução rapidamente, como também demonstrar os fluxos
de caixa descontados. O script CALCULA_TIR foi desenvolvido com essa finalidade. Ao executá-lo, apresenta-nos algumas orientações iniciais:

Carga do script
source("http://www.angelfire.com/un/cde/CALCULA_TIR.R")
[1] "********************************************************************************************"
[1] " Insira o projeto no formato de uma matriz n x 2 "
[1] " comando: projeto<-edit(data.frame()) by Jonas Liebl "
[1] " 1ª coluna: fluxo de 0 a n jonasliebl@outlook.com "
[1] " 2ª coluna: valores, respeitando o sinal do fluxo "
[1] " Execute tir() "
[1] "********************************************************************************************"

Ao digitar a linha de comando abaixo, habilita-se o editor de dados para inserção dos fluxos de caixa:

projeto<-edit(data.frame())

Fechando a janela do editor de dados com os fluxos de caixa devidamente informados, os valores são armazenados na variável de memória “projeto”. Digite
“projeto” para vê-los:

projeto
var1 var2
1 0 -100
2 1 40
3 2 50
4 3 60

Finalmente, basta digitar tir(). Não esqueça de colocar o (). Se digitar somente tir, será mostrado o conteúdo dessa variável de memória, que tem o conjunto
de instruções que executa o cálculo da taxa interna de retorno. Já o tir() executa o cálculo propriamente dito:

tir()
[1] "****************************************************** PROCESSAMENTO INICIADO ******************************************************"
[1] "ATENÇÃO: se o valor atual líquido for diferente de zero ou se der mensagem de erro, precisa alterar os parâmetros das listas de taxa"
[1] "************************************************************************************************************************************"
FLUXO VALOR COEFICIENTE VALOR_ATUAL
1 0 -100 1.000000 -100.00000
2 1 40 1.216478 32.88182
3 2 50 1.479818 33.78793
4 3 60 1.800166 33.33025
[1] "************************************************************************************************************************************"
[1] "A TAXA INTERNA DE RETORNO ESTIMADA É DE 21.647785 % - VALOR ATUAL LÍQUIDO $: 0"
[1] "************************************************************************************************************************************"

Além de informar a taxa interna de retorno de 21,647785%, mostra também o valor atual de cada fluxo de caixa na data focal 0, cujo somatório, denominado
valor atual líquido, é zero (-100,00000+32,88182+33,78793+33,33025=0). Atenção para a mensagem: “se o valor atual líquido for diferente de zero ou se der
mensagem de erro, precisa alterar os parâmetros das listas de taxa”. É que o script está preparado para testar, por tentativa e erro, as taxas compreendidas
entre 0,000001 e 60%. Eventual não zeramento, ou mensagem de erro, pode ser decorrente da taxa real extrapolar esse intervalo, necessitando alterar o
parâmetro do script.

A análise de investimento sob a ótica da taxa interna de retorno não é apenas uma questão para analistas financeiros. Pode ser útil também para compras
domésticas, como neste exemplo: uma geladeira de R$ 1.500,00 pode ser comprada em três parcelas mensais iguais de R$ 500,00, com a primeira de entrada,
ou à vista com 10% de desconto. O que vale mais a pena, retirar o dinheiro de determinado investimento que rende 5% ao mês para comprá-la à vista ou optar
por adquiri-la a prazo?

Neste caso, toma-se o valor à vista como valor do investimento (R$ 1.500,00 menos 10% = R$ 1.350,00). As prestações de R$ 500,00 são lançadas nos fluxos
0, 1 e 2, respectivamente. Assim, temos:

projeto<-edit(data.frame())
projeto
var1 var2
1 0 -1350
2 0 500
3 1 500
4 2 500

tir()
[1] "****************************************************** PROCESSAMENTO INICIADO ******************************************************"
[1] "ATENÇÃO: se o valor atual líquido for diferente de zero ou se der mensagem de erro, precisa alterar os parâmetros das listas de taxa"
[1] "************************************************************************************************************************************"
FLUXO VALOR COEFICIENTE VALOR_ATUAL
1 0 -1350 1.000000 -1350.000
2 0 500 1.000000 500.000
3 1 500 1.115544 448.212
4 2 500 1.244437 401.788
[1] "************************************************************************************************************************************"
[1] "A TAXA INTERNA DE RETORNO ESTIMADA É DE 11.554353 % - VALOR ATUAL LÍQUIDO $: 0"
[1] "************************************************************************************************************************************"

A opção pelo parcelamento implica uma taxa interna de juros de 11,554353% ao mês, muito superior ao rendimento mensal de 5% do investimento. Dessa
forma, compensa adquirir a geladeira à vista com o desconto de 10%.

Este caso da compra da geladeira, calculado pela ótica da TIR, também foi utilizado como exemplo para o Sistema Francês de Amortização, no modo
antecipado (vide artigo “Usando o R como calculadora financeira”). É que os sistemas de amortização seguem os mesmos princípios de “valor do dinheiro no
tempo” tratados em fluxo de caixa, portanto, os resultados devem ser os mesmos.

A rotina do processo iterativo do script CALCULA_TIR, para obtenção da taxa interna de retorno, foi otimizada em relação ao isfa() do script
CALCULADORA_FINANCEIRA. É uma forma de demonstrar que, em processamento de dados, há diversos caminhos para chegar ao mesmo resultado.

Esse script CALCULA_TIR, disponibilizado logo abaixo, pode ser copiado e colado no editor de script do R seguindo a sequência: Arquivo / Novo script, copiar
e colar, Arquivo / Salvar como CALCULA_TIR e Arquivo / Fechar Script. Assim teremos mais um aplicativo útil processado pelo R para ser utilizado sempre
que precisarmos.

print("********************************************************************************************")
print(" Insira o projeto no formato de uma matriz n x 2 ")
print(" comando: projeto<-edit(data.frame()) by Jonas Liebl ")
print(" 1ª coluna: fluxo de 0 a n jonasliebl@outlook.com ")
print(" 2ª coluna: valores, respeitando o sinal do fluxo ")
print(" Execute tir() ")
print("********************************************************************************************")
tir<-function(){

print("****************************************************** PROCESSAMENTO INICIADO ******************************************************")

print("ATENÇÃO: se o valor atual líquido for diferente de zero ou se der mensagem de erro, precisa alterar os parâmetros das listas de taxa")
print("************************************************************************************************************************************")

colnames(projeto)<-c("FLUXO","VALOR")
projeto<-data.frame(projeto)

taxa<-seq(0.1,60,0.1)

{for(contador in seq(taxa))
{x<-sum(projeto$VALOR/(1+taxa[contador]/100)^projeto$FLUXO)
ifelse(contador==1,val<-x,val<-c(val,x))}}

taxa<-seq(taxa[length(subset(val,val>0))],taxa[length(subset(val,val>0))+1],0.001)

{for(contador in seq(taxa))
{x<-sum(projeto$VALOR/(1+taxa[contador]/100)^projeto$FLUXO)
ifelse(contador==1,val<-x,val<-c(val,x))}}

taxa<-seq(taxa[length(subset(val,val>0))],taxa[length(subset(val,val>0))+1],0.000001)

{for(contador in seq(taxa))
{x<-sum(projeto$VALOR/(1+taxa[contador]/100)^projeto$FLUXO)
ifelse(contador==1,val<-x,val<-c(val,x))}}

taxa<-taxa[which.min(abs(val))]

projeto<-cbind(projeto,COEFICIENTE=(1+taxa/100)^projeto$FLUXO)
projeto<-cbind(projeto,VALOR_ATUAL=projeto$VALOR/projeto$COEFICIENTE)

write.csv2(projeto,row.names=FALSE,file="PROJETO.CSV")

print(projeto)
print("************************************************************************************************************************************")
print(paste("A TAXA INTERNA DE RETORNO ESTIMADA É DE",as.character(taxa),"% - VALOR ATUAL LÍQUIDO $:
",as.character(round(sum(projeto$VALOR_ATUAL)))))
print("************************************************************************************************************************************")}

Note que grande parte do script contém instruções ou informações destinadas ao usuário. Em programação, eventualmente chamada de “perfumaria”, é algo
necessário porque muitas vezes o usuário final é leigo em R e usa o script como uma ferramenta adicional, tal como faria com uma calculadora. O cálculo da
TIR propriamente dito consiste em três loopings que executam 1701 tentativas de taxas, ao final dos quais é selecionada aquela que mais aproxima o valor
atual líquido de zero. Além de apresentar o resultado no console, o R grava o arquivo PROJETO.CSV para posterior uso como anexo de relatórios, por exemplo.
 SOFTWARE R - O DESAFIO DO APRENDIZADO

Na minha visão de leigo da Tecnologia da Informação, um software me é mais interessante quanto mais cumprir dois requisitos que considero básicos e
importantes: ele precisa ser prático e democrático. O prático significa que ele de fato possa resolver problemas pessoais ou profissionais que estejam
assolando os meus dias. O democrático engloba não somente o acesso à ferramenta ou ao seu treinamento a preços viáveis para um mero mortal, como
também a possibilidade de iniciar o seu uso imediato para solucionar os meus problemas independentemente do nível de conhecimento que eu tenha sobre
ela. Eu acredito que o R cumpre esses dois requisitos com louvor. A gratuidade o torna democrático já na aquisição. Quanto ao aprendizado, é óbvio que
depende do espírito proativo da gente, mas existe vasto material de pesquisa disponível no mundo virtual. Se não se sabe por onde começar, basta perguntar
para o Google...

Uma vez instalado na máquina, começamos a construir o conhecimento. O R possui muitos “pacotes” prontos que até dispensariam grandes esforços de nossa
parte, mas eu gosto de viver a experiência do usuário e trilhar os meus próprios caminhos, mesmo com os tropeços inerentes a essa opção. Eu também gosto
de construir as minhas soluções de forma personalizada. Isso não somente fomenta o meu aprendizado, como também permite que eu entenda como o
software processa as minhas demandas. Com o artigo de hoje, pretendo demonstrar a evolução do aprendizado de um leigo em torno de um mesmo problema,
capturado em momentos distintos. É claro que essas não são as únicas e melhores soluções que se pode conseguir para essa empreitada. Como alguém já
disse, o importante não é o destino, mas sim a jornada!!! É um pedaço dessa jornada da construção do conhecimento que eu desejo compartilhar neste
momento até como estímulo para que outros companheiros se juntem a essa caminhada.

O problema

Vamos ao problema que estimulou o início dessa jornada de aprendizado. Não se trata de tema estatístico, algo que faz do R uma das mais requisitadas
ferramentas. Também não tem nada a ver com mineração de dados, assunto particularmente interessante para grandes descobertas através desse software.
É um problema de Matemática Financeira para o qual normalmente se usa a calculadora HP 12C. Desejei experimentar o R nessa seara por vislumbrar que
ele me daria soluções interessantes para questões dessa natureza. De fato me deu. Acabei desenvolvendo dois scripts, em momentos distintos, que não
somente efetuam os cálculos, como também geram planilhas de evolução, gravam arquivos para uso posterior e apresentam soluções gráficas. Vou demonstrar
caminhos distintos que conduzem à mesma solução, trilhados com diferentes graus de conhecimento sobre a ferramenta.

Um empréstimo de R$ 10.000,00 será pago em dez prestações mensais consecutivas de R$ 1.483,58, com a primeira vencendo no fim de um mês após
contrair a dívida. Qual é a taxa mensal de juros embutida na operação?

Como ponto de partida, vamos identificar as variáveis envolvidas na questão: temos o valor presente (PV) de R$ 10.000,00, as prestações (PMT) de R$
1.483,58 e o prazo (n) de 10 meses. Vamos criar essas três variáveis de memória através do console do R:

PV<-10000
PMT<-1483.58
n<-10
A primeira solução

Não existe uma fórmula para calcular a taxa mensal de juros (i) de maneira direta, isolando o “i”. Esse resultado é conseguido através de um processo iterativo,
por tentativa e erro. Para tanto, vamos testar, com uma sequência de taxas, a equivalência do valor presente e das prestações na data focal “n”. O resultado
será dado por aquela taxa que igualar os valores.

Essa construção é semelhante a que motivou o desenvolvimento do script CALCULADORA_FINANCEIRA.R (vide artigo “Usando o R como calculadora
financeira”), que foi a minha primeira empreitada logo após ser apresentado ao R. Imaginei testar a sequência de taxas e guardar os resultados numa variável
de memória do tipo “data.frame”, para, ao final do looping, identificar aquele que mais aproxima a equivalência do esperado.

Para não criar tabelas muito grandes e já sabendo que a taxa real está inclusa nesse intervalo, vamos iniciar as tentativas a partir de 5% até 10%, com
incremento de 1%. Vamos armazenar a sequência de taxas que serão testadas na variável de memória “taxa”:

taxa<-seq(5,10,1)

Visualizando a variável de memória “taxa”:

taxa
[1] 5 6 7 8 9 10

Agora vamos criar uma variável de memória do tipo “data.frame” para guardar os resultados obtidos com cada taxa testada:

lista_taxas<-matrix(c(0.00,0.00),1,2)
colnames(lista_taxas)<-c("TAXA","SALDO")
lista_taxas<-data.frame(lista_taxas)

Visualizando a variável de memória “lista_taxas”:

lista_taxas
TAXA SALDO
1 0 0

Note que essa variável de memória é uma matriz de duas colunas que será utilizada para “appendar” os resultados de cada tentativa para, ao final do
processamento, identificar aquela que mais se aproxima do resultado da questão.
Agora vamos processar a primeira rodada de sequência de taxas percorrendo o looping:

{for(contador in seq(length(taxa)))
{i<-taxa[contador]/100
SALDO<-round(PV*(1+i)^n-PMT*((1+i)^n-1)/i,2)
lista_taxas<-rbind(lista_taxas,c(taxa[contador],SALDO))}}

Consultando a variável de memória “lista_taxas”, temos:

lista_taxas
TAXA SALDO
1 0 0.00
2 5 -2371.36
3 6 -1646.29
4 7 -826.29
5 8 97.28
6 9 1133.71
7 10 2292.98

A taxa que mais se aproxima do resultado esperado é aquela que produz o saldo da equivalência mais próximo de zero. A primeira linha do “lista_taxas” não
interessa. Ela foi criada apenas para gerar o data.frame destinado a armazenar os resultados do looping. Portanto, vamos deletar essa linha do data.frame.

lista_taxas<-subset(lista_taxas,lista_taxas$TAXA!=0)

Uma outra maneira de deletar essa linha é:

lista_taxas<-lista_taxas[-1,]

Agora precisamos selecionar a taxa que mais aproxima de zero o saldo da equivalência. Uma forma de fazê-lo consiste em ranquear os saldos em valores
absolutos:

lista_taxas<-cbind(lista_taxas,RANKING=rank(abs(lista_taxas$SALDO)))

Observamos que o primeiro lugar do ranking indica o valor de R$ 97,28 como o mais próximo de zero, obtido pela taxa de 8%. É essa taxa que será extraída
para a continuidade do processamento:
lista_taxas
TAXA SALDO RANKING
2 5 -2371.36 6
3 6 -1646.29 4
4 7 -826.29 2
5 8 97.28 1
6 9 1133.71 3
7 10 2292.98 5

taxa<-subset(lista_taxas,lista_taxas$RANKING==1)[1]

Usamos a função subset() com o filtro para selecionar o registro cujo ranking é igual a 1. Lembre-se que o operador para comparação é constituído por dois
sinais de igual. Isso fará com que seja extraída a linha 5 com três colunas (TAXA, SALDO e RANKING), porém o que nos interessa é somente a TAXA. É por
isso que adicionamos o índice [1] à sintaxe, assim será capturado somente o valor da primeira coluna. Visualize a variável de memória “taxa”:

taxa
TAXA
5 8

Agora criaremos uma nova sequência de taxas compreendidas em torno de 8%, mas com incremento de 0,1% para obter uma taxa mais próxima da real com
uma casa decimal:

taxa<-seq(taxa$TAXA-1,taxa$TAXA+1,0.1)

taxa
[1] 7.0 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 8.0 8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9 9.0

Na sequência, reprocessaremos o looping para essas 21 taxas e efetuaremos o ranking dos saldos obtidos com cada qual:

lista_taxas<-matrix(c(0.00,0.00),1,2)
colnames(lista_taxas)<-c("TAXA","SALDO")
lista_taxas<-data.frame(lista_taxas)

{for(contador in seq(length(taxa)))
{i<-taxa[contador]/100
SALDO<-round(PV*(1+i)^n-PMT*((1+i)^n-1)/i,2)
i<-i*100
lista_taxas<-rbind(lista_taxas,c(taxa[contador],SALDO))}}
lista_taxas<-subset(lista_taxas,lista_taxas$TAXA!=0)
lista_taxas<-cbind(lista_taxas,RANKING=rank(abs(lista_taxas$SALDO)))

lista_taxas
TAXA SALDO RANKING
2 7.0 -826.29 18
3 7.1 -738.74 16
4 7.2 -650.15 14
5 7.3 -560.51 12
6 7.4 -469.80 10
7 7.5 -378.02 8
8 7.6 -285.16 6
9 7.7 -191.21 4
10 7.8 -96.16 2
11 7.9 0.00 1
12 8.0 97.28 3
13 8.1 195.68 5
14 8.2 295.22 7
15 8.3 395.91 9
16 8.4 497.76 11
17 8.5 600.78 13
18 8.6 704.97 15
19 8.7 810.35 17
20 8.8 916.93 19
21 8.9 1024.71 20
22 9.0 1133.71 21

A taxa que zera a equivalência é a indicada pelo primeiro lugar no ranking, cujo saldo correspondente é de R$ 0,00. Essa taxa será extraída pelo comando
abaixo:

taxa<-subset(lista_taxas,lista_taxas$RANKING==1)[1]

taxa
TAXA
11 7.9
Chegamos à resposta que atende a questão. Não há necessidade de continuar o processamento aumentando a quantidade de casas decimais porque a taxa
de 7,9% zerou a equivalência. Se fosse necessário, repetiríamos o looping para uma nova sequência de taxas compreendidas em torno de 7,9, mas com
incremento de 0,01, o que acrescentaria mais uma casa decimal para refinar o resultado.

A segunda solução

Quando desenvolvi o script CALCULA_TIR.R (vide artigo “O software R como ferramenta para gestão financeira”), já mais amadurecido no aprendizado do R,
vi que poderia ter uma solução mais compacta, sem necessidade de armazenar e ranquear resultados num data.frame. Poderíamos nos ater a uma lista de
taxas e armazenar os resultados numa lista de saldos.

taxa<-seq(5,10,1)

{for(contador in seq(taxa))
{i<-taxa[contador]/100
x<-round(PV*(1+i)^n-PMT*((1+i)^n-1)/i,2)
ifelse(contador==1,saldo<-x,saldo<-c(saldo,x))}}

Visualizando ambas as listas, “taxa” e “saldo”, temos:

taxa
[1] 5 6 7 8 9 10

saldo
[1] -2371.36 -1646.29 -826.29 97.28 1133.71 2292.98

Ambas as listas têm o mesmo tamanho e se relacionam em cada posição. A taxa de 8%, que ocupa a quarta posição da lista “taxa”, gerou um saldo de R$
97,28, que está na quarta posição da lista “saldo”. A posição anterior corresponde a uma taxa que produziu um saldo com sinal invertido. Sabemos que a taxa
real, que gera um saldo de R$ 0,00, está entre essas duas posições. Para obter uma nova sequência de taxas a serem testadas, precisamos saber quais são
as posições ocupadas pelos dois saldos mais próximos de zero na lista “saldo” e extrair as taxas que ocupam essas posições na lista “taxa”. Os comandos
abaixo identificam as posições desses saldos na lista “saldo”:

length(subset(saldo,saldo<0))
[1] 3

length(subset(saldo,saldo<0))+1
[1] 4
Os dois saldos mais próximos de zero, negativo e positivo respectivamente, encontram-se nas posições 3 e 4 da lista “saldo”. Podemos usar o [3] e o [4] como
índices para extrair as respectivas taxas da lista “taxa” e criar nova sequência a ser testada com o incremento de 0,1%:

taxa<-seq(taxa[length(subset(saldo,saldo<0))],taxa[length(subset(saldo,saldo<0))+1],0.1)

Visualizando a sequência de taxas para a nova rodada:

taxa
[1] 7.0 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 8.0

{for(contador in seq(taxa))
{i<-taxa[contador]/100
x<-round(PV*(1+i)^n-PMT*((1+i)^n-1)/i,2)
ifelse(contador==1,saldo<-x,saldo<-c(saldo,x))}}

Visualizando a lista “saldo”, temos 11 saldos correspondentes a cada taxa da lista “taxa”. O menor deles, em valor absoluto, está na décima posição:

saldo
[1] -826.29 -738.74 -650.15 -560.51 -469.80 -378.02 -285.16 -191.21 -96.16 0.00 97.28

Para identificar a posição ocupada por esse menor saldo em valor absoluto, podemos usar o comando:

which.min(abs(saldo))
[1] 10

A respectiva taxa poderá ser extraída da lista “taxa” usando o [10] como índice:

taxa[which.min(abs(saldo))]
[1] 7.9

Essa taxa de 7,9% é a resposta para o problema apresentado no início do artigo. Se ela ainda não tivesse zerado a equivalência do valor presente e das
prestações na data focal “n”, faríamos outra rodada com nova sequência de taxas, com incremento de 0,01.

Uma solução rápida

O R processa esse conjunto de comandos reunidos num script de forma muito rápida, não importa a quantidade de loopings incorporada ao processamento
para refinar a quantidade de decimais da resposta. Eventualmente, pode-se desejar uma solução rápida, pontual, sem o preciosismo de muitas casas decimais
e sem escrever muitas linhas de comando. Nesse caso, é possível processar uma única sequência de taxas num único looping e obter um resultado satisfatório
combinado com uma alternativa gráfica. Vamos lá:

taxa<-seq(5,10,1)

{for(contador in seq(taxa))
{i<-taxa[contador]/100
x<-round(PV*(1+i)^n-PMT*((1+i)^n-1)/i,2)
ifelse(contador==1,saldo<-x,saldo<-c(saldo,x))}}

Os comandos acima nos proporcionam duas listas:

taxa
[1] 5 6 7 8 9 10

saldo
[1] -2371.36 -1646.29 -826.29 97.28 1133.71 2292.98

As duas listas podem ser plotadas num gráfico com os seguintes argumentos:
saldo~taxa: a lista identificada à esquerda do til corresponde ao eixo “y”, enquanto que a outra, ao “x”;
type="l": será plotado um gráfico do tipo “linha”
lwd=2: esse 2 é a espessura da linha
col="blue": desejamos uma linha na cor azul

plot(saldo~taxa,type="l",lwd=2,col="blue")
Para auxiliar na obtenção da solução através do gráfico, precisamos acrescentar uma linha demarcando o saldo zero:

abline(h=0)

Sabemos que a taxa que produz a equivalência do valor presente e das prestações na data focal “n” é aquela que se encontra no ponto em que a linha azul
cruza a reta para y=0. O R tem uma função chamada locator(), acionada a partir do console, que permite que se posicione o cursor sobre determinado ponto
de um gráfico para obter a leitura da sua posição (x,y). O argumento da função é a quantidade de vezes que se pretende ler essa posição. Vamos fazê-lo uma
única vez:

locator(1)

Após digitar o comando, o R alterna para a janela do gráfico e habilita o cursor para que o posicionemos no ponto de interesse e pressionemos o mouse.
Vamos posicioná-lo o mais próximo possível do ponto em que ambas as curvas se cruzam e, após pressionar o cursor, vamos observar os registros no console:

locator(1)
$`x`
[1] 7.900362

$y
[1] 5.745957

Esse ponto que eu selecionei com o cursor corresponde à taxa de 7,900362%. O saldo da equivalência proporcionado por essa taxa na data focal “n” é de R$
5,74, praticamente irrelevante no contexto de um valor presente de R$ 10.000,00 e de dez prestações de R$ 1.483,58. Assim, se a intenção é apenas a de ter
uma ideia de qual é a taxa mensal de juros embutida na operação, o 7,900362% já está de bom tamanho. Obviamente, se precisamos de exatidão ou se os
valores envolvidos são de grande materialidade, aí compensa rodar um script com várias sequências de taxas e loopings para refinar a solução.

A função locator() pode ser executada com um maior número de tentativas, basta especificar no argumento. O R registrará no console todas as posições (x,y)
obtidas em cada clicada do mouse. A melhor resposta será a do “x” equivalente ao “y” mais próximo de zero.

Outra solução rápida

Obtém-se um resultado mais refinado se constituirmos a lista de taxas dessa primeira e única rodada com um incremento menor. Por exemplo, em vez de 1%,
podemos fazê-lo com 0,01%, já com foco em duas casas decimais:

taxa<-seq(5,10,0.01)

length(taxa)
[1] 501

O processamento do looping percorrerá uma lista de 501 taxas em vez de 6:

{for(contador in seq(taxa))
{i<-taxa[contador]/100
x<-round(PV*(1+i)^n-PMT*((1+i)^n-1)/i,2)
ifelse(contador==1,saldo<-x,saldo<-c(saldo,x))}}

Alguém percebeu alguma demora no processamento dos 501 cálculos realizados pelo R? Evidentemente, demorou alguns milésimos de segundo a mais,
porém nada perceptível para um mero mortal. Como resultado, temos também uma lista com 501 saldos:

length(saldo)
[1] 501

Qual é o saldo mais próximo de zero?

min(abs(saldo))
[1] 0

Qual é a posição que ele ocupa na lista saldo?

which.min(abs(saldo))
[1] 291
Qual é a taxa que ocupa essa posição na lista taxa?

taxa[which.min(abs(saldo))]
[1] 7.9

Neste caso, como o menor saldo obtido já é zero (R$ 0,00), não precisamos avançar com outras rodadas de sequência de taxas e/ou com alternativa gráfica
combinada com locator().

Considerações finais

Este ensaio buscou calcular a taxa de juros embutida numa operação de concessão de empréstimo, que é um tema tratado pela Matemática Financeira
envolvendo sistemas de amortização. Sistema de amortização é um método de cálculo que tem por objetivo pagar uma dívida ou financiamento no prazo
contratado, remunerando-o à taxa pactuada. O mais conhecido é o “Sistema Francês de Amortização”, também chamado de “Tabela Price”. É esse sistema
que se encontra residente na famosa calculadora financeira HP 12C. A sua principal característica é que apresenta prestações (ou parcelas) iguais.

Agora que temos todos os componentes dessa operação, vamos visualizar a respectiva planilha de evolução. Ela demonstra que o empréstimo de R$
10.000,00, pago em 10 prestações mensais de R$ 1.483,58 e remunerado a 7,9% ao mês, é efetivamente quitado ao se realizar o décimo pagamento. Isso
ratifica que a taxa obtida pelos processamentos acima está correta.

sfa(10000,7.9,10,0)
[1] "*************************************************"
[1] " VALOR DA PRESTAÇÃO: 1483.58 "
[1] "*************************************************"
PERÍODO PRESTAÇÃO JUROS AMORTIZAÇÃO SALDO
[1,] 0 0.00 0.00 0.00 10000.00
[2,] 1 1483.58 790.00 693.58 9306.42
[3,] 2 1483.58 735.21 748.37 8558.05
[4,] 3 1483.58 676.09 807.49 7750.56
[5,] 4 1483.58 612.29 871.29 6879.27
[6,] 5 1483.58 543.46 940.12 5939.15
[7,] 6 1483.58 469.19 1014.39 4924.76
[8,] 7 1483.58 389.06 1094.52 3830.24
[9,] 8 1483.58 302.59 1180.99 2649.25
[10,] 9 1483.58 209.29 1274.29 1374.96
[11,] 10 1483.58 108.62 1374.96 0.00

Essa planilha de evolução foi gerada com o script CALCULADORA_FINANCEIRA.R, objeto do meu primeiro artigo “Usando o R como calculadora financeira”.
Em Tecnologia da Informação, temos vários caminhos que conduzem à mesma solução. Podem ser mais longos, mais curtos, mais técnicos, mais intuitivos,
mais exatos ou aproximados... Qual é o mais adequado? Depende... Se buscamos uma solução empresarial, que vai ser processada milhares de vezes em
ambiente de rede, precisa de rapidez e exatidão. Se for um problema caseiro e pontual, não precisamos nos preocupar com economia de segundos ou com
refinamento de casas decimais. O importante é que o usuário consiga a solução desejada entendendo como a ferramenta se comporta. Importante também é
começar a jornada do aprendizado sem medo de errar e aprender com os erros. Essa jornada oferece múltiplas possibilidades de agregarmos novas
competências pessoais e o R é uma excelente ferramenta para isso.