exemplos_lisp

Prévia do material em texto

-----------------------------------------------------------------
EXEMPLOS DE CAR E CDR PARA A DECOMPOSIÇÃO DE PARES-COM-PONTOS
-----------------------------------------------------------------
Usar o símbolo 'apóstrofo' é só uma abreviatura do 'quote'
[1]> (car '(a b))
A
[2]> (car (quote(a b)))
A
[1]> (car '(4 5 6 7))
4
[5]> (cdr '(4 5 6 7))
(5 6 7)
[6]> (car '(a . 4))
A
[6]> (cdr '(a . 4))
4
-----------------------------------------------------------------
EXEMPLOS DE CONS PARA A CONSTRUÇÃO DE PARES-COM-PONTOS
-----------------------------------------------------------------
[6]> (cons 'a 'b)
(A . B)
[6]> (cons '1 '(a b))
(1 A B)
-----------------------------------------------------------------
Qual o resultado das expressões abaixo?
-----------------------------------------------------------------
[7]> (car '((a b c d)))
(A B C D)
[7]> (cdr '((a b c d)))
NIL
[7]> (car (cdr (car (cdr '((((a b) (c d)) (e f)) (g h))))))
H
-----------------------------------------------------------------
Maneira de não avaliar a primeira expressão. Use 'crase' no início e após 
a primeira vírgula, tudo é avaliado. Antes da vírgula, nada é avaliado.
-----------------------------------------------------------------
[4]> `(list (+ 1 2), (+ 2 3))
(LIST (+ 1 2) 5)
-----------------------------------------------------------------
Podemos usar um mesmo símbolo para mais de um objetivo. Nesse caso, xxx 
é definido como uma função. Depois, podemos criar uma constante xxx com 
valor igual a 5.
-----------------------------------------------------------------
[5]> (defun xxx (x) (+ 1 x))
XXX
[7]> (setf xxx 5)
5
[7]> (xxx 2)
3
[7]> (xxx (+ (xxx 5) 3))
10
[7]> (+ 4 xxx)
9
[7]> (xxx xxx)
6
-----------------------------------------------------------------
FUNÇÃO QE RETORNA O MAIOR ENTRE DOIS NÚMEROS
-----------------------------------------------------------------
(defun maior (x y) (if (> x y) x y))
-----------------------------------------------------------------
FUNÇÕES QUE RETORNA AS RAÍZES DE UMA EQUAÇÃO DO 2 GRAU.
-----------------------------------------------------------------
(defun disc (a b c) (- (* b b) (* 4 a c)))
(defun raizes (a b c) (if (>= (disc a b c) 0) (cons (raiz1 a b c) 
 (cons (raiz2 a b c) ())) (cons (preal a b c) (cons (pimag a b c) ()))))
(defun raiz1 (a b c) (/ (+ (- b) (sqrt (disc a b c))) (* 2 a)))
(defun raiz2 (a b c) (/ (- (- b) (sqrt (disc a b c))) (* 2 a)))
(defun preal (a b c) (/ (- b) (* 2 a)))
(defun pimag (a b c) (/ (sqrt (- (disc a b c))) (* 2 a)))
(raizes 4 5 6)
-----------------------------------------------------------------
FUNÇÕES QUE USAM COND
-----------------------------------------------------------------
(defun maior (x y) (cond ((> x y) x) (t y)))
(defun maior3 (x y z) (cond ((and (>= x y) (>= x z)) x) 
 ((and (>= y x) (>= y z)) y)
 ((and (>= z x) (>= z y)) z)))
-----------------------------------------------------------------
ATRIBUINDO VALORES A SÍMBOLOS
-----------------------------------------------------------------
Números inteiros muito grandes
[16]> (* 2 (expt 10 50))
200000000000000000000000000000000000000000000000000
Colocando em uma variável
[16]> (setf a (* 2 (expt 10 50)))
200000000000000000000000000000000000000000000000000
[16]> (* a a)
40000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000
[16]> (* a a a a a a a)
12800000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000
[17]> (setf b (* a a a a a a a a a a a a a))
81920000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000
[17]> (* b b b b b b b)
[17]> (expt b 200)
[18]> (setf c (expt b 200))
[18]> c
[20]> (log c)
301138.25
[21]> (mod c 7)
2
[22]> (mod c 9)
4
-----------------------------------------------------------------
RECURSÃO
-----------------------------------------------------------------
-----------------------------------------------------------------
Criando a função FATORIAL:
-----------------------------------------------------------------
Break 1 [7]> (defun fat (n) (if (= n 0) 1 (* n (fat (1- n)))))
FAT
Break 1 [7]> (fat 5)
120
Break 1 [7]> (fat 10)
3628800
Break 1 [7]> (fat 20)
2432902008176640000
Break 1 [7]> (fat 300)
30605751221644063603537046129726862938858880417357699941677674125947653317671686
7
46551529142247757334993914788870172636886426390775900315422684292790697455984122
5
47693027195460400801221577625217685425596535690350678872526432189626429936520457
6
44883038890975394348962543605322598077652127082243763944912012867867536830571229
3
68194364995646049816645022771650018517654646934011222603472972406633325858350687
0
15016979416885035375213755491028912640715715483028228493795263658014523523315693
6
48223343679925459409527682060806223281238738388081704960000000000000000000000000
0
000000000000000000000000000000000000000000000000
-----------------------------------------------------------------
Função recursiva para somar números inteiros de 1 a n.
-----------------------------------------------------------------
Break 1 [7]> (defun soma (n) (if (= n 0) 0 (+ n (soma (1- n)))))
SOMA
Break 1 [7]> (soma 5)
15
-----------------------------------------------------------------
Função que conta o número de itens em uma lista.
-----------------------------------------------------------------
[7]> (defun my-count (item lista) (if (null lista) 0 (+ (my-count item (cdr 
lista)) 
 (if (eq item (car lista)) 1 0))))
[8]> (defun my-count (item lista) (if (null lista) 0 (+ (my-count item (cdr 
lista)) 
 (if (equal item (car lista)) 1 0))))
USAR ESSA ABAIXO:
[10]> (defun my-count (item lista) (if (null lista) 0 (+ (my-count item (cdr 
lista)) 
 (if (equal item (car lista)) 1 0))))
MY-COUNT
-----------------------------------------------------------------
Função que recursivamente conta quantos inteiros positivos existem em uma lista.
-----------------------------------------------------------------
CONTPOS
Break 1 [7]> (defun contpos (lista) (if (null lista) 0 (if (> (car lista) 0) 
(+ 1 (contpos (cdr lista))) (contpos (cdr lista)))))
CONTPOS
Break 1 [7]> (contpos '(-1 5 0 8 -2 7))
3
-----------------------------------------------------------------
Função que recursivamente conta quantos inteiros positivos existem em uma
lista. Dessa vez, ao invés de if, usa cond.
-----------------------------------------------------------------
[7]> (defun contpos_cond (lista) (cond ((null lista) 0) ((> (car lista) 0) 
(1+ (contpos_cond (cdr lista)))) (t (contpos_cond (cdr lista)))))
CONTPOS_COND
[7]> (contpos_cond '(-1 5 0 -2 7))
2
[7]> (contpos_cond '(-1 5 0 8 -2 7))
3
-----------------------------------------------------------------
Função somaaux, que nada mais é que a função soma implementada de modo 
diferente.
-----------------------------------------------------------------
[7]> (defun somaaux (n acc) (if (= n 0) acc (somaaux (1- n) (+ n acc))))
SOMAAUX
[7]> (somaaux 50)
15
[7]> (somaaux 10 0)
55
-----------------------------------------------------------------
Função que retorna a última caixa de uma lista.
-----------------------------------------------------------------
[30]> (defun last-box (lista) (if (null lista) () (if (null (cdr lista)) lista 
(last-box (cdr lista)))))
LAST-BOX
[33]> (defun my-last (lista) (element-at lista (length lista)))
MY-LAST
[33]> (defun my-last (lista) (if (equal (cdr lista) null) (car lista) (my-last 
(cdr lista))))
MY-LAST
[34]> (defun my-last (lista) (if (equal (cdr lista) nil) (car lista) (my-last 
(cdr lista))))
MY-LAST
[34]> (my-last '(5 0 4 3 10))
10
[34]> (my-last '(5 0 4 (3 10)))
(3 10)
[34]> (defun my-last (lista) (if (equal (cdr lista) nil) lista (my-last (cdr 
lista))))
MY-LAST
[34]> (my-last '(5 0 4 (3 10)))
((3 10))
[31]> (last-box '(5 0 4 3 10))
(10)
[31]> (last-box '(5 0 4 (3 10)))
((3 10))
-----------------------------------------------------------------
Operadores: + e *
Soma e Multiplica qualquer quantidade de argumentos
-----------------------------------------------------------------
[1]> (*)
1
[2]> (+)
0
-----------------------------------------------------------------
Operadores: - e /
Subtração e Divisão do primeiro elemento pelos demais, um a um.
-----------------------------------------------------------------
[4]> (- 3)
-3
[5]> (- -3)
3
[5]> (- 5 3)
2
[5]> (- 10 1 2 4)
3
[6]> (/ 3)
1/3
[6]> (/ 3 6)
1/2
[6]> (/ 6 3)
2
[6]> (/ 6 3 2)
1
-----------------------------------------------------------------
Funçoes Aritméticas
-----------------------------------------------------------------
[6]> (floor 4.5)
4 ;
0.5
[6]> (floor -2.5)
-3 ;
0.5
[6]> (ceiling 5.5)
6 ;
-0.5
[6]> (ceiling -5.5)
-5 ;
-0.5
[6]> (truncate 1.5)
1 ;
0.5
[6]> (truncate -1.5)
-1 ;
-0.5
[30]> (multiple-value-list (truncate 3.4))
(3 0.4000001)
[6]> (round 4.75)
5 ;
-0.25
[6]> (round 4.25)
4 ;
0.25
[6]> (round 4.5)
4 ;
0.5
[6]> (round 0.5)
0 ;
0.5
[6]> (round 5.5)
6 ;
-0.5
-----------------------------------------------------------------
Funções 1+ e 1-
-----------------------------------------------------------------
[7]> (1+ 4)
5
[7]> (1- 4)
3
-----------------------------------------------------------------
Máximo Divisor Comum
-----------------------------------------------------------------
[7]> (gcd 7 6)
1
[7]> (gcd 7 8)
1
[7]> (gcd 7 9)
1
-----------------------------------------------------------------
Mínimo Múltiplo Comum
-----------------------------------------------------------------
[7]> (lcm 7 15)
105
[7]> (lcm 7 10)
70
[7]> (lcm 7 7)
7
-----------------------------------------------------------------
Valor Absoluto
-----------------------------------------------------------------
[7]> (abs -6)
6
[7]> (abs 6)
6
-----------------------------------------------------------------
Exponenciais: neperiano elevado a x (e^x) e x elevado a y (x^y)
-----------------------------------------------------------------
[8]> (exp 6)
403.4288
[8]> (exp 5)
148.41316
[8]> (expt 2 2)
4
-----------------------------------------------------------------
Logaritmos: log de x na base neperiana (1 parâmetro) e log de x na base 
y (2 parâmetros)
-----------------------------------------------------------------
[8]> (log 3)
1.0986123
[8]> (log 3 4)
0.79248124
-----------------------------------------------------------------
Seno, Cosseno, Tangente, Arco-seno, Arco-cosseno, Arco-tangente, Seno 
hiperbólico, Cosseno hiperbólico, Tangente hiperbólica, Arco-seno 
hiperbólico, Arco-cosseno hiperbólico e Arco-tangente hiperbólica.
-----------------------------------------------------------------
[8]> (sin 90)
0.89399666
-----------------------------------------------------------------
PI já é uma constante pré-definida em LISP:
-----------------------------------------------------------------
[9]> (- pi)
-3.1415926535897932385L0
-----------------------------------------------------------------
Números complexos
-----------------------------------------------------------------
[13]> #c(0 1)
#C(0 1)
realpart
realimag
[14]> (sqrt -1)
#C(0 1)
[14]> (sqrt -4)
#C(0 2)
[14]> (sqrt -3)
#C(0 1.7320508)
-----------------------------------------------------------------
Funções min e max de uma lista
-----------------------------------------------------------------
[14]> (min 5 6 9 -1 0 -4 100)
-4
-----------------------------------------------------------------
Variáveis semi-aleatórias
-----------------------------------------------------------------
[31]> (random 49)
22
[31]> (random 49)
44
-----------------------------------------------------------------
Exemplo de função incr que usa &optional
-----------------------------------------------------------------
(defun incr (x &optional (i 1))(+ x i))
> (incr 10)
11
> (incr 10 5)
15
-----------------------------------------------------------------
Exemplo de soma usando número arbitrário de argumentos: &rest indica que 
a função terá número arbitrário de parâmetros.
-----------------------------------------------------------------
[1]> (defun soma (&rest args) (soma_aux args))
SOMA
[2]> (defun soma_aux (lista) (if (null lista) 0 (+ (car lista) (soma_aux (cdr 
lista)))))
SOMA_AUX
[5]> (soma 5 4 6 3 -1)
17
[5]> (soma_aux '(5 4 6 3 -1))
17
-----------------------------------------------------------------
Exemplo de operadores lógicos
-----------------------------------------------------------------
[5]> (or nil t)
T
[5]> (or nil nil nil nil t)
T
[5]> (or nil nil nil nil nil)
NIL
[5]> (and nil t nil nil nil)
NIL
[5]> (and t t nil nil nil)
NIL
[5]> (and t t)
T
[5]> (and )
T
[5]> (or )
NIL
[5]> (not t )
NIL
[5]> (not nil)
T
-----------------------------------------------------------------
Exemplos do predicado ATOM
-----------------------------------------------------------------
[5]> (atom 5)
T
[5]> (atom t)
T
-----------------------------------------------------------------
Função que determina o MDC.
-----------------------------------------------------------------
[12]> (defun mdc (a b) (if (= b 0) a (mdc b (mod a b))))
MDC
[12]> (mdc 7 6)
1
-----------------------------------------------------------------
Função que retorna o n-ésimo número da lista (nth item lista)
-----------------------------------------------------------------
[2]> (nth 2 '(4 5 6 7 9))
6
[2]> (nth 0 '(4 5 6 7 9))
4
[3]> (defun my-length (l) (if (null l) 0 (1+ (my-length (cdr l)))))
MY-LENGTH
-----------------------------------------------------------------
Retorna o n-ésimo elemento de uma lista. Os índices começam de zero.
-----------------------------------------------------------------
(defun my-nth (indice lista) (if (= indice 0) (car lista)
(my-nth (1- indice) (cdr lista)) ) )
-----------------------------------------------------------------
Função que retorna o reverso de uma lista
-----------------------------------------------------------------
[3]> (reverse '(1 2 3 4 5 6))
(6 5 4 3 2 1)
-----------------------------------------------------------------
Função que retorna o último elemento de uma lista
-----------------------------------------------------------------
[3]> (last '(1 2 3 4 5 6))
(6)
-----------------------------------------------------------------
Função que retorna o segundo elemento de uma lista
-----------------------------------------------------------------
[3]> (second '(1 2 3 4 5 6))
2
-----------------------------------------------------------------
Função que retorna o quinto elemento de uma lista
-----------------------------------------------------------------
[3]> (fifth '(1 2 3 4 5 6))
5
-----------------------------------------------------------------
Função que cria uma lista
-----------------------------------------------------------------[3]> (list 1 2 3 4 5 6 7 8 9)
(1 2 3 4 5 6 7 8 9)
Nossa função para criar uma lista
[3]> (defun my-list (&rest args) args)
MY-LIST
[3]> (my-list 10 11 12 13)
(10 11 12 13)
-----------------------------------------------------------------
Função que concatena duas ou mais listas
-----------------------------------------------------------------
[3]> (append '(a b c) '(d e f)) 
(A B C D E F)
-----------------------------------------------------------------
Diferença de cons, list e append
-----------------------------------------------------------------
[3]> (cons '(a b c) '(d e f))
((A B C) D E F)
[3]> (list '(a b c) '(d e f))
((A B C) (D E F))
[3]> (append '(a b c) '(d e f))
(A B C D E F)
-----------------------------------------------------------------
Função que substitui o segundo parâmetro pelo primeiro, dentro da
expressão do terceiro parâmetro
-----------------------------------------------------------------
[3]> (subst 'a 'b '(a b c))
(A A C)
Errado:
[3]> (subst '(a b) '(x y) '((a b) (x y) (x (y))))
((A B) (X Y) (X (Y)))
Correto:
[15]> (subst '(a b) '(x y) '((a b) (x y) (x (y))) :test 'equal)
((A B) (A B) (X (Y)))
-----------------------------------------------------------------
Função que verifica se um item está contido na lista
-----------------------------------------------------------------
[3]> (member 4 '(5 6 7 8 9))
NIL
[3]> (member 8 '(5 6 7 8 9))
(8 9)
[3]> (member 6 '(5 6 7 8 9))
(6 7 8 9)
[3]> (member 'x '(a b c (d e x)))
NIL
-----------------------------------------------------------------
Nossa função que busca um membro na lista.
-----------------------------------------------------------------
[8]> (defun my-member (item l) (cond ((null l) nil) ((equal item (first l)) l) 
(t (my-member item (cdr l)))))
MY-MEMBER
[9]> (my-member '4 '(5 4 6 7))
(4 6 7)
-----------------------------------------------------------------
Função que retorna a posição de um item na lista.
-----------------------------------------------------------------
[9]> (position '4 '(5 4 6 7))
1
[9]> (position '5 '(5 4 6 7))
0
-----------------------------------------------------------------
Função que conta a quantidade de um item da lista.
-----------------------------------------------------------------
[9]> (count '5 '(5 4 6 7 5 5))
3
-----------------------------------------------------------------
Função que retorna uma subsequência na lista. 
(subseq lista inicio &opcional-fim)
-----------------------------------------------------------------
[10]> (subseq '(5 4 3 2 1) '2)
(3 2 1)
[11]> (subseq '(5 4 3 2 1) '3)
(2 1)
[11]> (subseq '(5 4 3 2 1) '4)
(1)
[11]> (subseq '(5 4 3 2 1) '5)
NIL
-----------------------------------------------------------------
Função que remove todas as ocorrências de um item na lista
-----------------------------------------------------------------
[11]> (remove '4 '(5 4 3 2 1))
(5 3 2 1)
[11]> (remove '4 '(5 4 4 4 3 2 1))
(5 3 2 1)
-----------------------------------------------------------------
Função que aplica outra função em uma lista.
(mapcar função lista)
-----------------------------------------------------------------
[12]> (mapcar '1+ '(1 2 3))
(2 3 4)
[15]> (mapcar '1- '(1 2 3))
(0 1 2)
Nossa própria função my-mapcar:
[15]> (defun my-mapcar (f l) (if (null l) () (cons (funcall f (car l)) 
(my-mapcar f (cdr l)))))
MY-MAPCAR
[15]> (my-mapcar '1+ '(1 2 3))
(2 3 4)
-----------------------------------------------------------------
CONJUNTOS
-----------------------------------------------------------------
[1]> (union '(4 5 6 7) '(3 4 5 6))
(7 3 4 5 6)
[2]> (defun my-union (l1 l2) (cond ((null l1) l2) ((member (car l1) l2) 
(my-union (cdr l1) l2)) (t (cons (car l1) (my-union (cdr l1) l2)))))
MY-UNION
[3]> (my-union '(4 5 6 7) '(3 4 5 6))
(7 3 4 5 6)
[4]> (my-union '(4 5 6 7) '(1 2 3 4))
(5 6 7 1 2 3 4)
[5]> (intersection '(4 5 6 7) '(1 2 3 4))
(4)
[6]> (intersection '(4 5 6 7) '(3 4 5 6))
(4 5 6)
[7]> (defun my-intersec (l1 l2) (cond ((null l1) ()) ((member (car l1) l2) (cons
(car l1) (my-intersec (cdr l1) l2))) (t (my-intersec (cdr l1) l2))))
MY-INTERSEC
[8]> (my-intersec '(4 5 6 7) '(3 4 5 6))
(4 5 6)
[9]> (my-intersec '(4 5 6 7) '(1 2 3 4))
(4)
[10]> (set-difference '(4 5 6 7) '(3 4 5))
(6 7)
[11]> (subsetp '(4 5 6 7) '(1 2 3 4 5 6 7 8 9 10 11))
T
[12]> (subsetp '(4 5 6 12) '(1 2 3 4 5 6 7 8 9 10 11))
NIL
-----------------------------------------------------------------
Empacotar elementos consecutivos iguais em sublistas
-----------------------------------------------------------------
IDEIA
(pack '( a a a b c c)) => ((a a a) (b) (c c))
 f
(a a a b) -----------------> ((a a a) (b))
cdr
 f
(a a b) -----------------> ((a a) (b))
Caso em que elemento é igual ao próximo:
(let ((res-ant (pack (cdr lista)))
 (cons (cons (car lista) (first res-ant)) (cdr res-ant)
Se elemento não é igual ao próximo:
(cons (list (car lista)) (pack (cdr lista)))
(defun pack (lista) 
 (cond ((null lista) ()) 
 ((or (null (cdr lista))
 (not (equal (first lista) (second lista))))
 (cons (list (car lista)) (pack (cdr lista))))
 (t (let ((res-ant (pack (cdr lista))))
 (cons (cons (car lista) (first res-ant)) (cdr res-ant))))
 )
)
-----------------------------------------------------------------
flatten: "achatar" uma estrutura de lista
-----------------------------------------------------------------
IDEIA
(flatten '(a (b) (c (d) e))) -=> (a b c d e)
 f
(a (b) c) -----------------> (a b c)
cdr ?
 f
((b) c) -----------------> (b c)
(cons (car lista) (flatten (cdr lista))
(append (flatten (car lista)) (flatten (cdr lista)))
(defun flatten (lista)
 (cond ((null lista) lista)
 ((atom (car lista)) (cons (car lista) (flatten (cdr lista))))
 (t (append (flatten (car lista)) (flatten (cdr lista))))
 )
)
-----------------------------------------------------------------
ARRAYS
-----------------------------------------------------------------
[13]> (make-array '(4 3 7))
#3A(((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL)))
[15]> (setf mat (make-array '(4 3 7)))
#3A(((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL)))
[15]> (aref mat 2 1 6)
NIL
[15]> (setf (aref mat 1 1 1) 0)
0
[15]> mat
#3A(((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL 0 NIL NIL NIL NIL NIL) (NIL NIL NIL NIL 
NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL)))
[15]> (setf (aref mat 0 0 0) 0)
0
[15]> mat
#3A(((0 NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL 
NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL 0 NIL NIL NIL NIL NIL) (NIL NIL NIL NIL 
NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NILNIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL)))
[16]> (setf (aref mat 2 2 2) 0)
0
[16]> mat
#3A(((0 NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL 
NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL 0 NIL NIL NIL NIL NIL) (NIL NIL NIL NIL 
NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL 0 NIL 
NIL NIL NIL))
 ((NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL NIL NIL NIL NIL) (NIL NIL NIL 
NIL NIL NIL NIL)))