Arquivos de tags: Lisp

Lisp: Calculando juros

Ultimamente tenho me interessado por ações na bolsa, poupanças, juros, etc. Para me ajudar nos cálculos, desenvolvi esse pequeno programa em lisp, que então pode ser chamado com: juros valor-inicial juros-mensal meses [acréscimo-mensal]

#!/usr/bin/clisp
(defun calc-juros (valor juros)
  "Calcula valor de juros (em porcento) sobre valor."
  (* valor (/ juros 100.0)))

(defun soma-juros (valor juros)
  "Calcula valor de juros (em porcento) e soma ao valor original."
  (+ valor (calc-juros valor juros)))

(defun total (valor juros meses &optional (deposito-mensal 0))
  "Calcula o valor total depois de alguns meses com juros."
  (total-itin valor juros meses deposito-mensal))

(defun total-itin (valor juros restantes deposito-mensal)
  (if (= restantes 0)
    valor
    (total-itin (+ deposito-mensal (soma-juros valor juros))
                juros
                (1- restantes)
                deposito-mensal)))

;; Para fazer funcionar a partir do shell:
(format t "~a"
(cond ((= (length ext:*args*) 4) (total (read-from-string (first ext:*args*))
                                        (read-from-string (second ext:*args*))
                                        (read-from-string (third ext:*args*))
                                        (read-from-string (fourth ext:*args*))))

      ((= (length ext:*args*) 3) (total (read-from-string (first ext:*args*))
                                        (read-from-string (second ext:*args*))
                                        (read-from-string (third ext:*args*))))

      (t "juros valor-inicial juros-mensal meses [deposito-mensal]")))
Publicidade

LISP: Introdução à Função Format II

No artigo passado nós vimos o básico sobre a função format e as diretrizes de uso geral. Agora iremos nos aprofundar um pouco, vendo diretrizes mais específicas e seus parâmetros. Começaremos com a diretriz ~c.
Saiba mais

LISP: argv

Quando o lisp surgiu, ele era uma linguagem de programação bastante avançada para a época. Tão avançada que foram necessárias máquinas especialmente projetadas para rodá-lo. O tempo foi passando e as máquinas evoluindo. Hoje podemos rodar lisp em qualquer máquina, em virtualmente qualquer sistema operacional.

Hoje em dia chamamos o interpretador lisp por uma linha de comando, que inclusive podemos passar argumentos através dessa linha de comando:
clisp source.lisp argumento1 argumento2 argumento3 ...

Mas na época que o lisp foi inventado, as linhas de comando eram o próprio lisp e por isso não havia motivo para criar um padrão de como acessar esses argumentos externos. Por esse motivo não há nenhuma norma de como deve ser feita a implementação do acesso a esses argumentos, chamados em C de argv[].

Justamente por não ser regulamentada, muitos tutoriais deixam isso de lado e eu passei um bom tempo me perguntando como acessar esses argumentos através de lisp. Na implementação que eu uso (clisp), é extremamente fácil. Salve esse script:

(print ext:*args*)
(print (first ext:*args*))
(print (second ext:*args*))

E rode-o com:

clisp args.lisp arg1 arg2 arg3 arg4

("arg1" "arg2" "arg3" "arg4")
"arg1"
"arg2"

Se você precisar de todos os argumentos passados, pode usar ext:argv também. Lembrando que isso vale para o clisp, outras implementações provavelmente funcionam de outra forma.

LISP: Introdução à função format I

A função format pode parecer estranha à primeira vista. Quem nunca programou faz cara de que não entendeu e quem está acostumado com o printf do C fica procurando %s ou %g ou %d ou …
Saiba mais