N-Argumentos
============

Um operador nary é usado para denotar uma funcedilhaão com qualquer número de argumentos, cada um dos quais é separado por uma ocorrência do operador, e.g. A+B ou A+B+C.  A funcedilhaão nary("x")  é uma funcedilhaão de extensão sintática para declarar x como sendo um operador nary. Funcedilhaões podem ser declaradas para serem nary.  Se declare(j,nary); é concluída, diz ao simplicador para simplificar, e.g. j(j(a,b),j(c,d)) para j(a, b, c, d).

Veja também syntax.

Operador não fixado
===================

Operadores nofix são usados para denotar funcedilhaões sem argumentos. A mera presencedilhaa de tal operador em um comando fará com que a funcedilhaão correspondente seja avaliada.  Por exemplo, quando se digita "exit;" para sair de uma parada do Maxima, "exit" tem comportamento similar a um operador nofix.  A funcedilhaão nofix("x") é uma funcedilhaão de extensão sintática que declara x como sendo um operador nofix.

Veja também syntax.

Operador Pósfixado
==================

Operadores postfix como a variedade prefix denotam funcedilhaões de um argumento simples, mas nesse caso  o argumento sucede imediatamente uma ocorrência do operador na seqüência de caracteres de entrada, e.g. 3! . Uma funcedilhaão postfix("x") é uma funcedilhaão de extensão sintática que declara x como sendo um operador postfix.

Veja também syntax.

Operador Préfixado
==================

Um operador prefix é um que significa uma funcedilhaão de um argumento, o qual imediatamente segue uma ocorrência do operador.  prefix("x") é uma funcedilhaão de extensão sintática que declara x como sendo um operador prefix.

Veja também syntax.

