@c /Lists.texi/1.28/Mon Jan  8 04:17:44 2007/-ko/
@menu
* Introdução a Listas::
* Definições para Listas::
@end menu

@node Introdução a Listas, Definições para Listas, Listas, Listas
@section Introdução a Listas

Listas são o bloco básico de construção para Maxima e Lisp.**Todos os outros tipos
de dado como arrays, tabelas desordenadas, números são representados como listas Lisp.
Essas listas Lisp possuem a forma

@example
((MPLUS) $A 2)
@end example

@noindent
para indicar a expressão @code{a+2}.**No nível um do Maxima poderemos ver
a notação infixa @code{a+2}.**Maxima também tem listas que foram impressas
como

@example
[1, 2, 7, x+y]
@end example

@noindent
para uma lista com 4 elementos.**Internamente isso corresponde a uma lista Lisp
da forma

@example
((MLIST) 1  2  7  ((MPLUS)  $X $Y ))
@end example

@noindent
O sinalizador que denota o tipo campo de uma expressão Maxima é uma lista
em si mesmo, após ter sido adicionado o simplificador a lista poderá transforma-se

@example
((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
@end example

@node Definições para Listas,  , Introdução a Listas, Listas
@section Definições para Listas

@c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
@c NEEDS CLARIFICATION AND EXAMPLES
@deffn {Função} append (@var{list_1}, ..., @var{list_n})
Retorna uma lista simples dos elementos de @var{list_1} seguidos
pelos elementos de @var{list_2}, ....  @code{append} também trabalha sobre
expressões gerais, e.g. @code{append (f(a,b), f(c,d,e));} retorna
@code{f(a,b,c,d,e)}.

Faça @code{example(append);} para um exemplo.

@end deffn

@c NEEDS CLARIFICATION AND EXAMPLES
@deffn {Função} assoc (@var{key}, @var{list}, @var{default})
@deffnx {Função} assoc (@var{key}, @var{list})
Essa função procura pela chave @var{key} do lado esquerdo da entrada @var{list}
que é da forma @code{[x,y,z,...]} onde cada elemento de @var{list} é uma expressão de
um operando binário e 2 elementos.  Por exemplo @code{x=1}, @code{2^3}, @code{[a,b]} etc.
A chave @var{key} é verificada contra o primeiro operando.  @code{assoc} retorna o segundo
operando se @code{key} for achada.  Se a chave @code{key} não for achada isso
retorna o valor padrão @var{default}.  @var{default} é opcional
e o padrão é @code{false}.

@end deffn

@c REPHRASE
@c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
@deffn {Função} atom (@var{expr})
Retorna @code{true} se @var{expr} for atomica (i.e. um número, nome ou sequência de caracteres) de outra forma retorna
@code{false}.  Desse modo @code{atom(5)} é @code{true} enquanto @code{atom(a[1])} e @code{atom(sin(x))} São
@code{false} (assumindo @code{a[1]} e @code{x} não estão associados).

@end deffn

@c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
@c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
@deffn {Função} cons (@var{expr}, @var{list})
Retorna uma nova lista construída do elemento @var{expr} como
seu primeiro elemento, seguido por elementos de @var{list}.  @code{cons} também trabalha
sobre outras expressões, e.g. @code{cons(x, f(a,b,c));}  ->  @code{f(x,a,b,c)}.

@end deffn

@deffn {Função} copylist (@var{list})
Retorna uma cópia da lista @var{list}.

@end deffn

@deffn {Função} create_list (@var{form}, @var{x_1}, @var{list_1}, ..., @var{x_n}, @var{list_n})

Cria uma lista por avaliação de @var{form} com @var{x_1} associando a
cada elemento @var{list_1}, e para cada tal associação anexa @var{x_2}
para cada elemento de @var{list_2}, ....
O número de elementos no resultado será
o produto do número de elementos de cada lista.
Cada variável @var{x_i} pode actualmente ser um síbolo --o qual não pode ser avaliado.
A lista de argumentos será avaliada uma única vez no início do bloco de 
repetição.  

@example
(%i82) create_list1(x^i,i,[1,3,7]);
(%o82) [x,x^3,x^7]
@end example

@noindent
Com um bloco de repetição duplo:

@example
(%i79) create_list([i,j],i,[a,b],j,[e,f,h]);
(%o79) [[a,e],[a,f],[a,h],[b,e],[b,f],[b,h]]
@end example

Em lugar de @var{list_i} dois argumentos podem ser fornecidos cada um dos quais será
avaliado como um número.   Esses podem vir a ser inclusive o limite inferior e
superior do bloco de repetição.   

@example
(%i81) create_list([i,j],i,[1,2,3],j,1,i);
(%o81) [[1,1],[2,1],[2,2],[3,1],[3,2],[3,3]]
@end example

Note que os limites ou lista para a variável @var{j} podem
depender do valor corrente de @var{i}.

@end deffn

@deffn {Função} delete (@var{expr_1}, @var{expr_2})
@deffnx {Função} delete (@var{expr_1}, @var{expr_2}, @var{n})
Remove todas as ocorrências de @var{expr_1} em @var{expr_2}. @var{expr_1}
pode ser uma parcela de @var{expr_2} (se isso for uma adição) ou um factor de @var{expr_2}
(se isso for um produto).

@c ===beg===
@c delete(sin(x), x+sin(x)+y);
@c ===end===
@example
(%i1) delete(sin(x), x+sin(x)+y);
(%o1)                         y + x

@end example

@code{delete(@var{expr_1}, @var{expr_2}, @var{n})} remove as primeiras @var{n} ocorrências de
@var{expr_1} em @var{expr_2}.  Se houver menos que @var{n}
ocorrências de @var{expr_1} em @var{expr_2} então todas as corrências seram excluídas.

@c ===beg===
@c delete(a, f(a,b,c,d,a));
@c delete(a, f(a,b,a,c,d,a), 2);
@c ===end===
@example
(%i1) delete(a, f(a,b,c,d,a));
(%o1)                      f(b, c, d)
(%i2) delete(a, f(a,b,a,c,d,a), 2);
(%o2)                     f(b, c, d, a)

@end example

@end deffn

@deffn {Função} eighth (@var{expr})
Retorna o oitavo item de uma expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
@c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
@deffn {Função} endcons (@var{expr}, @var{list})
Retorna uma nova lista consistindo de elementos de
@code{list} seguidos por @var{expr}.  @code{endcons} também trabalha  sobre expressões gerais, e.g.
@code{endcons(x, f(a,b,c));}  ->  @code{f(a,b,c,x)}.

@end deffn

@deffn {Função} fifth (@var{expr})
Retorna o quinto item da expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@c NEEDS CLARIFICATION AND EXAMPLES
@deffn {Função} first (@var{expr})
Retorna a primeira parte de @var{expr} que pode resultar no primeiro
elemento de uma lista, a primeira linha de uma matriz, a primeira parcela de uma adição,
etc.  Note que @code{first} e suas funções relacionadas, @code{rest} e @code{last}, trabalham
sobre a forma de @var{expr} que é mostrada não da forma que é digitada na
entrada.  Se a variável @code{inflag} é escolhida para @code{true} todavia, essa
funções olharão  na forma interna de @var{expr}.  Note que o
simplificador re-ordena expressões.  Desse modo @code{first(x+y)} será @code{x} se @code{inflag}
for @code{true} e @code{y} se @code{inflag} for @code{false} (@code{first(y+x)} fornece os mesmos
resultados).  As funções @code{second} .. @code{tenth} retornam da segunda até a
décima parte do seu argumento.

@end deffn

@deffn {Função} fourth (@var{expr})
Retorna o quarto item da expressõ ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@deffn {Função} get (@var{a}, @var{i})
Recupera a propriedade de utilizador indicada por @var{i} associada com
o átomo @var{a} ou retorna @code{false} se "a" não tem a propriedade @var{i}.

@code{get} avalia seus argumentos.

@c ===beg===
@c put (%e, 'transcendental, 'type);
@c put (%pi, 'transcendental, 'type)$
@c put (%i, 'algebraic, 'type)$
@c typeof (expr) := block ([q],
@c         if numberp (expr)
@c         then return ('algebraic),
@c         if not atom (expr)
@c         then return (maplist ('typeof, expr)),
@c         q: get (expr, 'type),
@c         if q=false
@c         then errcatch (error(expr,"is not numeric.")) else q)$
@c typeof (2*%e + x*%pi);
@c typeof (2*%e + %pi);
@c ===end===
@example
(%i1) put (%e, 'transcendental, 'type);
(%o1)                    transcendental
(%i2) put (%pi, 'transcendental, 'type)$
(%i3) put (%i, 'algebraic, 'type)$
(%i4) typeof (expr) := block ([q],
        if numberp (expr)
        then return ('algebraic),
        if not atom (expr)
        then return (maplist ('typeof, expr)),
        q: get (expr, 'type),
        if q=false
        then errcatch (error(expr,"is not numeric.")) else q)$
(%i5) typeof (2*%e + x*%pi);
x is not numeric.
(%o5)  [[transcendental, []], [algebraic, transcendental]]
(%i6) typeof (2*%e + %pi);
(%o6)     [transcendental, [algebraic, transcendental]]

@end example

@end deffn

@deffn {Função} join (@var{l}, @var{m})
Cria uma nova lista contendo os elementos das lista @var{l} e @var{m}, intercaladas.
O resultado tem os elementos @code{[@var{l}[1], @var{m}[1], @var{l}[2], @var{m}[2], ...]}.
As listas @var{l} e @var{m} podem conter qualquer tipo de elementos.

Se as listas forem de diferentes comprimentos, @code{join} ignora elementos da lista mais longa.

Maxima reclama se @var{L_1} ou @var{L_2} não for uma lista.

Exemplos:

@c ===beg===
@c L1: [a, sin(b), c!, d - 1];
@c join (L1, [1, 2, 3, 4]);
@c join (L1, [aa, bb, cc, dd, ee, ff]);
@c ===end===
@example
(%i1) L1: [a, sin(b), c!, d - 1];
(%o1)                [a, sin(b), c!, d - 1]
(%i2) join (L1, [1, 2, 3, 4]);
(%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
(%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
(%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]
@end example

@end deffn

@c NEEDS EXAMPLES
@c HOW IS "LAST" PART DETERMINED ??
@deffn {Função} last (@var{expr})
Retorna a última parte (parcela, linha, elemento, etc.) de @var{expr}.

@end deffn

@c NEEDS CLARIFICATION AND EXAMPLES
@deffn {Função} length (@var{expr})
Retorna (por padrão) o número de partes na forma
externa (mostrada) de @var{expr}.  Para listas isso é o número de elementos,
para matrizes isso é o número de linhas, e para adições isso é o número
de parcelas (veja @code{dispform}).

O comando @code{length} é afectado pelo comutador
@code{inflag}.  Então, e.g. @code{length(a/(b*c));} retorna 2 se
@code{inflag} for @code{false} (Assumindo @code{exptdispflag} sendo @code{true}), mas 3 se @code{inflag} for
@code{true} (A representação interna é essencialmente @code{a*b^-1*c^-1}).

@end deffn

@defvr {Variável de opção} listarith
Valor por omissão: @code{true} - se @code{false} faz com que quaisquer operações aritméticas
com listas sejam suprimidas; quando @code{true}, operações lista-matriz são
contagiosas fazendo com que listas sejam convertidas para matrizes retornando um resultado
que é sempre uma matriz.  Todavia, operações lista-lista podem retornar
listas.

@end defvr

@deffn {Função} listp (@var{expr})
Retorna @code{true} se @var{expr} for uma lista de outra forma retorna @code{false}.

@end deffn

@deffn {Função} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})
@deffnx {Função} makelist (@var{expr}, @var{x}, @var{list})
Constrói e retorna uma lista,
cada elemento dessa lista é gerado usando @var{expr}.

@code{makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})} retorna uma lista,
o @code{j}'ésimo elemento dessa lista é igual a @code{ev (@var{expr}, @var{i}=j)}
para @code{j} variando de @var{i_0} até @var{i_1}.

@code{makelist (@var{expr}, @var{x}, @var{list})} retorna uma lista,
o @code{j}'ésimo elemento é igual a @code{ev (@var{expr}, @var{x}=@var{list}[j])}
para @code{j} variando de 1 até @code{length (@var{list})}.

Exemplos:

@c ===beg===
@c makelist(concat(x,i),i,1,6);
@c makelist(x=y,y,[a,b,c]);
@c ===end===
@example
(%i1) makelist(concat(x,i),i,1,6);
(%o1)               [x1, x2, x3, x4, x5, x6]
(%i2) makelist(x=y,y,[a,b,c]);
(%o2)                 [x = a, x = b, x = c]

@end example

@end deffn

@deffn {Função} member (@var{expr_1}, @var{expr_2})

Retorna @code{true} se @code{is(@var{expr_1} = @var{a})}
para algum elemento @var{a} em @code{args(@var{expr_2})},
de outra forma retorna @code{false}.

@code{expr_2} é tipicamente uma lista,
nesse caso @code{args(@var{expr_2}) = @var{expr_2}}
e @code{is(@var{expr_1} = @var{a})} para algum elemento @var{a} em @code{expr_2} é o teste.

@code{member} não inspeciona partes dos argumentos de @code{expr_2},
então @code{member} pode retornar @code{false} mesmo se @code{expr_1} for uma parte de algum argumento de @code{expr_2}.

Veja também @code{elementp}.

Exemplos:

@c ===beg===
@c member (8, [8, 8.0, 8b0]);
@c member (8, [8.0, 8b0]);
@c member (b, [a, b, c]);
@c member (b, [[a, b], [b, c]]);
@c member ([b, c], [[a, b], [b, c]]);
@c F (1, 1/2, 1/4, 1/8);
@c member (1/8, %);
@c member ("ab", ["aa", "ab", sin(1), a + b]);
@c ===end===
@example
(%i1) member (8, [8, 8.0, 8b0]);
(%o1)                         true
(%i2) member (8, [8.0, 8b0]);
(%o2)                         false
(%i3) member (b, [a, b, c]);
(%o3)                         true
(%i4) member (b, [[a, b], [b, c]]);
(%o4)                         false
(%i5) member ([b, c], [[a, b], [b, c]]);
(%o5)                         true
(%i6) F (1, 1/2, 1/4, 1/8);
                               1  1  1
(%o6)                     F(1, -, -, -)
                               2  4  8
(%i7) member (1/8, %);
(%o7)                         true
(%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
(%o8)                         true
@end example

@end deffn

@deffn {Função} ninth (@var{expr})
Retorna o nono item da expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@c NEEDS EXAMPLES
@deffn {Função} rest (@var{expr}, @var{n})
@deffnx {Função} rest (@var{expr})
Retorna @var{expr} com seus primeiros @var{n} elementos removidos se @var{n} for
positivo e seus últimos @code{- @var{n}} elementos removidos se @var{n} for negativo.  Se @var{n} for 1
isso pode ser omitido.  @var{expr} pode ser uma lista, matriz, ou outra expressão.

@end deffn

@c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
@c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
@deffn {Função} reverse (@var{list})
Ordem reversa para os membros de @var{list} (não
os membros em si mesmos).  @code{reverse} também trabalha sobre expressões gerais,
e.g.  @code{reverse(a=b);} fornece @code{b=a}.

@end deffn

@deffn {Função} second (@var{expr})
Retorna o segundo item da expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@deffn {Função} seventh (@var{expr})
Retorna o sétimo item da expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@deffn {Função} sixth (@var{expr})
Retorna o sexto item da expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@deffn {Função} sublist_indices (@var{L}, @var{P})

Retorna os índices dos elementos @code{x} da lista @var{L} para os quais
o predicado @code{maybe(@var{P}(x))} retornar @code{true};
isso inclui @code{unknown} bem como @code{false}.
@var{P} pode ser um nome de função ou uma expressão lambda.
@var{L} deve ser uma lista literal.

Exemplos:
@c ===beg===
@c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b));
@c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
@c sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity);
@c assume (x < -1);
@c map (maybe, [x > 0, x < 0, x < -2]);
@c sublist_indices ([x > 0, x < 0, x < -2], identity);
@c ===end===

@example
(%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b));
(%o1)                     [2, 3, 7, 9]
(%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
(%o2)                  [1, 2, 3, 4, 7, 9]
(%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity);
(%o3)                       [1, 4, 5]
(%i4) assume (x < -1);
(%o4)                       [x < - 1]
(%i5) map (maybe, [x > 0, x < 0, x < -2]);
(%o5)                [false, true, unknown]
(%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
(%o6)                          [2]
@end example

@end deffn

@deffn {Função} tenth (@var{expr})
Retorna o décimo item da expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn

@deffn {Função} third (@var{expr})
Retorna o terceiro item da expressão ou lista @var{expr}.
Veja @code{first} para maiores detalhes.

@end deffn


