>>
(DE (NULL X) (EQP X NIL))
==
( EXPR LAMBDA ( X ) ( EQP X NIL ) )

>>
(DE (REV L) (COND ((NULL L) L)
		(T (APPEND (CAR L) (REV (CDR L))))))
==
( EXPR LAMBDA ( L ) ( COND ( ( NULL L ) L ) ( T ( APPEND ( CAR L ) ( REV ( CDR L ) ) ) ) ) )

>>
(DE (APPEND A L) (COND ((NULL L) (CONS A NIL))
			(T (CONS (CAR L) (APPEND A (CDR L))))))
==
( EXPR LAMBDA ( A L ) ( COND ( ( NULL L ) ( CONS A NIL ) ) ( T ( CONS ( CAR L ) ( APPEND A ( CDR L ) ) ) ) ) )

>>
(REV '(1 2 3 4 5 6 7 8 9 10))
==
( 10 9 8 7 6 5 4 3 2 1 )

>>
(DF (LIST X) (MAPLIST #'(LAMBDA (Z) (EVAL Z (CAR (CDR X)))) (CAR X)))
==
( FEXPR LAMBDA ( X ) ( MAPLIST ( QUOTE EVAL ) X ) )


>>
(LIST 1 2 3 4 (LIST 'A 'B 'C) 5 6 7 (LIST (SIN 3.0) (PLUS 5 11)))
==
( 1 2 3 4 ( A B C ) 5 6 7 ( 0.14112 16 ) )





>>
(DE (DIFF X V)
	(COND ((ATOMP X)
		  (COND ((EQP X V) 1)
			(T 0)))
		((EQP (CAR X) 'PLUS) (DIFFPLUS (CDR X) V))
		((EQP (CAR X) 'TIMES) (DIFFTIMES (CDR X) V))
		((EQP (CAR X) 'POW) (DIFFPOW (CDR X) (CDR (CDR X))))))
==
( EXPR LAMBDA ( X V ) ( COND ( ( ATOMP X ) ( COND ( ( EQP X V ) 1 ) ( T 0 ) ) ) ( ( EQP ( CAR X ) ( QUOTE PLUS ) ) ( DIFFPLUS ( CDR X ) V ) ) ( ( EQP ( CAR X ) ( QUOTE TIMES ) ) ( DIFFTIMES ( CDR X ) V ) ) ( ( EQP ( CAR X ) ( QUOTE POW ) ) ( DIFFPOW ( CDR X ) ( CDR ( CDR X ) ) ) ) ) )

>>
(DE (DIFFPLUS L W)
	(CONS 'PLUS (MAPLIST #'(LAMBDA (Z) (DIFF Z W)) L)))
==
( EXPR LAMBDA ( L W ) ( CONS ( QUOTE PLUS ) ( MAPLIST ( QUOTE ( LAMBDA ( Z ) ( DIFF Z W ) ) ) L ) ) )


>>
(DE (DIFFTIMES L V)
	(MODULE (L1)
	    (SETQ L1 (MAPLIST #'(LAMBDA (X) (DIFF X V)) L))
	    (CONS 'PLUS (INTERSPLICE L L1 'TIMES))))
==
( EXPR LAMBDA ( L V ) ( MODULE ( L1 ) ( SETQ L1 ( MAPLIST ( QUOTE ( LAMBDA ( X ) ( DIFF X V ) ) ) L ) ) ( CONS ( QUOTE PLUS ) ( INTERSPLICE L L1 ( QUOTE TIMES ) ) ) ) )

>>
(DE (MAPCAR F L)
	(COND ((EQP L NIL) NIL)
		(T (CONS (F (CAR L)) (MAPCAR F (CDR L))))))
==



>>
(DE (INTERSPLICE L L1 H)
     (MODULE (LR1 IR TT) 
	(IF (EQP NIL L) (RETURN NIL))
	(SETQ LR1 (CONS H (CONS (CAR L1) (CDR L))))
	(SETQ IR (INTERSPLICE (CDR L) (CDR L1) H))
	(SETQ TT (CAR L))
	(SETQ IR (MAPLIST #'(LAMBDA (X) (CONS H (CONS TT (CDR X)))) IR))
	(CONS LR1 IR)))
==
( EXPR LAMBDA ( L L1 H ) ( MODULE ( LR1 IR TT ) ( IF ( EQP NIL L ) ( RETURN NIL ) ) ( SETQ LR1 ( CONS H ( CONS ( CAR L1 ) ( CDR L ) ) ) ) ( SETQ IR ( INTERSPLICE ( CDR L ) ( CDR L1 ) H ) ) ( SETQ TT ( CAR L ) ) ( SETQ IR ( MAPLIST ( QUOTE ( LAMBDA ( X ) ( CONS H ( CONS TT ( CDR X ) ) ) ) ) IR ) ) ( CONS LR1 IR ) ) )



>>
(INTERSPLICE '(1 2 3 4 5) '(A B C D E) 'TIMES)
==
( ( TIMES A 2 3 4 5 ) ( TIMES 1 B 3 4 5 ) ( TIMES 1 2 C 4 5 ) ( TIMES 1 2 3 D 5 ) ( TIMES 1 2 3 4 E ) )

>>
(DIFF '(TIMES X (PLUS X 1) (PLUS X X X) A) 'X)
==
( PLUS ( TIMES 1 ( PLUS X 1 ) ( PLUS X X X ) A ) ( TIMES X ( PLUS 1 0 ) ( PLUS X X X ) A ) ( TIMES X ( PLUS X 1 ) ( PLUS 1 1 1 ) A ) ( TIMES X ( PLUS X 1 ) ( PLUS X X X ) 0 ) )


>>
(DF (TT X) X)
==



>>
(DE (FOO N)
	(COND ((EQL N 0) (TT N))
			(T (FOO (MINUS N 1)))))
==



>>
(DE (ADDN N) #'(LAMBDA (X) (PLUS X N)))
==

>>
(ADDN 12)
==

>>
(DE (TTT X) (MODULE (F G)
		(SETQ F X)
		(SETQ G (ADDN F))
		(G F)))
==


>>
(DE (COMPOSE F G) #'(LAMBDA (X) (F (G X))))
==


>>
(COMPOSE (ADDN 12) (ADDN 13))
==



>>
(DE (FLATTEN L) (COND ((ATOMP L) L)
				  (T (FLATTEN1 (MAPLIST #'FLATTEN L)))))
== 


>>
(DE (FLATTEN1 L) (COND ((EQP L NIL) NIL)
					(T (PREPEND (CAR L) (FLATTEN1 (CDR L))))))
==


>>
(DE (PREPEND L1 L2) (COND ((EQP L1 NIL) L2)
						((ATOMP L1) (PREPEND (CONS L1 NIL) L2))
						(T (CONS (CAR L1) (PREPEND (CDR L1) L2)))))
==



>>
(DE (LEN L) (COND ((EQP L NIL) 0) (T (PLUS 1 (LEN (CDR L))))))
==


>>
(DE (BS L) (COND ((EQP L NIL) 'X) (T (CONS (BS (CDR L)) (BS (CDR L))))))
==

>>
(LEN (FLATTEN (BS '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17))))
==


>>
(DE (HAN FR TO AUX L) (COND ((EQP L NIL) (CONS FR TO))
						(T (CONS (HAN FR AUX TO (CDR L)) 
								(CONS (HAN FR TO AUX NIL)
									(HAN AUX TO FR (CDR L)))))))
==

>>
(HAN 'FF 'TT 'AA '(1 2 3 4 5 6 7 8 9 10))
===


>>
(DE (HAN FR TO AUX L) (COND ((EQL L 0) (CONS FR TO))
						(T (CONS (HAN FR AUX TO (MINUS L 1)) 
								(CONS (HAN FR TO AUX 0)
									(HAN AUX TO FR (MINUS L 1)))))))
==

>>
(HAN 'FF 'TT 'AA 10)
===

The following lines are only for a standard Common Lisp for
comparison purposes
(DEFUN HAN (FR TO AUX L) (COND ((= L 0) (CONS FR TO)) (T (CONS (HAN FR AUX TO (- L 1)) (CONS (HAN FR TO AUX 0) (HAN AUX TO FR (- L 1)))))))
(DEFUN HAN (FR TO AUX L) (COND ((NULL L) (CONS FR TO)) (T (CONS (HAN FR AUX TO (CDR L)) (CONS (HAN FR TO AUX NIL) (HAN AUX TO FR (CDR L)))))))
(DEFUN HAN (FR TO AUX L) (IF (EQ L NIL) (CONS FR TO) (CONS (HAN FR AUX TO (CDR L))
							 (CONS (HAN FR TO AUX NIL) (HAN AUX TO FR (CDR L))))))


>>
(DE (INTERV M N) (COND ((GT M N) NIL)
                    (T (CONS M (INTERV (PLUS M 1) N)))))
==


>>
(DE (FIB N) (COND ((LTE N 2) 1)
               (T (PLUS (FIB (MINUS N 1)) (FIB (MINUS N 2))))))
==


>>
(FIB 30)

>>
(DE (GCD M N) (COND ((GT N M) (GCD N M))
		((EQL N 0) M)
		(T (GCD (MINUS M N) N))))
==



>>
(DE (FPACK) (MODULE (S D SET NEXT)
(SETQ SET #'(LAMBDA (X Y) (MODULE () (SETQ S X) (SETQ D Y))))
(SETQ NEXT #'(LAMBDA () (SETQ S (PLUS S D))))
(CONS SET NEXT)))
==
( EXPR #'( ( LAMBDA NIL ( MODULE ( S D SET NEXT ) ( SETQ SET ( FUNCTION ( LAMBDA ( X Y ) ( MODULE NIL ( SETQ S X ) ( SETQ D Y ) ) ) ) ) ( SETQ NEXT ( FUNCTION ( LAMBDA NIL ( SETQ S ( PLUS S D ) ) ) ) ) ( CONS SET NEXT ) ) )) )



>>
(SETQ RES (FPACK))
==
( #'( ( LAMBDA ( X Y ) ( MODULE NIL ( SETQ S X ) ( SETQ D Y ) ) )) #'( ( LAMBDA NIL ( SETQ S ( PLUS S D ) ) ) ) )

>>
(SETQ RES1 (FPACK))
==
( #'( ( LAMBDA ( X Y ) ( MODULE NIL ( SETQ S X ) ( SETQ D Y ) ) )) #'( ( LAMBDA NIL ( SETQ S ( PLUS S D ) ) ) ) )




>>
(SETQ SET (CAR RES))
==
#'( ( LAMBDA ( X Y ) ( MODULE NIL ( SETQ S X ) ( SETQ D Y ) ) ))


>>
(SETQ NEXT (CDR RES))
==
#'( ( LAMBDA NIL ( SETQ S ( PLUS S D ) ) ))

>>
(SETQ SET1 (CAR RES1))
==
#'( ( LAMBDA ( X Y ) ( MODULE NIL ( SETQ S X ) ( SETQ D Y ) ) ))


>>
(SETQ NEXT1 (CDR RES1))
==
#'( ( LAMBDA NIL ( SETQ S ( PLUS S D ) ) ))


>>
(SET1 12 23)
==
23


>>
(NEXT1)
==
58


>>
(SET 10 20)
==


>>
(DE (SSIN Y) (RSIN Y 0 1 Y 1 1e-6))
==
( EXPR #'( ( LAMBDA ( Y ) ( RSIN Y 0 1 Y 1.00000e-06 ) )) )



>>
(DE (RSIN Y S J TT SIGN EPS)
	(COND ((LTE TT EPS) S)
		(T (RSIN Y (PLUS S (TIMES SIGN TT))
							(PLUS J 2)
										(DIV (TIMES TT Y Y) (TIMES 1.0 (PLUS J 1)
																					(PLUS J 2))) 
				(TIMES -1 SIGN) EPS))))
==




>>
(DE (ARCTAN Y) (TIMES Y (DIV 1 (PLUS 1 (TIMES Y Y))) (ARCTAN1 Y 0 1 1 1e-220#)))
==



>>
(DE (ARCTAN1 Y S J TT EPS)
	(COND ((LTE TT EPS) S)
		(T (ARCTAN1 Y (PLUS S TT)
							(PLUS J 2)
										(TIMES TT (PLUS J 1) Y Y (DIV 1 (PLUS 1 (TIMES Y Y)) (PLUS J 2)))
				EPS))))
==



(DEFUN ARCTAN (Y) (* Y (/ 1 (+ 1 (* Y Y))) (ARCTAN1 Y 0 1 1
 1.0l-220)))
==

(DEFUN ARCTAN1 (Y S J TT EPS) (COND ((<= TT EPS) S) (T (ARCTAN1 Y (+ S TT) (+ J 2) (* TT (+ J 1) Y Y (/ 1 (+ 1 (* Y Y)) (+ J 2))) EPS))))
==


>>
(DE (TC L)
	(COND ((EQP L NIL) NIL)
			(T (MODULE ()
						(TC (CDR L))
						(TC (CDR L))
						(TC (CDR L))
						(TC (CDR L))))))
==

>>
(DE (TT N) (COND ((EQL N 0) 1) (T (TT (MINUS N 1)))))
==


>>
(DE (SUM S TT) (COND ((EQL TT 0) S)
	(T (SUM (PLUS S (PLUS TT 1)) (MINUS TT 1)))))
==