Corman Common Lisp 3.0
Version of implementation Corman Common Lisp of programming language LispKey features of version 3.0:
 Improved math and numeric code performance and stability.
 Added integration with .NET.
 Numerous bug fixes and minor changes in kernel functions, garbage collection, ANSI compatibility etc.
 IDE improvements.
Examples:
Fibonacci numbers  Lisp (23):
This example uses recursive definition of Fibonacci numbers and expands use of loop
macro to finally
clause (expression evaluated after the loop is done).
(defun fibonacci (n)
(if (< n 3)
1
(+ (fibonacci ( n 1)) (fibonacci ( n 2))) ) )
(loop for i from 1 to 16
do (format t "~D, " (fibonacci i))
finally (format t "...~%") )
Fibonacci numbers  Lisp (24):
This example uses iterative definition of Fibonacci numbers, though expressed through recursive calls of fibiter
.
(defun fibonacci (n)
(defun fibiter (a b count)
(if (zerop count)
b
(fibiter (+ a b) a ( count 1)) ) )
(fibiter 1 0 n) )
(loop for i from 1 to 16
do (format t "~D, " (fibonacci i))
finally (format t "...~%") )
Hello, World!  Lisp (21):
When executed in interactive mode, program output looks as follows:
Hello, World!
NIL
First line contains standard output, second — the result of expression evaluation (in this case there is none).
(format t "Hello, World!~%")
Factorial  Lisp (22):
This example uses recursive factorial definition (which is natural for Lisp). Features:

math operators:
( n 1)
is prefix notation equivalent ton1
in infix notation; 
comparison operators:
(= n 0)
evaluates toT
if n is zero, and tonil
(used as false) otherwise; 
conditional operator
if
: Lisp expressions are evaluated using brackets, so they can be written in several lines; 
function definition using
defun
; 
Common Lisp macro
loop
; 
format specifiers in
format
:~D
corresponds to printing an integer, and~%
is endofline.
(defun factorial (n)
(if (= n 0)
1
(* n (factorial ( n 1))) ) )
(loop for i from 0 to 16
do (format t "~D! = ~D~%" i (factorial i)) )
Quadratic equation  Lisp (172):
Common Lisp provides complex numbers as datatype, printed as #C(real imag)
. writetostring
converts a number into a string.
Note that for interactive evaluation it’s enough to add (quadraticroots2 1 0 1)
to see the result of calculation, while for compiled execution you’ll have to wrap call of this function in printing command, like (format t (quadraticroots2 1 0 1))
.
(defun quadraticroots2 (A B C)
(cond ((= A 0) (string "Not a quadratic equation."))
(t
(let ((D ( (* B B) (* 4 A C))))
(cond ((= D 0) (concatenate 'string "x = " (writetostring (/ (+ ( B) (sqrt D)) (* 2 A)))))
(t
(values (concatenate 'string "x1 = " (writetostring (/ (+ ( B) (sqrt D)) (* 2 A))))
(concatenate 'string "x2 = " (writetostring (/ ( ( B) (sqrt D)) (* 2 A)))))))))))
CamelCase  Lisp (277):
(defun camelcase (s)
(remove #\Space
(stringcapitalize
(substitute #\Space nil s :key #'alphacharp))))
(princ (camelcase (readline)))
Factorial  Lisp (121):
In this example the inner loop with collect
clause produces a list of numbers from 1 to n
. After this operation *
is applied to this list, and the product of the numbers is printed.
(loop for n from 0 to 16
do (format t "~D! = ~D~%" n
(apply '* (loop for i from 1 to n
collect i)) ) )
Comments
]]>blog comments powered by Disqus
]]>