doc/info/pt_BR/Operators.texi

   1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
   2 @c /Operators.texi/1.39/Fri Jun  8 05:36:44 2007/-ko/
   3 @iftex
   4 @hyphenation{con-se-cu-ti-vos}
   5 @hyphenation{u-san-do}
   6 @end iftex
   7 @menu
   8 * N-Argumentos::
   9 * Operador não fixado::
  10 * Operador Pósfixado::
  11 * Operador Préfixado::
  12 * Operadores Aritméticos::
  13 * Operadores Relacionais::
  14 * Operadores Geral::
  15 @end menu
  16
  17
  18 @node N-Argumentos, Operador não fixado, Operadores, Operadores
  19 @section N-Argumentos
  20 Um operador @code{nary} é usado para denotar uma função com qualquer número de
  21 argumentos, cada um dos quais é separado por uma ocorrência do
  22 operador, e.g. A+B ou A+B+C.  A função @code{nary("x")}  é uma função
  23 de extensão sintática para declarar x como sendo um operador @code{nary}.
  24 Funções podem ser declaradas para serem
  25 @code{nary}.  Se @code{declare(j,nary);} é concluída, diz ao simplicador para
  26 simplificar, e.g. @code{j(j(a,b),j(c,d))} para @code{j(a, b, c, d)}.
  27
  28 Veja também @code{syntax}.
  29
  30 @node Operador não fixado, Operador Pósfixado, N-Argumentos, Operadores
  31 @section Operador não fixado
  32 Operadores @code{nofix} são usados para denotar funções sem argumentos.
  33 A mera presença de tal operador em um comando fará com que a
  34 função correspondente seja avaliada.  Por exemplo, quando se digita
  35 "exit;" para sair de uma parada do Maxima, "exit" tem comportamento similar a um
  36 operador @code{nofix}.  A função @code{nofix("x")} é uma função de extensão
  37 sintática que declara x como sendo um operador @code{nofix}.
  38
  39 Veja também @code{syntax}.
  40
  41 @node Operador Pósfixado, Operador Préfixado, Operador não fixado, Operadores
  42 @section Operador Pósfixado
  43 Operadores @code{postfix} como a variedade @code{prefix} denotam funções
  44 de um argumento simples, mas nesse caso  o argumento sucede
  45 imediatamente uma ocorrência do operador na seq@"{u}ência de caracteres de entrada, e.g. 3! .
  46 Uma função @code{postfix("x")} é uma função de extensão
  47 sintática que declara x como sendo um operador @code{postfix}.
  48
  49 Veja também @code{syntax}.
  50
  51 @node Operador Préfixado, Operadores Aritméticos, Operador Pósfixado, Operadores
  52 @section Operador Préfixado
  53 Um operador @code{prefix} é um que significa uma função de um
  54 argumento, o qual imediatamente segue uma ocorrência do
  55 operador.  @code{prefix("x")} é uma função de extensão
  56 sintática que declara x como sendo um operador @code{prefix}.
  57
  58 Veja também @code{syntax}.
  59
  60 @node Operadores Aritméticos, Operadores Relacionais, Operador Préfixado, Operadores
  61 @section Operadores Aritméticos
  62
  63 @deffn {Operador} +
  64 @ifinfo
  65 @fnindex Adição
  66 @end ifinfo
  67 @deffnx {Operador} -
  68 @ifinfo
  69 @fnindex Subtração
  70 @end ifinfo
  71 @deffnx {Operador} *
  72 @ifinfo
  73 @fnindex Multiplicação
  74 @end ifinfo
  75 @deffnx {Operador} /
  76 @ifinfo
  77 @fnindex Divisão
  78 @end ifinfo
  79 @deffnx {Operador} ^
  80 @ifinfo
  81 @fnindex Exponenciação
  82 @end ifinfo
  83
  84 Os símbolos @code{+} @code{*} @code{/} e @code{^} representam
  85 adição, multiplicação, divisão, e exponenciação, respectivamente.
  86 O nome desses operadores são @code{"+"} @code{"*"} @code{"/"} e @code{"^"},
  87 os quais podem aparecer em lugares onde o nome da função ou operador é requerido.
  88
  89 Os símbolos @code{+} e @code{-} representam a adição unária e a negação unária, respectivamente,
  90 e os nomes desses operadores são @code{"+"} e @code{"-"}, respectivamente.
  91
  92 A subtração @code{a - b} é representada dentro do Maxima como a adição, @code{a + (- b)}.
  93 Expressões tais como @code{a + (- b)} são mostradas como subtração.
  94 Maxima reconhece @code{"-"} somente como o nome do operador unário de negação,
  95 e não como o nome do operador binário de subração.
  96
  97 A divisão @code{a / b} é representada dentro do Maxima como multiplicação, @code{a * b^(- 1)}.
  98 Expressões tais como @code{a * b^(- 1)} são mostradas como divisão.
  99 Maxima reconhece @code{"/"} como o nome do operador de divisão.
 100
 101 A adição e a multiplicação são operadores enários e comutativos.
 102 a divisão e a exponenciação são operadores binários e não comutativos.
 103
 104 Maxima ordena os operandos de operadores não comutativos para construir uma representação canônica.
 105 Para armazenamento interno, a ordem é determinada por @code{orderlessp}.
 106 Para mostrar na tela, a ordem para adição é determinada por @code{ordergreatp},
 107 e para a multiplicação, a ordem é a mesma da ordenação para armazenamento interno.
 108
 109 Computações aritiméticas são realizadas sobre números literais
 110 (inteiro, racionais, números comuns em ponto flutuante, e grandes números em ponto flutuante de dupla precisão).
 111 Execto a exponenciação, todas as operações aritméticas sobre números são simplificadas para números.
 112 A exponenciação é simplificada para um número se ou o operando é um número comum em ponto flutuante ou um grande número em ponto flutuante de dupla precisão
 113 ou se o resultado for um inteiro exato ou um racional exato;
 114 de outra forma uma exponenciação pode ser simplificada para @code{sqrt} ou outra exponenciação ou permanecer inalterada.
 115
 116 A propagação de números em ponto flutuante aplica-se a computações aritiméticas:
 117 Se qualquer operando for um grande número em ponto flutuante, o resultado é um grande número em ponto flutuante;
 118 de outra forma, se qualquer operando for um número em ponto flutuante comum, o resultado é um número comum em ponto flutuante;
 119 de outra forma, se os operandos forem racioanis ou inteiros e o resultado será um racional ou inteiro.
 120
 121 Computaçãoes aritiméticas são uma simplificação, não uma avaliação.
 122 Dessa forma a aritmética é realizada em  expressões com apóstrofo (mas simplificadas).
 123
 124 Operações aritméticas são aplicadas elemento-por-elemento
 125 para listas quando a variável global @code{listarith} for @code{true},
 126 e sempre aplicada elemento-por-elemento para matrizes.
 127 Quando um operando for uma lista ou uma matriz e outro for um operando de algum outro tipo,
 128 o outro operando é combinado com cada um dos elementos da lista ou matriz.
 129
 130 Exemplos:
 131
 132 Adição e multiplicação são opeadores enários comutativos.
 133 Maxima ordena os operandos para construir uma representação canônica.
 134 Os nomes desses operadores são @code{"+"} e @code{"*"}.
 135 @c ===beg===
 136 @c c + g + d + a + b + e + f;
 137 @c [op (%), args (%)];
 138 @c c * g * d * a * b * e * f;
 139 @c [op (%), args (%)];
 140 @c apply ("+", [a, 8, x, 2, 9, x, x, a]);
 141 @c apply ("*", [a, 8, x, 2, 9, x, x, a]);
 142 @c ===end===
 143
 144 @example
 145 (%i1) c + g + d + a + b + e + f;
 146 (%o1)               g + f + e + d + c + b + a
 147 (%i2) [op (%), args (%)];
 148 (%o2)              [+, [g, f, e, d, c, b, a]]
 149 (%i3) c * g * d * a * b * e * f;
 150 (%o3)                     a b c d e f g
 151 (%i4) [op (%), args (%)];
 152 (%o4)              [*, [a, b, c, d, e, f, g]]
 153 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
 154 (%o5)                    3 x + 2 a + 19
 155 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
 156                                  2  3
 157 (%o6)                       144 a  x
 158 @end example
 159
 160 Divisão e exponenciação são operadores binários e não comutativos.
 161 Os nomes desses operadores são @code{"/"} e @code{"^"}.
 162 @c ===beg===
 163 @c [a / b, a ^ b];
 164 @c [map (op, %), map (args, %)];
 165 @c [apply ("/", [a, b]), apply ("^", [a, b])];
 166 @c ===end===
 167
 168 @example
 169 (%i1) [a / b, a ^ b];
 170                               a   b
 171 (%o1)                        [-, a ]
 172                               b
 173 (%i2) [map (op, %), map (args, %)];
 174 (%o2)              [[/, ^], [[a, b], [a, b]]]
 175 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
 176                               a   b
 177 (%o3)                        [-, a ]
 178                               b
 179 @end example
 180
 181 Subtração e divisão são representados internamente
 182 em termos de adição e multiplicação, respectivamente.
 183 @c ===beg===
 184 @c [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
 185 @c [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
 186 @c ===end===
 187
 188 @example
 189 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
 190 (%o1)                      [+, a, - b]
 191 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
 192                                    1
 193 (%o2)                       [*, a, -]
 194                                    b
 195 @end example
 196
 197 Cálculos são realizados sobre números lterais.
 198 A propagação de números em poto flutuante aplica-se.
 199 @c ===beg===
 200 @c 17 + b - (1/2)*29 + 11^(2/4);
 201 @c [17 + 29, 17 + 29.0, 17 + 29b0];
 202 @c ===end===
 203
 204 @example
 205 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
 206                                        5
 207 (%o1)                   b + sqrt(11) + -
 208                                        2
 209 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
 210 (%o2)                   [46, 46.0, 4.6b1]
 211 @end example
 212
 213 Computações aritméticas são uma simplificação, não uma avaliação.
 214 @c ===beg===
 215 @c simp : false;
 216 @c '(17 + 29*11/7 - 5^3);
 217 @c simp : true;
 218 @c '(17 + 29*11/7 - 5^3);
 219 @c ===end===
 220
 221 @example
 222 (%i1) simp : false;
 223 (%o1)                         false
 224 (%i2) '(17 + 29*11/7 - 5^3);
 225                               29 11    3
 226 (%o2)                    17 + ----- - 5
 227                                 7
 228 (%i3) simp : true;
 229 (%o3)                         true
 230 (%i4) '(17 + 29*11/7 - 5^3);
 231                                 437
 232 (%o4)                         - ---
 233                                  7
 234 @end example
 235
 236 A aritmética é realizada elemento-por-elemento para listas lists (dependendo de @code{listarith}) e dependendo de matrizes.
 237 @c ===beg===
 238 @c matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
 239 @c 5 * matrix ([a, x], [h, u]);
 240 @c listarith : false;
 241 @c [a, c, m, t] / [1, 7, 2, 9];
 242 @c [a, c, m, t] ^ x;
 243 @c listarith : true;
 244 @c [a, c, m, t] / [1, 7, 2, 9];
 245 @c [a, c, m, t] ^ x;
 246 @c ===end===
 247
 248 @example
 249 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
 250                         [ a - 1  x - 2 ]
 251 (%o1)                   [              ]
 252                         [ h - 3  u - 4 ]
 253 (%i2) 5 * matrix ([a, x], [h, u]);
 254                           [ 5 a  5 x ]
 255 (%o2)                     [          ]
 256                           [ 5 h  5 u ]
 257 (%i3) listarith : false;
 258 (%o3)                         false
 259 (%i4) [a, c, m, t] / [1, 7, 2, 9];
 260                           [a, c, m, t]
 261 (%o4)                     ------------
 262                           [1, 7, 2, 9]
 263 (%i5) [a, c, m, t] ^ x;
 264                                       x
 265 (%o5)                     [a, c, m, t]
 266 (%i6) listarith : true;
 267 (%o6)                         true
 268 (%i7) [a, c, m, t] / [1, 7, 2, 9];
 269                               c  m  t
 270 (%o7)                     [a, -, -, -]
 271                               7  2  9
 272 (%i8) [a, c, m, t] ^ x;
 273                           x   x   x   x
 274 (%o8)                   [a , c , m , t ]
 275 @end example
 276
 277 @end deffn
 278
 279 @deffn {Operador} **
 280
 281 Operador de exponenciação.
 282 Maxima reconhece @code{**} como o mesmo operador que @code{^} em entrada,
 283 e @code{**} é mostrado como @code{^} em saída unidimensional,
 284 ou colocando o expoente  como sobrescrito em saída bidimensional.
 285
 286 A função @code{fortran} mostra o operador de exponenciação com como @code{**},
 287 independente de a entrada ter sido na forma @code{**} ou a forma @code{^}.
 288
 289 Exemplos:
 290
 291 @c ===beg===
 292 @c is (a**b = a^b);
 293 @c x**y + x^z;
 294 @c string (x**y + x^z);
 295 @c fortran (x**y + x^z);
 296 @c ===end===
 297 @example
 298 (%i1) is (a**b = a^b);
 299 (%o1)                         true
 300 (%i2) x**y + x^z;
 301                               z    y
 302 (%o2)                        x  + x
 303 (%i3) string (x**y + x^z);
 304 (%o3)                        x^z+x^y
 305 (%i4) fortran (x**y + x^z);
 306       x**z+x**y
 307 (%o4)                         done
 308 @end example
 309
 310 @end deffn
 311
 312 @node Operadores Relacionais, Operadores Geral, Operadores Aritméticos, Operadores
 313 @section Operadores Relacionais
 314
 315 @deffn {Operador} <
 316 @ifinfo
 317 @fnindex Menor que
 318 @end ifinfo
 319 @deffnx {Operador} <=
 320 @ifinfo
 321 @fnindex Menor que ou igual a
 322 @end ifinfo
 323 @deffnx {Operador} >=
 324 @ifinfo
 325 @fnindex Maior que ou igual a
 326 @end ifinfo
 327 @deffnx {Operador} >
 328 @ifinfo
 329 @fnindex Maior que
 330 @end ifinfo
 331
 332 @end deffn
 333
 334 @node Operadores Geral, , Operadores Relacionais, Operadores
 335 @section Operadores Geral
 336
 337 @deffn {Operador} ^^
 338 @ifinfo
 339 @fnindex exponenciação não comutativa
 340 @end ifinfo
 341
 342 @end deffn
 343
 344 @deffn {Operador} !
 345 @ifinfo
 346 @fnindex Fatorial
 347 @end ifinfo
 348 O operador fatorial.
 349 Para qualquer número complexo @code{x} (incluíndo números inteiros, racionais, e reais) exceto para
 350 inteiros negativos, @code{x!} é definido como @code{gamma(x+1)}.
 351
 352 Para um inteiro @code{x}, @code{x!} simplifica para o produto de inteiros de 1 a @code{x} inclusive.
 353 @code{0!} simplifica para 1.
 354 Para um número em ponto flutuante @code{x}, @code{x!} simplifica para o valor de @code{gamma (x+1)}.
 355 Para @code{x} igual a @code{n/2} onde @code{n} é um inteiro ímpar,
 356 @code{x!} simplifica para um fator racional vezes @code{sqrt (%pi)}
 357 (uma vez que @code{gamma (1/2)} é igual a @code{sqrt (%pi)}).
 358 Se @code{x} for qualquer outra coisa,
 359 @code{x!} não é simplificado.
 360
 361 As variáveis
 362 @code{factlim}, @code{minfactorial}, e @code{factcomb} controlam a simplificação
 363 de expressões contendo fatoriais.
 364
 365 As funções @code{gamma}, @code{bffac}, e @code{cbffac}
 366 são variedades da função @code{gamma}.
 367 @code{makegamma} substitui @code{gamma} para funções relacionadas a fatoriais.
 368
 369 Veja também @code{binomial}.
 370
 371 O fatorial de um inteiro, inteiro dividido por dois, ou argumento em ponto flutuante é simplificado
 372 a menos que o operando seja maior que @code{factlim}.
 373
 374 @c ===beg===
 375 @c factlim : 10;
 376 @c [0!, (7/2)!, 4.77!, 8!, 20!];
 377 @c ===end===
 378 @example
 379 (%i1) factlim : 10;
 380 (%o1)                          10
 381 (%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
 382 +            105 sqrt(%pi)
 383 +(%o2)   [1, -------------, 81.44668037931199, 40320, 20!]
 384 +                 16
 385 @end example
 386
 387 O fatorial de um número complexo, constante conhecida, ou expressão geral não é simplificado.
 388 Ainda assim pode ser possível simplificar o fatorial após avaliar o operando.
 389
 390 @c ===beg===
 391 @c [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
 392 @c ev (%, numer, %enumer);
 393 @c ===end===
 394 @example
 395 (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
 396 (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
 397 (%i2) ev (%, numer, %enumer);
 398 (%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357,
 399                                                1.227580202486819]
 400 @end example
 401
 402 O fatorial de um símbolo não associado não é simplificado.
 403
 404 @c ===beg===
 405 @c kill (foo);
 406 @c foo!;
 407 @c ===end===
 408 @example
 409 (%i1) kill (foo);
 410 (%o1)                         done
 411 (%i2) foo!;
 412 (%o2)                         foo!
 413 @end example
 414
 415 Fatoriais são simplificados, não avaliados.
 416 Dessa forma @code{x!} pode ser substituído mesmo em uma expressão com apóstrofo.
 417
 418 @c ===beg===
 419 @c '([0!, (7/2)!, 4.77!, 8!, 20!]);
 420 @c ===end===
 421 @example
 422 (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
 423           105 sqrt(%pi)
 424 (%o1) [1, -------------, 81.44668037931199, 40320,
 425                16
 426                                              2432902008176640000]
 427 @end example
 428
 429 @end deffn
 430
 431 @deffn {Operador} !!
 432 @ifinfo
 433 @fnindex Duplo fatorial
 434 @end ifinfo
 435 O operador de duplo fatorial.
 436
 437 Para um número inteiro, número em ponto flutuante, ou número racional @code{n},
 438 @code{n!!} avalia para o produto @code{n (n-2) (n-4) (n-6) ... (n - 2 (k-1))}
 439 onde @code{k} é igual a @code{entier (n/2)},
 440 que é, o maior inteiro menor que ou igual a @code{n/2}.
 441 Note que essa definição não coincide com outras definições publicadas
 442 para argumentos que não são inteiros.
 443 @c REPORTED TO BUG TRACKER AS BUG # 1093138 !!!
 444
 445 Para um inteiro par (ou ímpar) @code{n}, @code{n!!} avalia para o produto de
 446 todos os inteiros consecutivos pares (ou ímpares) de 2 (ou 1) até @code{n} inclusive.
 447
 448 Para um argumento @code{n} que não é um número inteiro, um número em ponto flutuante, ou um número racional,
 449 @code{n!!} retorna uma forma substantiva @code{genfact (n, n/2, 2)}.
 450 @c n!! IS NEITHER SIMPLIFIED NOR EVALUATED IN THIS CASE -- MENTION THAT? OR TOO MUCH DETAIL ???
 451
 452 @end deffn
 453
 454 @deffn {Operador} #
 455 @ifinfo
 456 @fnindex Não igual (desigualdade sintática)
 457 @end ifinfo
 458 Representa a negação da igualdade sintática @code{=}.
 459
 460 Note que pelo fato de as regras de avaliação de expressões predicadas
 461 (em particular pelo fato de @code{not @var{expr}} fazer com que ocorra a avaliação de @var{expr}),
 462 a forma @code{not @var{a} = @var{b}} não é equivalente à forma @code{@var{a} # @var{b}} em alguns casos.
 463
 464 Note que devido às regras para avaliação de expressões predicadas
 465 (em particular devido a @code{not @var{expr}} fazer com que a avaliação de @var{expr} ocorra),
 466 @code{not @var{a} = @var{b}} é equivalente a @code{is(@var{a} # @var{b})},
 467 em lugar de ser equivalente a @code{@var{a} # @var{b}}.
 468
 469 Exemplos:
 470 @c ===beg===
 471 @c a = b;
 472 @c é (a = b);
 473 @c a # b;
 474 @c not a = b;
 475 @c é (a # b);
 476 @c é (not a = b);
 477 @c ===end===
 478 @example
 479 (%i1) a = b;
 480 (%o1)                         a = b
 481 (%i2) é (a = b);
 482 (%o2)                         false
 483 (%i3) a # b;
 484 (%o3)                         a # b
 485 (%i4) not a = b;
 486 (%o4)                         true
 487 (%i5) é (a # b);
 488 (%o5)                         true
 489 (%i6) é (not a = b);
 490 (%o6)                         true
 491 @end example
 492
 493 @end deffn
 494
 495 @deffn {Operador} .
 496 @ifinfo
 497 @fnindex Multiplicação não comutativa matricial
 498 @end ifinfo
 499 O operador ponto, para multiplicação (não comutativa) de matrizes.
 500 Quando "." é usado com essa finalidade, espaços devem ser colocados em ambos os lados desse
 501 operador, e.g. A . B.  Isso disting@"{u}e o operador ponto plenamente de um ponto decimal em
 502 um número em ponto flutuante.
 503
 504 Veja também
 505 @code{dot},
 506 @code{dot0nscsimp},
 507 @code{dot0simp},
 508 @code{dot1simp},
 509 @code{dotassoc},
 510 @code{dotconstrules},
 511 @code{dotdistrib},
 512 @code{dotexptsimp},
 513 @code{dotident},
 514 e
 515 @code{dotscrules}.
 516
 517 @end deffn
 518
 519 @deffn {Operador} :
 520 @ifinfo
 521 @fnindex Operador de atribuição
 522 @end ifinfo
 523 O operador de atribuição.  E.g. A:3 escolhe a variável A para 3.
 524
 525 @end deffn
 526
 527 @deffn {Operador} ::
 528 @ifinfo
 529 @fnindex Operador de atribuição (avalia o lado esquerdo da igualdade)
 530 @end ifinfo
 531 Operador de atribuição.  :: atribui o valor da expressão
 532 em seu lado direito para o valor da quantidade na sua esquerda, que pode
 533 avaliar para uma variável atômica ou variável subscrita.
 534
 535 @end deffn
 536
 537 @deffn {Operador} ::=
 538 @ifinfo
 539 @fnindex Operador de definição de função de macro
 540 @end ifinfo
 541 Operador de definição de função de macro.
 542 @code{::=} define uma função (chamada uma "macro" por razões históricas)
 543 que coloca um apóstrofo em seus argumentos (evitando avaliação),
 544 e a expressão que é retornada (chamada a "expansão de macro")
 545 é avaliada no contexto a partir do qual a macro foi chamada.
 546 Uma função de macro é de outra forma o mesmo que uma função comum.
 547
 548 @code{macroexpand} retorna uma expansão de macro (sem avaliar a expansão).
 549 @code{macroexpand (foo (x))} seguida por @code{''%} é equivalente a @code{foo (x)}
 550 quando @code{foo} for uma função de macro.
 551
 552 @code{::=} coloca o nome da nova função de macro dentro da lista global @code{macros}.
 553 @code{kill}, @code{remove}, e @code{remfunction} desassocia definições de função de macro
 554 e remove nomes de @code{macros}.
 555
 556 @code{fundef} e @code{dispfun} retornam respectivamente uma definição de função de macro
 557 e uma atribuição dessa definição a um rótulo, respectivamente.
 558
 559 Funções de macro comumente possuem expressões @code{buildq} e
 560 @code{splice} para construir uma expressão,
 561 que é então avaliada.
 562
 563 Exemplos
 564
 565 Uma função de macro coloca um apóstrofo em seus argumentos evitando então a avaliação,
 566 então mensagem (1) mostra @code{y - z}, não o valor de @code{y - z}.
 567 A expansão de macro (a expressão com apóstrofo @code{'(print ("(2) x is equal to", x))}
 568 é avaliada no contexto a partir do qual a macro for chamada,
 569 mostrando a mensagem (2).
 570
 571 @c ===beg===
 572 @c x: %pi;
 573 @c y: 1234;
 574 @c z: 1729 * w;
 575 @c printq1 (x) ::= block (print ("(1) x is equal to", x), '(print ("(2) x is equal to", x)));
 576 @c printq1 (y - z);
 577 @c ===end===
 578 @example
 579 (%i1) x: %pi;
 580 (%o1)                          %pi
 581 (%i2) y: 1234;
 582 (%o2)                         1234
 583 (%i3) z: 1729 * w;
 584 (%o3)                        1729 w
 585 (%i4) printq1 (x) ::= block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x)));
 586 (%o4) printq1(x) ::= block(print("(1) x é igual a", x),
 587                                 '(print("(2) x é igual a", x)))
 588 (%i5) printq1 (y - z);
 589 (1) x é igual a y - z
 590 (2) x é igual a %pi
 591 (%o5)                          %pi
 592 @end example
 593
 594 Uma função comum avalia seus argumentos, então message (1) mostra o valor de @code{y - z}.
 595 O valor de retorno não é avaliado, então mensagem (2) não é mostrada
 596 até a avaliação explícita @code{''%}.
 597
 598 @c ===beg===
 599 @c x: %pi;
 600 @c y: 1234;
 601 @c z: 1729 * w;
 602 @c printe1 (x) := block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x)));
 603 @c printe1 (y - z);
 604 @c ''%;
 605 @c ===end===
 606 @example
 607 (%i1) x: %pi;
 608 (%o1)                          %pi
 609 (%i2) y: 1234;
 610 (%o2)                         1234
 611 (%i3) z: 1729 * w;
 612 (%o3)                        1729 w
 613 (%i4) printe1 (x) := block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x)));
 614 (%o4) printe1(x) := block(print("(1) x é igual a", x),
 615                                 '(print("(2) x é igual a", x)))
 616 (%i5) printe1 (y - z);
 617 (1) x é igual a 1234 - 1729 w
 618 (%o5)              print((2) x é igual a, x)
 619 (%i6) ''%;
 620 (2) x é igual a %pi
 621 (%o6)                          %pi
 622 @end example
 623
 624 @code{macroexpand} retorna uma expansão de macro.
 625 @code{macroexpand (foo (x))} seguido por @code{''%} é equivalente a @code{foo (x)}
 626 quando @code{foo} for uma função de macro.
 627
 628 @c ===beg===
 629 @c x: %pi;
 630 @c y: 1234;
 631 @c z: 1729 * w;
 632 @c g (x) ::= buildq ([x], print ("x é igual a", x));
 633 @c macroexpand (g (y - z));
 634 @c ''%;
 635 @c g (y - z);
 636 @c ===end===
 637 @example
 638 (%i1) x: %pi;
 639 (%o1)                          %pi
 640 (%i2) y: 1234;
 641 (%o2)                         1234
 642 (%i3) z: 1729 * w;
 643 (%o3)                        1729 w
 644 (%i4) g (x) ::= buildq ([x], print ("x é igual a", x));
 645 (%o4)    g(x) ::= buildq([x], print("x é igual a", x))
 646 (%i5) macroexpand (g (y - z));
 647 (%o5)              print(x é igual a, y - z)
 648 (%i6) ''%;
 649 x é igual a 1234 - 1729 w
 650 (%o6)                     1234 - 1729 w
 651 (%i7) g (y - z);
 652 x é igual a 1234 - 1729 w
 653 (%o7)                     1234 - 1729 w
 654 @end example
 655
 656 @end deffn
 657
 658 @deffn {Operador} :=
 659 @ifinfo
 660 @fnindex Operador de definição de função
 661 @end ifinfo
 662 O operador de definição de função.  E.g. @code{f(x):=sin(x)} define
 663 uma função @code{f}.
 664
 665 @end deffn
 666
 667 @deffn {Operador} =
 668 @ifinfo
 669 @fnindex Operador de equação
 670 @fnindex Igual (igualdade sintática)
 671 @end ifinfo
 672 O operador de equação.
 673
 674 Uma expressão @code{@var{a} = @var{b}}, por si mesma, representa
 675 uma equação não avaliada, a qual pode ou não se manter.
 676 Equações não avaliadas podem aparecer como argumentos para @code{solve} e @code{algsys}
 677 ou algumas outras funções.
 678
 679 A função @code{is} avalia @code{=} para um valor Booleano.
 680 @code{is(@var{a} = @var{b})} avalia @code{@var{a} = @var{b}} para @code{true} quando @var{a} e @var{b}
 681 forem idênticos. Isto é, @var{a} e @var{b} forem átomos que são idênticos,
 682 ou se eles não forem átomos e seus operadores forem idênticos e seus argumentos forem idênticos.
 683 De outra forma, @code{is(@var{a} = @var{b})} avalia para @code{false};
 684 @code{is(@var{a} = @var{b})} nunca avalia para @code{unknown}.
 685 Quando @code{is(@var{a} = @var{b})} for @code{true}, @var{a} e @var{b} são ditos para serem sintaticamente iguais,
 686 em contraste para serem expressões equivalentes, para as quais @code{is(equal(@var{a}, @var{b}))} é @code{true}.
 687 Expressões podem ser equivalentes e não sintáticamente iguais.
 688
 689 A negação de @code{=} é representada por @code{#}.
 690 Da mesma forma que com @code{=}, uma expressão @code{@var{a} # @var{b}}, por si mesma, não é avaliada.
 691 @code{is(@var{a} # @var{b})} avalia @code{@var{a} # @var{b}} para
 692 @code{true} ou @code{false}.
 693
 694 Complementando a função @code{is},
 695 alguns outros operadores avaliam @code{=} e @code{#} para @code{true} ou @code{false},
 696 a saber @code{if}, @code{and}, @code{or}, e @code{not}.
 697
 698 Note que pelo fato de as regras de avaliação de expressões predicadas
 699 (em particular pelo fato de @code{not @var{expr}} fazer com que ocorra a avaliação de @var{expr}),
 700 a forma @code{not @var{a} = @var{b}} é equivalente a @code{is(@var{a} # @var{b})},
 701 em lugar de ser equivalente a @code{@var{a} # @var{b}}.
 702
 703 @code{rhs} e @code{lhs} retornam o primeiro membro e o segundo membro de uma equação,
 704 respectivamente, de uma equação ou inequação.
 705
 706 Veja também @code{equal} e @code{notequal}.
 707
 708 Exemplos:
 709
 710 Uma expressão @code{@var{a} = @var{b}}, por si mesma, representa
 711 uma equação não avaliada, a qual pode ou não se manter.
 712
 713 @c ===beg===
 714 @c eq_1 : a * x - 5 * y = 17;
 715 @c eq_2 : b * x + 3 * y = 29;
 716 @c solve ([eq_1, eq_2], [x, y]);
 717 @c subst (%, [eq_1, eq_2]);
 718 @c ratsimp (%);
 719 @c ===end===
 720 @example
 721 (%i1) eq_1 : a * x - 5 * y = 17;
 722 (%o1)                    a x - 5 y = 17
 723 (%i2) eq_2 : b * x + 3 * y = 29;
 724 (%o2)                    3 y + b x = 29
 725 (%i3) solve ([eq_1, eq_2], [x, y]);
 726                         196         29 a - 17 b
 727 (%o3)          [[x = ---------, y = -----------]]
 728                      5 b + 3 a       5 b + 3 a
 729 (%i4) subst (%, [eq_1, eq_2]);
 730          196 a     5 (29 a - 17 b)
 731 (%o4) [--------- - --------------- = 17,
 732        5 b + 3 a      5 b + 3 a
 733                                   196 b     3 (29 a - 17 b)
 734                                 --------- + --------------- = 29]
 735                                 5 b + 3 a      5 b + 3 a
 736 (%i5) ratsimp (%);
 737 (%o5)                  [17 = 17, 29 = 29]
 738 @end example
 739
 740 @code{is(@var{a} = @var{b})} avalia @code{@var{a} = @var{b}} para @code{true} quando @var{a} e @var{b}
 741 são sintaticamente iguais (isto é, identicos).
 742 Expressões podem ser equivalentes e não sintaticamente iguais.
 743
 744 @c ===beg===
 745 @c a : (x + 1) * (x - 1);
 746 @c b : x^2 - 1;
 747 @c [is (a = b), is (a # b)];
 748 @c [is (equal (a, b)), is (notequal (a, b))];
 749 @c ===end===
 750 @example
 751 (%i1) a : (x + 1) * (x - 1);
 752 (%o1)                    (x - 1) (x + 1)
 753 (%i2) b : x^2 - 1;
 754                               2
 755 (%o2)                        x  - 1
 756 (%i3) [is (a = b), is (a # b)];
 757 (%o3)                     [false, true]
 758 (%i4) [is (equal (a, b)), is (notequal (a, b))];
 759 (%o4)                     [true, false]
 760 @end example
 761
 762 Alguns operadores avaliam @code{=} e @code{#} para @code{true} ou @code{false}.
 763
 764 @c ===beg===
 765 @c if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR;
 766 @c eq_3 : 2 * x = 3 * x;
 767 @c eq_4 : exp (2) = %e^2;
 768 @c [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
 769 @c ===end===
 770 @example
 771 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR;
 772 (%o1)                          FOO
 773 (%i2) eq_3 : 2 * x = 3 * x;
 774 (%o2)                       2 x = 3 x
 775 (%i3) eq_4 : exp (2) = %e^2;
 776                               2     2
 777 (%o3)                       %e  = %e
 778 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
 779 (%o4)                  [false, true, true]
 780 @end example
 781
 782 Devido a @code{not @var{expr}} fazer com que a avaliação de @var{expr} ocorra,
 783 @code{not @var{a} = @var{b}} é equivalente a @code{is(@var{a} # @var{b})}.
 784
 785 @c ===beg===
 786 @c [2 * x # 3 * x, not (2 * x = 3 * x)];
 787 @c is (2 * x # 3 * x);
 788 @c ===end===
 789 @example
 790 (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
 791 (%o1)                   [2 x # 3 x, true]
 792 (%i2) is (2 * x # 3 * x);
 793 (%o2)                         true
 794 @end example
 795
 796 @end deffn
 797
 798 @c NEEDS EXAMPLES
 799 @deffn {Operador} and
 800 @ifinfo
 801 @fnindex Conjunção lógica
 802 @end ifinfo
 803 O operador lógico de conjunção.
 804 @code{and} é um operador n-ário infixo;
 805 seus operandos são expressões Booleanas, e seu resultado é um valor Booleano.
 806
 807 @code{and} força avaliação (como @code{is}) de um ou mais operandos,
 808 e pode forçar a avaliação de todos os operandos.
 809
 810 Operandos são avaliados na ordem em que aparecerem.
 811 @code{and} avalia somente quantos de seus operandos forem necessários para determinar o resultado.
 812 Se qualquer operando for @code{false},
 813 o resultado é @code{false} e os operandos restantes não são avaliados.
 814
 815 O sinalizador global @code{prederror} governa o comportamento de @code{and}
 816 quando um operando avaliado não pode ser determinado como sendo @code{true} ou @code{false}.
 817 @code{and} imprime uma mensagem de erro quando @code{prederror} for @code{true}.
 818 De outra forma, operandos que não avaliam para @code{true} ou para @code{false} são aceitos,
 819 and o resultado é uma expressão Booleana.
 820
 821 @code{and} não é comutativo:
 822 @code{a and b} pode não ser igual a @code{b and a} devido ao tratamento de operandos indeterminados.
 823
 824 @end deffn
 825
 826 @c NEEDS EXAMPLES
 827 @deffn {Operador} or
 828 @ifinfo
 829 @fnindex Disjunção lógica
 830 @end ifinfo
 831 O operador lógico de disjunção.
 832 @code{or} é um operador n-ário infixo;
 833 seus operandos são expressões Booleanas, e seu resultado é um valor Booleano.
 834
 835 @code{or} força avaliação (como @code{is}) de um ou mais operandos,
 836 e pode forçar a avaliação de todos os operandos.
 837
 838 Operandos são avaliados na ordem em que aparecem.
 839 @code{or} avalia somente quantos de seus operandos forem necessários para determinar o resultado.
 840 Se qualquer operando for @code{true},
 841 o resultado é @code{true} e os operandos restantes não são avaliados.
 842
 843 O sinalizador global @code{prederror} governa o comportamento de @code{or}
 844 quando um operando avaliado não puder ser determinado como sendo @code{true} ou @code{false}.
 845 @code{or} imprime uma mensagem de erro quando @code{prederror} for @code{true}.
 846 De outra forma, operandos que não avaliam para @code{true} ou para @code{false} são aceitos,
 847 E o resultado é uma expressão Booleana.
 848
 849 @code{or} não é comutativo:
 850 @code{a or b} pode não ser igual a @code{b or a} devido ao tratamento de operando indeterminados.
 851
 852 @end deffn
 853
 854 @c NEEDS EXAMPLES
 855 @deffn {Operador} not
 856 @ifinfo
 857 @fnindex Negação lógica
 858 @end ifinfo
 859 O operador lógico de negação.
 860 @code{not} é operador prefixado;
 861 Seu operando é uma expressão Booleana, e seu resultado é um valor Booleano.
 862
 863 @code{not} força a avaliação (como @code{is}) de seu operando.
 864
 865 O sinalizador global @code{prederror} governa o comportamento de @code{not}
 866 quando seu operando não pode ser determinado em termos de @code{true} ou @code{false}.
 867 @code{not} imprime uma mensagem de erro quando @code{prederror} for @code{true}.
 868 De outra forma, operandos que não avaliam para @code{true} ou para @code{false} são aceitos,
 869 e o resultado é uma expressão Booleana.
 870
 871 @end deffn
 872
 873 @deffn {Função} abs (@var{expr})
 874 Retorna o valor absoluto de @var{expr}.  Se @var{expr} for um número complexo, retorna o módulo
 875 complexo de @var{expr}.
 876
 877 @end deffn
 878
 879 @defvr {Palavra chave} additive
 880 Se @code{declare(f,additive)} tiver sido executado, então:
 881
 882 (1) Se @code{f} for uma função de uma única variável, sempre que o simplificador encontrar @code{f} aplicada
 883 a uma adição, @code{f} será distribuído sobre aquela adição.  I.e. @code{f(y+x)} irá
 884 simplificar para @code{f(y)+f(x)}.
 885
 886 (2) Se @code{f} for uma função de 2 ou mais argumentos, a adição é definida como
 887 adição no primeiro argumento para @code{f}, como no caso de @code{sum} ou
 888 @code{integrate}, i.e. @code{f(h(x)+g(x),x)} irá simplificar para @code{f(h(x),x)+f(g(x),x)}.
 889 Essa simplificação não ocorre quando @code{f} é aplicada para expressões da
 890 forma @code{sum(x[i],i,lower-limit,upper-limit)}.
 891
 892 @end defvr
 893
 894 @c NEEDS TO BE REWORKED. NOT CONVINCED THIS SYMBOL NEEDS ITS OWN ITEM
 895 @c (SHOULD BE DESCRIBED IN CONTEXT OF EACH FUNCTION WHICH RECOGNIZES IT)
 896 @defvr {Palavra chave} allbut
 897 trabalha com os comandos @code{part} (i.e. @code{part}, @code{inpart}, @code{substpart},
 898 @code{substinpart}, @code{dpart}, e @code{lpart}).  Por exemplo,
 899
 900 @c ===beg===
 901 @c expr : e + d + c + b + a;
 902 @c part (expr, [2, 5]);
 903 @c ===end===
 904 @example
 905 (%i1) expr : e + d + c + b + a;
 906 (%o1)                   e + d + c + b + a
 907 (%i2) part (expr, [2, 5]);
 908 (%o2)                         d + a
 909 @end example
 910
 911 enquanto
 912
 913 @c ===beg===
 914 @c expr : e + d + c + b + a;
 915 @c part (expr, allbut (2, 5));
 916 @c ===end===
 917 @example
 918 (%i1) expr : e + d + c + b + a;
 919 (%o1)                   e + d + c + b + a
 920 (%i2) part (expr, allbut (2, 5));
 921 (%o2)                       e + c + b
 922 @end example
 923
 924 @code{allbut} é também reconhecido por @code{kill}.
 925
 926 @c ===beg===
 927 @c [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
 928 @c kill (allbut (cc, dd));
 929 @c [aa, bb, cc, dd];
 930 @c ===end===
 931 @example
 932 (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
 933 (%o1)                 [11, 22, 33, 44, 55]
 934 (%i2) kill (allbut (cc, dd));
 935 (%o0)                         done
 936 (%i1) [aa, bb, cc, dd];
 937 (%o1)                   [aa, bb, 33, 44]
 938 @end example
 939
 940 @code{kill(allbut(@var{a_1}, @var{a_2}, ...))} tem o mesmo efeito que @code{kill(all)}
 941 exceto que não elimina os símbolos @var{a_1}, @var{a_2}, ... .
 942
 943 @end defvr
 944
 945 @defvr {Declaração} antisymmetric
 946 Se @code{declare(h,antisymmetric)} é concluída, diz ao
 947 simplicador que @code{h} é uma função antisimétrica.  E.g. @code{h(x,z,y)} simplificará para
 948 @code{- h(x, y, z)}.  Isto é, dará (-1)^n vezes o resultado dado por
 949 @code{symmetric} ou @code{commutative}, quando n for o número de interescolhas de dois
 950 argumentos necessários para converter isso naquela forma.
 951
 952 @end defvr
 953
 954 @deffn {Função} cabs (@var{expr})
 955 Retorna o valor absoluto complexo (o módulo complexo) de
 956 @var{expr}.
 957
 958 @end deffn
 959
 960 @deffn {Função} ceiling (@var{x})
 961
 962 Quando @var{x} for um número real, retorna o último inteiro que
 963 é maior que ou igual a @var{x}.
 964
 965 Se @var{x} for uma expressão constante (@code{10 * %pi}, por exemplo),
 966 @code{ceiling} avalia @var{x} usando grandes números em ponto flutuante, e
 967 aplica @code{ceiling} para o grande número em ponto flutuante resultante. Porque @code{ceiling} usa
 968 avaliação de ponto flutuante, é possível, embora improvável,
 969 que @code{ceiling} possa retornar uma valor errôneo para entradas
 970 constantes. Para prevenir erros, a avaliação de ponto flutuante
 971 é concluída usando três valores para @code{fpprec}.
 972
 973 Para entradas não constantes, @code{ceiling} tenta retornar um valor
 974 simplificado.  Aqui está um exemplo de simplificações que @code{ceiling}
 975 conhece:
 976
 977 @c ===beg===
 978 @c ceiling (ceiling (x));
 979 @c ceiling (floor (x));
 980 @c declare (n, integer)$
 981 @c [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
 982 @c assume (x > 0, x < 1)$
 983 @c ceiling (x);
 984 @c tex (ceiling (a));
 985 @c ===end===
 986 @example
 987 (%i1) ceiling (ceiling (x));
 988 (%o1)                      ceiling(x)
 989 (%i2) ceiling (floor (x));
 990 (%o2)                       floor(x)
 991 (%i3) declare (n, integer)$
 992 (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
 993 (%o4)                [n, abs(n), max(n, 6)]
 994 (%i5) assume (x > 0, x < 1)$
 995 (%i6) ceiling (x);
 996 (%o6)                           1
 997 (%i7) tex (ceiling (a));
 998 $$\left \lceil a \right \rceil$$
 999 (%o7)                         false
1000 @end example
1001
1002 A função @code{ceiling} não mapeia automaticamente sobre listas ou matrizes.
1003 Finalmente, para todas as entradas que forem manifestamente complexas, @code{ceiling} retorna
1004 uma forma substantiva.
1005
1006 Se o intervalo de uma função é um subconjunto dos inteiros, o intervalo pode ser
1007 declarado @code{integervalued}. Ambas as funções @code{ceiling} e @code{floor}
1008 podem usar essa informação; por exemplo:
1009
1010 @c ===beg===
1011 @c declare (f, integervalued)$
1012 @c floor (f(x));
1013 @c ceiling (f(x) - 1);
1014 @c ===end===
1015 @example
1016 (%i1) declare (f, integervalued)$
1017 (%i2) floor (f(x));
1018 (%o2)                         f(x)
1019 (%i3) ceiling (f(x) - 1);
1020 (%o3)                       f(x) - 1
1021 @end example
1022
1023 @end deffn
1024
1025 @deffn {Função} charfun (@var{p})
1026
1027 Retorna 0 quando o predicado @var{p} avaliar para @code{false}; retorna
1028 1 quando o predicado avaliar para @code{true}.  Quando o predicado
1029 avaliar para alguma coisa que não @code{true} ou @code{false} (@code{unknown}),
1030 retorna uma forma substantiva.
1031
1032 Exemplos:
1033
1034 @c ===beg===
1035 @c charfun (x < 1);
1036 @c subst (x = -1, %);
1037 @c e : charfun ('"and" (-1 < x, x < 1))$
1038 @c [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1039 @c ===end===
1040 @example
1041 (%i1) charfun (x < 1);
1042 (%o1)                    charfun(x < 1)
1043 (%i2) subst (x = -1, %);
1044 (%o2)                           1
1045 (%i3) e : charfun ('"and" (-1 < x, x < 1))$
1046 (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1047 (%o4)                       [0, 1, 0]
1048 @end example
1049
1050 @end deffn
1051
1052 @defvr {Declaração} commutative
1053 Se @code{declare(h,commutative)} é concluída, diz ao
1054 simplicador que @code{h} é uma função comutativa.  E.g. @code{h(x,z,y)} irá
1055 simplificar para @code{h(x, y, z)}.  Isto é o mesmo que @code{symmetric}.
1056
1057 @end defvr
1058
1059 @deffn {Função} compare (@var{x}, @var{y})
1060
1061 Retorna um operador de comparação @var{op}
1062 (@code{<}, @code{<=}, @code{>}, @code{>=}, @code{=}, ou @code{#}) tal que
1063 @code{is (@var{x} @var{op} @var{y})} avalia para @code{true};
1064 quando ou @var{x} ou @var{y} dependendo de @code{%i} e
1065 @code{@var{x} # @var{y}}, retorna @code{notcomparable};
1066 Quando não existir tal operador ou
1067 Maxima não estiver apto a determinar o operador, retorna @code{unknown}.
1068
1069 Exemplos:
1070
1071 @c ===beg===
1072 @c compare (1, 2);
1073 @c compare (1, x);
1074 @c compare (%i, %i);
1075 @c compare (%i, %i + 1);
1076 @c compare (1/x, 0);
1077 @c compare (x, abs(x));
1078 @c ===end===
1079 @example
1080 (%i1) compare (1, 2);
1081 (%o1)                           <
1082 (%i2) compare (1, x);
1083 (%o2)                        unknown
1084 (%i3) compare (%i, %i);
1085 (%o3)                           =
1086 (%i4) compare (%i, %i + 1);
1087 (%o4)                     notcomparable
1088 (%i5) compare (1/x, 0);
1089 (%o5)                           #
1090 (%i6) compare (x, abs(x));
1091 (%o6)                          <=
1092 @end example
1093
1094 A função @code{compare} não tenta de terminar se o domínio real de
1095 seus argumentos é não vazio; dessa forma
1096
1097 @c ===beg===
1098 @c compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1099 @c ===end===
1100 @example
1101 (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1102 (%o1)                           <
1103 @end example
1104
1105 O domínio real de @code{acos (x^2 + 1)} é vazio.
1106
1107 @end deffn
1108
1109 @deffn {Função} entier (@var{x})
1110 Retorna o último inteiro menor que ou igual a @var{x} onde @var{x} é numérico.  @code{fix} (como em
1111 @code{fixnum}) é um sinônimo disso, então @code{fix(@var{x})} é precisamente o mesmo.
1112
1113 @end deffn
1114
1115 @c NEEDS CLARIFICATION
1116 @deffn {Função} equal (@var{a}, @var{b})
1117
1118 Representa a equivalência, isto é, valor igual.
1119
1120 Por si mesma, @code{equal} não avalia ou simplifica.
1121 A função @code{is} tenta avaliar @code{equal} para um valor Booleano.
1122 @code{is(equal(@var{a}, @var{b}))}
1123 retorna @code{true} (ou @code{false}) se
1124 e somente se @var{a} e @var{b} forem iguais (ou não iguais) para todos os possíveis
1125 valores de suas variáveis, como determinado através da avaliação de @code{ratsimp(@var{a} - @var{b})};
1126 se @code{ratsimp} retornar 0, as duas expressões são consideradas equivalentes.
1127 Duas expressões podem ser equivalentes mesmo se mesmo se elas não forem sintaticamente iguais (i.e., identicas).
1128
1129 Quando @code{is} falhar em reduzir @code{equal} a @code{true} ou @code{false},
1130 o resultado é governado através do sinalizador global @code{prederror}.
1131 Quando @code{prederror} for @code{true},
1132 @code{is} reclama com uma mensagem de erro.
1133 De outra forma, @code{is} retorna @code{unknown}.
1134
1135 Complementando @code{is},
1136 alguns outros operadores avaliam @code{equal} e @code{notequal} para @code{true} ou @code{false},
1137 a saber @code{if}, @code{and}, @code{or}, e @code{not}.
1138
1139 @c FOLLOWING STATEMENT IS MORE OR LESS TRUE BUT I DON'T THINK THE DETAILS ARE CORRECT
1140 @c Declarations (integer, complex, etc)
1141 @c for variables appearing in @var{a} and @var{b} are ignored by @code{equal}.
1142 @c All variables are effectively assumed to be real-valued.
1143
1144 A negação de @code{equal} é @code{notequal}.
1145
1146 Exemplos:
1147
1148 Por si mesmo, @code{equal} não avalia ou simplifica.
1149
1150 @c ===beg===
1151 @c equal (x^2 - 1, (x + 1) * (x - 1));
1152 @c equal (x, x + 1);
1153 @c equal (x, y);
1154 @c ===end===
1155 @example
1156 (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
1157                         2
1158 (%o1)            equal(x  - 1, (x - 1) (x + 1))
1159 (%i2) equal (x, x + 1);
1160 (%o2)                    equal(x, x + 1)
1161 (%i3) equal (x, y);
1162 (%o3)                      equal(x, y)
1163 @end example
1164
1165 A função @code{is} tenta avaliar @code{equal} para um valor Booleano.
1166 @code{is(equal(@var{a}, @var{b}))} retorna @code{true} quando @code{ratsimp(@var{a} - @var{b})} retornar 0.
1167 Duas expressões podem ser equivalentes mesmo se não forem sintaticamente iguais (i.e., identicas).
1168
1169 @c ===beg===
1170 @c ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1171 @c is (equal (x^2 - 1, (x + 1) * (x - 1)));
1172 @c is (x^2 - 1 = (x + 1) * (x - 1));
1173 @c ratsimp (x - (x + 1));
1174 @c is (equal (x, x + 1));
1175 @c is (x = x + 1);
1176 @c ratsimp (x - y);
1177 @c is (equal (x, y));
1178 @c is (x = y);
1179 @c ===end===
1180 @example
1181 (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1182 (%o1)                           0
1183 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
1184 (%o2)                         true
1185 (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
1186 (%o3)                         false
1187 (%i4) ratsimp (x - (x + 1));
1188 (%o4)                          - 1
1189 (%i5) is (equal (x, x + 1));
1190 (%o5)                         false
1191 (%i6) is (x = x + 1);
1192 (%o6)                         false
1193 (%i7) ratsimp (x - y);
1194 (%o7)                         x - y
1195 (%i8) is (equal (x, y));
1196 (%o8)                        unknown
1197 (%i9) is (x = y);
1198 (%o9)                         false
1199 @end example
1200
1201 Quando @code{is} falha em reduzir @code{equal} a @code{true} ou @code{false},
1202 o resultado é governado através do sinalizador global @code{prederror}.
1203
1204 @c ===beg===
1205 @c [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1206 @c ratsimp (aa - bb);
1207 @c prederror : true;
1208 @c is (equal (aa, bb));
1209 @c prederror : false;
1210 @c is (equal (aa, bb));
1211 @c ===end===
1212  @example
1213 (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1214                     2             2
1215 (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
1216 (%i2) ratsimp (aa - bb);
1217 (%o2)                        4 x + 2
1218 (%i3) prederror : true;
1219  (%o3)                         true
1220 (%i4) is (equal (aa, bb));
1221 Maxima was unable to evaluate the predicate:
1222        2             2
1223 equal(x  + 2 x + 1, x  - 2 x - 1)
1224  -- an error.  Quitting.  To debug this try debugmode(true);
1225 (%i5) prederror : false;
1226 (%o5)                         false
1227 (%i6) is (equal (aa, bb));
1228 (%o6)                        unknown
1229 @end example
1230
1231 Alguns operadores avaliam @code{equal} e @code{notequal} para @code{true} ou @code{false}.
1232
1233 @c ===beg===
1234 @c if equal (y, y - 1) then FOO else BAR;
1235 @c eq_1 : equal (x, x + 1);
1236 @c eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1237 @c [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1238 @c ===end===
1239 @example
1240 (%i1) if equal (y, y - 1) then FOO else BAR;
1241 (%o1)                          BAR
1242 (%i2) eq_1 : equal (x, x + 1);
1243 (%o2)                    equal(x, x + 1)
1244 (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1245                          2                   2
1246 (%o3)             equal(y  + 2 y + 1, (y + 1) )
1247 (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1248 (%o4)                  [false, true, true]
1249 @end example
1250
1251 Devido a @code{not @var{expr}} fazer com que ocorra a avaliação de @var{expr},
1252 @code{not equal(@var{a}, @var{b})} é equivalente a @code{is(notequal(@var{a}, @var{b}))}.
1253
1254 @c ===beg===
1255 @c [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1256 @c is (notequal (2*z, 2*z - 1));
1257 @c ===end===
1258 @example
1259 (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1260 (%o1)            [notequal(2 z, 2 z - 1), true]
1261 (%i2) is (notequal (2*z, 2*z - 1));
1262 (%o2)                         true
1263 @end example
1264
1265 @end deffn
1266
1267 @deffn {Função} floor (@var{x})
1268
1269 Quando @var{x} for um número real, retorna o maior inteiro que
1270 é menor que ou igual a @var{x}.
1271
1272 Se @var{x} for uma expressão constante (@code{10 * %pi}, for exemplo),
1273 @code{floor} avalia @var{x} usando grandes números em ponto flutuante, e
1274 aplica @code{floor} ao grande número em ponto flutuante resultante. Porque @code{floor} usa
1275 avaliação em ponto flutuante, é possível, embora improvável,
1276 que @code{floor} não possa retornar um valor errôneo para entradas
1277 constantes.  Para prevenir erros, a avaliação de ponto flutuante
1278 é concluída usando três valores para @code{fpprec}.
1279
1280 Para entradas não constantes, @code{floor} tenta retornar um valor
1281 simplificado.  Aqui está exemplos de simplificações que @code{floor}
1282 conhece:
1283
1284 @c ===beg===
1285 @c floor (ceiling (x));
1286 @c floor (floor (x));
1287 @c declare (n, integer)$
1288 @c [floor (n), floor (abs (n)), floor (min (n, 6))];
1289 @c assume (x > 0, x < 1)$
1290 @c floor (x);
1291 @c tex (floor (a));
1292 @c ===end===
1293 @example
1294 (%i1) floor (ceiling (x));
1295 (%o1)                      ceiling(x)
1296 (%i2) floor (floor (x));
1297 (%o2)                       floor(x)
1298 (%i3) declare (n, integer)$
1299 (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
1300 (%o4)                [n, abs(n), min(n, 6)]
1301 (%i5) assume (x > 0, x < 1)$
1302 (%i6) floor (x);
1303 (%o6)                           0
1304 (%i7) tex (floor (a));
1305 $$\left \lfloor a \right \rfloor$$
1306 (%o7)                         false
1307 @end example
1308
1309 A função @code{floor} não mapeia automaticamente sobre listas ou matrizes.
1310 Finalmente, para todas as entradas que forem manifestamente complexas, @code{floor} retorna
1311 uma forma substantiva.
1312
1313 Se o intervalo de uma função for um subconjunto dos inteiros, o intervalo pode ser
1314 declarado @code{integervalued}. Ambas as funções @code{ceiling} e @code{floor}
1315 podem usar essa informação; por exemplo:
1316
1317 @c ===beg===
1318 @c declare (f, integervalued)$
1319 @c floor (f(x));
1320 @c ceiling (f(x) - 1);
1321 @c ===end===
1322 @example
1323 (%i1) declare (f, integervalued)$
1324 (%i2) floor (f(x));
1325 (%o2)                         f(x)
1326 (%i3) ceiling (f(x) - 1);
1327 (%o3)                       f(x) - 1
1328 @end example
1329
1330 @end deffn
1331
1332 @deffn {Função} notequal (@var{a}, @var{b})
1333 Represents the negation of @code{equal(@var{a}, @var{b})}.
1334
1335 Exemplos:
1336
1337 @c ===beg===
1338 @c equal (a, b);
1339 @c maybe (equal (a, b));
1340 @c notequal (a, b);
1341 @c not equal (a, b);
1342 @c maybe (notequal (a, b));
1343 @c assume (a > b);
1344 @c equal (a, b);
1345 @c maybe (equal (a, b));
1346 @c notequal (a, b);
1347 @c maybe (notequal (a, b));
1348 @c ===end===
1349 @example
1350 (%i1) equal (a, b);
1351 (%o1)                      equal(a, b)
1352 (%i2) maybe (equal (a, b));
1353 (%o2)                        unknown
1354 (%i3) notequal (a, b);
1355 (%o3)                    notequal(a, b)
1356 (%i4) not equal (a, b);
1357 (%o4)                    notequal(a, b)
1358 (%i5) maybe (notequal (a, b));
1359 (%o5)                        unknown
1360 (%i6) assume (a > b);
1361 (%o6)                        [a > b]
1362 (%i7) equal (a, b);
1363 (%o7)                      equal(a, b)
1364 (%i8) maybe (equal (a, b));
1365 (%o8)                         false
1366 (%i9) notequal (a, b);
1367 (%o9)                    notequal(a, b)
1368 (%i10) maybe (notequal (a, b));
1369 (%o10)                        true
1370 @end example
1371
1372 @end deffn
1373
1374 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
1375 @c NOTE THAT eval IS RECOGNIZED ONLY AS AN ARGUMENT TO ev,
1376 @c BUT FOR SOME REASON eval DOES NOT HAVE THE evflag PROPERTY
1377 @deffn {Operador} eval
1378 Como um argumento em uma chamada a @code{ev (@var{expr})},
1379 @code{eval} causa uma avaliação extra de @var{expr}.
1380 Veja @code{ev}.
1381
1382 @end deffn
1383
1384 @deffn {Função} evenp (@var{expr})
1385 Retorna @code{true} se @var{expr} for um inteiro sempre.
1386 @c THIS IS STRANGE -- SHOULD RETURN NOUN FORM IF INDETERMINATE
1387 @code{false} é retornado em todos os outros casos.
1388
1389 @end deffn
1390
1391 @deffn {Função} fix (@var{x})
1392 Um sinônimo para @code{entier (@var{x})}.
1393
1394 @end deffn
1395
1396 @deffn {Função} fullmap (@var{f}, @var{expr_1}, ...)
1397 Similar a @code{map}, mas @code{fullmap} mantém mapeadas para
1398 baixo todas as subexpressões até que os operadores principais não mais sejam os
1399 mesmos.
1400
1401 @code{fullmap} é usada pelo simplificador do
1402 Maxima para certas manipulações de matrizes; dessa forma, Maxima algumas vezes gera
1403 uma mensagem de erro concernente a @code{fullmap} mesmo apesar de @code{fullmap} não ter sido
1404 explicitamente chamada pelo usuário.
1405
1406 Exemplos:
1407
1408 @c ===beg===
1409 @c a + b * c;
1410 @c fullmap (g, %);
1411 @c map (g, %th(2));
1412 @c ===end===
1413 @example
1414 (%i1) a + b * c;
1415 (%o1)                        b c + a
1416 (%i2) fullmap (g, %);
1417 (%o2)                   g(b) g(c) + g(a)
1418 (%i3) map (g, %th(2));
1419 (%o3)                     g(b c) + g(a)
1420 @end example
1421
1422 @end deffn
1423
1424 @deffn {Função} fullmapl (@var{f}, @var{list_1}, ...)
1425 Similar a @code{fullmap}, mas @code{fullmapl} somente mapeia sobre
1426 listas e matrizes.
1427
1428 Exemplo:
1429
1430 @c ===beg===
1431 @c fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1432 @c ===end===
1433 @example
1434 (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1435 (%o1)                [[a + 3, 4], [4, 3.5]]
1436 @end example
1437
1438 @end deffn
1439
1440 @deffn {Função} is (@var{expr})
1441 Tenta determinar se a @var{expr} predicada (expressões que avaliam para @code{true}
1442 ou @code{false}) é dedutível de fatos localizados na base de dados de @code{assume}.
1443
1444 Se a dedutibilidade do predicado for @code{true} ou @code{false},
1445 @code{is} retorna @code{true} ou @code{false}, respectivamente.
1446 De outra forma, o valor de retorno é governado através do sinalizador global @code{prederror}.
1447 Quando @code{prederror} for @code{true},
1448 @code{is} reclama com uma mensagem de erro.
1449 De outra forma, @code{is} retorna @code{unknown}.
1450
1451 @code{ev(@var{expr}, pred)}
1452 (que pode ser escrita da forma  @code{@var{expr}, pred} na linha de comando interativa)
1453 é equivalente a @code{is(@var{expr})}.
1454
1455 Veja também @code{assume}, @code{facts}, e @code{maybe}.
1456
1457 Exemplos:
1458
1459 @code{is} causa avaliação de predicados.
1460 @c GENERATED FROM:
1461 @c %pi > %e;
1462 @c é (%pi > %e);
1463
1464 @example
1465 (%i1) %pi > %e;
1466 (%o1)                       %pi > %e
1467 (%i2) é (%pi > %e);
1468 (%o2)                         true
1469 @end example
1470
1471 @code{is} tenta derivar predicados da base de dados do @code{assume}.
1472
1473 @c ===beg===
1474 @c assume (a > b);
1475 @c assume (b > c);
1476 @c é (a < b);
1477 @c é (a > c);
1478 @c é (equal (a, c));
1479 @c ===end===
1480 @example
1481 (%i1) assume (a > b);
1482 (%o1)                        [a > b]
1483 (%i2) assume (b > c);
1484 (%o2)                        [b > c]
1485 (%i3) é (a < b);
1486 (%o3)                         false
1487 (%i4) é (a > c);
1488 (%o4)                         true
1489 (%i5) é (equal (a, c));
1490 (%o5)                         false
1491 @end example
1492
1493 Se @code{is} não puder nem comprovar nem refutar uma forma predicada a partir da base de dados de @code{assume},
1494 o sinalizador global @code{prederror} governa o comportamento de @code{is}.
1495
1496 @c ===beg===
1497 @c assume (a > b);
1498 @c prederror: true$
1499 @c é (a > 0);
1500 @c prederror: false$
1501 @c é (a > 0);
1502 @c ===end===
1503 @example
1504 (%i1) assume (a > b);
1505 (%o1)                        [a > b]
1506 (%i2) prederror: true$
1507 (%i3) é (a > 0);
1508 Maxima was unable to evaluate the predicate:
1509 a > 0
1510  -- an error.  Quitting.  To debug this try debugmode(true);
1511 (%i4) prederror: false$
1512 (%i5) é (a > 0);
1513 (%o5)                        unknown
1514 @end example
1515
1516 @end deffn
1517
1518 @deffn {Função} maybe (@var{expr})
1519 Tenta determinar se a @var{expr} predicada
1520 é dedutível dos fatos na base de dados de @code{assume}.
1521
1522 Se a dedutibilidade do predicado for @code{true} ou @code{false},
1523 @code{maybe} retorna @code{true} ou @code{false}, respectivamente.
1524 De outra forma, @code{maybe} retorna @code{unknown}.
1525
1526 @code{maybe} é funcinalmente equivalente a @code{is} com @code{prederror: false},
1527 mas o resultado é computado sem atualmente atribuir um valor a @code{prederror}.
1528
1529 Veja também @code{assume}, @code{facts}, e @code{is}.
1530
1531 Exemplos:
1532
1533 @c ===beg===
1534 @c maybe (x > 0);
1535 @c assume (x > 1);
1536 @c maybe (x > 0);
1537 @c ===end===
1538 @example
1539 (%i1) maybe (x > 0);
1540 (%o1)                        unknown
1541 (%i2) assume (x > 1);
1542 (%o2)                        [x > 1]
1543 (%i3) maybe (x > 0);
1544 (%o3)                         true
1545 @end example
1546
1547 @end deffn
1548
1549 @deffn {Função} isqrt (@var{x})
1550 Retorna o "inteiro raíz quadrada"
1551 do valor absoluto de @var{x},
1552 que é um inteiro.
1553
1554 @end deffn
1555
1556 @deffn {Função} lmax (@var{L})
1557
1558 Quando @var{L} for uma lista ou um conjunto, retorna @code{apply ('max, args (@var{L}))}.  Quando @var{L} não for uma
1559 lista ou também não for um conjunto, sinaliza um erro.
1560
1561 @end deffn
1562
1563 @deffn {Função} lmin (@var{L})
1564
1565 Quando @var{L} for uma lista ou um conjunto, retorna @code{apply ('min, args (@var{L}))}. Quando @var{L} não for uma
1566 lista ou ou também não for um conjunto, sinaliza um erro.
1567
1568 @end deffn
1569
1570 @deffn {Função} max (@var{x_1}, ..., @var{x_n})
1571
1572 Retorna um valor simplificado para o máximo entre as expressões @var{x_1} a @var{x_n}.
1573 Quando @code{get (trylevel, maxmin)}, for dois ou mais, @code{max} usa a simplificação
1574 @code{max (e, -e) --> |e|}.  Quando @code{get (trylevel, maxmin)} for 3 ou mais, @var{max} tenta
1575 eliminar expressões que estiverem entre dois outros argumentos; por exemplo,
1576 @code{max (x, 2*x, 3*x) --> max (x, 3*x)}. Para escolher o valor de @code{trylevel} para 2, use
1577 @code{put (trylevel, 2, maxmin)}.
1578
1579 @end deffn
1580
1581 @deffn {Função} min (@var{x_1}, ..., @var{x_n})
1582
1583 Retorna um valor simplificado para o mínimo entre as expressões @code{x_1} até @code{x_n}.
1584 Quando @code{get (trylevel, maxmin)}, for 2 ou mais, @code{min} usa a simplificação
1585 @code{min (e, -e) --> -|e|}.  Quando @code{get (trylevel, maxmin)} for 3 ou mais, @code{min} tenta
1586 eliminar expressões que estiverem entre dois outros argumentos; por exemplo,
1587 @code{min (x, 2*x, 3*x) --> min (x, 3*x)}. Para escolher o valor de @code{trylevel} para 2, use
1588 @code{put (trylevel, 2, maxmin)}.
1589
1590 @end deffn
1591
1592 @deffn {Função} polymod (@var{p})
1593 @deffnx {Função} polymod (@var{p}, @var{m})
1594 Converte o polinômio @var{p} para uma representação modular
1595 com relação ao módulo corrente que é o valor da variável
1596 @code{modulus}.
1597
1598 @code{polymod (@var{p}, @var{m})} especifica um módulo @var{m} para ser usado
1599 em lugar do valor corrente de @code{modulus}.
1600
1601 Veja @code{modulus}.
1602
1603 @end deffn
1604
1605 @deffn {Função} mod (@var{x}, @var{y})
1606
1607 Se @var{x} e @var{y} forem números reais e @var{y} for não nulo,
1608 retorna @code{@var{x} - @var{y} * floor(@var{x} / @var{y})}.
1609 Adicionalmente para todo real @var{x}, nós temos @code{mod (@var{x}, 0) = @var{x}}. Para uma discursão da
1610 definição @code{mod (@var{x}, 0) = @var{x}}, veja a Seção 3.4, de "Concrete Mathematics,"
1611 por Graham, Knuth, e Patashnik. A função @code{mod (@var{x}, 1)}
1612 é uma função dente de serra com período 1 e com @code{mod (1, 1) = 0} e
1613 @code{mod (0, 1) = 0}.
1614
1615 Para encontrar o argumento (um número no intervalo @code{(-%pi, %pi]}) de um
1616 número complexo, use a função @code{@var{x} |-> %pi - mod (%pi - @var{x}, 2*%pi)}, onde
1617 @var{x} é um argumento.
1618
1619 Quando @var{x} e @var{y} forem expressões constantes (@code{10 * %pi}, por exemplo), @code{mod}
1620 usa o mesmo esquema de avaliação em ponto flutuante que @code{floor} e @code{ceiling} usam.
1621 Novamente, é possível, embora improvável, que @code{mod} possa retornar um
1622 valor errôneo nesses casos.
1623
1624 Para argumentos não numéricos @var{x} ou @var{y}, @code{mod }conhece muitas regras de
1625 simplificação:
1626
1627 @c ===beg===
1628 @c mod (x, 0);
1629 @c mod (a*x, a*y);
1630 @c mod (0, x);
1631 @c ===end===
1632 @example
1633 (%i1) mod (x, 0);
1634 (%o1)                           x
1635 (%i2) mod (a*x, a*y);
1636 (%o2)                      a mod(x, y)
1637 (%i3) mod (0, x);
1638 (%o3)                           0
1639 @end example
1640
1641 @end deffn
1642
1643 @deffn {Função} oddp (@var{expr})
1644 é @code{true} se @var{expr} for um inteiro ímpar.
1645 @c THIS IS STRANGE -- SHOULD RETURN NOUN FORM IF INDETERMINATE
1646 @code{false} é retornado em todos os outros casos.
1647
1648 @end deffn
1649
1650 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
1651 @c NOTE THAT pred IS RECOGNIZED ONLY AS AN ARGUMENT TO ev,
1652 @c BUT FOR SOME REASON pred DOES NOT HAVE THE evflag PROPERTY
1653 @deffn {Operador} pred
1654 Como um argumento em uma chamada a @code{ev (@var{expr})},
1655 @code{pred} faz com que predicados (expressões que avaliam para @code{true}
1656 ou @code{false}) sejam avaliados.
1657 Veja @code{ev}.
1658
1659 @end deffn
1660
1661 @deffn {Função} make_random_state (@var{n})
1662 @deffnx {Função} make_random_state (@var{s})
1663 @deffnx {Função} make_random_state (true)
1664 @deffnx {Função} make_random_state (false)
1665 @c OMIT THIS FOR NOW. SEE COMMENT BELOW.
1666 @c @defunx make_random_state (@var{a})
1667 Um objeto de estado randômico representa o estado do gerador de números randômicos (aleatórios).
1668 O estado compreende 627 palavras de 32 bits.
1669
1670 @code{make_random_state (@var{n})} retorna um novo objeto de estado randômico
1671 criado de um valor inteiro semente igual a @var{n} modulo 2^32.
1672 @var{n} pode ser negativo.
1673
1674 @c OMIT THIS FOR NOW. NOT SURE HOW THIS IS SUPPOSED TO WORK.
1675 @c @code{make_random_state (@var{a})} returns a new random state object
1676 @c created from an array @var{a}, which must be a Lisp array of 32 unsigned bytes.
1677
1678 @code{make_random_state (@var{s})} retorna uma copia do estado randômico @var{s}.
1679
1680 @code{make_random_state (true)} retorna um novo objeto de estado randômico,
1681 usando a hora corrente  do relógio do computador como semente.
1682
1683 @code{make_random_state (false)} retorna uma cópia do estado corrente
1684 do gerador de números randômicos.
1685
1686 @end deffn
1687
1688 @deffn {Função} set_random_state (@var{s})
1689 Copia @var{s} para o estado do gerador de números randômicos.
1690
1691 @code{set_random_state} sempre retorna @code{done}.
1692
1693 @end deffn
1694
1695 @deffn {Função} random (@var{x})
1696 Retorna um número pseudorandômico. Se @var{x} é um inteiro, @code{random (@var{x})} retorna um
1697 inteiro de 0 a @code{@var{x} - 1} inclusive. Se @var{x} for um número em ponto flutuante,
1698 @code{random (@var{x})} retorna um número não negativo em ponto flutuante menor que @var{x}.
1699 @code{random} reclama com um erro se @var{x} não for nem um inteiro nem um número em ponto flutuante,
1700 ou se @var{x} não for positivo.
1701
1702 As funções @code{make_random_state} e @code{set_random_state}
1703 mantém o estado do gerador de números randômicos.
1704
1705 O gerador de números randômicos do Maxima é uma implementação do algorítmo de Mersenne twister MT 19937.
1706
1707 Exemplos:
1708
1709 @c ===beg===
1710 @c s1: make_random_state (654321)$
1711 @c set_random_state (s1);
1712 @c random (1000);
1713 @c random (9573684);
1714 @c random (2^75);
1715 @c s2: make_random_state (false)$
1716 @c random (1.0);
1717 @c random (10.0);
1718 @c random (100.0);
1719 @c set_random_state (s2);
1720 @c random (1.0);
1721 @c random (10.0);
1722 @c random (100.0);
1723 @c ===end===
1724 @example
1725 (%i1) s1: make_random_state (654321)$
1726 (%i2) set_random_state (s1);
1727 (%o2)                         done
1728 (%i3) random (1000);
1729 (%o3)                          768
1730 (%i4) random (9573684);
1731 (%o4)                        7657880
1732 (%i5) random (2^75);
1733 (%o5)                11804491615036831636390
1734 (%i6) s2: make_random_state (false)$
1735 (%i7) random (1.0);
1736 (%o7)                   .2310127244107132
1737 (%i8) random (10.0);
1738 (%o8)                   4.394553645870825
1739 (%i9) random (100.0);
1740 (%o9)                   32.28666704056853
1741 (%i10) set_random_state (s2);
1742 (%o10)                        done
1743 (%i11) random (1.0);
1744 (%o11)                  .2310127244107132
1745 (%i12) random (10.0);
1746 (%o12)                  4.394553645870825
1747 (%i13) random (100.0);
1748 (%o13)                  32.28666704056853
1749 @end example
1750
1751 @end deffn
1752
1753 @deffn {Função} rationalize (@var{expr})
1754
1755 Converte todos os números em ponto flutuante de precisão dupla e grandes números em ponto flutuante na expressão do Maxima
1756 @var{expr} para seus exatos equivalentes racionais. Se você não estiver faminilarizado com
1757 a representação binária de números em ponto flutuante, você pode se
1758 surpreender que @code{rationalize (0.1)} não seja igual a 1/10.  Esse comportamento
1759 não é especial para o Maxima -- o número 1/10 tem uma representação binária
1760 repetitiva e não terminada.
1761
1762 @c ===beg===
1763 @c rationalize (0.5);
1764 @c rationalize (0.1);
1765 @c fpprec : 5$
1766 @c rationalize (0.1b0);
1767 @c fpprec : 20$
1768 @c rationalize (0.1b0);
1769 @c rationalize (sin (0.1*x + 5.6));
1770 @c ===end===
1771 @example
1772 (%i1) rationalize (0.5);
1773                                 1
1774 (%o1)                           -
1775                                 2
1776 (%i2) rationalize (0.1);
1777                                1
1778 (%o2)                          --
1779                                10
1780  (%i3) fpprec : 5$
1781 (%i4) rationalize (0.1b0);
1782                              209715
1783 (%o4)                        -------
1784                              2097152
1785 (%i5) fpprec : 20$
1786 (%i6) rationalize (0.1b0);
1787                      236118324143482260685
1788 (%o6)                ----------------------
1789                      2361183241434822606848
1790 (%i7) rationalize (sin (0.1*x + 5.6));
1791                               x    28
1792 (%o7)                     sin(-- + --)
1793                               10   5
1794 @end example
1795
1796 Exemplo de utilização:
1797
1798 @c ===beg===
1799 @c unitfrac(r) := block([uf : [], q],
1800 @c     if not(ratnump(r)) then error("A entrada para 'unitfrac' deve ser um número racional"),
1801 @c     while r # 0 do (
1802 @c         uf : cons(q : 1/ceiling(1/r), uf),
1803 @c         r : r - q),
1804 @c     reverse(uf));
1805 @c unitfrac (9/10);
1806 @c apply ("+", %);
1807 @c unitfrac (-9/10);
1808 @c apply ("+", %);
1809 @c unitfrac (36/37);
1810 @c apply ("+", %);
1811 @c ===end===
1812 @example
1813 (%i1) unitfrac(r) := block([uf : [], q],
1814     if not(ratnump(r)) then error("The input to 'unitfrac' must be a rational number"),
1815     while r # 0 do (
1816         uf : cons(q : 1/ceiling(1/r), uf),
1817         r : r - q),
1818     reverse(uf));
1819 (%o1) unitfrac(r) := block([uf : [], q],
1820 if not ratnump(r) then error("The input to 'unitfrac' must be a rational number"
1821                                      1
1822 ), while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
1823                                          1
1824                                  ceiling(-)
1825                                          r
1826 reverse(uf))
1827 (%i2) unitfrac (9/10);
1828                             1  1  1
1829 (%o2)                      [-, -, --]
1830                             2  3  15
1831 (%i3) apply ("+", %);
1832                                9
1833 (%o3)                          --
1834                                10
1835 (%i4) unitfrac (-9/10);
1836                                   1
1837 (%o4)                       [- 1, --]
1838                                   10
1839 (%i5) apply ("+", %);
1840                                 9
1841 (%o5)                         - --
1842                                 10
1843 (%i6) unitfrac (36/37);
1844                         1  1  1  1    1
1845 (%o6)                  [-, -, -, --, ----]
1846                         2  3  8  69  6808
1847 (%i7) apply ("+", %);
1848                                36
1849 (%o7)                          --
1850                                37
1851 @end example
1852
1853 @end deffn
1854
1855 @deffn {Função} sign (@var{expr})
1856 Tenta determinar o sinal de @var{expr}
1857 a partir dos fatos na base de dados corrente.  Retorna uma das
1858 seguintes respostar: @code{pos} (positivo), @code{neg} (negativo), @code{zero}, @code{pz}
1859 (positivo ou zero), @code{nz} (negativo ou zero), @code{pn} (positivo ou negativo),
1860 ou @code{pnz} (positivo, negativo, ou zero, i.e. nada se sabe sobre o sinal da epressão).
1861
1862 @end deffn
1863
1864 @deffn {Função} signum (@var{x})
1865 Para um @var{x} numérico retorna 0 se @var{x} for 0, de outra forma retorna -1 ou +1
1866 à medida que @var{x} seja menor ou maior que 0, respectivamente.
1867
1868 Se @var{x} não for numérico então uma forma simplificada mas equivalente é retornada.
1869 Por exemplo, @code{signum(-x)} fornece @code{-signum(x)}.
1870 @c UMM, THIS ISN'T THE WHOLE STORY, AS IT APPEARS signum CONSULTS THE assume DATABASE FOR SYMBOLIC ARGUMENT
1871
1872 @end deffn
1873
1874 @deffn {Função} sort (@var{L}, @var{P})
1875 @deffnx {Função} sort (@var{L})
1876 Organiza uma lista @var{L} coforme o predicado @code{P} de dois argumentos,
1877 de forma que @code{@var{P} (@var{L}[k], @var{L}[k + 1])} seja @code{true}
1878 para qualquer dois elementos sucessivos.
1879 O predicado pode ser especificado como o nome de uma função ou operador binário infixo,
1880 ou como uma expressão @code{lambda}.
1881 Se especificado como o nome de um operador,
1882 o nome deve ser contido entre "aspas duplas".
1883
1884 A lista ordenada é retornada como novo objeto;
1885 o argumento @var{L} não é modificado.
1886 Para construir o valor de retorno,
1887 @code{sort} faz uma cópia superficial dos elementos de @var{L}.
1888 @c DUNNO IF WE NEED TO GO INTO THE IMPLICATIONS OF SHALLOW COPY HERE ...
1889 @c MIGHT CONSIDER A REF FOR TOTAL ORDER HERE
1890 Se o predicado @var{P} não for uma ordem total sobre os elementos de @var{L},
1891 então @code{sort} possivelvente pode executar para concluir sem error,
1892 mas os resultados são indefinidos.
1893 @code{sort} reclama se o predicado avaliar para alguma outra coisa
1894 que não seja @code{true} ou @code{false}.
1895
1896 @code{sort (@var{L})} é equivalente a @code{sort (@var{L}, orderlessp)}.
1897 Isto é, a ordem padrão de organização é ascendente,
1898 como determinado por @code{orderlessp}.
1899 Todos os átomos do Maxima e expressões são comparáveis sob @code{orderlessp},
1900 embora exista exemplos isolados de expressões para as quais @code{orderlessp} não é transitiva;
1901 isso é uma falha.
1902
1903 Exemplos:
1904
1905 @c ===beg===
1906 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
1907 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x], ordergreatp);
1908 @c sort ([%pi, 3, 4, %e, %gamma]);
1909 @c sort ([%pi, 3, 4, %e, %gamma], "<");
1910 @c my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
1911 @c sort (my_list);
1912 @c sort (my_list, lambda ([a, b], orderlessp (reverse (a), reverse (b))));
1913 @c ===end===
1914 @example
1915 (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
1916                5
1917 (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
1918                2
1919 (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x], ordergreatp);
1920                                                    5
1921 (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
1922                                                    2
1923 (%i3) sort ([%pi, 3, 4, %e, %gamma]);
1924 (%o3)                [3, 4, %e, %gamma, %pi]
1925 (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
1926 (%o4)                [%gamma, %e, 3, %pi, 4]
1927 (%i5) my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
1928 (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
1929 (%i6) sort (my_list);
1930 (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
1931 (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a), reverse (b))));
1932 (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
1933 @end example
1934
1935 @end deffn
1936
1937 @deffn {Função} sqrt (@var{x})
1938 A raíz quadrada de @var{x}. É representada internamente por
1939 @code{@var{x}^(1/2)}.  Veja também @code{rootscontract}.
1940
1941 @code{radexpand} se @code{true} fará com que n-ésimas raízes de fatores de um produto
1942 que forem potências de n sejam colocados fora do radical, e.g.
1943 @code{sqrt(16*x^2)} retonará @code{4*x} somente se @code{radexpand} for @code{true}.
1944
1945 @end deffn
1946
1947 @defvr {Variável de opção} sqrtdispflag
1948 Valor padrão: @code{true}
1949
1950 Quando @code{sqrtdispflag} for @code{false},
1951 faz com que @code{sqrt} seja mostrado como expoente 1/2.
1952 @c AND OTHERWISE ... ??
1953
1954 @end defvr
1955
1956 @c NEEDS EXPANSION, CLARIFICATION, MORE EXAMPLES
1957 @c sublis CAN ONLY SUBSTITUTE FOR ATOMS, RIGHT ?? IF SO, SAY SO
1958 @deffn {Função} sublis (@var{lista}, @var{expr})
1959 Faz multiplas substituições paralelas dentro de uma expressão.
1960
1961 A variável @code{sublis_apply_lambda} controla a simplificação após
1962 @code{sublis}.
1963
1964 Exemplo:
1965
1966 @example
1967 @c ===beg===
1968 @c sublis ([a=b, b=a], sin(a) + cos(b));
1969 @c ===end===
1970 @end example
1971
1972 @end deffn
1973
1974 @deffn {Função} sublist (@var{lista}, @var{p})
1975 Retorna a lista de elementos da @var{lista} da qual o
1976 predicado @code{p} retornar @code{true}.
1977
1978 Exemplo:
1979
1980 @c ===beg===
1981 @c L: [1, 2, 3, 4, 5, 6];
1982 @c sublist (L, evenp);
1983 @c ===end===
1984 @example
1985 (%i1) L: [1, 2, 3, 4, 5, 6];
1986 (%o1)                  [1, 2, 3, 4, 5, 6]
1987 (%i2) sublist (L, evenp);
1988 (%o2)                       [2, 4, 6]
1989 @end example
1990
1991 @end deffn
1992
1993 @defvr {Variável de opção} sublis_apply_lambda
1994 Valor padrão: @code{true} - controla se os substitutos de
1995 @code{lambda} são aplicados na simplificação após as @code{sublis} serem usadas ou
1996 se você tem que fazer um @code{ev} para pegar coisas para aplicar.  @code{true} significa faça a
1997 aplicação.
1998
1999 @end defvr
2000
2001 @c NEEDS CLARIFICATION, MORE EXAMPLES
2002 @deffn {Função} subst (@var{a}, @var{b}, @var{c})
2003 Substitue @var{a} por @var{b} em @var{c}.  @var{b} deve ser um átomo ou uma
2004 subexpressão completa de @var{c}.  Por exemplo, @code{x+y+z} é uma subexpressão
2005 completa de @code{2*(x+y+z)/w} enquanto @code{x+y} não é. Quando @var{b} não tem
2006 essas características, pode-se algumas vezes usar @code{substpart} ou @code{ratsubst}
2007 (veja abaixo).  Alternativamente, se @var{b} for da forma de @code{e/f} então se poderá
2008 usar @code{subst (a*f, e, c)} enquanto se @var{b} for da forma @code{e^(1/f)} então se poderá
2009 usar @code{subst (a^f, e, c)}.  O comando @code{subst} também discerne o @code{x^y} de @code{x^-y}
2010 de modo que @code{subst (a, sqrt(x), 1/sqrt(x))} retorna @code{1/a}.  @var{a} e @var{b} podem também ser
2011 operadores de uma expressão contida entre aspas duplas @code{"} ou eles podem ser nomes de
2012 função.  Se se desejar substituir por uma variável independente em
2013 formas derivadas então a função @code{at} (veja abaixo) poderá ser usada.
2014
2015 @c UMM, REVERSE THIS AND MOVE IT TO substitute ??
2016 @code{subst} é um álias para @code{substitute}.
2017
2018 @code{subst (@var{eq_1}, @var{expr})} ou @code{subst ([@var{eq_1}, ..., @var{eq_k}], @var{expr})}
2019 são outras formas
2020 permitidas.  As @var{eq_i} são equações indicando substituições a serem feitas.
2021 Para cada equação, o lado direito será substituído pelo lado esquerdo na
2022 expressão @var{expr}.
2023
2024 @code{exptsubst} se @code{true} permite que substituições
2025 como @code{y} por @code{%e^x} em @code{%e^(a*x)} ocorram.
2026
2027 @c WHAT IS THIS ABOUT ??
2028 Quando @code{opsubst} for @code{false},
2029 @code{subst} tentará substituir dentro do operador de uma expressão.
2030 E.g. @code{(opsubst: false, subst (x^2, r, r+r[0]))} trabalhará.
2031
2032 Exemplos:
2033
2034 @example
2035 (%i1) subst (a, x+y, x + (x+y)^2 + y);
2036                                     2
2037 (%o1)                      y + x + a
2038 (%i2) subst (-%i, %i, a + b*%i);
2039 (%o2)                       a - %i b
2040 @end example
2041
2042 @noindent
2043 Para exemplos adicionais, faça @code{example (subst)}.
2044
2045 @end deffn
2046
2047 @c NEEDS CLARIFICATION
2048 @deffn {Função} substinpart (@var{x}, @var{expr}, @var{n_1}, ..., @var{n_k})
2049 Similar a @code{substpart}, mas @code{substinpart} trabalha sobre a
2050 representação interna de @var{expr}.
2051
2052 Exemplos:
2053
2054 @c ===beg===
2055 @c x . 'diff (f(x), x, 2);
2056 @c substinpart (d^2, %, 2);
2057 @c substinpart (f1, f[1](x + 1), 0);
2058 @c ===end===
2059 @example
2060 (%i1) x . 'diff (f(x), x, 2);
2061                               2
2062                              d
2063 (%o1)                   x . (--- (f(x)))
2064                                2
2065                              dx
2066 (%i2) substinpart (d^2, %, 2);
2067                                   2
2068 (%o2)                        x . d
2069 (%i3) substinpart (f1, f[1](x + 1), 0);
2070 (%o3)                       f1(x + 1)
2071 @end example
2072
2073 Se o último argumento para a função @code{part} for uma lista de índices então
2074 muitas subexpressões são escolhidas, cada uma correspondendo a um
2075 índice da lista.  Dessa forma
2076
2077 @c ===beg===
2078 @c part (x + y + z, [1, 3]);
2079 @c ===end===
2080 @example
2081 (%i1) part (x + y + z, [1, 3]);
2082 (%o1)                         z + x
2083 @end example
2084
2085 @code{piece} recebe o valor da última expressão selecionada quando usando as
2086 funções @code{part}.  @code{piece} é escolhida durante a execução da função e
2087 dessa forma pode ser referenciada para a própria função como mostrado abaixo.
2088 Se @code{partswitch} for escolhida para @code{true} então @code{end} é retornado quando uma
2089 parte selecionada de uma expressão não existir, de outra forma uma mensagem
2090 de erro é fornecida.
2091
2092 @c ===beg===
2093 @c expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
2094 @c part (expr, 2, [1, 3]);
2095 @c sqrt (piece/54);
2096 @c substpart (factor (piece), expr, [1, 2, 3, 5]);
2097 @c expr: 1/x + y/x - 1/z;
2098 @c substpart (xthru (piece), expr, [2, 3]);
2099 @c ===end===
2100 @example
2101 (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
2102               3         2       2            3
2103 (%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
2104 (%i2) part (expr, 2, [1, 3]);
2105                                   2
2106 (%o2)                         54 y
2107 (%i3) sqrt (piece/54);
2108 (%o3)                        abs(y)
2109 (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
2110                                3
2111 (%o4)               (3 y + 2 x)  + y + x + 1
2112 (%i5) expr: 1/x + y/x - 1/z;
2113                              1   y   1
2114 (%o5)                      - - + - + -
2115                              z   x   x
2116 (%i6) substpart (xthru (piece), expr, [2, 3]);
2117                             y + 1   1
2118 (%o6)                       ----- - -
2119                               x     z
2120 @end example
2121
2122 Também, escolhendo a opção @code{inflag} para @code{true} e chamando @code{part} ou @code{substpart} é
2123 o mesmo que chamando @code{inpart} ou @code{substinpart}.
2124
2125 @end deffn
2126
2127 @c NEEDS CLARIFICATION
2128 @deffn {Função} substpart (@var{x}, @var{expr}, @var{n_1}, ..., @var{n_k})
2129 Substitue @var{x} para a subexpressão
2130 selecionada pelo resto dos argumentos como em @code{part}.  Isso retorna o
2131 novo valor de @var{expr}.  @var{x} pode ser algum operador a ser substituído por um
2132 operador de @var{expr}.  Em alguns casos @var{x} precisa ser contido em aspas duplas @code{"}
2133 (e.g.  @code{substpart ("+", a*b, 0)} retorna @code{b + a}).
2134
2135 @c ===beg===
2136 @c 1/(x^2 + 2);
2137 @c substpart (3/2, %, 2, 1, 2);
2138 @c a*x + f(b, y);
2139 @c substpart ("+", %, 1, 0);
2140 @c ===end===
2141 @example
2142 (%i1) 1/(x^2 + 2);
2143                                1
2144 (%o1)                        ------
2145                               2
2146                              x  + 2
2147 (%i2) substpart (3/2, %, 2, 1, 2);
2148                                1
2149 (%o2)                       --------
2150                              3/2
2151                             x    + 2
2152 (%i3) a*x + f (b, y);
2153 (%o3)                     a x + f(b, y)
2154 (%i4) substpart ("+", %, 1, 0);
2155 (%o4)                    x + f(b, y) + a
2156 @end example
2157
2158 Também, escolhendo a opção @code{inflag} para @code{true} e chamando @code{part} ou @code{substpart} é
2159 o mesmo que chamando @code{inpart} ou @code{substinpart}.
2160
2161 @end deffn
2162
2163 @c NEEDS EXPANSION AND EXAMPLES
2164 @deffn {Função} subvarp (@var{expr})
2165 Retorna @code{true} se @var{expr} for uma variável subscrita (i.e. que possui índice ou subscrito em sua grafia), por exemplo
2166 @code{a[i]}.
2167
2168 @end deffn
2169
2170 @deffn {Função} symbolp (@var{expr})
2171 Retorna @code{true} se @var{expr} for um símbolo, de outra forma retorna @code{false}.
2172 com efeito, @code{symbolp(x)} é equivalente ao predicado @code{atom(x) and not numberp(x)}.
2173
2174 @c FOLLOWING REALLY WANTS TO BE @xref{Identiifers} BUT THAT
2175 @c LEAVES THE UNPLEASANT RESIDUE *Note ...:: IN THE OUTPUT OF describe
2176 Veja também @ref{Identificadores}
2177
2178 @end deffn
2179
2180 @deffn {Função} unorder ()
2181 Disabilita a ação de alias criada pelo último uso dos comandos
2182 de ordenação @code{ordergreat} e @code{orderless}. @code{ordergreat} e @code{orderless} não podem
2183 ser usados mais que uma vez cada sem chamar @code{unorder}.
2184 Veja também @code{ordergreat} e @code{orderless}.
2185
2186 Exemplos:
2187
2188 @c HMM, IN THIS EXAMPLE, WHY ISN'T %o5 EQUAL TO ZERO ???
2189 @c ===beg===
2190 @c unorder();
2191 @c b*x + a^2;
2192 @c ordergreat (a);
2193 @c b*x + a^2;
2194 @c  %th(1) - %th(3);
2195 @c unorder();
2196 @c ===end===
2197 @example
2198 (%i1) unorder();
2199 (%o1)                          []
2200 (%i2) b*x + a^2;
2201                                    2
2202 (%o2)                       b x + a
2203 (%i3) ordergreat (a);
2204 (%o3)                         done
2205 (%i4) b*x + a^2;
2206  %th(1) - %th(3);
2207                              2
2208 (%o4)                       a  + b x
2209 (%i5) unorder();
2210                               2    2
2211 (%o5)                        a  - a
2212 @end example
2213
2214 @end deffn
2215
2216 @c THIS ITEM SEEMS OUT OF PLACE -- IS IT FROM A SHARE PACKAGE ??
2217 @c NEEDS EXAMPLES
2218 @deffn {Função} vectorpotential (@var{givencurl})
2219 Retorna o potencial do vetor de um dado
2220 vetor de torção, no sistema de coordenadas corrente.
2221 @code{potentialzeroloc} tem um papel similar ao de @code{potential}, mas a ordem dos
2222 lados esquerdos das equações deve ser uma permutação cíclica das
2223 variáveis de coordenadas.
2224
2225 @end deffn
2226
2227 @deffn {Função} xthru (@var{expr})
2228 Combina todos os termos de @var{expr} (o qual pode ser uma adição) sobre um
2229 denominador comum sem produtos e somas exponenciadas
2230 como @code{ratsimp} faz.  @code{xthru} cancela fatores comuns no numerador e
2231 denominador de expressões racionais mas somente se os fatores são
2232 explícitos.
2233
2234 @c REPHRASE IN NEUTRAL TONE (GET RID OF "IT IS BETTER")
2235 Algumas vezes é melhor usar @code{xthru} antes de @code{ratsimp} em uma
2236 expressão com o objetivo de fazer com que fatores explicitos do máximo divisor comum entre o
2237 numerador e o denominador seja cancelado simplificando dessa forma a
2238 expressão a ser aplicado o @code{ratsimp}.
2239
2240 @c ===beg===
2241 @c ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
2242 @c xthru (%);
2243 @c ===end===
2244 @example
2245 (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
2246                                 20
2247                  1       (x + 2)   - 2 y       x
2248 (%o1)        --------- + --------------- - ---------
2249                     19             20             20
2250              (y + x)        (y + x)        (y + x)
2251 (%i2) xthru (%);
2252                                  20
2253                           (x + 2)   - y
2254 (%o2)                     -------------
2255                                    20
2256                             (y + x)
2257 @end example
2258
2259 @end deffn
2260
2261 @c THIS FUNCTION APPEARS TO BE A HACK; SEE 4'TH ITEM BELOW
2262 @c DUNNO WHETHER WE CAN CLEAR THIS UP
2263 @deffn {Função} zeroequiv (@var{expr}, @var{v})
2264 Testa se a expressão @var{expr} na variável
2265 @var{v} é equivalente a zero, retornando @code{true}, @code{false}, ou
2266 @code{dontknow} (não sei).
2267
2268 @code{zeroequiv} Tem essas restrições:
2269 @enumerate
2270 @item
2271 Não use funções que o Maxima não sabe como
2272 diferenciar e avaliar.
2273 @item
2274 Se a expressão tem postes sobre o eixo real, podem existir erros
2275 no resultado (mas isso é improvável ocorrer).
2276 @item
2277 Se a expressão contem funções que não são soluções para
2278 equações diferenciais de primeira ordem (e.g.  funções de Bessel) pode ocorrer
2279 resultados incorretos.
2280 @item
2281 O algorítmo usa avaliação em pontos aleatóriamente escolhidos para
2282 subexpressões selecionadas cuidadosamente.  Isso é sempre negócio um tanto
2283 quanto perigoso, embora o algorítmo tente minimizar o
2284 potencial de erro.
2285 @end enumerate
2286
2287 Por exemplo
2288  @code{zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)} retorna
2289 @code{true} e @code{zeroequiv (%e^x + x, x)} retorna @code{false}.
2290 Por outro lado @code{zeroequiv (log(a*b) - log(a) - log(b), a)} retorna @code{dontknow} devido à
2291 presença de um parâmetro extra @code{b}.
2292
2293 @end deffn
2294