doc/info/pt_BR/Lists.texi.update

   1 @c
   2 @c versao pt_BR baseada no md5sum abaixo:
   3 @c 5b5c718aee36d662677111cae1133bf1  Lists.texi
   4 @c
   5 @c -----------------------------------------------------------------------------
   6 @page
   7 @node Lists, Arrays, Constants, Data Types and Structures
   8 @section Lists
   9 @c -----------------------------------------------------------------------------
  10
  11 @menu
  12 * Introduction to Lists::
  13 * Functions and Variables for Lists::
  14 @end menu
  15
  16 @c -----------------------------------------------------------------------------
  17 @node Introduction to Lists, Functions and Variables for Lists, Lists, Lists
  18 @subsection Introduction to Lists
  19 @c -----------------------------------------------------------------------------
  20
  21 Listas s@~{a}o o bloco b@'{a}sico de constru@,{c}@~{a}o para o Maxima e para o Lisp.  Todos os tipos de dados
  22 que n@~{a}o vetores est@'{a}ticos, tabelas hash e n@'{u}meros s@~{a}o representados como listas Lisp,
  23 Essas listas Lisp possuem a forma
  24
  25 @example
  26 ((MPLUS) $A 2)
  27 @end example
  28
  29 @noindent
  30 para indicar para indicar uma express@~{a}o @code{a+2}.  A n@'{i}vel de Maxima se pode ver
  31 a nota@,{c}@~{a}o com infixo @code{a+2}.  Maxima tamb@'{e}m tem listas que s@~{a}o mostradas
  32 como
  33
  34 @example
  35 [1, 2, 7, x+y]
  36 @end example
  37
  38 @noindent
  39 para uma lista com 4 elementos.  Internamente essa lista de 4 elementos corresponde a uma lista Lisp
  40 da forma
  41
  42 @example
  43 ((MLIST) 1  2  7  ((MPLUS)  $X $Y ))
  44 @end example
  45
  46 @noindent
  47 O sinalizador que denota o tipo de campo da express@~{a}o do Maxima @'{e} uma lista
  48 propriamente dita, uma vez que essa lista tenha estado no simplificador a lista pode tornar-se
  49
  50 @example
  51 ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
  52 @end example
  53
  54 @c -----------------------------------------------------------------------------
  55 @node Functions and Variables for Lists,  , Introduction to Lists, Lists
  56 @subsection Functions and Variables for Lists
  57 @c -----------------------------------------------------------------------------
  58
  59 @c -----------------------------------------------------------------------------
  60 @anchor{[}
  61 @anchor{]}
  62 @fnindex Delimitadores de lista
  63 @fnindex Operador de subscrito
  64
  65 @defvr  {Operador} [
  66 @defvrx {Operador} ]
  67
  68 Os operadores @code{[} e @code{]} delimitam o in@'{i}cio e o fim, respectivamente, de uma lista.
  69
  70 Os operadores @code{[} e @code{]} tamb@'{e}m delimitam os subscritos de
  71 uma lista, vetor est@'{a}tico, vetor est@'{a}tico hash, ou fun@,{c}@~{a}o de vetor est@'{a}tico.
  72
  73 Exemplos:
  74
  75 @c ===beg===
  76 @c x: [a, b, c];
  77 @c x[3];
  78 @c array (y, fixnum, 3);
  79 @c y[2]: %pi;
  80 @c y[2];
  81 @c z['foo]: 'bar;
  82 @c z['foo];
  83 @c g[k] := 1/(k^2+1);
  84 @c g[10];
  85 @c ===end===
  86 @example
  87 @group
  88 (%i1) x: [a, b, c];
  89 (%o1)                       [a, b, c]
  90 @end group
  91 @group
  92 (%i2) x[3];
  93 (%o2)                           c
  94 @end group
  95 @group
  96 (%i3) array (y, fixnum, 3);
  97 (%o3)                           y
  98 @end group
  99 @group
 100 (%i4) y[2]: %pi;
 101 (%o4)                          %pi
 102 @end group
 103 @group
 104 (%i5) y[2];
 105 (%o5)                          %pi
 106 @end group
 107 @group
 108 (%i6) z['foo]: 'bar;
 109 (%o6)                          bar
 110 @end group
 111 @group
 112 (%i7) z['foo];
 113 (%o7)                          bar
 114 @end group
 115 @group
 116 (%i8) g[k] := 1/(k^2+1);
 117                                   1
 118 (%o8)                     g  := ------
 119                            k     2
 120                                 k  + 1
 121 @end group
 122 @group
 123 (%i9) g[10];
 124                                 1
 125 (%o9)                          ---
 126                                101
 127 @end group
 128 @end example
 129
 130 @opencatbox
 131 @category{Listas} @category{Operadores}
 132 @closecatbox
 133 @end defvr
 134
 135 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
 136 @c NEEDS CLARIFICATION AND EXAMPLES
 137
 138 @c -----------------------------------------------------------------------------
 139 @anchor{append}
 140 @deffn {Fun@,{c}@~{a}o} append (@var{list_1}, @dots{}, @var{list_n})
 141
 142 Retorna uma lista simples contendo os elementos de @var{list_1} seguidos
 143 pelos elementos de @var{list_2}, @dots{}  A fun@,{c}@~{a}o @code{append} tamb@'{e}m funciona sobre
 144 express@~{o}es gerais, e.g. @code{append (f(a,b), f(c,d,e));} retorna
 145 @code{f(a,b,c,d,e)}.
 146
 147 Fa@,{c}a @code{example(append);} para um exemplo.
 148
 149 @opencatbox
 150 @category{Listas} @category{Express@~{o}es}
 151 @closecatbox
 152 @end deffn
 153
 154 @c NEEDS CLARIFICATION AND EXAMPLES
 155
 156 @c -----------------------------------------------------------------------------
 157 @anchor{assoc}
 158 @deffn {Fun@,{c}@~{a}o} assoc @
 159 @fname{assoc} (@var{chave}, @var{lista}, @var{retorno}) @
 160 @fname{assoc} (@var{chave}, @var{lista})
 161
 162 Essa fun@,{c}@~{a}o busca por @var{chave} no lado esquerdo da
 163 @var{lista} de entrada. O argumento @var{lista} deve ser uma lista, cada um dos
 164 elementos dessa lista @'{e} uma express@~{a}o com exatamente duas partes. Na maioria dos casos,
 165 os elementos de @var{lista} s@~{a}o tamb@'{e}m listas, cada lista com dois
 166 elementos.
 167
 168 A fun@,{c}@~{a}o @code{assoc} iterage percorrendo toda @var{lista}, procurando pela
 169 primeira parte de cada elemento que seja igual a @var{chave}. Se um elemento
 170 for encontrado onde a compara@,{c}@~{a}o @'{e} verdadeira, @code{assoc} retorna a segunda
 171 parte daquele elemento. Se n@~{a}o houver tal elemento na lista,
 172 @code{assoc} retorna ou @code{false} ou @var{retorno}, se este for informado.
 173
 174 Por exemplo, na express@~{a}o @code{assoc (y, [[x,1], [y,2],
 175 [z,3]])}, a fun@,{c}@~{a}o @code{assoc} busca por @code{x} no lado
 176 esquerdo da lista @code{[[y,1],[x,2]]} e encontra @code{x} no segundo
 177 termo, retornando @code{2}. Em @code{assoc (z, [[x,1], [z,2], [z,3]])},
 178 a busca para no primeiro termo iniciando com @code{z} e retorna
 179 @code{2}. Em @code{assoc (x, [[y,1]])}, n@~{a}o existe elemento coincidente,
 180 ent@~{a}o @code{assoc} retorna @code{false}.
 181
 182 @c ===beg===
 183 @c assoc (y, [[x,1], [y,2],[z,3]]);
 184 @c assoc (z, [[x,1], [z,2], [z,3]]);
 185 @c assoc (x, [[y,1]]);
 186 @c ===end===
 187 @example
 188 @group
 189 (%i1)                 assoc(y, [[x, 1], [y, 2], [z, 3]])
 190 (%o1)                                  2
 191 @end group
 192 @group
 193 (%i2)                 assoc(z, [[x, 1], [z, 2], [z, 3]])
 194 (%o2)                                  2
 195 @end group
 196 @group
 197 (%i3)                         assoc(x, [[y, 1]])
 198 (%o3)                                false
 199 @end group
 200 @end example
 201
 202 @opencatbox
 203 @category{Listas} @category{Express@~{o}es}
 204 @closecatbox
 205 @end deffn
 206
 207 @c -----------------------------------------------------------------------------
 208 @anchor{cons}
 209 @deffn {Fun@,{c}@~{a}o} cons @
 210 @fname{cons} (@var{expr}, @var{lista}) @
 211 @fname{cons} (@var{expr_1}, @var{expr_2})
 212
 213 O comando @code{cons (@var{expr}, @var{lista})} retorna uma nova lista constru@'{i}da tendo
 214 @var{expr} como seu primeiro elemento, seguido pelos elementos de @var{lista}. @'{E}
 215 an@'{a}loga @`{a} opera@,{c}@~{a}o Lisp de constru@,{c}@~{a}o de linguagem "cons".
 216
 217 A fun@,{c}@~{a}o @code{cons} do Maxima pode tamb@'{e}m ser usada onde o segundo argumento @'{e} outra coisa al@'{e}m
 218 de uma lista. Nesse caso, @code{cons (@var{expr_1}, @var{expr_2})}
 219 retorna uma express@~{a}o com o mesmo operador que @var{expr_2} mas com argumento @code{cons(expr_1, args(expr_2))}.
 220
 221 Exemplos:
 222
 223 @c ===beg===
 224 @c cons(a,[b,c,d])
 225 @c cons(a,f(b,c,d))
 226 @c ===end===
 227 @example
 228 @group
 229 (%i1) cons(a,[b,c,d]);
 230 (%o1)                            [a, b, c, d]
 231 (%i2) cons(a,f(b,c,d));
 232 (%o2)                            f(a, b, c, d)
 233 @end group
 234 @end example
 235
 236 Em geral, @code{cons} aplicada a uma n@~{a}o lista n@~{a}o faz sentido. Por exemplo, @code{cons(a,b^c)}
 237 resulta em uma express@~{a}o ilegal, uma vez que '^' n@~{a}o pode receber tr@^{e}s argumentos.
 238
 239 Quando @code{inflag} for @code{true}, @code{cons} trabalha sobre a estrutura interna de uma express@~{a}o, de outra forma
 240 @code{cons} trabalha sobre a forma exibida na tela. Especialmente quando @code{inflag} for @code{true}, @code{cons} applied
 241 a uma n@~{a}o lista algumas vezes fornece um resultado surpreendente; por exemplo
 242 @c ===beg===
 243 @c cons(a,-a), inflag : true
 244 @c cons(a,-a), inflag : false;
 245 @c ===end===
 246 @example
 247 @group
 248 (%i1) cons(a,-a), inflag : true;
 249                                         2
 250 (%o1)                                - a
 251 (%i2) cons(a,-a), inflag : false;
 252 (%o2)                                  0
 253 @end group
 254 @end example
 255
 256 @opencatbox
 257 @category{Listas} @category{Express@~{o}es}
 258 @closecatbox
 259 @end deffn
 260
 261 @c -----------------------------------------------------------------------------
 262 @anchor{copylist}
 263 @deffn {Fun@,{c}@~{a}o} copylist (@var{lista})
 264
 265 Retorna uma c@'{o}pia da lista @var{lista}.
 266
 267 @opencatbox
 268 @category{Listas}
 269 @closecatbox
 270 @end deffn
 271
 272 @c -----------------------------------------------------------------------------
 273 @anchor{create_list}
 274 @deffn {Fun@,{c}@~{a}o} create_list (@var{formula}, @var{x_1}, @var{list_1}, @dots{}, @var{x_n}, @var{list_n})
 275
 276 Cria uma lista avaliando @var{formula} com @var{x_1} associado a
 277 cada elemento de @var{list_1}, e para cada tal associa@,{c}@~{a}o associa @var{x_2}
 278 a cada elemento de @var{list_2}, @dots{}
 279 O n@'{u}mero de elementos no resultado ir@'{a} ser
 280 o produto do n@'{u}mero de elementos em cada lista.
 281 Cada vari@'{a}vel @var{x_i} deve atualmente ser um s@'{i}mbolo -- esse s@'{i}mbolo n@~{a}o ir@'{a} ser avaliado.
 282 Os argumentos da lista ir@~{a}o ser avaliados uma @'{u}nica vez no in@'{i}cio da
 283 itera@,{c}@~{a}o @footnote{Nota do tradutor: tem-se a f@'{o}rmula da qual fazem
 284 parte as vari@'{a}veis @var{x_1} @dots{} @var{x_n}.
 285 A vari@'{a}vel @var{x_1} varia dentro de @var{list_1}, @dots{},
 286 a vari@'{a}vel @var{x_n} varia dentro de @var{list_n}.}.
 287
 288 @c ===beg===
 289 @c create_list (x^i, i, [1, 3, 7]);
 290 @c ===end===
 291 @example
 292 @group
 293 (%i1) create_list (x^i, i, [1, 3, 7]);
 294                                 3   7
 295 (%o1)                      [x, x , x ]
 296 @end group
 297 @end example
 298
 299 @noindent
 300 Com uma itera@,{c}@~{a}o dupla:
 301
 302 @c ===beg===
 303 @c create_list ([i, j], i, [a, b], j, [e, f, h]);
 304 @c ===end===
 305 @example
 306 @group
 307 (%i1) create_list ([i, j], i, [a, b], j, [e, f, h]);
 308 (%o1)   [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]
 309 @end group
 310 @end example
 311
 312 Ao inv@'{e}s de @var{list_i} dois argumentos podem ser fornecidos cada um dos quais deve
 313 avaliar para um n@'{u}mero.  Esses dois argumentos fornecidos ir@~{a}o ser associados aos limites inferior e superior, respecivamente e
 314 inclusive ambos, da itera@,{c}@~{a}o.
 315
 316 @c ===beg===
 317 @c create_list ([i, j], i, [1, 2, 3], j, 1, i);
 318 @c ===end===
 319 @example
 320 @group
 321 (%i1) create_list ([i, j], i, [1, 2, 3], j, 1, i);
 322 (%o1)   [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]
 323 @end group
 324 @end example
 325
 326 Note que os limites ou lista para a vari@'{a}vel @code{j} pode
 327 depender do valor atual de @code{i}.
 328
 329 @opencatbox
 330 @category{Listas}
 331 @closecatbox
 332 @end deffn
 333
 334 @c -----------------------------------------------------------------------------
 335 @anchor{delete}
 336 @deffn  {Fun@,{c}@~{a}o} delete @
 337 @fname{delete} (@var{expr_1}, @var{expr_2}) @
 338 @fname{delete} (@var{expr_1}, @var{expr_2}, @var{n})
 339
 340 A fun@,{c}@~{a}o usada na forma @code{delete(@var{expr_1}, @var{expr_2})}
 341 remove da @var{expr_2} quaisquer argumentos de seu operador de n@'{i}vel mais alto
 342 que @'{e} o mesmo (como determinado por "=") que se encontra em @var{expr_1}.
 343 Note que "=" testa para a igualdade comum, n@~{a}o para equival@^{e}ncia.
 344 Note tamb@'{e}m que argumentos de subexpress@~{o}es n@~{a}o s@~{a}o afetados.
 345
 346 A @var{expr_1} pode ser um @'{a}tomo ou pode ser uma express@~{a}o n@~{a}o at@^{o}mica.
 347 A @var{expr_2} pode ser uma express@~{a}o n@~{a}o at@^{o}mica.
 348 A fun@,{c}@~{a}o @code{delete} retorna uma nova express@~{a}o;
 349 A fun@,{c}@~{a}o @code{delete} n@~{a}o modifica a @var{expr_2}.
 350
 351 A fun@,{c}@~{a}o usada na forma @code{delete(@var{expr_1}, @var{expr_2}, @var{n})}
 352 remove de @var{expr_2} os primeiros @var{n} argumentos do operador de n@'{i}vel mais alto
 353 que @'{e} o mesmo que se encontra em @var{expr_1}.
 354 Se houverem menos argumentos que os @var{n} informados,
 355 ent@~{a}o todos os argumentos ser@~{a}o removidos.
 356
 357 Exemplos:
 358
 359 Removendo elementos de uma lista.
 360
 361 @c ===beg===
 362 @c delete (y, [w, x, y, z, z, y, x, w]);
 363 @c ===end===
 364 @example
 365 @group
 366 (%i1) delete (y, [w, x, y, z, z, y, x, w]);
 367 (%o1)                  [w, x, z, z, x, w]
 368 @end group
 369 @end example
 370
 371 Removendo parcelas de uma soma.
 372
 373 @c ===beg===
 374 @c delete (sin(x), x + sin(x) + y);
 375 @c ===end===
 376 @example
 377 @group
 378 (%i1) delete (sin(x), x + sin(x) + y);
 379 (%o1)                         y + x
 380 @end group
 381 @end example
 382
 383 Removendo fatores de um produto.
 384
 385 @c ===beg===
 386 @c delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
 387 @c ===end===
 388 @example
 389 @group
 390 (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
 391 (%o1)                (u - w) (u - y) (u - z)
 392 @end group
 393 @end example
 394
 395 Removendo argumentos de uma express@~{a}o arbitr@'{a}ria.
 396
 397 @c ===beg===
 398 @c delete (a, foo (a, b, c, d, a));
 399 @c ===end===
 400 @example
 401 @group
 402 (%i1) delete (a, foo (a, b, c, d, a));
 403 (%o1)                     foo(b, c, d)
 404 @end group
 405 @end example
 406
 407 Limitando o n@'{u}mero de argumentos removidos.
 408
 409 @c ===beg===
 410 @c delete (a, foo (a, b, a, c, d, a), 2);
 411 @c ===end===
 412 @example
 413 @group
 414 (%i1) delete (a, foo (a, b, a, c, d, a), 2);
 415 (%o1)                    foo(b, c, d, a)
 416 @end group
 417 @end example
 418
 419 A fun@,{c}@~{a}o usada na forma @code{delete(@var{expr_1}, @var{expr_2}, @var{n})}
 420 remove de @var{expr_2} os primeiros @var{n} argumentos do operador de n@'{i}vel mais alto
 421 que @'{e} o mesmo que se encontra em @var{expr_1}.
 422 Argumentos que s@~{a}o @code{equal} mas n@~{a}o forem "=" n@~{a}o s@~{a}o removidos.
 423
 424 @c ===beg===
 425 @c [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))];
 426 @c [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
 427 @c delete (0, [0, 0.0, 0b0]);
 428 @c is (equal ((x + y)*(x - y), x^2 - y^2));
 429 @c is ((x + y)*(x - y) = x^2 - y^2);
 430 @c delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
 431 @c ===end===
 432 @example
 433 @group
 434 (%i1) [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))];
 435 rat: replaced 0.0 by 0/1 = 0.0
 436 `rat' replaced 0.0B0 by 0/1 = 0.0B0
 437 (%o1)                  [true, true, true]
 438 @end group
 439 @group
 440 (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
 441 (%o2)                 [true, false, false]
 442 @end group
 443 @group
 444 (%i3) delete (0, [0, 0.0, 0b0]);
 445 (%o3)                     [0.0, 0.0b0]
 446 @end group
 447 @group
 448 (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
 449 (%o4)                         true
 450 @end group
 451 @group
 452 (%i5) is ((x + y)*(x - y) = x^2 - y^2);
 453 (%o5)                         false
 454 @end group
 455 @group
 456 (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
 457                               2    2
 458 (%o6)                       [x  - y ]
 459 @end group
 460 @end example
 461
 462 @opencatbox
 463 @category{Listas} @category{Express@~{o}es}
 464 @closecatbox
 465 @end deffn
 466
 467 @c -----------------------------------------------------------------------------
 468 @anchor{eighth}
 469 @deffn {Fun@,{c}@~{a}o} eighth (@var{expr})
 470
 471 Retorna o oitavo item da express@~{a}o ou lista @var{expr}.
 472 Veja @mref{first}
 473 para maiores detalhes.
 474
 475 @opencatbox
 476 @category{Listas} @category{Express@~{o}es}
 477 @closecatbox
 478 @end deffn
 479
 480 @c -----------------------------------------------------------------------------
 481 @anchor{endcons}
 482 +@deffn  {Fun@,{c}@~{a}o} endcons @
 483 @fname{endcons} (@var{expr}, @var{lista}) @
 484 @fname{endcons} (@var{expr_1}, @var{expr_2})
 485
 486 O comando @code{endcons (@var{expr}, @var{lista})} retorna uma nova lista constru@'{i}da a partir dos elementos de
 487 @var{lista} seguidos por @var{expr}. A fun@,{c}@~{a}o do Maxima @code{endcons} pode tamb@'{e}m ser usada onde
 488 o segundo argumento @'{e} outra coisa al@'{e}m de uma lista e isso pode ser @'{u}til. Nesse caso,
 489 @code{endcons (@var{expr_1}, @var{expr_2})} retorna uma express@~{a}o com o mesmo operador que
 490 @var{expr_2} mas com argumento @code{endcons(expr_1, args(expr_2))}. Exemplos:
 491 @c ===beg===
 492 @c endcons(a,[b,c,d])
 493 @c endcons(a,f(b,c,d))
 494 @c ===end===
 495 @example
 496 @group
 497 (%i1) endcons(a,[b,c,d]);
 498 (%o1)                            [b, c, d, a]
 499 (%i2) endcons(a,f(b,c,d));
 500 (%o2)                            f(b, c, d, a)
 501 @end group
 502 @end example
 503
 504 Em geral, @code{endcons} aplicada a uma n@~{a}o lista n@~{a}o faz sentido. Por exemplo, @code{endcons(a,b^c)}
 505 resulta em uma express@~{a}o ilegal, uma vez que '^' n@~{a}o pode receber tr@^{e}s argumentos.
 506
 507 Quando @code{inflag} for @code{true}, @code{endcons} trabalha sobre a estrutura interna de uma express@~{a}o, de outra forma
 508 @code{endcons} trabalha sobre a forma exibida na tela. Especialmente quando @code{inflag} for @code{true}, @code{endcons} aplicada
 509 a uma n@~{a}o lista algumas vezes fornece resultado surpreendente; por exemplo
 510 @c ===beg===
 511 @c endcons(a,-a), inflag : true
 512 @c endcons(a,-a), inflag : false;
 513 @c ===end===
 514 @example
 515 @group
 516 (%i1) endcons(a,-a),inflag : true;
 517                                         2
 518 (%o1)                                - a
 519 (%i2) endcons(a,-a),inflag : false;
 520 (%o2)                                  0
 521 @end group
 522 @end example
 523
 524 @opencatbox
 525 @category{Listas} @category{Express@~{o}es}
 526 @closecatbox
 527 @end deffn
 528
 529
 530 @c -----------------------------------------------------------------------------
 531 @anchor{fifth}
 532 @deffn {Fun@,{c}@~{a}o} fifth (@var{expr})
 533
 534 Retorna o quinto item da express@~{a}o ou lista @var{expr}.
 535 Veja @mref{first}
 536 para maiores detalhes.
 537
 538 @opencatbox
 539 @category{Listas} @category{Express@~{o}es}
 540 @closecatbox
 541 @end deffn
 542
 543 @c NEEDS CLARIFICATION AND EXAMPLES
 544
 545 @c -----------------------------------------------------------------------------
 546 @anchor{first}
 547 @deffn {Fun@,{c}@~{a}o} first (@var{expr})
 548
 549 Retorna a primeira parte de @var{expr} que pode resultar no primeiro elemento de uma
 550 lista, a primeira linha de uma matriz, a primeira parcela de uma soma, etc.  Note que
 551 @code{first} e suas fun@,{c}@~{o}es semelhantes, @code{rest} e @code{last}, trabalham
 552 sobre a forma de @var{expr} que @'{e} mostrada e n@~{a}o na forma que @'{e} digitada na
 553 entrada.  Se a vari@'{a}vel @mref{inflag}
 554 for ajstada para @code{true} todavia, essas
 555 fun@,{c}@~{o}es ir@~{a}o trabalhar sobre a forma interna de @var{expr}.  Note que o
 556 simplificador reordena express@~{o}es.  Dessa forma @code{first(x+y)} ir@'{a} retornar @code{x} se
 557 @code{inflag} for @code{true} e @code{y} se @code{inflag} for @code{false}
 558 (@code{first(y+x)} retorna o mesmo resultado independentemente do valor de @code{inflag}).  A fun@,{c}@~{a}o @code{second} @dots{}
 559 @code{tenth} retornam da segunda at@'{e} a d@'{e}cima parte de seu argumento de entrada.
 560
 561 @opencatbox
 562 @category{Listas} @category{Express@~{o}es}
 563 @closecatbox
 564 @end deffn
 565
 566 @c -----------------------------------------------------------------------------
 567 @anchor{fourth}
 568 @deffn {Fun@,{c}@~{a}o} fourth (@var{expr})
 569
 570 Retorna o quarto item da express@~{a}o ou lista @var{expr}.
 571 Veja @mref{first}
 572 para maiores detalhes.
 573
 574 @opencatbox
 575 @category{Listas} @category{Express@~{o}es}
 576 @closecatbox
 577 @end deffn
 578
 579 @c -----------------------------------------------------------------------------
 580 @anchor{join}
 581 @deffn {Fun@,{c}@~{a}o} join (@var{l}, @var{m})
 582 \e
 583 Cria uma nova lista contendo elementos das listas @var{l} e @var{m},
 584 interspersed.  The result has elements @code{[@var{l}[1], @var{m}[1],
 585 @var{l}[2], @var{m}[2], ...]}.  The lists @var{l} and @var{m} may contain any
 586 type of elements.
 587
 588 If the lists are different lengths, @code{join} ignores elements of the longer
 589 list.
 590
 591 Maxima complains if @var{l} or @var{m} is not a list.
 592
 593 Exemplos:
 594
 595 @c ===beg===
 596 @c L1: [a, sin(b), c!, d - 1];
 597 @c join (L1, [1, 2, 3, 4]);
 598 @c join (L1, [aa, bb, cc, dd, ee, ff]);
 599 @c ===end===
 600 @example
 601 @group
 602 (%i1) L1: [a, sin(b), c!, d - 1];
 603 (%o1)                [a, sin(b), c!, d - 1]
 604 @end group
 605 @group
 606 (%i2) join (L1, [1, 2, 3, 4]);
 607 (%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
 608 @end group
 609 @group
 610 (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
 611 (%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]
 612 @end group
 613 @end example
 614
 615 @opencatbox
 616 @category{Listas}
 617 @closecatbox
 618 @end deffn
 619
 620 @c NEEDS EXAMPLES
 621 @c HOW IS "LAST" PART DETERMINED ??
 622
 623 @c -----------------------------------------------------------------------------
 624 @anchor{last}
 625 @deffn {Fun@,{c}@~{a}o} last (@var{expr})
 626
 627 retorna a @'{u}ltima parte (termo, linha, elemento, etc.) de @var{expr}.
 628
 629 @opencatbox
 630 @category{Listas} @category{Express@~{o}es}
 631 @closecatbox
 632 @end deffn
 633
 634 @c NEEDS CLARIFICATION AND EXAMPLES
 635
 636 @c -----------------------------------------------------------------------------
 637 @anchor{length}
 638 @deffn {Fun@,{c}@~{a}o} length (@var{expr})
 639
 640 Retorna (por padr@~{a}o) o n@'{u}mero de partes na forma
 641 externa (mostrada) de @var{expr}.  No caso de listas corresponde ao n@'{u}mero de elementos,
 642 para matrizes corresponde ao n@'{u}mero de linhas, e para somas corresponde ao n@'{u}mero de
 643 parcelas (veja @mref{dispform}
 644 ).
 645
 646 A fun@,{c}@~{a}o @code{length} @'{e} afetada pela vari@'{a}vel @mrefdot{inflag}
 647 .  Ent@~{a}o, e.g. @code{length(a/(b*c));} fornece 2 se @code{inflag} for @code{false} (Assumindo
 648 que @mref{exptdispflag}
 649 @'{e} @code{true}), mas 3 se @code{inflag} for @code{true} (a
 650 representa@,{c}@~{a}o interna @'{e} essencialmente @code{a*b^-1*c^-1}).
 651
 652 @opencatbox
 653 @category{Listas} @category{Express@~{o}es}
 654 @closecatbox
 655 @end deffn
 656
 657 @c -----------------------------------------------------------------------------
 658 @anchor{listarith}
 659 @defvr {Vari@'{a}vel de op@,{c}@~{a}o} listarith
 660 Valor padr@~{a}o: @code{true}
 661
 662 Se @code{false} faz com que quaisquer opera@,{c}@~{o}es aritm@'{e}ticas com listas sejam suprimidas;
 663 quando @code{true}, opera@,{c}@~{o}es lista-matriz s@~{a}o contagiosas fazendo com que listas sejam
 664 convertidas em matrizes retornando um resultado que @'{e} sempre uma matriz.  Todavia,
 665 opera@,{c}@~{o}es lista-lista devem retornar listas.
 666
 667 @opencatbox
 668 @category{Listas} @category{Global flags}
 669 @closecatbox
 670 @end defvr
 671
 672 @c -----------------------------------------------------------------------------
 673 @deffn {Fun@,{c}@~{a}o} listp (@var{expr})
 674
 675 Retorna @code{true} se @var{expr} for uma lista e @code{false} caso n@~{a}o seja.
 676
 677 @opencatbox
 678 @category{Listas} @category{Fun@,{c}@~{o}es predicado}
 679 @closecatbox
 680 @end deffn
 681
 682 @c -----------------------------------------------------------------------------
 683 @anchor{makelist}
 684 @deffn  Fun@,{c}@~{a}o{} makelist @
 685 @fname{makelist} () @
 686 @fname{makelist} (@var{expr}, @var{n}) @
 687 @fname{makelist} (@var{expr}, @var{i}, @var{i_max}) @
 688 @fname{makelist} (@var{expr}, @var{i}, @var{i_0}, @var{i_max}) @
 689 @fname{makelist} (@var{expr}, @var{i}, @var{i_0}, @var{i_max}, @var{incr}) @
 690 @fname{makelist} (@var{expr}, @var{x}, @var{lista})
 691
 692 A primeira forma, @code{makelist ()}, cria uma lista vazia. A segunda forma,
 693 @code{makelist (@var{expr})}, cria uma lista com @var{expr} sendo seu @'{u}nico
 694 elemento. A forma @code{makelist (@var{expr}, @var{n})} cria uma lista de @var{n}
 695 elementos gerados a partir de @var{expr}.
 696
 697 A forma mais geral, @code{makelist (@var{expr}, @var{i}, @var{i_0},
 698 @var{i_max}, @var{step})}, retorna a lista de elementos obtidos quando
 699 @code{ev (@var{expr}, @var{i}=@var{j})} @'{e} aplicada aos elementos
 700 @var{j} da sequ@^{e}ncia: @var{i_0}, @var{i_0} + @var{step}, @var{i_0} +
 701 2*@var{step}, ..., com @var{|j|} menor que ou igual a @var{|i_max|}.
 702
 703 O incremento @var{incr} pode ser um n@'{u}mero (positivo ou negativo) ou uma
 704 express@~{a}o. Se fo omitido, o valor padr@~{a}o 1 ir@'{a} ser usado. Se ambos
 705 @var{i_0} e @var{incr} forem omitidos, eles ir@~{a}o ambos terem o valor
 706 padr@~{a}o 1.
 707
 708 @code{makelist (@var{expr}, @var{x}, @var{lista})} retorna uma lista, o
 709 @code{j}'@'{e}simo elemento dessa lista @'{e} igual a
 710 @code{ev (@var{expr}, @var{x}=@var{lista}[j])} para @code{j} variando de 1 a
 711 @code{length (@var{lista})}.
 712
 713 Exemplos:
 714
 715 @c ===beg===
 716 @c makelist (concat (x,i), i, 6);
 717 @c makelist (x=y, y, [a, b, c]);
 718 @c makelist (x^2, x, 3, 2*%pi, 2);
 719 @c makelist (random(6), 4);
 720 @c flatten (makelist (makelist (i^2, 3), i, 4));
 721 @c flatten (makelist (makelist (i^2, i, 3), 4));
 722 @c ===end===
 723 @example
 724 @group
 725 (%i1) makelist (concat (x,i), i, 6);
 726 (%o1)               [x1, x2, x3, x4, x5, x6]
 727 @end group
 728 @group
 729 (%i2) makelist (x=y, y, [a, b, c]);
 730 (%o2)                 [x = a, x = b, x = c]
 731 @end group
 732 @group
 733 (%i3) makelist (x^2, x, 3, 2*%pi, 2);
 734 (%o3)                        [9, 25]
 735 @end group
 736 @group
 737 (%i4) makelist (random(6), 4);
 738 (%o4)                     [2, 0, 2, 5]
 739 @end group
 740 @group
 741 (%i5) flatten (makelist (makelist (i^2, 3), i, 4));
 742 (%o5)        [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]
 743 @end group
 744 @group
 745 (%i6) flatten (makelist (makelist (i^2, i, 3), 4));
 746 (%o6)         [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]
 747 @end group
 748 @end example
 749
 750 @opencatbox
 751 @category{Listas}
 752 @closecatbox
 753 @end deffn
 754
 755 @c -----------------------------------------------------------------------------
 756 @anchor{member}
 757 @deffn {Fun@,{c}@~{a}o} member (@var{expr_1}, @var{expr_2})
 758
 759 Retorna @code{true} se @code{is(@var{expr_1} = @var{a})}
 760 para algum elemento @var{a} em @code{args(@var{expr_2})},
 761 de outra forma retorna @code{false}.
 762
 763 A @code{expr_2} @'{e} tipicamente uma lista, nesse caso
 764 @code{args(@var{expr_2}) = @var{expr_2}} e @code{is(@var{expr_1} = @var{a})}
 765 para algum elemento @var{a} em @code{expr_2} @'{e} testado.
 766
 767 A fun@,{c}@~{a}o @code{member} n@~{a}o inspeciona partes dos elementos de @code{expr_2}, de forma que a fun@,{c}@~{a}o @code{member}
 768 pode retornar @code{false} mesmo que @code{expr_1} seja uma parte de algum argumento de
 769 @code{expr_2}.
 770
 771 Veja tamb@'{e}m @mrefdot{elementp}
 772
 773 Exemplos:
 774
 775 @c ===beg===
 776 @c member (8, [8, 8.0, 8b0]);
 777 @c member (8, [8.0, 8b0]);
 778 @c member (b, [a, b, c]);
 779 @c member (b, [[a, b], [b, c]]);
 780 @c member ([b, c], [[a, b], [b, c]]);
 781 @c F (1, 1/2, 1/4, 1/8);
 782 @c member (1/8, %);
 783 @c member ("ab", ["aa", "ab", sin(1), a + b]);
 784 @c ===end===
 785 @example
 786 @group
 787 (%i1) member (8, [8, 8.0, 8b0]);
 788 (%o1)                         true
 789 @end group
 790 @group
 791 (%i2) member (8, [8.0, 8b0]);
 792 (%o2)                         false
 793 @end group
 794 @group
 795 (%i3) member (b, [a, b, c]);
 796 (%o3)                         true
 797 @end group
 798 @group
 799 (%i4) member (b, [[a, b], [b, c]]);
 800 (%o4)                         false
 801 @end group
 802 @group
 803 (%i5) member ([b, c], [[a, b], [b, c]]);
 804 (%o5)                         true
 805 @end group
 806 @group
 807 (%i6) F (1, 1/2, 1/4, 1/8);
 808                                1  1  1
 809 (%o6)                     F(1, -, -, -)
 810                                2  4  8
 811 @end group
 812 @group
 813 (%i7) member (1/8, %);
 814 (%o7)                         true
 815 @end group
 816 @group
 817 (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
 818 (%o8)                         true
 819 @end group
 820 @end example
 821
 822 @opencatbox
 823 @category{Listas} @category{Express@~{o}es} @category{Fun@,{c}@~{o}es predicado}
 824 @closecatbox
 825 @end deffn
 826
 827 @c -----------------------------------------------------------------------------
 828 @anchor{ninth}
 829 @deffn {Fun@,{c}@~{a}o} ninth (@var{expr})
 830
 831 Retorna o nono item da express@~{a}o ou lista @var{expr}.
 832 Veja @mref{first}
 833 para maiores detalhes.
 834
 835 @opencatbox
 836 @category{Listas} @category{Express@~{o}es}
 837 @closecatbox
 838 @end deffn
 839
 840 @c -----------------------------------------------------------------------------
 841 @anchor{pop}
 842 @deffn {Fun@,{c}@~{a}o} pop (@var{lista})
 843
 844 A fun@,{c}@~{a}o @code{pop} remove e retorna o primeiro elemento da lista @var{lista}. O segundo argumento
 845 @var{lista} deve ser um @mref{mapatom} que est@'{a} associado a uma lista n@~{a}o vazia. Se o argumento @var{lista} n@~{a}o
 846 for associado a uma lista n@~{a}o vazia, Maxima sinaliza um erro. Para exemplos, veja @mref{push}.
 847
 848 @opencatbox
 849 @category{Listas} @category{Express@~{o}es}
 850 @closecatbox
 851 @end deffn
 852
 853 @c -----------------------------------------------------------------------------
 854 @anchor{push}
 855 @deffn {Fun@,{c}@~{a}o} push (@var{item}, @var{lista})
 856
 857 A fun@,{c}@~{a}o @code{push} anexa no in@'{i}cio de uma @var{lista} o item @var{item} e retorna uma c@'{o}pia da nova lista.
 858 O segundo argumento @var{lista} deve ser um @mref{mapatom} que esteja associado a uma lista. O primeiro argumento @var{item}
 859 pode ser qualquer s@'{i}mbolo do Maxima ou express@~{a}o do Maxima. Se o argumento @var{lista} n@~{a}o estiver associado a uma lista, Maxima
 860 sinaliza um erro.
 861
 862 Para remover o primeiro item de uma lista, veja @mref{pop}.
 863
 864 Exemplos:
 865
 866 @c ===beg===
 867 @c ll: [];
 868 @c push (x, ll);
 869 @c push (x^2+y, ll);
 870 @c a: push ("string", ll);
 871 @c pop (ll);
 872 @c pop (ll);
 873 @c pop (ll);
 874 @c ll;
 875 @c a;
 876 @c ===end===
 877 @example
 878 @group
 879 (%i1) ll : [];
 880 (%o1)                                 []
 881 (%i2) push(x,ll);
 882 (%o2)                                 [x]
 883 (%i3) push(x^2+y,ll);
 884                                         2
 885 (%o3)                             [y + x , x]
 886 (%i4) push("string",ll);
 887                                             2
 888 (%o4)                         [string, y + x , x]
 889 (%i5) pop(ll);
 890 (%o5)                               string
 891 (%i6) pop(ll);
 892                                          2
 893 (%o6)                               y + x
 894 (%i7) pop(ll);
 895 (%o7)                                  x
 896 (%i8) ll;
 897 (%o8)                                 []
 898 (%i9)
 899 @end group
 900 @end example
 901
 902 @opencatbox
 903 @category{Listas} @category{Express@~{o}es}
 904 @closecatbox
 905 @end deffn
 906
 907
 908 @c -----------------------------------------------------------------------------
 909 @anchor{rest}
 910 @deffn  {Fun@,{c}@~{a}o} rest @
 911 @fname{rest} (@var{expr}, @var{n}) @
 912 @fname{rest} (@var{expr})
 913
 914 Retorna @var{expr} com seus primeiros @var{n} elementos removidos se @var{n}
 915 for positivo ou seus últimos @code{- @var{n}} elementos removidos se @var{n}
 916 for negativo. Se @var{n} for 1 a explicitação de @var{n} pode ser omitida. O primeiro argumento
 917 @var{expr} pode ser uma lista, matriz, ou outra expressão. Quando @var{expr}
 918 for um @mref{mapatom}, @code{rest} sinaliza um erro; quando @var{expr} for uma lista
 919 vazia e @code{partswitch} for @code{false}, @code{rest} sinaliza um erro. Quando
 920 @var{expr} for uma lista vazia e @code{partswitch} for @code{true}, @code{rest}.
 921 retorna @code{end}.
 922
 923 Aplicando @code{rest} a uma expressão como @code{f(a,b,c)} retorna
 924 @code{f(b,c)}. Em geral, aplicando @code{rest} a algo que não é lista não
 925 faz sentido. Por exemplo, devido a '^' requerer dois argumentos,
 926 @code{rest(a^b)} resulta em uma mesnagem de erro. As funções
 927 @code{args} e @code{op} podem ser também úteis, uma vez que @code{args(a^b)}
 928 retorna @code{[a,b]} e @code{op(a^b)} retorna ^.
 929
 930 @example
 931 @group
 932 (%i1) rest(a+b+c);
 933 (%o1) b+a
 934 (%i2) rest(a+b+c,2);
 935 (%o2) a
 936 (%i3) rest(a+b+c,-2);
 937 (%o3) c
 938 @end group
 939 @end example
 940
 941 @opencatbox
 942 @category{Listas} @category{Express@~{o}es}
 943 @closecatbox
 944 @end deffn
 945
 946 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
 947 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
 948
 949 @c -----------------------------------------------------------------------------
 950 @anchor{reverse}
 951 @deffn {Fun@,{c}@~{a}o} reverse (@var{lista})
 952
 953 Reverte a ordem dos elementos de @var{lista} (n@~{a}o
 954 os membros propriamente ditos).  A fun@,{c}@~{a}o @code{reverse} tamb@'{e}m trabalha sobre express@~{o}es gerais,
 955 e.g.  @code{reverse(a=b);} fornece @code{b=a}.
 956
 957 @opencatbox
 958 @category{Listas} @category{Express@~{o}es}
 959 @closecatbox
 960 @end deffn
 961
 962 @c -----------------------------------------------------------------------------
 963 @anchor{second}
 964 @deffn {Fun@,{c}@~{a}o} second (@var{expr})
 965
 966 Retorna o segundo item da express@~{a}o ou lista @var{expr}.
 967 Veja @mref{first}
 968 para mais detalhes.
 969
 970 @opencatbox
 971 @category{Listas} @category{Express@~{o}es}
 972 @closecatbox
 973 @end deffn
 974
 975 @c -----------------------------------------------------------------------------
 976 @anchor{seventh}
 977 @deffn {Fun@,{c}@~{a}o} seventh (@var{expr})
 978
 979 Retorna o s@'{e}timo item da express@~{a}o ou lista @var{expr}.
 980 Veja @mref{first}
 981 para mais detalhes.
 982
 983 @opencatbox
 984 @category{Listas} @category{Express@~{o}es}
 985 @closecatbox
 986 @end deffn
 987
 988 @c -----------------------------------------------------------------------------
 989 @anchor{sixth}
 990 @deffn {Fun@,{c}@~{a}o} sixth (@var{expr})
 991
 992 Retorna o sexto item da express@~{a}o ou lista @var{expr}.
 993 Veja @mref{first}
 994 para mais detalhes.
 995
 996 @opencatbox
 997 @category{Listas} @category{Express@~{o}es}
 998 @closecatbox
 999 @end deffn
1000
1001 @c -----------------------------------------------------------------------------
1002 @anchor{sort}
1003 @deffn  {Fun@,{c}@~{a}o} sort @
1004 @fname{sort} (@var{L}, @var{P}) @
1005 @fname{sort} (@var{L})
1006
1007 O comando @code{sort(@var{L}, @var{P})} ordena a lista @var{L} conforme o predicado @code{P} de dois argumentos
1008 que definem uma ordena@,{c}@~{a}o estrita fraca @footnote{Nota do tradutor: ordena@,{c}@`{a}o estrita fraca usa o menor/maior
1009 ou igual. A ordena@,{c}@~{a}o estrita forte n@~{a}o tem o igual. Dicotomia e tricotomia.}sobre os elementos de @var{L}.
1010 Se @code{@var{P}(a, b)} for @code{true}, ent@~{a}o @code{a} aparece antes de @code{b} no resultado.
1011 Se nem @code{@var{P}(a, b)} e nem @code{@var{P}(b, a)} forem @code{true},
1012 ent@~{a}o @code{a} e @code{b} s@~{a}o equivalentes, e aparecem no resultado na mesma ordem que aparecem na entrada.
1013 Isto @'{e}, @code{sort} @'{e} uma ordena@,{c}@~{a}o est@'{a}vel.
1014
1015 Se @code{@var{P}(a, b)} e @code{@var{P}(b, a)} forem ambos @code{true} para algum elementos de @var{L},
1016 ent@~{a}o @var{P} n@~{a}o @'{e} um predicado de ordena@,{c}@~{a}o v@'{a}lido, e o resultado @'{e} indefinido.
1017 Se @code{@var{P}(a, b)} for alguma outra coisa al@'{e}m de @code{true} ou @code{false}, @code{sort} sinaliza um erro.
1018
1019 O predicado pode ser um nome de fun@,{c}@~{a}o
1020 ou um operador bin@'{a}rio infixo, ou uma express@~{a}o @code{lambda}.  Se especificado como
1021 o nome de um operador, o nome deve ser informado entre aspas duplas.
1022
1023 A lista ordenada @'{e} retornada como um novo objeto; o argumento @var{L} n@~{a}o @'{e} modificado.
1024
1025 A entrada @code{sort(@var{L})} @'{e} equivalente a @code{sort(@var{L}, orderlessp)}.
1026
1027 A ordem padr@~{a}o de montagem de uma lista @'{e} a ascendente, como determinado por @mrefdot{orderlessp}
1028 O predicado @code{ordergreatp} ordena uma lista em ordem descendente.
1029
1030 Todos os @'{a}tomos e express@~{o}es do Maxima s@~{a}o compar@'{a}veis tanto por @code{orderlessp} quanto por @code{ordergreatp}.
1031
1032 Operadores @code{<} e @code{>} ordenam n@'{u}meros, constantes, e express@~{o}es constantes em magnitude.
1033 Note que @code{orderlessp} e @code{ordergreatp} n@~{a}o ordenam n@'{u}meros, constantes, e nem express@~{o}es constantes em magnitude.
1034
1035 O predicado @code{ordermagnitudep} ordena n@'{u}meros, constantes, e express@~{o}es constantes da mesma forma que @code{<},
1036 e todos os outros elementos da mesma forma que @code{orderlessp}.
1037
1038 Exemplos:
1039
1040 A fun@,{c}@~{a}o @code{sort} ordena uma lista conforme um predicado de dosi argumentos
1041 que definem uma ordem estrita fraca sobre os elementos da lista.
1042
1043 @c ===beg===
1044 @c sort ([1, a, b, 2, 3, c], 'orderlessp);
1045 @c sort ([1, a, b, 2, 3, c], 'ordergreatp);
1046 @c ===end===
1047 @example
1048 @group
1049 (%i1) sort ([1, a, b, 2, 3, c], 'orderlessp);
1050 (%o1)                  [1, 2, 3, a, b, c]
1051 (%i2) sort ([1, a, b, 2, 3, c], 'ordergreatp);
1052 (%o2)                  [c, b, a, 3, 2, 1]
1053 @end group
1054 @end example
1055
1056 O predicado pode ser um nome de fun@,{c}@~{a}o
1057 ou operador bin@'{a}rio infixo, ou uma express@~{a}o @code{lambda}.  Se for
1058 o nome de um operador, o nome deve ser informado entre aspas duplas.
1059
1060 @c ===beg===
1061 @c L : [[1, x], [3, y], [4, w], [2, z]];
1062 @c foo (a, b) := a[1] > b[1];
1063 @c sort (L, 'foo);
1064 @c infix (">>");
1065 @c a >> b := a[1] > b[1];
1066 @c sort (L, ">>");
1067 @c sort (L, lambda ([a, b], a[1] > b[1]));
1068 @c ===end===
1069 @example
1070 @group
1071 (%i1) L : [[1, x], [3, y], [4, w], [2, z]];
1072 (%o1)           [[1, x], [3, y], [4, w], [2, z]]
1073 (%i2) foo (a, b) := a[1] > b[1];
1074 (%o2)                 foo(a, b) := a  > b
1075                                     1    1
1076 (%i3) sort (L, 'foo);
1077 (%o3)           [[4, w], [3, y], [2, z], [1, x]]
1078 (%i4) infix (">>");
1079 (%o4)                          >>
1080 (%i5) a >> b := a[1] > b[1];
1081 (%o5)                   a >> b := a  > b
1082                                    1    1
1083 (%i6) sort (L, ">>");
1084 (%o6)           [[4, w], [3, y], [2, z], [1, x]]
1085 (%i7) sort (L, lambda ([a, b], a[1] > b[1]));
1086 (%o7)           [[4, w], [3, y], [2, z], [1, x]]
1087 @end group
1088 @end example
1089
1090 O comando @code{sort(@var{L})} @'{e} equivalente a @code{sort(@var{L}, orderlessp)}.
1091
1092 @c ===beg===
1093 @c L : [a, 2*b, -5, 7, 1 + %e, %pi];
1094 @c sort (L);
1095 @c sort (L, 'orderlessp);
1096 @c ===end===
1097 @example
1098 @group
1099 (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
1100 (%o1)             [a, 2 b, - 5, 7, %e + 1, %pi]
1101 (%i2) sort (L);
1102 (%o2)             [- 5, 7, %e + 1, %pi, a, 2 b]
1103 (%i3) sort (L, 'orderlessp);
1104 (%o3)             [- 5, 7, %e + 1, %pi, a, 2 b]
1105 @end group
1106 @end example
1107
1108 A ordem padr@~{a}o de ordena@,{c}@~{a}o de uma lista @'{e} a ascendente, como determinado por @mrefdot{orderlessp}
1109 O predicado @code{ordergreatp} ordena uma lista em ordem descendente.
1110
1111 @c ===beg===
1112 @c L : [a, 2*b, -5, 7, 1 + %e, %pi];
1113 @c sort (L);
1114 @c sort (L, 'ordergreatp);
1115 @c ===end===
1116 @example
1117 @group
1118 (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
1119 (%o1)                    [a, 2 b, - 5, 7, %e + 1, %pi]
1120 (%i2) sort (L);
1121 (%o2)                    [- 5, 7, %e + 1, %pi, a, 2 b]
1122 (%i3) sort (L, 'ordergreatp);
1123 (%o3)                    [2 b, a, %pi, %e + 1, 7, - 5]
1124 @end group
1125 @end example
1126
1127 Todos os @'{a}tomos e expres@~{o}es do Maxima s@~{a}o compar@'{a}veis tanto por @code{orderlessp} quanto por @code{ordergreatp}.
1128
1129 @c ===beg===
1130 @c L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
1131 @c sort (L, orderlessp);
1132 @c sort (L, ordergreatp);
1133 @c ===end===
1134 @example
1135 @group
1136 (%i1) L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
1137                                                  5
1138 (%o1)  [11, - 17, 2.9b1, 9 c, 7.55, foo(x, y), - -, b + a]
1139                                                  2
1140 (%i2) sort (L, orderlessp);
1141                 5
1142 (%o2)  [- 17, - -, 7.55, 11, 2.9b1, b + a, 9 c, foo(x, y)]
1143                 2
1144 (%i3) sort (L, ordergreatp);
1145                                                   5
1146 (%o3)  [foo(x, y), 9 c, b + a, 2.9b1, 11, 7.55, - -, - 17]
1147                                                   2
1148 @end group
1149 @end example
1150
1151 Operadores @code{<} e @code{>} ordenam n@'{u}meros, constantes e express@~{o}es constates em magnitude.
1152 Note que @code{orderlessp} e @code{ordergreatp} n@~{a}o ordenam n@'{u}meros, constantes, express@~{o}es constantes em magnitude.
1153
1154 @c ===beg===
1155 @c L : [%pi, 3, 4, %e, %gamma];
1156 @c sort (L, ">");
1157 @c sort (L, ordergreatp);
1158 @c ===end===
1159 @example
1160 @group
1161 (%i1) L : [%pi, 3, 4, %e, %gamma];
1162 (%o1)                [%pi, 3, 4, %e, %gamma]
1163 (%i2) sort (L, ">");
1164 (%o2)                [4, %pi, 3, %e, %gamma]
1165 (%i3) sort (L, ordergreatp);
1166 (%o3)                [%pi, %gamma, %e, 4, 3]
1167 @end group
1168 @end example
1169
1170 O predicado @code{ordermagnitudep} ordena n@'{u}meros, constantes, e exress@~{o}es constantes da mesma forma que @code{<},
1171 e todos os outros elementos da mesma forma que @code{orderlessp}.
1172
1173 @c ===beg===
1174 @c L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
1175 @c sort (L, ordermagnitudep);
1176 @c sort (L, orderlessp);
1177 @c ===end===
1178 @example
1179 @group
1180 (%i1) L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
1181 (%o1) [%i, %i + 1, 2 x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0,
1182                                                            1.0b0]
1183 (%i2) sort (L, ordermagnitudep);
1184 (%o2) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
1185                                                      %i + 1, 2 x]
1186 (%i3) sort (L, orderlessp);
1187 (%o3) [0, 1, 1.0, 2, 3, %e, %i, %i + 1, inf, minf, sin(1),
1188                                                       1.0b0, 2 x]
1189 @end group
1190 @end example
1191
1192 @opencatbox
1193 @category{Listas}
1194 @closecatbox
1195 @end deffn
1196
1197 @c -----------------------------------------------------------------------------
1198 @anchor{sublist}
1199 @deffn {Fun@,{c}@~{a}o} sublist (@var{lista}, @var{p})
1200
1201 Retorna a lista dos elementos de @var{lista} para os quais o predicado @code{p}
1202 retorna @code{true}.
1203
1204 Exemplo:
1205
1206 @c ===beg===
1207 @c L: [1, 2, 3, 4, 5, 6];
1208 @c sublist (L, evenp);
1209 @c ===end===
1210 @example
1211 @group
1212 (%i1) L: [1, 2, 3, 4, 5, 6];
1213 (%o1)                  [1, 2, 3, 4, 5, 6]
1214 @end group
1215 @group
1216 (%i2) sublist (L, evenp);
1217 (%o2)                       [2, 4, 6]
1218 @end group
1219 @end example
1220
1221 @opencatbox
1222 @category{Listas}
1223 @closecatbox
1224 @end deffn
1225
1226 @c -----------------------------------------------------------------------------
1227 @anchor{sublist_indices}
1228 @deffn {Fun@,{c}@~{a}o} sublist_indices (@var{L}, @var{P})
1229
1230 Retorna os @'{i}ndices dos elementos @code{x} da lista @var{L} para os quais
1231 o predicado @code{maybe(@var{P}(x))} retornar @code{true};
1232 Esse retorno exclui @code{unknown} (desconhecido) bem como @code{false}.
1233 O predicado @var{P} pode ser o nome de uma fun@,{c}@~{a}o ou uma express@~{a}o @code{lambda}.
1234 A lista @var{L} deve ser uma lista literal.
1235
1236 Exemplos:
1237
1238 @c ===beg===
1239 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
1240 @c                        lambda ([x], x='b));
1241 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
1242 @c sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
1243 @c                        identity);
1244 @c assume (x < -1);
1245 @c map (maybe, [x > 0, x < 0, x < -2]);
1246 @c sublist_indices ([x > 0, x < 0, x < -2], identity);
1247 @c ===end===
1248 @example
1249 @group
1250 (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
1251                        lambda ([x], x='b));
1252 (%o1)                     [2, 3, 7, 9]
1253 @end group
1254 @group
1255 (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
1256 (%o2)                  [1, 2, 3, 4, 7, 9]
1257 @end group
1258 @group
1259 (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
1260                        identity);
1261 (%o3)                       [1, 4, 5]
1262 @end group
1263 @group
1264 (%i4) assume (x < -1);
1265 (%o4)                       [x < - 1]
1266 @end group
1267 @group
1268 (%i5) map (maybe, [x > 0, x < 0, x < -2]);
1269 (%o5)                [false, true, unknown]
1270 @end group
1271 @group
1272 (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
1273 (%o6)                          [2]
1274 @end group
1275 @end example
1276
1277 @opencatbox
1278 @category{Listas}
1279 @closecatbox
1280 @end deffn
1281
1282 @c -----------------------------------------------------------------------------
1283 @anchor{unique}
1284 @deffn {Fun@,{c}@~{a}o} unique (@var{L})
1285
1286 Retorna os elementos da lista @var{L} sem repeti@,{c}@~{o}es.
1287
1288 Quando a lista @var{L} n@~{a}o tem elementos repetidos,
1289 @code{unique} retorna uma mera c@'{o}pia de @var{L},
1290 not @var{L} itself.
1291
1292 Se @var{L} n@~{a}o for uma lista, @code{unique} retorna @var{L}.
1293
1294 Exemplo:
1295
1296 @c ===beg===
1297 @c unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
1298 @c ===end===
1299 @example
1300 @group
1301 (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
1302 (%o1)              [1, 2, %e, %pi, [1], b + a]
1303 @end group
1304 @end example
1305 @end deffn
1306
1307 @c -----------------------------------------------------------------------------
1308 @anchor{tenth}
1309 @deffn {Fun@,{c}@~{a}o} tenth (@var{expr})
1310
1311 Retorna o d@'{e}cimo item da express@~{a}o ou lista @var{expr}.
1312 Veja @mref{first}
1313 para mais detalhes.
1314
1315 @opencatbox
1316 @category{Listas} @category{Express@~{o}es}
1317 @closecatbox
1318 @end deffn
1319
1320 @c -----------------------------------------------------------------------------
1321 @anchor{third}
1322 @deffn {Fun@,{c}@~{a}o} third (@var{expr})
1323
1324 Retorna o terceiro item da express@~{a}o ou lista @var{expr}.
1325 Veja @mref{first}
1326 para mais detalhes.
1327
1328 @opencatbox
1329 @category{Listas} @category{Express@~{o}es}
1330 @closecatbox
1331 @end deffn
1332