Lisp – Vestigium

Errores aritméticos en Haskell y en Lisp

PorJosé A. Alonso 8 enero 20118 marzo 2013

La primera vez que uno se encuentra con los siguientes cálculos aritméticos en Haskell puede sorprenderse.

~> ghci
GHCi, version 6.12.1: http://www.haskell.org/ghc/  
ghci> 1.1 == 1.1
True
ghci> 1.1+1.1 == 2.2
True
ghci> 1.1+1.1+1.1 == 3.3
False
ghci> 2.2+1.1 == 3.3
False

~> ghci

GHCi, version 6.12.1: http://www.haskell.org/ghc/

ghci> 1.1 == 1.1

True

ghci> 1.1+1.1 == 2.2

True

ghci> 1.1+1.1+1.1 == 3.3

False

ghci> 2.2+1.1 == 3.3

False

El mismo comportamiento se da en Common Lisp

~> clisp
Welcome to GNU CLISP 2.44.1 (2008-02-23) <http://clisp.cons.org/>

[1]> (= 1.1 1.1)
T
[2]> (= (+ 1.1 1.1) 2.2)
T
[3]> (= (+ 1.1 1.1 1.1) 3.3)
NIL
[4]> (= (+ 1.1 2.2) 3.3)
NIL

~> clisp

Welcome to GNU CLISP 2.44.1 (2008-02-23) <http://clisp.cons.org/>

[1]> (= 1.1 1.1)

[2]> (= (+ 1.1 1.1) 2.2)

[3]> (= (+ 1.1 1.1 1.1) 3.3)

NIL

[4]> (= (+ 1.1 2.2) 3.3)

NIL

Para comprender estos cálculos es aconsejable leer What Every Computer Scientist Should Know About Floating-Point Arithmetic.

Comparación de 3 implementaciones de Common Lisp (Clisp, GCL y SBCL) mediante la función de Takeuchi

PorJosé A. Alonso 16 septiembre 20109 abril 2014

En artículos anteriores comentamos la función de Takeuchi como prueba de rendimiento y la usamos para la comparación del rendimiento de Haskell, Maxima y Common Lisp.

En este artículo voy a usar una variación de la prueba anterior para comparar tres implementaciones de Common Lisp: Clisp, GCL (GNU Common Lisp) y SBCL (Steel Bank Common Lisp).

La función de Takeuchi es
$tak(x,y,z) = \newline \left\{ \begin{array}{ll} y, & \mathrm{si} \ x \leq y \\ \mathrm{tak}(\mathrm{tak}(x-1,y,z), \mathrm{tak}(y-1,z,x), \mathrm{tak}(z-1,x,y)) & \mathrm{en\ caso\ contrario} \end{array} \right.$

La prueba consistirá en comparar los tiempos empleados en calcular tak(n,0,n+1) para n entre 10 y 15.
Read More “Comparación de 3 implementaciones de Common Lisp (Clisp, GCL y SBCL) mediante la función de Takeuchi”

Programas compactos para calcular pi con la fórmula de Leibniz

PorJosé A. Alonso 13 septiembre 201022 diciembre 2010

En artículos anteriores hemos comparado la eficiencia de programas en distintos lenguajes. En este vamos a comparar la simplicidad de los programas para resolver un problema.

Como ejemplo he elegido el problema del cálculo compacto del número $\pi$ mediante la fórmula de Leibniz

$<br /> \pi = 4 \times \left(1 - \dfrac{1}{3} + \dfrac{1}{5} - \dfrac{1}{7} + \dots\right)<br />$

El enunciado de problema es el siguiente

Escribir un programa, con el menor número posible de caracteres, para calcular el número $\pi$ usando la fórmula de Leibniz con un error menor que 0.00001.

El problema se ha planteado en Code Golf: Leibniz formula for Pi y se han escrito distintas respuestas que resumo al final del artículo. Antes voy a presentar programas compactos en nuestros lenguajes habituales (Haskell, Maxima y Common Lisp).

Competición de IA de Google 2010

PorJosé A. Alonso 7 septiembre 20108 marzo 2013

Se ha anunciado la Google AI Challenge del 2010. Este año el objetivo es crear un programa para el juego de la Guerra de los Planetas que juege tan inteligentemente como sea posible.

El juego de la guerra de los planetas es un juego de estrategia inspirado en el Galcon.

Se puede participar en la competición programando la estrategia del juego en distintos lenguajes de programación a los que en breve se añadirán Haskell y Common Lisp.

Esta competición puede utilizarse en distintas asignaturas que impartimos:

Apología de la programación en Lisp

PorJosé A. Alonso 1 septiembre 20108 marzo 2013

Recientemente se ha publicado el artículo Why We Love Lisp que es una apología de la programación en Lisp.

Algunas de las aspectos de Lisp en las que se basa la apología son:
Read More “Apología de la programación en Lisp”