doc/info/pt_BR/Lists.texi

   1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
   2 @c /Lists.texi/1.30/Sat Jun  2 00:12:55 2007/-ko/
   3
   4 @menu
   5 * Introdução a Listas::
   6 * Funções e Variáveis Definidas para Listas::
   7 @end menu
   8
   9 @node Introdução a Listas, Funções e Variáveis Definidas para Listas, Listas, Listas
  10 @section Introdução a Listas
  11
  12 Listas são o bloco básico de construção para Maxima e Lisp.**Todos os outros tipos
  13 de dado como arrays, tabelas desordenadas, números são representados como listas Lisp.
  14 Essas listas Lisp possuem a forma
  15
  16 @example
  17 ((MPLUS) $A 2)
  18 @end example
  19
  20 @noindent
  21 para indicar a expressão @code{a+2}.**No nível um do Maxima poderemos ver
  22 a notação infixa @code{a+2}.**Maxima também tem listas que foram impressas
  23 como
  24
  25 @example
  26 [1, 2, 7, x+y]
  27 @end example
  28
  29 @noindent
  30 para uma lista com 4 elementos.**Internamente isso corresponde a uma lista Lisp
  31 da forma
  32
  33 @example
  34 ((MLIST) 1  2  7  ((MPLUS)  $X $Y ))
  35 @end example
  36
  37 @noindent
  38 O sinalizador que denota o tipo campo de uma expressão Maxima é uma lista
  39 em si mesmo, após ter sido adicionado o simplificador a lista poderá transforma-se
  40
  41 @example
  42 ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
  43 @end example
  44
  45 @node Funções e Variáveis Definidas para Listas,  , Introdução a Listas, Listas
  46 @section Funções e Variáveis Definidas para Listas
  47
  48 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
  49 @c NEEDS CLARIFICATION AND EXAMPLES
  50 @deffn {Função} append (@var{list_1}, ..., @var{list_n})
  51 Retorna uma lista simples dos elementos de @var{list_1} seguidos
  52 pelos elementos de @var{list_2}, ....  @code{append} também trabalha sobre
  53 expressões gerais, e.g. @code{append (f(a,b), f(c,d,e));} retorna
  54 @code{f(a,b,c,d,e)}.
  55
  56 Faça @code{example(append);} para um exemplo.
  57
  58 @end deffn
  59
  60 @c NEEDS CLARIFICATION AND EXAMPLES
  61 @deffn {Função} assoc (@var{key}, @var{list}, @var{default})
  62 @deffnx {Função} assoc (@var{key}, @var{list})
  63 Essa função procura pela chave @var{key} do lado esquerdo da entrada @var{list}
  64 que é da forma @code{[x,y,z,...]} onde cada elemento de @var{list} é uma expressão de
  65 um operando binário e 2 elementos.  Por exemplo @code{x=1}, @code{2^3}, @code{[a,b]} etc.
  66 A chave @var{key} é verificada contra o primeiro operando.  @code{assoc} retorna o segundo
  67 operando se @code{key} for achada.  Se a chave @code{key} não for achada isso
  68 retorna o valor padrão @var{default}.  @var{default} é opcional
  69 e o padrão é @code{false}.
  70
  71 @end deffn
  72
  73 @c REPHRASE
  74 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
  75 @deffn {Função} atom (@var{expr})
  76 Retorna @code{true} se @var{expr} for atomica (i.e. um número, nome ou seq@"{u}ência de caracteres) de outra forma retorna
  77 @code{false}.  Desse modo @code{atom(5)} é @code{true} enquanto @code{atom(a[1])} e @code{atom(sin(x))} São
  78 @code{false} (assumindo @code{a[1]} e @code{x} não estão associados).
  79
  80 @end deffn
  81
  82 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
  83 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
  84 @deffn {Função} cons (@var{expr}, @var{list})
  85 Retorna uma nova lista construída do elemento @var{expr} como
  86 seu primeiro elemento, seguido por elementos de @var{list}.  @code{cons} também trabalha
  87 sobre outras expressões, e.g. @code{cons(x, f(a,b,c));}  ->  @code{f(x,a,b,c)}.
  88
  89 @end deffn
  90
  91 @deffn {Função} copylist (@var{list})
  92 Retorna uma cópia da lista @var{list}.
  93
  94 @end deffn
  95
  96 @deffn {Função} create_list (@var{form}, @var{x_1}, @var{list_1}, ..., @var{x_n}, @var{list_n})
  97
  98 Cria uma lista por avaliação de @var{form} com @var{x_1} associando a
  99 cada elemento @var{list_1}, e para cada tal associação anexa @var{x_2}
 100 para cada elemento de @var{list_2}, ....
 101 O número de elementos no resultado será
 102 o produto do número de elementos de cada lista.
 103 Cada variável @var{x_i} pode atualmente ser um síbolo --o qual não pode ser avaliado.
 104 A lista de argumentos será avaliada uma única vez no início do bloco de
 105 repetição.
 106
 107 @example
 108 (%i82) create_list1(x^i,i,[1,3,7]);
 109 (%o82) [x,x^3,x^7]
 110 @end example
 111
 112 @noindent
 113 Com um bloco de repetição duplo:
 114
 115 @example
 116 (%i79) create_list([i,j],i,[a,b],j,[e,f,h]);
 117 (%o79) [[a,e],[a,f],[a,h],[b,e],[b,f],[b,h]]
 118 @end example
 119
 120 Em lugar de @var{list_i} dois argumentos podem ser fornecidos cada um dos quais será
 121 avaliado como um número.   Esses podem vir a ser inclusive o limite inferior e
 122 superior do bloco de repetição.
 123
 124 @example
 125 (%i81) create_list([i,j],i,[1,2,3],j,1,i);
 126 (%o81) [[1,1],[2,1],[2,2],[3,1],[3,2],[3,3]]
 127 @end example
 128
 129 Note que os limites ou lista para a variável @code{j} podem
 130 depender do valor corrente de @code{i}.
 131
 132 @end deffn
 133
 134 @deffn {Função} delete (@var{expr_1}, @var{expr_2})
 135 @deffnx {Função} delete (@var{expr_1}, @var{expr_2}, @var{n})
 136 Remove todas as ocorrências de @var{expr_1} em @var{expr_2}. @var{expr_1}
 137 pode ser uma parcela de @var{expr_2} (se isso for uma adição) ou um fator de @var{expr_2}
 138 (se isso for um produto).
 139
 140 @c ===beg===
 141 @c delete(sin(x), x+sin(x)+y);
 142 @c ===end===
 143 @example
 144 (%i1) delete(sin(x), x+sin(x)+y);
 145 (%o1)                         y + x
 146
 147 @end example
 148
 149 @code{delete(@var{expr_1}, @var{expr_2}, @var{n})} remove as primeiras @var{n} ocorrências de
 150 @var{expr_1} em @var{expr_2}.  Se houver menos que @var{n}
 151 ocorrências de @var{expr_1} em @var{expr_2} então todas as corrências seram excluídas.
 152
 153 @c ===beg===
 154 @c delete(a, f(a,b,c,d,a));
 155 @c delete(a, f(a,b,a,c,d,a), 2);
 156 @c ===end===
 157 @example
 158 (%i1) delete(a, f(a,b,c,d,a));
 159 (%o1)                      f(b, c, d)
 160 (%i2) delete(a, f(a,b,a,c,d,a), 2);
 161 (%o2)                     f(b, c, d, a)
 162
 163 @end example
 164
 165 @end deffn
 166
 167 @deffn {Função} eighth (@var{expr})
 168 Retorna o oitavo item de uma expressão ou lista @var{expr}.
 169 Veja @code{first} para maiores detalhes.
 170
 171 @end deffn
 172
 173 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
 174 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
 175 @deffn {Função} endcons (@var{expr}, @var{list})
 176 Retorna uma nova lista consistindo de elementos de
 177 @code{list} seguidos por @var{expr}.  @code{endcons} também trabalha  sobre expressões gerais, e.g.
 178 @code{endcons(x, f(a,b,c));}  ->  @code{f(a,b,c,x)}.
 179
 180 @end deffn
 181
 182 @deffn {Função} fifth (@var{expr})
 183 Retorna o quinto item da expressão ou lista @var{expr}.
 184 Veja @code{first} para maiores detalhes.
 185
 186 @end deffn
 187
 188 @c NEEDS CLARIFICATION AND EXAMPLES
 189 @deffn {Função} first (@var{expr})
 190 Retorna a primeira parte de @var{expr} que pode resultar no primeiro
 191 elemento de uma lista, a primeira linha de uma matriz, a primeira parcela de uma adição,
 192 etc.  Note que @code{first} e suas funções relacionadas, @code{rest} e @code{last}, trabalham
 193 sobre a forma de @var{expr} que é mostrada não da forma que é digitada na
 194 entrada.  Se a variável @code{inflag} é escolhida para @code{true} todavia, essa
 195 funções olharão  na forma interna de @var{expr}.  Note que o
 196 simplificador re-ordena expressões.  Desse modo @code{first(x+y)} será @code{x} se @code{inflag}
 197 for @code{true} e @code{y} se @code{inflag} for @code{false} (@code{first(y+x)} fornece os mesmos
 198 resultados).  As funções @code{second} .. @code{tenth} retornam da segunda até a
 199 décima parte do seu argumento.
 200
 201 @end deffn
 202
 203 @deffn {Função} fourth (@var{expr})
 204 Retorna o quarto item da expressão ou lista @var{expr}.
 205 Veja @code{first} para maiores detalhes.
 206
 207 @end deffn
 208
 209 @deffn {Função} get (@var{a}, @var{i})
 210 Recupera a propriedade de usuário indicada por @var{i} associada com
 211 o átomo @var{a} ou retorna @code{false} se "a" não tem a propriedade @var{i}.
 212
 213 @code{get} avalia seus argumentos.
 214
 215 @c ===beg===
 216 @c put (%e, 'transcendental, 'type);
 217 @c put (%pi, 'transcendental, 'type)$
 218 @c put (%i, 'algebraic, 'type)$
 219 @c typeof (expr) := block ([q],
 220 @c         if numberp (expr)
 221 @c         then return ('algebraic),
 222 @c         if not atom (expr)
 223 @c         then return (maplist ('typeof, expr)),
 224 @c         q: get (expr, 'type),
 225 @c         if q=false
 226 @c         then errcatch (error(expr,"is not numeric.")) else q)$
 227 @c typeof (2*%e + x*%pi);
 228 @c typeof (2*%e + %pi);
 229 @c ===end===
 230 @example
 231 (%i1) put (%e, 'transcendental, 'type);
 232 (%o1)                    transcendental
 233 (%i2) put (%pi, 'transcendental, 'type)$
 234 (%i3) put (%i, 'algebraic, 'type)$
 235 (%i4) typeof (expr) := block ([q],
 236         if numberp (expr)
 237         then return ('algebraic),
 238         if not atom (expr)
 239         then return (maplist ('typeof, expr)),
 240         q: get (expr, 'type),
 241         if q=false
 242         then errcatch (error(expr,"is not numeric.")) else q)$
 243 (%i5) typeof (2*%e + x*%pi);
 244 x is not numeric.
 245 (%o5)  [[transcendental, []], [algebraic, transcendental]]
 246 (%i6) typeof (2*%e + %pi);
 247 (%o6)     [transcendental, [algebraic, transcendental]]
 248
 249 @end example
 250
 251 @end deffn
 252
 253 @deffn {Função} join (@var{l}, @var{m})
 254 Cria uma nova lista contendo os elementos das lista @var{l} e @var{m}, intercaladas.
 255 O resultado tem os elementos @code{[@var{l}[1], @var{m}[1], @var{l}[2], @var{m}[2], ...]}.
 256 As listas @var{l} e @var{m} podem conter qualquer tipo de elementos.
 257
 258 Se as listas forem de diferentes comprimentos, @code{join} ignora elementos da lista mais longa.
 259
 260 Maxima reclama se @var{l} ou @var{m} não for uma lista.
 261
 262 Exemplos:
 263
 264 @c ===beg===
 265 @c L1: [a, sin(b), c!, d - 1];
 266 @c join (L1, [1, 2, 3, 4]);
 267 @c join (L1, [aa, bb, cc, dd, ee, ff]);
 268 @c ===end===
 269 @example
 270 (%i1) L1: [a, sin(b), c!, d - 1];
 271 (%o1)                [a, sin(b), c!, d - 1]
 272 (%i2) join (L1, [1, 2, 3, 4]);
 273 (%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
 274 (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
 275 (%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]
 276 @end example
 277
 278 @end deffn
 279
 280 @c NEEDS EXAMPLES
 281 @c HOW IS "LAST" PART DETERMINED ??
 282 @deffn {Função} last (@var{expr})
 283 Retorna a última parte (parcela, linha, elemento, etc.) de @var{expr}.
 284
 285 @end deffn
 286
 287 @c NEEDS CLARIFICATION AND EXAMPLES
 288 @deffn {Função} length (@var{expr})
 289 Retorna (por padrão) o número de partes na forma
 290 externa (mostrada) de @var{expr}.  Para listas isso é o número de elementos,
 291 para matrizes isso é o número de linhas, e para adições isso é o número
 292 de parcelas (veja @code{dispform}).
 293
 294 O comando @code{length} é afetado pelo comutador
 295 @code{inflag}.  Então, e.g. @code{length(a/(b*c));} retorna 2 se
 296 @code{inflag} for @code{false} (Assumindo @code{exptdispflag} sendo @code{true}), mas 3 se @code{inflag} for
 297 @code{true} (A representação interna é essencialmente @code{a*b^-1*c^-1}).
 298
 299 @end deffn
 300
 301 @defvr {Variável de opção} listarith
 302 Valor padrão: @code{true} - se @code{false} faz com que quaisquer operações aritméticas
 303 com listas sejam suprimidas; quando @code{true}, operações lista-matriz são
 304 contagiosas fazendo com que listas sejam convertidas para matrizes retornando um resultado
 305 que é sempre uma matriz.  Todavia, operações lista-lista podem retornar
 306 listas.
 307
 308 @end defvr
 309
 310 @deffn {Função} listp (@var{expr})
 311 Retorna @code{true} se @var{expr} for uma lista de outra forma retorna @code{false}.
 312
 313 @end deffn
 314
 315 @deffn {Função} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})
 316 @deffnx {Função} makelist (@var{expr}, @var{x}, @var{list})
 317 Constrói e retorna uma lista,
 318 cada elemento dessa lista é gerado usando @var{expr}.
 319
 320 @code{makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})} retorna uma lista,
 321 o @code{j}'ésimo elemento dessa lista é igual a @code{ev (@var{expr}, @var{i}=j)}
 322 para @code{j} variando de @var{i_0} até @var{i_1}.
 323
 324 @code{makelist (@var{expr}, @var{x}, @var{list})} retorna uma lista,
 325 o @code{j}'ésimo elemento é igual a @code{ev (@var{expr}, @var{x}=@var{list}[j])}
 326 para @code{j} variando de 1 até @code{length (@var{list})}.
 327
 328 Exemplos:
 329
 330 @c ===beg===
 331 @c makelist(concat(x,i),i,1,6);
 332 @c makelist(x=y,y,[a,b,c]);
 333 @c ===end===
 334 @example
 335 (%i1) makelist(concat(x,i),i,1,6);
 336 (%o1)               [x1, x2, x3, x4, x5, x6]
 337 (%i2) makelist(x=y,y,[a,b,c]);
 338 (%o2)                 [x = a, x = b, x = c]
 339
 340 @end example
 341
 342 @end deffn
 343
 344 @deffn {Função} member (@var{expr_1}, @var{expr_2})
 345
 346 Retorna @code{true} se @code{is(@var{expr_1} = @var{a})}
 347 para algum elemento @var{a} em @code{args(@var{expr_2})},
 348 de outra forma retorna @code{false}.
 349
 350 @code{expr_2} é tipicamente uma lista,
 351 nesse caso @code{args(@var{expr_2}) = @var{expr_2}}
 352 e @code{is(@var{expr_1} = @var{a})} para algum elemento @var{a} em @code{expr_2} é o teste.
 353
 354 @code{member} não inspeciona partes dos argumentos de @code{expr_2},
 355 então @code{member} pode retornar @code{false} mesmo se @code{expr_1} for uma parte de algum argumento de @code{expr_2}.
 356
 357 Veja também @code{elementp}.
 358
 359 Exemplos:
 360
 361 @c ===beg===
 362 @c member (8, [8, 8.0, 8b0]);
 363 @c member (8, [8.0, 8b0]);
 364 @c member (b, [a, b, c]);
 365 @c member (b, [[a, b], [b, c]]);
 366 @c member ([b, c], [[a, b], [b, c]]);
 367 @c F (1, 1/2, 1/4, 1/8);
 368 @c member (1/8, %);
 369 @c member ("ab", ["aa", "ab", sin(1), a + b]);
 370 @c ===end===
 371 @example
 372 (%i1) member (8, [8, 8.0, 8b0]);
 373 (%o1)                         true
 374 (%i2) member (8, [8.0, 8b0]);
 375 (%o2)                         false
 376 (%i3) member (b, [a, b, c]);
 377 (%o3)                         true
 378 (%i4) member (b, [[a, b], [b, c]]);
 379 (%o4)                         false
 380 (%i5) member ([b, c], [[a, b], [b, c]]);
 381 (%o5)                         true
 382 (%i6) F (1, 1/2, 1/4, 1/8);
 383                                1  1  1
 384 (%o6)                     F(1, -, -, -)
 385                                2  4  8
 386 (%i7) member (1/8, %);
 387 (%o7)                         true
 388 (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
 389 (%o8)                         true
 390 @end example
 391
 392 @end deffn
 393
 394 @deffn {Função} ninth (@var{expr})
 395 Retorna o nono item da expressão ou lista @var{expr}.
 396 Veja @code{first} para maiores detalhes.
 397
 398 @end deffn
 399
 400 @c NEEDS EXAMPLES
 401 @deffn {Função} rest (@var{expr}, @var{n})
 402 @deffnx {Função} rest (@var{expr})
 403 Retorna @var{expr} com seus primeiros @var{n} elementos removidos se @var{n} for
 404 positivo e seus últimos @code{- @var{n}} elementos removidos se @var{n} for negativo.  Se @var{n} for 1
 405 isso pode ser omitido.  @var{expr} pode ser uma lista, matriz, ou outra expressão.
 406
 407 @end deffn
 408
 409 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
 410 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
 411 @deffn {Função} reverse (@var{list})
 412 Ordem reversa para os membros de @var{list} (não
 413 os membros em si mesmos).  @code{reverse} também trabalha sobre expressões gerais,
 414 e.g.  @code{reverse(a=b);} fornece @code{b=a}.
 415
 416 @end deffn
 417
 418 @deffn {Função} second (@var{expr})
 419 Retorna o segundo item da expressão ou lista @var{expr}.
 420 Veja @code{first} para maiores detalhes.
 421
 422 @end deffn
 423
 424 @deffn {Função} seventh (@var{expr})
 425 Retorna o sétimo item da expressão ou lista @var{expr}.
 426 Veja @code{first} para maiores detalhes.
 427
 428 @end deffn
 429
 430 @deffn {Função} sixth (@var{expr})
 431 Retorna o sexto item da expressão ou lista @var{expr}.
 432 Veja @code{first} para maiores detalhes.
 433
 434 @end deffn
 435
 436 @deffn {Função} sublist_indices (@var{L}, @var{P})
 437
 438 Retorna os índices dos elementos @code{x} da lista @var{L} para os quais
 439 o predicado @code{maybe(@var{P}(x))} retornar @code{true};
 440 isso inclui @code{unknown} bem como @code{false}.
 441 @var{P} pode ser um nome de função ou uma expressão lambda.
 442 @var{L} deve ser uma lista literal.
 443
 444 Exemplos:
 445 @c ===beg===
 446 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b));
 447 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
 448 @c sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity);
 449 @c assume (x < -1);
 450 @c map (maybe, [x > 0, x < 0, x < -2]);
 451 @c sublist_indices ([x > 0, x < 0, x < -2], identity);
 452 @c ===end===
 453
 454 @example
 455 (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b));
 456 (%o1)                     [2, 3, 7, 9]
 457 (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
 458 (%o2)                  [1, 2, 3, 4, 7, 9]
 459 (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity);
 460 (%o3)                       [1, 4, 5]
 461 (%i4) assume (x < -1);
 462 (%o4)                       [x < - 1]
 463 (%i5) map (maybe, [x > 0, x < 0, x < -2]);
 464 (%o5)                [false, true, unknown]
 465 (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
 466 (%o6)                          [2]
 467 @end example
 468
 469 @end deffn
 470
 471 @deffn {Função} tenth (@var{expr})
 472 Retorna o décimo item da expressão ou lista @var{expr}.
 473 Veja @code{first} para maiores detalhes.
 474
 475 @end deffn
 476
 477 @deffn {Função} third (@var{expr})
 478 Retorna o terceiro item da expressão ou lista @var{expr}.
 479 Veja @code{first} para maiores detalhes.
 480
 481 @end deffn
 482
 483