Operadores Aritméticos
======================

 -- Operador: +
 -- Operador: -
 -- Operador: *
 -- Operador: /
 -- Operador: ^

     Os símbolos + * / e ^ representam adicedilhaão, multiplicacedilhaão, divisão, e exponenciacedilhaão, respectivamente. O nome desses operadores são "+" "*" "//" e "^", os quais podem aparecer em lugares onde o nome da funcedilhaão ou operador é requerido.

     Os símbolos + e - representam a adicedilhaão unária e a negacedilhaão unária, respectivamente, e os nomes desses operadores são "+" e "-", respectivamente.

     A subtracedilhaão a - b é representada dentro do Maxima como a adicedilhaão, a + (- b). Expressões tais como a + (- b) são mostradas como subtracedilhaão. Maxima reconhece "-" somente como o nome do operador unário de negacedilhaão, e não como o nome do operador binário de subracedilhaão.

     A divisão a / b é representada dentro do Maxima como multiplicacedilhaão, a * b^(- 1). Expressões tais como a * b^(- 1) são mostradas como divisão. Maxima reconhece "//" como o nome do operador de divisão.

     A adicedilhaão e a multiplicacedilhaão são operadores enários e comutativos. a divisão e a exponenciacedilhaão são operadores binários e não comutativos.

     Maxima ordena os operandos de operadores não comutativos para construir uma representacedilhaão canônica. Para armazenamento interno, a ordem é determinada por orderlessp. Para mostrar na tela, a ordem para adicedilhaão é determinada por ordergreatp, e para a multiplicacedilhaão, a ordem é a mesma da ordenacedilhaão para armazenamento interno.

     Computacedilhaões aritiméticas são realizadas sobre números literais (inteiro, racionais, números comuns em ponto flutuante, e grandes números em ponto flutuante de dupla precisão). Execto a exponenciacedilhaão, todas as operacedilhaões aritméticas sobre números são simplificadas para números. A exponenciacedilhaã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 ou se o resultado for um inteiro exato ou um racional exato; de outra forma uma exponenciacedilhaão pode ser simplificada para sqrt ou outra exponenciacedilhaão ou permanecer inalterada.

     A propagacedilhaão de números em ponto flutuante aplica-se a computacedilhaões aritiméticas: Se qualquer operando for um grande número em ponto flutuante, o resultado é um grande número em ponto flutuante; de outra forma, se qualquer operando for um número em ponto flutuante comum, o resultado é um número comum em ponto flutuante; de outra forma, se os operandos forem racioanis ou inteiros e o resultado será um racional ou inteiro.

     Computacedilhaãoes aritiméticas são uma simplificacedilhaão, não uma avaliacedilhaão. Dessa forma a aritmética é realizada em  expressões com apóstrofo (mas simplificadas).

     Operacedilhaões aritméticas são aplicadas elemento-por-elemento para listas quando a variável global listarith for true, e sempre aplicada elemento-por-elemento para matrizes. Quando um operando for uma lista ou uma matriz e outro for um operando de algum outro tipo, o outro operando é combinado com cada um dos elementos da lista ou matriz.

     Exemplos:

     Adicedilhaão e multiplicacedilhaão são opeadores enários comutativos. Maxima ordena os operandos para construir uma representacedilhaão canônica. Os nomes desses operadores são "+" e "*".

          (%i1) c + g + d + a + b + e + f;
          (%o1)               g + f + e + d + c + b + a
          (%i2) [op (%), args (%)];
          (%o2)              [+, [g, f, e, d, c, b, a]]
          (%i3) c * g * d * a * b * e * f;
          (%o3)                     a b c d e f g
          (%i4) [op (%), args (%)];
          (%o4)              [*, [a, b, c, d, e, f, g]]
          (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
          (%o5)                    3 x + 2 a + 19
          (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
                                           2  3
          (%o6)                       144 a  x

     Divisão e exponenciacedilhaão são operadores binários e não comutativos. Os nomes desses operadores são "//" e "^".

          (%i1) [a / b, a ^ b];
                                        a   b
          (%o1)                        [-, a ]
                                        b
          (%i2) [map (op, %), map (args, %)];
          (%o2)              [[//, ^], [[a, b], [a, b]]]
          (%i3) [apply ("//", [a, b]), apply ("^", [a, b])];
                                        a   b
          (%o3)                        [-, a ]
                                        b

     Subtracedilhaão e divisão são representados internamente em termos de adicedilhaão e multiplicacedilhaão, respectivamente.

          (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
          (%o1)                      [+, a, - b]
          (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
                                             1
          (%o2)                       [*, a, -]
                                             b

     Cálculos são realizados sobre números lterais. A propagacedilhaão de números em poto flutuante aplica-se.

          (%i1) 17 + b - (1/2)*29 + 11^(2/4);
                                                 5
          (%o1)                   b + sqrt(11) + -
                                                 2
          (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
          (%o2)                   [46, 46.0, 4.6b1]

     Computacedilhaões aritméticas são uma simplificacedilhaão, não uma avaliacedilhaão.

          (%i1) simp : false;
          (%o1)                         false
          (%i2) '(17 + 29*11/7 - 5^3);
                                        29 11    3
          (%o2)                    17 + ----- - 5
                                          7
          (%i3) simp : true;
          (%o3)                         true
          (%i4) '(17 + 29*11/7 - 5^3);
                                          437
          (%o4)                         - ---
                                           7

     A aritmética é realizada elemento-por-elemento para listas lists (dependendo de listarith) e dependendo de matrizes.

          (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
                                  [ a - 1  x - 2 ]
          (%o1)                   [              ]
                                  [ h - 3  u - 4 ]
          (%i2) 5 * matrix ([a, x], [h, u]);
                                    [ 5 a  5 x ]
          (%o2)                     [          ]
                                    [ 5 h  5 u ]
          (%i3) listarith : false;
          (%o3)                         false
          (%i4) [a, c, m, t] / [1, 7, 2, 9];
                                    [a, c, m, t]
          (%o4)                     ------------
                                    [1, 7, 2, 9]
          (%i5) [a, c, m, t] ^ x;
                                                x
          (%o5)                     [a, c, m, t]
          (%i6) listarith : true;
          (%o6)                         true
          (%i7) [a, c, m, t] / [1, 7, 2, 9];
                                        c  m  t
          (%o7)                     [a, -, -, -]
                                        7  2  9
          (%i8) [a, c, m, t] ^ x;
                                    x   x   x   x
          (%o8)                   [a , c , m , t ]

 -- Operador: **

     Operador de exponenciacedilhaão. Maxima reconhece ** como o mesmo operador que ^ em entrada, e ** é mostrado como ^ em saída unidimensional, ou colocando o expoente  como sobrescrito em saída bidimensional.

     A funcedilhaão fortran mostra o operador de exponenciacedilhaão com como **, independente de a entrada ter sido na forma ** ou a forma ^.

     Exemplos:

          (%i1) is (a**b = a^b);
          (%o1)                         true
          (%i2) x**y + x^z;
                                        z    y
          (%o2)                        x  + x
          (%i3) string (x**y + x^z);
          (%o3)                        x^z+x^y
          (%i4) fortran (x**y + x^z);
                x**z+x**y
          (%o4)                         done

Operadores Relacionais
======================

 -- Operador: <
 -- Operador: <=
 -- Operador: >=
 -- Operador: >

Operadores Geral
================

 -- Operador: ^^

 -- Operador: !
     O operador fatorial. Para qualquer número complexo x (incluíndo números inteiros, racionais, e reais) exceto para inteiros negativos, x! é definido como gamma(x+1).

     Para um inteiro x, x! simplifica para o produto de inteiros de 1 a x inclusive. 0! simplifica para 1. Para um número em ponto flutuante x, x! simplifica para o valor de gamma (x+1). Para x igual a n/2 onde n é um inteiro ímpar, x! simplifica para um fator racional vezes sqrt (%pi) (uma vez que gamma (1/2) é igual a sqrt (%pi)). Se x for qualquer outra coisa, x! não é simplificado.

     As variáveis factlim, minfactorial, e factcomb controlam a simplificacedilhaão de expressões contendo fatoriais.

     As funcedilhaões gamma, bffac, e cbffac são variedades da funcedilhaão gamma. makegamma substitui gamma para funcedilhaões relacionadas a fatoriais.

     Veja também binomial.

     O fatorial de um inteiro, inteiro dividido por dois, ou argumento em ponto flutuante é simplificado a menos que o operando seja maior que factlim.

          (%i1) factlim : 10;
          (%o1)                          10
          (%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
          +            105 sqrt(%pi)
          +(%o2)   [1, -------------, 81.44668037931199, 40320, 20!]
          +                 16

     O fatorial de um número complexo, constante conhecida, ou expressão geral não é simplificado. Ainda assim pode ser possível simplificar o fatorial após avaliar o operando.

          (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
          (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
          (%i2) ev (%, numer, %enumer);
          (%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357,
                                                         1.227580202486819]

     O fatorial de um símbolo não associado não é simplificado.

          (%i1) kill (foo);
          (%o1)                         done
          (%i2) foo!;
          (%o2)                         foo!

     Fatoriais são simplificados, não avaliados. Dessa forma x! pode ser substituído mesmo em uma expressão com apóstrofo.

          (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
                    105 sqrt(%pi)
          (%o1) [1, -------------, 81.44668037931199, 40320,
                         16
                                                       2432902008176640000]

 -- Operador: !!
     O operador de duplo fatorial.

     Para um número inteiro, número em ponto flutuante, ou número racional n, n!! avalia para o produto n (n-2) (n-4) (n-6) ... (n - 2 (k-1)) onde k é igual a entier (n/2), que é, o maior inteiro menor que ou igual a n/2. Note que essa definicedilhaão não coincide com outras definicedilhaões publicadas para argumentos que não são inteiros.

     Para um inteiro par (ou ímpar) n, n!! avalia para o produto de todos os inteiros consecutivos pares (ou ímpares) de 2 (ou 1) até n inclusive.

     Para um argumento n que não é um número inteiro, um número em ponto flutuante, ou um número racional, n!! retorna uma forma substantiva genfact (n, n/2, 2).

 -- Operador: #
     Representa a negacedilhaão da igualdade sintática =.

     Note que pelo fato de as regras de avaliacedilhaão de expressões predicadas (em particular pelo fato de not EXPR fazer com que ocorra a avaliacedilhaão de EXPR), a forma not A = B não é equivalente à forma A # B em alguns casos.

     Note que devido às regras para avaliacedilhaão de expressões predicadas (em particular devido a not EXPR fazer com que a avaliacedilhaão de EXPR ocorra), not A = B é equivalente a is(A # B), em lugar de ser equivalente a A # B.

     Exemplos:

          (%i1) a = b;
          (%o1)                         a = b
          (%i2) é (a = b);
          (%o2)                         false
          (%i3) a # b;
          (%o3)                         a # b
          (%i4) not a = b;
          (%o4)                         true
          (%i5) é (a # b);
          (%o5)                         true
          (%i6) é (not a = b);
          (%o6)                         true

 -- Operador: .
     O operador ponto, para multiplicacedilhaão (não comutativa) de matrizes. Quando "." é usado com essa finalidade, espacedilhaos devem ser colocados em ambos os lados desse operador, e.g. A . B.  Isso distingüe o operador ponto plenamente de um ponto decimal em um número em ponto flutuante.

     Veja também dot, dot0nscsimp, dot0simp, dot1simp, dotassoc, dotconstrules, dotdistrib, dotexptsimp, dotident, e dotscrules.

 -- Operador: :
     O operador de atribuicedilhaão.  E.g. A:3 escolhe a variável A para 3.

 -- Operador: ::
     Operador de atribuicedilhaão.  :: atribui o valor da expressão em seu lado direito para o valor da quantidade na sua esquerda, que pode avaliar para uma variável atômica ou variável subscrita.

 -- Operador: ::=
     Operador de definicedilhaão de funcedilhaão de macro. ::= define uma funcedilhaão (chamada uma "macro" por razões históricas) que coloca um apóstrofo em seus argumentos (evitando avaliacedilhaão), e a expressão que é retornada (chamada a "expansão de macro") é avaliada no contexto a partir do qual a macro foi chamada. Uma funcedilhaão de macro é de outra forma o mesmo que uma funcedilhaão comum.

     macroexpand retorna uma expansão de macro (sem avaliar a expansão). macroexpand (foo (x)) seguida por ''% é equivalente a foo (x) quando foo for uma funcedilhaão de macro.

     ::= coloca o nome da nova funcedilhaão de macro dentro da lista global macros. kill, remove, e remfunction desassocia definicedilhaões de funcedilhaão de macro e remove nomes de macros.

     fundef e dispfun retornam respectivamente uma definicedilhaão de funcedilhaão de macro e uma atribuicedilhaão dessa definicedilhaão a um rótulo, respectivamente.

     Funcedilhaões de macro comumente possuem expressões buildq e splice para construir uma expressão, que é então avaliada.

     Exemplos

     Uma funcedilhaão de macro coloca um apóstrofo em seus argumentos evitando então a avaliacedilhaão, então mensagem (1) mostra y - z, não o valor de y - z. A expansão de macro (a expressão com apóstrofo '(print ("(2) x is equal to", x)) é avaliada no contexto a partir do qual a macro for chamada, mostrando a mensagem (2).

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) printq1 (x) ::= block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x)));
          (%o4) printq1(x) ::= block(print("(1) x é igual a", x),
                                          '(print("(2) x é igual a", x)))
          (%i5) printq1 (y - z);
          (1) x é igual a y - z
          (2) x é igual a %pi
          (%o5)                          %pi

     Uma funcedilhaão comum avalia seus argumentos, então message (1) mostra o valor de y - z. O valor de retorno não é avaliado, então mensagem (2) não é mostrada até a avaliacedilhaão explícita ''%.

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) printe1 (x) := block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x)));
          (%o4) printe1(x) := block(print("(1) x é igual a", x),
                                          '(print("(2) x é igual a", x)))
          (%i5) printe1 (y - z);
          (1) x é igual a 1234 - 1729 w
          (%o5)              print((2) x é igual a, x)
          (%i6) ''%;
          (2) x é igual a %pi
          (%o6)                          %pi

     macroexpand retorna uma expansão de macro. macroexpand (foo (x)) seguido por ''% é equivalente a foo (x) quando foo for uma funcedilhaão de macro.

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) g (x) ::= buildq ([x], print ("x é igual a", x));
          (%o4)    g(x) ::= buildq([x], print("x é igual a", x))
          (%i5) macroexpand (g (y - z));
          (%o5)              print(x é igual a, y - z)
          (%i6) ''%;
          x é igual a 1234 - 1729 w
          (%o6)                     1234 - 1729 w
          (%i7) g (y - z);
          x é igual a 1234 - 1729 w
          (%o7)                     1234 - 1729 w

 -- Operador: :=
     O operador de definicedilhaão de funcedilhaão.  E.g. f(x):=sin(x) define uma funcedilhaão f.

 -- Operador: =
     O operador de equacedilhaão.

     Uma expressão A = B, por si mesma, representa uma equacedilhaão não avaliada, a qual pode ou não se manter. Equacedilhaões não avaliadas podem aparecer como argumentos para solve e algsys ou algumas outras funcedilhaões.

     A funcedilhaão is avalia = para um valor Booleano. is(A = B) avalia A = B para true quando A e B forem idênticos. Isto é, A e B forem átomos que são idênticos, ou se eles não forem átomos e seus operadores forem idênticos e seus argumentos forem idênticos. De outra forma, is(A = B) avalia para false; is(A = B) nunca avalia para unknown. Quando is(A = B) for true, A e B são ditos para serem sintaticamente iguais, em contraste para serem expressões equivalentes, para as quais is(equal(A, B)) é true. Expressões podem ser equivalentes e não sintáticamente iguais.

     A negacedilhaão de = é representada por #. Da mesma forma que com =, uma expressão A # B, por si mesma, não é avaliada. is(A # B) avalia A # B para true ou false.

     Complementando a funcedilhaão is, alguns outros operadores avaliam = e # para true ou false, a saber if, and, or, e not.

     Note que pelo fato de as regras de avaliacedilhaão de expressões predicadas (em particular pelo fato de not EXPR fazer com que ocorra a avaliacedilhaão de EXPR), a forma not A = B é equivalente a is(A # B), em lugar de ser equivalente a A # B.

     rhs e lhs retornam o primeiro membro e o segundo membro de uma equacedilhaão, respectivamente, de uma equacedilhaão ou inequacedilhaão.

     Veja também equal e notequal.

     Exemplos:

     Uma expressão A = B, por si mesma, representa uma equacedilhaão não avaliada, a qual pode ou não se manter.

          (%i1) eq_1 : a * x - 5 * y = 17;
          (%o1)                    a x - 5 y = 17
          (%i2) eq_2 : b * x + 3 * y = 29;
          (%o2)                    3 y + b x = 29
          (%i3) solve ([eq_1, eq_2], [x, y]);
                                  196         29 a - 17 b
          (%o3)          [[x = ---------, y = -----------]]
                               5 b + 3 a       5 b + 3 a
          (%i4) subst (%, [eq_1, eq_2]);
                   196 a     5 (29 a - 17 b)
          (%o4) [--------- - --------------- = 17,
                 5 b + 3 a      5 b + 3 a
                                            196 b     3 (29 a - 17 b)
                                          --------- + --------------- = 29]
                                          5 b + 3 a      5 b + 3 a
          (%i5) ratsimp (%);
          (%o5)                  [17 = 17, 29 = 29]

     is(A = B) avalia A = B para true quando A e B são sintaticamente iguais (isto é, identicos). Expressões podem ser equivalentes e não sintaticamente iguais.

          (%i1) a : (x + 1) * (x - 1);
          (%o1)                    (x - 1) (x + 1)
          (%i2) b : x^2 - 1;
                                        2
          (%o2)                        x  - 1
          (%i3) [is (a = b), is (a # b)];
          (%o3)                     [false, true]
          (%i4) [is (equal (a, b)), is (notequal (a, b))];
          (%o4)                     [true, false]

     Alguns operadores avaliam = e # para true ou false.

          (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR;
          (%o1)                          FOO
          (%i2) eq_3 : 2 * x = 3 * x;
          (%o2)                       2 x = 3 x
          (%i3) eq_4 : exp (2) = %e^2;
                                        2     2
          (%o3)                       %e  = %e
          (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
          (%o4)                  [false, true, true]

     Devido a not EXPR fazer com que a avaliacedilhaão de EXPR ocorra, not A = B é equivalente a is(A # B).

          (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
          (%o1)                   [2 x # 3 x, true]
          (%i2) is (2 * x # 3 * x);
          (%o2)                         true

 -- Operador: and
     O operador lógico de conjuncedilhaão. and é um operador n-ário infixo; seus operandos são expressões Booleanas, e seu resultado é um valor Booleano.

     and forcedilhaa avaliacedilhaão (como is) de um ou mais operandos, e pode forcedilhaar a avaliacedilhaão de todos os operandos.

     Operandos são avaliados na ordem em que aparecerem. and avalia somente quantos de seus operandos forem necessários para determinar o resultado. Se qualquer operando for false, o resultado é false e os operandos restantes não são avaliados.

     O sinalizador global prederror governa o comportamento de and quando um operando avaliado não pode ser determinado como sendo true ou false. and imprime uma mensagem de erro quando prederror for true. De outra forma, operandos que não avaliam para true ou para false são aceitos, and o resultado é uma expressão Booleana.

     and não é comutativo: a and b pode não ser igual a b and a devido ao tratamento de operandos indeterminados.

 -- Operador: or
     O operador lógico de disjuncedilhaão. or é um operador n-ário infixo; seus operandos são expressões Booleanas, e seu resultado é um valor Booleano.

     or forcedilhaa avaliacedilhaão (como is) de um ou mais operandos, e pode forcedilhaar a avaliacedilhaão de todos os operandos.

     Operandos são avaliados na ordem em que aparecem. or avalia somente quantos de seus operandos forem necessários para determinar o resultado. Se qualquer operando for true, o resultado é true e os operandos restantes não são avaliados.

     O sinalizador global prederror governa o comportamento de or quando um operando avaliado não puder ser determinado como sendo true ou false. or imprime uma mensagem de erro quando prederror for true. De outra forma, operandos que não avaliam para true ou para false são aceitos, E o resultado é uma expressão Booleana.

     or não é comutativo: a or b pode não ser igual a b or a devido ao tratamento de operando indeterminados.

 -- Operador: not
     O operador lógico de negacedilhaão. not é operador prefixado; Seu operando é uma expressão Booleana, e seu resultado é um valor Booleano.

     not forcedilhaa a avaliacedilhaão (como is) de seu operando.

     O sinalizador global prederror governa o comportamento de not quando seu operando não pode ser determinado em termos de true ou false. not imprime uma mensagem de erro quando prederror for true. De outra forma, operandos que não avaliam para true ou para false são aceitos, e o resultado é uma expressão Booleana.

 -- Funcedilhaão: abs (EXPR)
     Retorna o valor absoluto de EXPR.  Se EXPR for um número complexo, retorna o módulo complexo de EXPR.

 -- Palavra chave: additive
     Se declare(f,additive) tiver sido executado, então:

     (1) Se f for uma funcedilhaão de uma única variável, sempre que o simplificador encontrar f aplicada a uma adicedilhaão, f será distribuído sobre aquela adicedilhaão.  I.e. f(y+x) irá simplificar para f(y)+f(x).

     (2) Se f for uma funcedilhaão de 2 ou mais argumentos, a adicedilhaão é definida como adicedilhaão no primeiro argumento para f, como no caso de sum ou integrate, i.e. f(h(x)+g(x),x) irá simplificar para f(h(x),x)+f(g(x),x). Essa simplificacedilhaão não ocorre quando f é aplicada para expressões da forma sum(x[i],i,lower-limit,upper-limit).

 -- Palavra chave: allbut
     trabalha com os comandos part (i.e. part, inpart, substpart, substinpart, dpart, e lpart).  Por exemplo,

          (%i1) expr : e + d + c + b + a;
          (%o1)                   e + d + c + b + a
          (%i2) part (expr, [2, 5]);
          (%o2)                         d + a

     enquanto

          (%i1) expr : e + d + c + b + a;
          (%o1)                   e + d + c + b + a
          (%i2) part (expr, allbut (2, 5));
          (%o2)                       e + c + b

     allbut é também reconhecido por kill.

          (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
          (%o1)                 [11, 22, 33, 44, 55]
          (%i2) kill (allbut (cc, dd));
          (%o0)                         done
          (%i1) [aa, bb, cc, dd];
          (%o1)                   [aa, bb, 33, 44]

     kill(allbut(A_1, A_2, ...)) tem o mesmo efeito que kill(all) exceto que não elimina os símbolos A_1, A_2, ... .

 -- Declaracedilhaão: antisymmetric
     Se declare(h,antisymmetric) é concluída, diz ao simplicador que h é uma funcedilhaão antisimétrica.  E.g. h(x,z,y) simplificará para - h(x, y, z).  Isto é, dará (-1)^n vezes o resultado dado por symmetric ou commutative, quando n for o número de interescolhas de dois argumentos necessários para converter isso naquela forma.

 -- Funcedilhaão: cabs (EXPR)
     Retorna o valor absoluto complexo (o módulo complexo) de EXPR.

 -- Funcedilhaão: ceiling (X)

     Quando X for um número real, retorna o último inteiro que é maior que ou igual a X.

     Se X for uma expressão constante (10 * %pi, por exemplo), ceiling avalia X usando grandes números em ponto flutuante, e aplica ceiling para o grande número em ponto flutuante resultante. Porque ceiling usa avaliacedilhaão de ponto flutuante, é possível, embora improvável, que ceiling possa retornar uma valor errôneo para entradas constantes. Para prevenir erros, a avaliacedilhaão de ponto flutuante é concluída usando três valores para fpprec.

     Para entradas não constantes, ceiling tenta retornar um valor simplificado.  Aqui está um exemplo de simplificacedilhaões que ceiling conhece:

          (%i1) ceiling (ceiling (x));
          (%o1)                      ceiling(x)
          (%i2) ceiling (floor (x));
          (%o2)                       floor(x)
          (%i3) declare (n, integer)$
          (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
          (%o4)                [n, abs(n), max(n, 6)]
          (%i5) assume (x > 0, x < 1)$
          (%i6) ceiling (x);
          (%o6)                           1
          (%i7) tex (ceiling (a));
          $$\left \lceil a \right \rceil$$
          (%o7)                         false

     A funcedilhaão ceiling não mapeia automaticamente sobre listas ou matrizes. Finalmente, para todas as entradas que forem manifestamente complexas, ceiling retorna uma forma substantiva.

     Se o intervalo de uma funcedilhaão é um subconjunto dos inteiros, o intervalo pode ser declarado integervalued. Ambas as funcedilhaões ceiling e floor podem usar essa informacedilhaão; por exemplo:

          (%i1) declare (f, integervalued)$
          (%i2) floor (f(x));
          (%o2)                         f(x)
          (%i3) ceiling (f(x) - 1);
          (%o3)                       f(x) - 1

 -- Funcedilhaão: charfun (P)

     Retorna 0 quando o predicado P avaliar para false; retorna 1 quando o predicado avaliar para true.  Quando o predicado avaliar para alguma coisa que não true ou false (unknown), retorna uma forma substantiva.

     Exemplos:

          (%i1) charfun (x < 1);
          (%o1)                    charfun(x < 1)
          (%i2) subst (x = -1, %);
          (%o2)                           1
          (%i3) e : charfun ('"and" (-1 < x, x < 1))$
          (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
          (%o4)                       [0, 1, 0]

 -- Declaracedilhaão: commutative
     Se declare(h,commutative) é concluída, diz ao simplicador que h é uma funcedilhaão comutativa.  E.g. h(x,z,y) irá simplificar para h(x, y, z).  Isto é o mesmo que symmetric.

 -- Funcedilhaão: compare (X, Y)

     Retorna um operador de comparacedilhaão OP (<, <=, >, >=, =, ou #) tal que is (X OP Y) avalia para true; quando ou X ou Y dependendo de %i e X # Y, retorna notcomparable; Quando não existir tal operador ou Maxima não estiver apto a determinar o operador, retorna unknown.

     Exemplos:

          (%i1) compare (1, 2);
          (%o1)                           <
          (%i2) compare (1, x);
          (%o2)                        unknown
          (%i3) compare (%i, %i);
          (%o3)                           =
          (%i4) compare (%i, %i + 1);
          (%o4)                     notcomparable
          (%i5) compare (1/x, 0);
          (%o5)                           #
          (%i6) compare (x, abs(x));
          (%o6)                          <=

     A funcedilhaão compare não tenta de terminar se o domínio real de seus argumentos é não vazio; dessa forma

          (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
          (%o1)                           <

     O domínio real de acos (x^2 + 1) é vazio.

 -- Funcedilhaão: entier (X)
     Retorna o último inteiro menor que ou igual a X onde X é numérico.  fix (como em fixnum) é um sinônimo disso, então fix(X) é precisamente o mesmo.

 -- Funcedilhaão: equal (A, B)

     Representa a equivalência, isto é, valor igual.

     Por si mesma, equal não avalia ou simplifica. A funcedilhaão is tenta avaliar equal para um valor Booleano. is(equal(A, B)) retorna true (ou false) se e somente se A e B forem iguais (ou não iguais) para todos os possíveis valores de suas variáveis, como determinado através da avaliacedilhaão de ratsimp(A - B); se ratsimp retornar 0, as duas expressões são consideradas equivalentes. Duas expressões podem ser equivalentes mesmo se mesmo se elas não forem sintaticamente iguais (i.e., identicas).

     Quando is falhar em reduzir equal a true ou false, o resultado é governado através do sinalizador global prederror. Quando prederror for true, is reclama com uma mensagem de erro. De outra forma, is retorna unknown.

     Complementando is, alguns outros operadores avaliam equal e notequal para true ou false, a saber if, and, or, e not.

     A negacedilhaão de equal é notequal.

     Exemplos:

     Por si mesmo, equal não avalia ou simplifica.

          (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                                  2
          (%o1)            equal(x  - 1, (x - 1) (x + 1))
          (%i2) equal (x, x + 1);
          (%o2)                    equal(x, x + 1)
          (%i3) equal (x, y);
          (%o3)                      equal(x, y)

     A funcedilhaão is tenta avaliar equal para um valor Booleano. is(equal(A, B)) retorna true quando ratsimp(A - B) retornar 0. Duas expressões podem ser equivalentes mesmo se não forem sintaticamente iguais (i.e., identicas).

          (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
          (%o1)                           0
          (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
          (%o2)                         true
          (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
          (%o3)                         false
          (%i4) ratsimp (x - (x + 1));
          (%o4)                          - 1
          (%i5) is (equal (x, x + 1));
          (%o5)                         false
          (%i6) is (x = x + 1);
          (%o6)                         false
          (%i7) ratsimp (x - y);
          (%o7)                         x - y
          (%i8) is (equal (x, y));
          (%o8)                        unknown
          (%i9) is (x = y);
          (%o9)                         false

     Quando is falha em reduzir equal a true ou false, o resultado é governado através do sinalizador global prederror.

          (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                              2             2
          (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
          (%i2) ratsimp (aa - bb);
          (%o2)                        4 x + 2
          (%i3) prederror : true;
           (%o3)                         true
          (%i4) is (equal (aa, bb));
          Maxima was unable to evaluate the predicate:
                 2             2
          equal(x  + 2 x + 1, x  - 2 x - 1)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) prederror : false;
          (%o5)                         false
          (%i6) is (equal (aa, bb));
          (%o6)                        unknown

     Alguns operadores avaliam equal e notequal para true ou false.

          (%i1) if equal (y, y - 1) then FOO else BAR;
          (%o1)                          BAR
          (%i2) eq_1 : equal (x, x + 1);
          (%o2)                    equal(x, x + 1)
          (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                                   2                   2
          (%o3)             equal(y  + 2 y + 1, (y + 1) )
          (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
          (%o4)                  [false, true, true]

     Devido a not EXPR fazer com que ocorra a avaliacedilhaão de EXPR, not equal(A, B) é equivalente a is(notequal(A, B)).

          (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
          (%o1)            [notequal(2 z, 2 z - 1), true]
          (%i2) is (notequal (2*z, 2*z - 1));
          (%o2)                         true

 -- Funcedilhaão: floor (X)

     Quando X for um número real, retorna o maior inteiro que é menor que ou igual a X.

     Se X for uma expressão constante (10 * %pi, for exemplo), floor avalia X usando grandes números em ponto flutuante, e aplica floor ao grande número em ponto flutuante resultante. Porque floor usa avaliacedilhaão em ponto flutuante, é possível, embora improvável, que floor não possa retornar um valor errôneo para entradas constantes.  Para prevenir erros, a avaliacedilhaão de ponto flutuante é concluída usando três valores para fpprec.

     Para entradas não constantes, floor tenta retornar um valor simplificado.  Aqui está exemplos de simplificacedilhaões que floor conhece:

          (%i1) floor (ceiling (x));
          (%o1)                      ceiling(x)
          (%i2) floor (floor (x));
          (%o2)                       floor(x)
          (%i3) declare (n, integer)$
          (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
          (%o4)                [n, abs(n), min(n, 6)]
          (%i5) assume (x > 0, x < 1)$
          (%i6) floor (x);
          (%o6)                           0
          (%i7) tex (floor (a));
          $$\left \lfloor a \right \rfloor$$
          (%o7)                         false

     A funcedilhaão floor não mapeia automaticamente sobre listas ou matrizes. Finalmente, para todas as entradas que forem manifestamente complexas, floor retorna uma forma substantiva.

     Se o intervalo de uma funcedilhaão for um subconjunto dos inteiros, o intervalo pode ser declarado integervalued. Ambas as funcedilhaões ceiling e floor podem usar essa informacedilhaão; por exemplo:

          (%i1) declare (f, integervalued)$
          (%i2) floor (f(x));
          (%o2)                         f(x)
          (%i3) ceiling (f(x) - 1);
          (%o3)                       f(x) - 1

 -- Funcedilhaão: notequal (A, B)
     Represents the negation of equal(A, B).

     Exemplos:

          (%i1) equal (a, b);
          (%o1)                      equal(a, b)
          (%i2) maybe (equal (a, b));
          (%o2)                        unknown
          (%i3) notequal (a, b);
          (%o3)                    notequal(a, b)
          (%i4) not equal (a, b);
          (%o4)                    notequal(a, b)
          (%i5) maybe (notequal (a, b));
          (%o5)                        unknown
          (%i6) assume (a > b);
          (%o6)                        [a > b]
          (%i7) equal (a, b);
          (%o7)                      equal(a, b)
          (%i8) maybe (equal (a, b));
          (%o8)                         false
          (%i9) notequal (a, b);
          (%o9)                    notequal(a, b)
          (%i10) maybe (notequal (a, b));
          (%o10)                        true

 -- Operador: eval
     Como um argumento em uma chamada a ev (EXPR), eval causa uma avaliacedilhaão extra de EXPR. Veja ev.

 -- Funcedilhaão: evenp (EXPR)
     Retorna true se EXPR for um inteiro sempre. false é retornado em todos os outros casos.

 -- Funcedilhaão: fix (X)
     Um sinônimo para entier (X).

 -- Funcedilhaão: fullmap (F, EXPR_1, ...)
     Similar a map, mas fullmap mantém mapeadas para baixo todas as subexpressões até que os operadores principais não mais sejam os mesmos.

     fullmap é usada pelo simplificador do Maxima para certas manipulacedilhaões de matrizes; dessa forma, Maxima algumas vezes gera uma mensagem de erro concernente a fullmap mesmo apesar de fullmap não ter sido explicitamente chamada pelo usuário.

     Exemplos:

          (%i1) a + b * c;
          (%o1)                        b c + a
          (%i2) fullmap (g, %);
          (%o2)                   g(b) g(c) + g(a)
          (%i3) map (g, %th(2));
          (%o3)                     g(b c) + g(a)

 -- Funcedilhaão: fullmapl (F, LIST_1, ...)
     Similar a fullmap, mas fullmapl somente mapeia sobre listas e matrizes.

     Exemplo:

          (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
          (%o1)                [[a + 3, 4], [4, 3.5]]

 -- Funcedilhaão: is (EXPR)
     Tenta determinar se a EXPR predicada (expressões que avaliam para true ou false) é dedutível de fatos localizados na base de dados de assume.

     Se a dedutibilidade do predicado for true ou false, is retorna true ou false, respectivamente. De outra forma, o valor de retorno é governado através do sinalizador global prederror. Quando prederror for true, is reclama com uma mensagem de erro. De outra forma, is retorna unknown.

     ev(EXPR, pred) (que pode ser escrita da forma  EXPR, pred na linha de comando interativa) é equivalente a is(EXPR).

     Veja também assume, facts, e maybe.

     Exemplos:

     is causa avaliacedilhaão de predicados.

          (%i1) %pi > %e;
          (%o1)                       %pi > %e
          (%i2) é (%pi > %e);
          (%o2)                         true

     is tenta derivar predicados da base de dados do assume.

          (%i1) assume (a > b);
          (%o1)                        [a > b]
          (%i2) assume (b > c);
          (%o2)                        [b > c]
          (%i3) é (a < b);
          (%o3)                         false
          (%i4) é (a > c);
          (%o4)                         true
          (%i5) é (equal (a, c));
          (%o5)                         false

     Se is não puder nem comprovar nem refutar uma forma predicada a partir da base de dados de assume, o sinalizador global prederror governa o comportamento de is.

          (%i1) assume (a > b);
          (%o1)                        [a > b]
          (%i2) prederror: true$
          (%i3) é (a > 0);
          Maxima was unable to evaluate the predicate:
          a > 0
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) prederror: false$
          (%i5) é (a > 0);
          (%o5)                        unknown

 -- Funcedilhaão: maybe (EXPR)
     Tenta determinar se a EXPR predicada é dedutível dos fatos na base de dados de assume.

     Se a dedutibilidade do predicado for true ou false, maybe retorna true ou false, respectivamente. De outra forma, maybe retorna unknown.

     maybe é funcinalmente equivalente a is com prederror: false, mas o resultado é computado sem atualmente atribuir um valor a prederror.

     Veja também assume, facts, e is.

     Exemplos:

          (%i1) maybe (x > 0);
          (%o1)                        unknown
          (%i2) assume (x > 1);
          (%o2)                        [x > 1]
          (%i3) maybe (x > 0);
          (%o3)                         true

 -- Funcedilhaão: isqrt (X)
     Retorna o "inteiro raíz quadrada" do valor absoluto de X, que é um inteiro.

 -- Funcedilhaão: lmax (L)

     Quando L for uma lista ou um conjunto, retorna apply ('max, args (L)).  Quando L não for uma lista ou também não for um conjunto, sinaliza um erro.

 -- Funcedilhaão: lmin (L)

     Quando L for uma lista ou um conjunto, retorna apply ('min, args (L)). Quando L não for uma lista ou ou também não for um conjunto, sinaliza um erro.

 -- Funcedilhaão: max (X_1, ..., X_N)

     Retorna um valor simplificado para o máximo entre as expressões X_1 a X_N. Quando get (trylevel, maxmin), for dois ou mais, max usa a simplificacedilhaão max (e, -e) --> |e|.  Quando get (trylevel, maxmin) for 3 ou mais, MAX tenta eliminar expressões que estiverem entre dois outros argumentos; por exemplo, max (x, 2*x, 3*x) --> max (x, 3*x). Para escolher o valor de trylevel para 2, use put (trylevel, 2, maxmin).

 -- Funcedilhaão: min (X_1, ..., X_N)

     Retorna um valor simplificado para o mínimo entre as expressões x_1 até x_n. Quando get (trylevel, maxmin), for 2 ou mais, min usa a simplificacedilhaão min (e, -e) --> -|e|.  Quando get (trylevel, maxmin) for 3 ou mais, min tenta eliminar expressões que estiverem entre dois outros argumentos; por exemplo, min (x, 2*x, 3*x) --> min (x, 3*x). Para escolher o valor de trylevel para 2, use put (trylevel, 2, maxmin).

 -- Funcedilhaão: polymod (P)
 -- Funcedilhaão: polymod (P, M)
     Converte o polinômio P para uma representacedilhaão modular com relacedilhaão ao módulo corrente que é o valor da variável modulus.

     polymod (P, M) especifica um módulo M para ser usado em lugar do valor corrente de modulus.

     Veja modulus.

 -- Funcedilhaão: mod (X, Y)

     Se X e Y forem números reais e Y for não nulo, retorna X - Y * floor(X / Y). Adicionalmente para todo real X, nós temos mod (X, 0) = X. Para uma discursão da definicedilhaão mod (X, 0) = X, veja a Secedilhaão 3.4, de "Concrete Mathematics," por Graham, Knuth, e Patashnik. A funcedilhaão mod (X, 1) é uma funcedilhaão dente de serra com período 1 e com mod (1, 1) = 0 e mod (0, 1) = 0.

     Para encontrar o argumento (um número no intervalo (-%pi, %pi]) de um número complexo, use a funcedilhaão X |-> %pi - mod (%pi - X, 2*%pi), onde X é um argumento.

     Quando X e Y forem expressões constantes (10 * %pi, por exemplo), mod usa o mesmo esquema de avaliacedilhaão em ponto flutuante que floor e ceiling usam. Novamente, é possível, embora improvável, que mod possa retornar um valor errôneo nesses casos.

     Para argumentos não numéricos X ou Y, mod conhece muitas regras de simplificacedilhaão:

          (%i1) mod (x, 0);
          (%o1)                           x
          (%i2) mod (a*x, a*y);
          (%o2)                      a mod(x, y)
          (%i3) mod (0, x);
          (%o3)                           0

 -- Funcedilhaão: oddp (EXPR)
     é true se EXPR for um inteiro ímpar. false é retornado em todos os outros casos.

 -- Operador: pred
     Como um argumento em uma chamada a ev (EXPR), pred faz com que predicados (expressões que avaliam para true ou false) sejam avaliados. Veja ev.

 -- Funcedilhaão: make_random_state (N)
 -- Funcedilhaão: make_random_state (S)
 -- Funcedilhaão: make_random_state (true)
 -- Funcedilhaão: make_random_state (false)
     Um objeto de estado randômico representa o estado do gerador de números randômicos (aleatórios). O estado compreende 627 palavras de 32 bits.

     make_random_state (N) retorna um novo objeto de estado randômico criado de um valor inteiro semente igual a N modulo 2^32. N pode ser negativo.

     make_random_state (S) retorna uma copia do estado randômico S.

     make_random_state (true) retorna um novo objeto de estado randômico, usando a hora corrente  do relógio do computador como semente.

     make_random_state (false) retorna uma cópia do estado corrente do gerador de números randômicos.

 -- Funcedilhaão: set_random_state (S)
     Copia S para o estado do gerador de números randômicos.

     set_random_state sempre retorna done.

 -- Funcedilhaão: random (X)
     Retorna um número pseudorandômico. Se X é um inteiro, random (X) retorna um inteiro de 0 a X - 1 inclusive. Se X for um número em ponto flutuante, random (X) retorna um número não negativo em ponto flutuante menor que X. random reclama com um erro se X não for nem um inteiro nem um número em ponto flutuante, ou se X não for positivo.

     As funcedilhaões make_random_state e set_random_state mantém o estado do gerador de números randômicos.

     O gerador de números randômicos do Maxima é uma implementacedilhaão do algorítmo de Mersenne twister MT 19937.

     Exemplos:

          (%i1) s1: make_random_state (654321)$
          (%i2) set_random_state (s1);
          (%o2)                         done
          (%i3) random (1000);
          (%o3)                          768
          (%i4) random (9573684);
          (%o4)                        7657880
          (%i5) random (2^75);
          (%o5)                11804491615036831636390
          (%i6) s2: make_random_state (false)$
          (%i7) random (1.0);
          (%o7)                   .2310127244107132
          (%i8) random (10.0);
          (%o8)                   4.394553645870825
          (%i9) random (100.0);
          (%o9)                   32.28666704056853
          (%i10) set_random_state (s2);
          (%o10)                        done
          (%i11) random (1.0);
          (%o11)                  .2310127244107132
          (%i12) random (10.0);
          (%o12)                  4.394553645870825
          (%i13) random (100.0);
          (%o13)                  32.28666704056853

 -- Funcedilhaão: rationalize (EXPR)

     Converte todos os números em ponto flutuante de precisão dupla e grandes números em ponto flutuante na expressão do Maxima EXPR para seus exatos equivalentes racionais. Se você não estiver faminilarizado com a representacedilhaão binária de números em ponto flutuante, você pode se surpreender que rationalize (0.1) não seja igual a 1/10.  Esse comportamento não é especial para o Maxima -- o número 1/10 tem uma representacedilhaão binária repetitiva e não terminada.

          (%i1) rationalize (0.5);
                                          1
          (%o1)                           -
                                          2
          (%i2) rationalize (0.1);
                                         1
          (%o2)                          --
                                         10
           (%i3) fpprec : 5$
          (%i4) rationalize (0.1b0);
                                       209715
          (%o4)                        -------
                                       2097152
          (%i5) fpprec : 20$
          (%i6) rationalize (0.1b0);
                               236118324143482260685
          (%o6)                ----------------------
                               2361183241434822606848
          (%i7) rationalize (sin (0.1*x + 5.6));
                                        x    28
          (%o7)                     sin(-- + --)
                                        10   5

     Exemplo de utilizacedilhaão:

          (%i1) unitfrac(r) := block([uf : [], q],
              if not(ratnump(r)) then error("The input to 'unitfrac' must be a rational number"),
              while r # 0 do (
                  uf : cons(q : 1/ceiling(1/r), uf),
                  r : r - q),
              reverse(uf));
          (%o1) unitfrac(r) := block([uf : [], q],
          if not ratnump(r) then error("The input to 'unitfrac' must be a rational number"
                                               1
          ), while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
                                                   1
                                           ceiling(-)
                                                   r
          reverse(uf))
          (%i2) unitfrac (9/10);
                                      1  1  1
          (%o2)                      [-, -, --]
                                      2  3  15
          (%i3) apply ("+", %);
                                         9
          (%o3)                          --
                                         10
          (%i4) unitfrac (-9/10);
                                            1
          (%o4)                       [- 1, --]
                                            10
          (%i5) apply ("+", %);
                                          9
          (%o5)                         - --
                                          10
          (%i6) unitfrac (36/37);
                                  1  1  1  1    1
          (%o6)                  [-, -, -, --, ----]
                                  2  3  8  69  6808
          (%i7) apply ("+", %);
                                         36
          (%o7)                          --
                                         37

 -- Funcedilhaão: sign (EXPR)
     Tenta determinar o sinal de EXPR a partir dos fatos na base de dados corrente.  Retorna uma das seguintes respostar: pos (positivo), neg (negativo), zero, pz (positivo ou zero), nz (negativo ou zero), pn (positivo ou negativo), ou pnz (positivo, negativo, ou zero, i.e. nada se sabe sobre o sinal da epressão).

 -- Funcedilhaão: signum (X)
     Para um X numérico retorna 0 se X for 0, de outra forma retorna -1 ou +1 à medida que X seja menor ou maior que 0, respectivamente.

     Se X não for numérico então uma forma simplificada mas equivalente é retornada. Por exemplo, signum(-x) fornece -signum(x).

 -- Funcedilhaão: sort (L, P)
 -- Funcedilhaão: sort (L)
     Organiza uma lista L coforme o predicado P de dois argumentos, de forma que P (L[k], L[k + 1]) seja true para qualquer dois elementos sucessivos. O predicado pode ser especificado como o nome de uma funcedilhaão ou operador binário infixo, ou como uma expressão lambda. Se especificado como o nome de um operador, o nome deve ser contido entre "aspas duplas".

     A lista ordenada é retornada como novo objeto; o argumento L não é modificado. Para construir o valor de retorno, sort faz uma cópia superficial dos elementos de L. Se o predicado P não for uma ordem total sobre os elementos de L, então sort possivelvente pode executar para concluir sem error, mas os resultados são indefinidos. sort reclama se o predicado avaliar para alguma outra coisa que não seja true ou false.

     sort (L) é equivalente a sort (L, orderlessp). Isto é, a ordem padrão de organizacedilhaão é ascendente, como determinado por orderlessp. Todos os átomos do Maxima e expressões são comparáveis sob orderlessp, embora exista exemplos isolados de expressões para as quais orderlessp não é transitiva; isso é uma falha.

     Exemplos:

          (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
                         5
          (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
                         2
          (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x], ordergreatp);
                                                             5
          (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
                                                             2
          (%i3) sort ([%pi, 3, 4, %e, %gamma]);
          (%o3)                [3, 4, %e, %gamma, %pi]
          (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
          (%o4)                [%gamma, %e, 3, %pi, 4]
          (%i5) my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
          (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
          (%i6) sort (my_list);
          (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
          (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a), reverse (b))));
          (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]

 -- Funcedilhaão: sqrt (X)
     A raíz quadrada de X. É representada internamente por X^(1/2).  Veja também rootscontract.

     radexpand se true fará com que n-ésimas raízes de fatores de um produto que forem potências de n sejam colocados fora do radical, e.g. sqrt(16*x^2) retonará 4*x somente se radexpand for true.

 -- Variável de opcedilhaão: sqrtdispflag
     Valor padrão: true

     Quando sqrtdispflag for false, faz com que sqrt seja mostrado como expoente 1/2.

 -- Funcedilhaão: sublis (LISTA, EXPR)
     Faz multiplas substituicedilhaões paralelas dentro de uma expressão.

     A variável sublis_apply_lambda controla a simplificacedilhaão após sublis.

     Exemplo:

 -- Funcedilhaão: sublist (LISTA, P)
     Retorna a lista de elementos da LISTA da qual o predicado p retornar true.

     Exemplo:

          (%i1) L: [1, 2, 3, 4, 5, 6];
          (%o1)                  [1, 2, 3, 4, 5, 6]
          (%i2) sublist (L, evenp);
          (%o2)                       [2, 4, 6]

 -- Variável de opcedilhaão: sublis_apply_lambda
     Valor padrão: true - controla se os substitutos de lambda são aplicados na simplificacedilhaão após as sublis serem usadas ou se você tem que fazer um ev para pegar coisas para aplicar.  true significa facedilhaa a aplicacedilhaão.

 -- Funcedilhaão: subst (A, B, C)
     Substitue A por B em C.  B deve ser um átomo ou uma subexpressão completa de C.  Por exemplo, x+y+z é uma subexpressão completa de 2*(x+y+z)/w enquanto x+y não é. Quando B não tem essas características, pode-se algumas vezes usar substpart ou ratsubst (veja abaixo).  Alternativamente, se B for da forma de e/f então se poderá usar subst (a*f, e, c) enquanto se B for da forma e^(1/f) então se poderá usar subst (a^f, e, c).  O comando subst também discerne o x^y de x^-y de modo que subst (a, sqrt(x), 1/sqrt(x)) retorna 1/a.  A e B podem também ser operadores de uma expressão contida entre aspas duplas " ou eles podem ser nomes de funcedilhaão.  Se se desejar substituir por uma variável independente em formas derivadas então a funcedilhaão at (veja abaixo) poderá ser usada.

     subst é um álias para substitute.

     subst (EQ_1, EXPR) ou subst ([EQ_1, ..., EQ_K], EXPR) são outras formas permitidas.  As EQ_I são equacedilhaões indicando substituicedilhaões a serem feitas. Para cada equacedilhaão, o lado direito será substituído pelo lado esquerdo na expressão EXPR.

     exptsubst se true permite que substituicedilhaões como y por %e^x em %e^(a*x) ocorram.

     Quando opsubst for false, subst tentará substituir dentro do operador de uma expressão. E.g. (opsubst: false, subst (x^2, r, r+r[0])) trabalhará.

     Exemplos:

          (%i1) subst (a, x+y, x + (x+y)^2 + y);
                                              2
          (%o1)                      y + x + a
          (%i2) subst (-%i, %i, a + b*%i);
          (%o2)                       a - %i b

     Para exemplos adicionais, facedilhaa example (subst).

 -- Funcedilhaão: substinpart (X, EXPR, N_1, ..., N_K)
     Similar a substpart, mas substinpart trabalha sobre a representacedilhaão interna de EXPR.

     Exemplos:

          (%i1) x . 'diff (f(x), x, 2);
                                        2
                                       d
          (%o1)                   x . (--- (f(x)))
                                         2
                                       dx
          (%i2) substinpart (d^2, %, 2);
                                            2
          (%o2)                        x . d
          (%i3) substinpart (f1, f[1](x + 1), 0);
          (%o3)                       f1(x + 1)

     Se o último argumento para a funcedilhaão part for uma lista de índices então muitas subexpressões são escolhidas, cada uma correspondendo a um índice da lista.  Dessa forma

          (%i1) part (x + y + z, [1, 3]);
          (%o1)                         z + x

     piece recebe o valor da última expressão selecionada quando usando as funcedilhaões part.  piece é escolhida durante a execucedilhaão da funcedilhaão e dessa forma pode ser referenciada para a própria funcedilhaão como mostrado abaixo. Se partswitch for escolhida para true então end é retornado quando uma parte selecionada de uma expressão não existir, de outra forma uma mensagem de erro é fornecida.

          (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
                        3         2       2            3
          (%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
          (%i2) part (expr, 2, [1, 3]);
                                            2
          (%o2)                         54 y
          (%i3) sqrt (piece/54);
          (%o3)                        abs(y)
          (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
                                         3
          (%o4)               (3 y + 2 x)  + y + x + 1
          (%i5) expr: 1/x + y/x - 1/z;
                                       1   y   1
          (%o5)                      - - + - + -
                                       z   x   x
          (%i6) substpart (xthru (piece), expr, [2, 3]);
                                      y + 1   1
          (%o6)                       ----- - -
                                        x     z

     Também, escolhendo a opcedilhaão inflag para true e chamando part ou substpart é o mesmo que chamando inpart ou substinpart.

 -- Funcedilhaão: substpart (X, EXPR, N_1, ..., N_K)
     Substitue X para a subexpressão selecionada pelo resto dos argumentos como em part.  Isso retorna o novo valor de EXPR.  X pode ser algum operador a ser substituído por um operador de EXPR.  Em alguns casos X precisa ser contido em aspas duplas " (e.g.  substpart ("+", a*b, 0) retorna b + a).

          (%i1) 1/(x^2 + 2);
                                         1
          (%o1)                        ------
                                        2
                                       x  + 2
          (%i2) substpart (3/2, %, 2, 1, 2);
                                         1
          (%o2)                       --------
                                       3/2
                                      x    + 2
          (%i3) a*x + f (b, y);
          (%o3)                     a x + f(b, y)
          (%i4) substpart ("+", %, 1, 0);
          (%o4)                    x + f(b, y) + a

     Também, escolhendo a opcedilhaão inflag para true e chamando part ou substpart é o mesmo que chamando inpart ou substinpart.

 -- Funcedilhaão: subvarp (EXPR)
     Retorna true se EXPR for uma variável subscrita (i.e. que possui índice ou subscrito em sua grafia), por exemplo a[i].

 -- Funcedilhaão: symbolp (EXPR)
     Retorna true se EXPR for um símbolo, de outra forma retorna false. com efeito, symbolp(x) é equivalente ao predicado atom(x) and not numberp(x).

     Veja também Identificadores

 -- Funcedilhaão: unorder ()
     Disabilita a acedilhaão de alias criada pelo último uso dos comandos de ordenacedilhaão ordergreat e orderless. ordergreat e orderless não podem ser usados mais que uma vez cada sem chamar unorder. Veja também ordergreat e orderless.

     Exemplos:

          (%i1) unorder();
          (%o1)                          []
          (%i2) b*x + a^2;
                                             2
          (%o2)                       b x + a
          (%i3) ordergreat (a);
          (%o3)                         done
          (%i4) b*x + a^2;
           %th(1) - %th(3);
                                       2
          (%o4)                       a  + b x
          (%i5) unorder();
                                        2    2
          (%o5)                        a  - a

 -- Funcedilhaão: vectorpotential (GIVENCURL)
     Retorna o potencial do vetor de um dado vetor de torcedilhaão, no sistema de coordenadas corrente. potentialzeroloc tem um papel similar ao de potential, mas a ordem dos lados esquerdos das equacedilhaões deve ser uma permutacedilhaão cíclica das variáveis de coordenadas.

 -- Funcedilhaão: xthru (EXPR)
     Combina todos os termos de EXPR (o qual pode ser uma adicedilhaão) sobre um denominador comum sem produtos e somas exponenciadas como ratsimp faz.  xthru cancela fatores comuns no numerador e denominador de expressões racionais mas somente se os fatores são explícitos.

     Algumas vezes é melhor usar xthru antes de ratsimp em uma expressão com o objetivo de fazer com que fatores explicitos do máximo divisor comum entre o numerador e o denominador seja cancelado simplificando dessa forma a expressão a ser aplicado o ratsimp.

          (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
                                          20
                           1       (x + 2)   - 2 y       x
          (%o1)        --------- + --------------- - ---------
                              19             20             20
                       (y + x)        (y + x)        (y + x)
          (%i2) xthru (%);
                                           20
                                    (x + 2)   - y
          (%o2)                     -------------
                                             20
                                      (y + x)

 -- Funcedilhaão: zeroequiv (EXPR, V)
     Testa se a expressão EXPR na variável V é equivalente a zero, retornando true, false, ou dontknow (não sei).

     zeroequiv Tem essas restricedilhaões:

      1. Não use funcedilhaões que o Maxima não sabe como diferenciar e avaliar.

      2. Se a expressão tem postes sobre o eixo real, podem existir erros no resultado (mas isso é improvável ocorrer).

      3. Se a expressão contem funcedilhaões que não são solucedilhaões para equacedilhaões diferenciais de primeira ordem (e.g.  funcedilhaões de Bessel) pode ocorrer resultados incorretos.

      4. O algorítmo usa avaliacedilhaão em pontos aleatóriamente escolhidos para subexpressões selecionadas cuidadosamente.  Isso é sempre negócio um tanto quanto perigoso, embora o algorítmo tente minimizar o potencial de erro.

     Por exemplo zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x) retorna true e zeroequiv (%e^x + x, x) retorna false. Por outro lado zeroequiv (log(a*b) - log(a) - log(b), a) retorna dontknow devido à presencedilhaa de um parâmetro extra b.