LISP

( + 2 3 )

This form adds the numbers 2 an 3.

( + ( * 2 2 ) ( * 3 3 ) )

This form the number 2 is squared and sent as the first argument to the addition operator. The number 3 is squared and sent as the second argument. Then 4 and 9 are added. If you wanted to use this form more than once, you would define a new function as

(defun sum-of-squares (a b)

( + ( * a a ) ( * b b ) ) )

The defun macro defines functions. The name of the function being defined is sum-of-squares. (a b ) are the two arguments.

quote is a special form that return its arguments unevaluated. for example

( + 2 2 )

=> 4

(quote ( + 2 2 ) )

=> ( + 2 2 )

‘( + 2 2 )

=> ( + 2 2 ) the symbol => indicates the returned value.

quote is used when it is necessary to pass a literal value to a function without evaluation.

Primitive functions

In numeric programming we have +, -, *, and /. These function deal with numbers. In Lisp, we have car, cdr, and cones. These deal with list.

car gives the first element of a list. cdr gives the rest of the list. cones builds lists. for example,

(car ‘ ( a b c ) )

=> A

(cdr ‘( a b c ) )

=> ( B C )

(cons ‘ a ‘ ( b c ) )

=> ( A B C )

( car (cdr ‘ ( a b c) ) )

=> B

DATA TYPE

Common

Numbers

Rational

Integers

Fixnums

Short

Single

Double

Long

Symbol

functions

( type-of 7 )

=> FIXNUM

( type-of 7.2 )

=> FLOAT

(type-of 7/2)

=> RATIO

type-of function return most specific type.

The abs function returns the absolute value of a number.

(abs 4.5)

=> 4.5

(abs -6/7)

=> 6/7

The expt function return the result of one number raised to the power of another number.

( expt 2 0 )

=> 1

( expt 3 2 )

=> 9

( expt 2 -2)

=> 1/4

The round function changes a number to the nearest even integer.

( round 3.5 )

=> 4

-0.5

( round 2.5 )

=> 2

0.5

A predicate is a function that return either nil or a non-nil value. A nil value means false

and a non-nil value means true.

(numberp ‘a )

=> NIL

(characterp #\a )

=> T

(floatp 4.5)

=> T

The defun macro is the defining functions.

( defun cube ( x )

“This function returns the cube of the argument.”

( * x x x ) )

=> CUBE

( cube 3 )

=> 27

( cube 2 )

=> 8

Iteration

The loop macro repeatedly evaluates a seris of forms.

(defun count-down (x )

( loop

( print x )

(setq x ( - x 1 ) )

(if (zero x) (return “lift off ) ) ) )

=> COUNT-DOWN

(count-down 10)

=> 10

9

8

7

6

5

4

3

2

1

“lift off”

The do macro repeatedly evaluates a series of forms until an end condition is met.

( defun count-down-2 ( x ) ;;similar to the loop count-down

(do ( ( a x ( 1 - a ) ) ) ;;the subtraction is done automatically

( ( zerop a ) “ lift off “ ) ;;no if, no return

( print a ) ) )

=> COUNT-DOWN-2

(count-down-2 5)

=> 5

4

3

2

1

“ lift off “

Definition

Lists:- A list is a structure that contain zero or more elements. A list begins and ends

with parentheses. The following are lists.

( list ‘a’ b )

( a b c )

( )

( * ( + 1 3) 9 )

SYNTAX FORMAT

Constants

A Constant has a value that cannot be changed. For example, pi has an approximate

value of PI. Trying to change the value of pi, or trying to bind the constant to another

value causes an error.

Append

The append function concatenates list into one list. It creates a new list and does not modify the argument lists.

( append ‘ ( a b ) ‘ ( c d ) )

=> ( A B C D ) ;; => indicates the output

( append ‘ ( ( 1 a ) ( 2 b ) ) ‘ ( ( 3 c ) ( 4 d ) ) )

=> ( ( 1 A ) ( 2 B ) ( 3 C ) ( 4 D ) )

Input/Output

The print function output a new line followed by the printed representation of an object.

The following example show the result of print.

( print “Hello” )

=> “Hello” ; printed result

“Hello” ; value returned

Read

The read equivant to write is read.

To read keyboarded input, execute (read), type characters, and press [ENTER]

for example

(read)

abcde

=> ABCDE

(read)

“abcde”

=> “abcde”

Write

The write function outputs the printed representation of an object. The function provides

keyword that correlate to the ouput variable.

For example

(write ‘symbol)

=> SYMBOL

SYMBOL

Boolean Values

and, not, or

The and macro looks at the forms and determines if none of them is nil. If a form returns nil, and return nil. It does not evaluate the remaining forms. If none of the forms nil, and

returns nil, and return the value of the last form.

( setq class ‘(tom larry lary moe joe ) )

=> ( TOM LARRY LARY MOE JOE )

(and (member ‘ tom class) )

=> ( TOM LARRY LARY MOE JOE )

( and ( member ‘ sue class) )

=> NIL

( and ( member ‘lary class)

( member ‘tom class)

(member ‘joe class)

=> (JOE)

Not

The not function evaluates its argument and inverts the value. If the argument is nil,

not returns t. If the argument is t, not return nil.

( not ( member ‘joe class ) )

=> NIL

( not ( member ‘ sue class ) )

=> T

Or

The or macro looks at the forms and determines if at least one of them is true. It evaluates the forms is the order given. When a non-nil result is found, or return that value

It does not evaluate the remaning forms.

( or ( member ‘joe class )

( member ‘sue class )

=> (JOE)

( or (member ‘sue class)

(member ‘mary class)

(member ‘rick class)

(member ‘tom class)

=> ( TOM LARRY LARY MOE JOE )

caar First element of the first element

cadr Second element

cdar Rest of the first element

cddr Rest aftet the second element

caddr Third element

cdddr Rest after the third element

cadddr Fourth element

cddddr Rest after the fourth element