Introducedilhaão a Expressões
=============================

Existe um conjunto de palavras reservadas que não pode ser usado como nome de variável.   Seu uso pode causar um possível erro crítico de sintaxe.

     integrate            next           from                 diff
     in                   at             limit                sum
     for                  and            elseif               then
     else                 do             or                   if
     unless               product        while                thru
     step

Muitas coisas em Maxima são expressões.   Uma sequência de expressões
pode ser feita dentro de uma expressão maior através da separacedilhaão dessas através de vírgulas e
colocando parêntesis em torno dela.   Isso é similar ao C
expressão com vírgula.

     (%i1) x: 3$
     (%i2) (x: x+1, x: x^2);
     (%o2)                          16
     (%i3) (if (x > 17) then 2 else 4);
     (%o3)                           4
     (%i4) (if (x > 17) then x: 2 else y: 4, y+x);
     (%o4)                          20

Mesmo ciclos em Maxima são expressões, embora o valor de retorno desses ciclos não seja muito útil (eles retornam sempre done).

     (%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
     (%i2) y;
     (%o2)                         done

enquanto que o que realmente queira seja provavelmente incluir um terceiro termo na expressão com vírgula que fornece de volta o valor actualizado.

     (%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
     (%i4) y;
     (%o4)                        3628800

Atribuicedilhaão
================

Existem dois operadores de atribuicedilhaão no Maxima, ":" e "::". E.g., a: 3 escolhe a variável a para 3. :: atribui o valor da expressão sobre seu lado direito para o valor da quantidade sobre seu lado esquerdo, que deve avaliar para uma variável atômica ou para uma variável com subscrito.

Complexo
========

Uma expressão complexa é especificada no Maxima através da adicedilhaão da parte real da expressão a %i vezes a parte imaginária.  Dessa forma as raízes da equacedilhaão x^2 - 4*x + 13 = 0 são 2 + 3*%i e 2 - 3*%i.  Note que produtos de simplificacedilhaão de expressões complexas podem ser efetuadas através da expansão do produto.  Simplificacedilhaão de quocientes, raízes, e outras funcedilhaões de expressões complexas podem usualmente serem realizadas através do uso das funcedilhaões realpart, imagpart, rectform, polarform, abs, carg.

Substantivos e Verbos
=====================

Maxima distingue entre operadores que são "substantivos" e operadores que são "verbos". Um verbo é um operador que pode ser executado. Um substantivo é um operador que aparece como um símbolo em uma expressão, sem ser executado. Por padrão, nomes de funcedilhaão são verbos. Um verbo pode ser mudado em um substantivo através da adicedilhaão de um apóstrofo no início do nome da funcedilhaão ou aplicando a funcedilhaão nounify. Um substantivo pode ser mudado em um verbo através da aplicacedilhaão da funcedilhaão verbify. O sinalizador de avaliacedilhaão nouns faz com que ev avalie substantivos em uma expressão.

A forma verbal é distinguida através de um sinal de dólar $ no início do símbolo Lisp correspondente. De forma oposta, a forma substantiva é distinguida através de um sinal de % no início do símbolo Lisp correspondente. Alguns substantivos possuem propriedades especiais de exibicedilhaão, tais como 'integrate e 'derivative (retornado por diff), mas muitos não. Por padrão, as formas substantiva e verbal de uma funcedilhaão são idênticas quando mostradas. O sinalizador global noundisp faz com que Maxima mostre substantivos com um apóstrofo no início '.

Veja também noun, nouns, nounify, e verbify.

Exemplos:

     (%i1) foo (x) := x^2;
                                          2
     (%o1)                     foo(x) := x
     (%i2) foo (42);
     (%o2)                         1764
     (%i3) 'foo (42);
     (%o3)                        foo(42)
     (%i4) 'foo (42), nouns;
     (%o4)                         1764
     (%i5) declare (bar, noun);
     (%o5)                         done
     (%i6) bar (x) := x/17;
                                          x
     (%o6)                    ''bar(x) := --
                                          17
     (%i7) bar (52);
     (%o7)                        bar(52)
     (%i8) bar (52), nouns;
                                    52
     (%o8)                          --
                                    17
     (%i9) integrate (1/x, x, 1, 42);
     (%o9)                        log(42)
     (%i10) 'integrate (1/x, x, 1, 42);
                                  42
                                 /
                                 [   1
     (%o10)                      I   - dx
                                 ]   x
                                 /
                                  1
     (%i11) ev (%, nouns);
     (%o11)                       log(42)

Identificadores
===============

Identificadores do Maxima podem compreender caracteres alfabéticos, mais os numerais de 0 a 9, mais qualquer caractere especial precedido por um caractere contra-barra \.

Um numeral pode ser o primeiro caractere de um identificador se esse numeral for precedido por uma contra-barra. Numerais que forem o segundo ou o último caractere não precisam ser precedidos por uma contra barra.

Caracteres podem ser declarados para serem alfabéticos por meio da funcedilhaão declare. Se então declarados alfabéticos, eles não precisam serem precedidos de uma contrabarra em um identificador. Os caracteres alfabéticos vão inicialmente de A a Z, de a a z, %, e _.

Maxima é sensível à caixa . Os identificadores algumacoisa, ALGUMACOISA, e Algumacoisa são distintos. Veja Lisp e Maxima para mais sobre esse ponto.

Um identificador Maxima é um símbolo Lisp que comecedilhaa com um sinal de dólar $. Qualquer outro símbolo Lisp é precedido por um ponto de interrogacedilhaão ? quando aparecer no Maxima. Veja Lisp e Maxima para maiores detalhes sobre esse ponto.

Exemplos:

     (%i1) %an_ordinary_identifier42;
     (%o1)               %an_ordinary_identifier42
     (%i2) embedded\ spaces\ in\ an\ identifier;
     (%o2)           embedded spaces in an identifier
     (%i3) symbolp (%);
     (%o3)                         true
     (%i4) [foo+bar, foo\+bar];
     (%o4)                 [foo + bar, foo+bar]
     (%i5) [1729, \1729];
     (%o5)                     [1729, 1729]
     (%i6) [symbolp (foo\+bar), symbolp (\1729)];
     (%o6)                     [true, true]
     (%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
     (%o7)                    [false, false]
     (%i8) baz\~quux;
     (%o8)                       baz~quux
     (%i9) declare ("~", alphabetic);
     (%o9)                         done
     (%i10) baz~quux;
     (%o10)                      baz~quux
     (%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
     (%o11)                [false, false, false]
     (%i12) :lisp (defvar *my-lisp-variable* '$foo)
     *MY-LISP-VARIABLE*
     (%i12) ?\*my\-lisp\-variable\*;
     (%o12)                         foo

Sequências de caracteres
========================

Strings (sequências de caracteres) são contidas entre aspas duplas " em entradas de dados usados pelo Maxima, e mostradas com ou sem as aspas duplas, dependendo do valor escolhido para a variável global stringdisp.

Sequências de caracteres podem conter quaisquer caracteres, incluindo tabulacedilhaões (tab), nova linha (ou fim de linha), e caracteres de retorno da cabecedilhaa de impressão (carriage return). A sequência \" é reconhecida com uma aspa dupla literal, e \\ como uma contrabarra literal. Quando a contrabarra aparecer no final de uma linha, a contrabarra e a terminacedilhaão de linha (ou nova linha ou retorno de carro e nova linha) são ignorados, de forma que a sequência de caracteres continue na próxima linha. Nenhuma outra combinacedilhaão especial de contrabarra com outro caractere é reconhecida; quando a contrabarra aparecer antes de qualquer outro caractere que não seja ", \, ou um fim de linha, a contrabarra é ignorada. Não exite caminho para representar um caractere especial (tal como uma tabulacedilhaão, nova linha, ou retorno da cabecedilhaa de impressão) excepto através de encaixar o caractere literal na sequência de caracteres.

Não existe tipo de caractere no Maxima; um caractere simples é representado como uma sequência de caracteres de um único caractere.

Sequências de caracteres no Maxima são implementadas como símbolos do Lisp, não como sequencias de caracteres do not Lisp; o que pode mudar em futuras versões do Maxima. Maxima pode mostrar sequências de caracteres do Lisp e caracteres do Lisp, embora algumas outras operacedilhaões (por exemplo, testes de igualdade) possam falhar.

O pacote adicional stringproc contém muitas funcedilhaões que trabalham com sequências de caracteres.

Exemplos:

     (%i1) s_1 : "Isso é uma sequência de caracteres  do Maxima.";
     (%o1)               Isso é uma sequência de caracteres  do Maxima.
     (%i2) s_2 : "Caracteres \"aspas duplas\" e contrabarras \\ encaixados em uma sequência de caracteres.";
     (%o2) Caracteres "aspas duplas" e contrabarra \ encaixados em uma sequência de caracteres.
     (%i3) s_3 : "Caractere de fim de linha encaixado
     nessa sequência de caracteres.";
     (%o3) Caractere de fim de linha encaixado
     nessa sequência de caracteres.
     (%i4) s_4 : "Ignore o \
     caractere de \
     fim de linha nessa \
     sequência de caracteres.";
     (%o4) Ignore o caractere de fim de linha nessa sequência de caracteres.
     (%i5) stringdisp : false;
     (%o5)                         false
     (%i6) s_1;
     (%o6)               Isso é uma sequência de caracteres  do Maxima.
     (%i7) stringdisp : true;
     (%o7)                         true
     (%i8) s_1;
     (%o8)              "Isso é uma sequência de caracteres  do Maxima."

Desigualdade
============

Maxima tem os operadores de desigualdade <, <=, >=, >, #, e notequal. Veja if para uma descricedilhaão de expressões condicionais.

Sintaxe
=======

É possível definir novos operadores com precedência especificada, remover a definicedilhaão de operadores existentes, ou redefinir a precedência de operadores existentes. Um operador pode ser unário prefixado ou unário pósfixado, binario infixado, n-ário infixado, matchfix, ou nofix. "Matchfix" significa um par de símbolos que abracedilhaam seu argumento ou seus argumentos, e "nofix" significa um operador que não precisa de argumentos. Como exemplos dos diferentes tipos de operadores, existe o seguinte.

unário prefixado
     negacedilhaão - a

unário posfixado
     factorial a!

binário infixado
     exponenciacedilhaão a^b

n-ário infixado
     adicedilhaão a + b

matchfix
     construcedilhaão de lista [a, b]

(Não existe operadores internos nofix; para um exemplo de tal operador, veja nofix.)

O mecanismo para definir um novo operador é directo. Somente é necessário declarar uma funcedilhaão como um operador; a funcedilhaão operador pode ou não estar definida previamente.

Um exemplo de operadores definidos pelo utilizador é o seguinte. Note que a chamada explícita de funcedilhaão "dd" (a) é equivalente a dd a, da mesma forma "<-" (a, b) é equivalente a a <- b. Note também que as funcedilhaões "dd" e "<-" são indefinidas nesse exemplo.

     (%i1) prefix ("dd");
     (%o1)                          dd
     (%i2) dd a;
     (%o2)                         dd a
     (%i3) "dd" (a);
     (%o3)                         dd a
     (%i4) infix ("<-");
     (%o4)                          <-
     (%i5) a <- dd b;
     (%o5)                      a <- dd b
     (%i6) "<-" (a, "dd" (b));
     (%o6)                      a <- dd b

As funcedilhaões máxima que definem novos operadores estão sumarizadas nessa tabela, equilibrando expoente associado esquerdo (padrão) e o expoente associado direito ("eae" e "ead", respectivamente). (Associacedilhaão de expoentes determina a precedência do operador. todavia, uma vez que os expoentes esquerdo e direito podem ser diferentes, associacedilhaão de expoentes é até certo ponto mais complicado que precedência.) Alguma das funcedilhaões de definicedilhaão de operacedilhaões tomam argumentos adicionais; veja as descricedilhaões de funcedilhaão para maiores detalhes.

prefixado
     ead=180

posfixado
     eae=180

infixado
     eae=180, ead=180

nário
     eae=180, ead=180

matchfix
     (associacedilhaão de expoentes não é aplicável)

nofix
     (associacedilhaão de expoentes não é aplicável)

Para comparacedilhaão, aqui está alguns operadores internos e seus expoentes associados esquerdo e direito.

     Operador   eae     ead

       :        180     20
       ::       180     20
       :=       180     20
       ::=      180     20
       !        160
       !!       160
       ^        140     139
       .        130     129
       *        120
       /        120     120
       +        100     100
       -        100     134
       =        80      80
       #        80      80
       >        80      80
       >=       80      80
       <        80      80
       <=       80      80
       not              70
       and      65
       or       60
       ,        10
       $        -1
       ;        -1

remove e kill removem propriedades de operador de um átomo. remove ("A", op) remove somente as propriedades de operador de A. kill ("A") remove todas as propriedades de A, incluindo as propriedades de operador. Note que o nome do operador dever estar abracedilhaado por aspas duplas.

     (%i1) infix ("##");
     (%o1)                          ##
     (%i2) "##" (a, b) := a^b;
                                          b
     (%o2)                     a ## b := a
     (%i3) 5 ## 3;
     (%o3)                          125
     (%i4) remove ("##", op);
     (%o4)                         done
     (%i5) 5 ## 3;
     Incorrect syntax: # is not a prefix operator
     5 ##
       ^
     (%i5) "##" (5, 3);
     (%o5)                          125
     (%i6) infix ("##");
     (%o6)                          ##
     (%i7) 5 ## 3;
     (%o7)                          125
     (%i8) kill ("##");
     (%o8)                         done
     (%i9) 5 ## 3;
     Incorrect syntax: # is not a prefix operator
     5 ##
       ^
     (%i9) "##" (5, 3);
     (%o9)                       ##(5, 3)

Definicedilhaões para Expressões
================================

 -- Funcedilhaão: at (EXPR, [EQN_1, ..., EQN_N])
 -- Funcedilhaão: at (EXPR, EQN)
     Avalia a expressão EXPR com as variáveis assumindo os valores como especificado para elas na lista de equacedilhaões [EQN_1, ..., EQN_N] ou a equacedilhaão simples EQN.

     Se uma subexpressão depender de qualquer das variáveis para a qual um valor foi especificado mas não existe atvalue especificado e essa subexpressão não pode ser avaliada de outra forma, então uma forma substantiva de at é retornada que mostra em uma forma bidimensional.

     at realiza múltiplas substituicedilhaões em série, não em paralelo.

     Veja também atvalue. Para outras funcedilhaões que realizam substituicedilhaões, veja também subst e ev.

     Exemplos:

          (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                          2
          (%o1)                          a
          (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
          (%o2)                        @2 + 1
          (%i3) printprops (all, atvalue);
                                          !
                            d             !
                           --- (f(@1, @2))!       = @2 + 1
                           d@1            !
                                          !@1 = 0

                                               2
                                    f(0, 1) = a

          (%o3)                         done
          (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x);
                            d                          d
          (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                            dx                         dx
          (%i5) at (%, [x = 0, y = 1]);
                                                   !
                        2              d           !
          (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                       dx          !
                                                   !x = 0, y = 1

 -- Funcedilhaão: box (EXPR)
 -- Funcedilhaão: box (EXPR, A)
     Retorna EXPR dentro de uma caixa. O valor de retorno é uma expressão com box como o operador e EXPR como o argumento. Uma caixa é desenhada sobre a tela quando display2d for true.

     box (EXPR, A) Empacota EXPR em uma caixa rotulada pelo símbolo A. O rótulo é truncado se for maior que a largura da caixa.

     box avalia seu argumento. Todavia, uma expressão dentro de uma caixa não avalia para seu conteúdo, então expressões dentro de caixas são efectivamente excluídas de cálculos.

     boxchar é o caractere usado para desenhar a caixa em box e nas funcedilhaões dpart e lpart.

     Exemplos:

          (%i1) box (a^2 + b^2);
                                      """""""""
                                      " 2    2"
          (%o1)                       "b  + a "
                                      """""""""
          (%i2) a : 1234;
          (%o2)                         1234
          (%i3) b : c - d;
          (%o3)                         c - d
          (%i4) box (a^2 + b^2);
                                """"""""""""""""""""
                                "       2          "
          (%o4)                 "(c - d)  + 1522756"
                                """"""""""""""""""""
          (%i5) box (a^2 + b^2, term_1);
                                term_1""""""""""""""
                                "       2          "
          (%o5)                 "(c - d)  + 1522756"
                                """"""""""""""""""""
          (%i6) 1729 - box (1729);
                                           """"""
          (%o6)                     1729 - "1729"
                                           """"""
          (%i7) boxchar: "-";
          (%o7)                           -
          (%i8) box (sin(x) + cos(y));
                                  -----------------
          (%o8)                   -cos(y) + sin(x)-
                                  -----------------

 -- Variável de opcedilhaão: boxchar
     Valor por omissão: "

     boxchar é o caractere usado para desenhar a caixa por box e nas funcedilhaões dpart e lpart.

     Todas as caixas em uma expressão são desenhadas com o valor actual de boxchar; o caractere de desenho não é armazenado com a expressão de caixa. Isso quer dizer que se desenhar uma caixa e em seguida mudar o caracter de desenho a caixa anteriormente desenhada será redesenhada com o caracter mudado caso isso seja solicitado.

 -- Funcedilhaão: carg (Z)
     Retorna o argumento complexo de Z. O argumento complexo é um ângulo theta no intervalo de (-%pi, %pi] tal que r exp (theta %i) = Z onde r é o módulo de Z.

     carg é uma funcedilhaão computacional, não uma funcedilhaão de simplificacedilhaão.

     carg ignora a declaracedilhaão declare (X, complex), e trata X como uma variável real. Isso é um erro.

     Veja também abs (módulo de número complexo), polarform, rectform, realpart, e imagpart.

     Exemplos:

          (%i1) carg (1);
          (%o1)                           0
          (%i2) carg (1 + %i);
                                         %pi
          (%o2)                          ---
                                          4
          (%i3) carg (exp (%i));
          (%o3)                           1
          (%i4) carg (exp (%pi * %i));
          (%o4)                          %pi
          (%i5) carg (exp (3/2 * %pi * %i));
                                          %pi
          (%o5)                         - ---
                                           2
          (%i6) carg (17 * exp (2 * %i));
          (%o6)                           2

 -- Opereador especial: constant
     declare (A, constant) declara A para ser uma constante. Veja declare.

 -- Funcedilhaão: constantp (EXPR)
     Retorna true se EXPR for uma expressão constante, de outra forma retorna false.

     Uma expressão é considerada uma expressão constante se seus argumentos forem números (incluindo números racionais, como mostrado com /R/), constantes simbólicas como %pi, %e, e %i, variáveis associadas a uma constante ou constante declarada através de declare, ou funcedilhaões cujos argumentos forem constantes.

     constantp avalia seus argumentos.

     Exemplos:

          (%i1) constantp (7 * sin(2));
          (%o1)                                true
          (%i2) constantp (rat (17/29));
          (%o2)                                true
          (%i3) constantp (%pi * sin(%e));
          (%o3)                                true
          (%i4) constantp (exp (x));
          (%o4)                                false
          (%i5) declare (x, constant);
          (%o5)                                done
          (%i6) constantp (exp (x));
          (%o6)                                true
          (%i7) constantp (foo (x) + bar (%e) + baz (2));
          (%o7)                                false
          (%i8)

 -- Funcedilhaão: declare (A_1, P_1, A_2, P_2, ...)
     Atribui aos átomos ou lista de átomos A_I a propriedade ou lista de propriedades P_I. Quando A_I e/ou P_I forem listas, cada um dos átomos recebe todas as propriedades.

     declare não avalia seus argumentos. declare sempre retorna done.

     Como colocado na descricedilhaão para cada sinalizador de declaracedilhaão, para alguns sinalizadores featurep(OBJECTO, RECURSO) retorna true se OBJECTO tiver sido declarado para ter RECURSO. Todavia, featurep não reconhece alguns sinalizadores; isso é um erro.

     Veja também features.

     declare reconhece as seguintes propriedades:

     evfun
          Torna A_I conhecido para ev de forma que a funcedilhaão nomeada por A_I é aplicada quando A_I aparece como um sinalizador argumento de ev. Veja evfun.

     evflag
          Torna A_I conhecido para a funcedilhaão ev de forma que A_I é associado a true durante a execucedilhaão de ev quando A_I aparece como um sinalizador argumento de ev. Veja evflag.

     bindtest
          Diz ao Maxima para disparar um erro quando A_I for avaliado como sendo livre de associacedilhaão.

     noun
          Diz ao Maxima para passar A_I como um substantivo. O efeito disso é substituir intâncias de A_I com 'A_I ou nounify(A_I), ependendo do contexto.

     constant
          Diz ao Maxima para considerar A_I uma constante simbólica.

     scalar
          Diz ao Maxima para considerar A_I uma variável escalar.

     nonscalar
          Diz ao Maxima para considerar A_I uma variável não escalar. The usual application is to declare a variable as a symbolic vector or matrix.

     mainvar
          Diz ao Maxima para considerar A_I uma "variável principal" (mainvar). ordergreatp determina a ordenacedilhaão de átomos como segue:

          (variáveis principais) > (outras variáveis) > (variáveis escalares) > (constantes) > (números)

     alphabetic
          Diz ao Maxima para reconhecer todos os caracteres em A_I (que deve ser uma sequência de caracteres) como caractere alfabético.

     feature
          Diz ao Maxima para reconhecer A_I como nome de um recurso. Other atoms may then be declared to have the A_I property.

     rassociative, lassociative
          Diz ao Maxima para reconhecer A_I como uma funcão associativa a direita ou associativa a esquerda.

     nary
          Diz ao Maxima para reconhecer A_I como uma funcedilhaão n-ária (com muitos argumentos).

          A declaracedilhaão nary não tem o mesmo objectivo que uma chamada à funcedilhaão nary. O único efeito de declare(foo, nary) é para instruir o simplificador do Maxima a melhorar as próximas expressões, por exemplo, para simplificar foo(x, foo(y, z)) para foo(x, y, z).

     symmetric, antisymmetric, commutative
          Diz ao Maxima para reconhecer A_I como uma funcedilhaão simétrica ou antisimétrica. commutative é o mesmo que symmetric.

          oddfun, evenfun Diz ao Maxima para reconhecer A_I como uma funcedilhaão par ou uma funcedilhaão ímpar.

     outative
          Diz ao Maxima para simplificar expressões A_I colocando factores constantes em evidência no primeiro argumento.

          Quando A_I tiver um argumento, um factor é onsiderado constante se for um literal ou se for declarado como sendo constante.

          Quando A_I tiver dois ou mais argumentos, um factor é considerado constante se o segundo argumento for um símbolo e o factor estiver livre do segundo argumento.

     multiplicative
          Diz ao Maxima para simplificar expressões do tipo A_I através da substituicedilhaão A_I(x * y * z * ...) --> A_I(x) * A_I(y) * A_I(z) * .... A substituicedilhaão é realizada no primeiro argumento somente.

     additive
          Diz ao Maxima para simplificar expressões do tipo A_I através da substituicedilhaão A_I(x + y + z + ...) --> A_I(x) + A_I(y) + A_I(z) + .... A substituicedilhaão é realizada no primeiro argumento somente.

     linear
          Equivalente a declarar A_I ao mesmo tempo outative e additive.

     integer, noninteger
          Diz ao Maxima para reconhecer A_I como como uma variável inteira ou como uma variável não inteira.

          Maxima reconhece os seguintes recursos de objectos:

     even, odd
          Diz ao Maxima para reconhecer A_I como uma variável inteira par ou como uma variável inteira ímpar.

     rational, irrational
          Diz ao Maxima para reconhecer A_I como uma variável real e racional ou como uma variável real e irracional.

     real, imaginary, complex
          Dia ao Maxima para reconhecer A_I como uma variável real, imaginária pura ou complexa.

     increasing, decreasing
          Dia ao Maxima para reconhecer A_I como uma funcedilhaão de incremento ou decremento.

     posfun
          Diz ao Maxima para reconhecer A_I como uma funcedilhaão positiva.

     integervalued
          Diz ao Maxima para reconhecer A_I como uma funcedilhaão de valores inteiros.

     Exemplos:

     Declaracedilhaões evfun e evflag.

          (%i1) declare (expand, evfun);
          (%o1)                         done
          (%i2) (a + b)^3;
                                             3
          (%o2)                       (b + a)
          (%i3) (a + b)^3, expand;
                               3        2      2      3
          (%o3)               b  + 3 a b  + 3 a  b + a
          (%i4) declare (demoivre, evflag);
          (%o4)                         done
          (%i5) exp (a + b*%i);
                                       %i b + a
          (%o5)                      %e
          (%i6) exp (a + b*%i), demoivre;
                                a
          (%o6)               %e  (%i sin(b) + cos(b))

     Declaracedilhaão bindtest.

          (%i1) aa + bb;
          (%o1)                        bb + aa
          (%i2) declare (aa, bindtest);
          (%o2)                         done
          (%i3) aa + bb;
          aa unbound variable
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) aa : 1234;
          (%o4)                         1234
          (%i5) aa + bb;
          (%o5)                       bb + 1234

     Declaracedilhaão noun.

          (%i1) factor (12345678);
                                       2
          (%o1)                     2 3  47 14593
          (%i2) declare (factor, noun);
          (%o2)                         done
          (%i3) factor (12345678);
          (%o3)                   factor(12345678)
          (%i4) ''%, nouns;
                                       2
          (%o4)                     2 3  47 14593

     Declaracedilhaões constant, scalar, nonscalar, e mainvar.

     Declaracedilhaão alphabetic.

          (%i1) xx\~yy\`\@ : 1729;
          (%o1)                         1729
          (%i2) declare ("~`@", alphabetic);
          (%o2)                         done
          (%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
          (%o3)               `xx@@yy~ + @yy`xx + 1729
          (%i4) listofvars (%);
          (%o4)                  [@yy`xx, `xx@@yy~]

     Declaracedilhaão feature.

          (%i1) declare (FOO, feature);
          (%o1)                         done
          (%i2) declare (x, FOO);
          (%o2)                         done
          (%i3) featurep (x, FOO);
          (%o3)                         true

     Declaracedilhaões rassociative e lassociative.

     Declaracedilhaão nary.

          (%i1) H (H (a, b), H (c, H (d, e)));
          (%o1)               H(H(a, b), H(c, H(d, e)))
          (%i2) declare (H, nary);
          (%o2)                         done
          (%i3) H (H (a, b), H (c, H (d, e)));
          (%o3)                   H(a, b, c, d, e)

     Declaracedilhaões symmetric e antisymmetric.

          (%i1) S (b, a);
          (%o1)                        S(b, a)
          (%i2) declare (S, symmetric);
          (%o2)                         done
          (%i3) S (b, a);
          (%o3)                        S(a, b)
          (%i4) S (a, c, e, d, b);
          (%o4)                   S(a, b, c, d, e)
          (%i5) T (b, a);
          (%o5)                        T(b, a)
          (%i6) declare (T, antisymmetric);
          (%o6)                         done
          (%i7) T (b, a);
          (%o7)                       - T(a, b)
          (%i8) T (a, c, e, d, b);
          (%o8)                   T(a, b, c, d, e)

     Declaracedilhaões oddfun e evenfun.

          (%i1) o (- u) + o (u);
          (%o1)                     o(u) + o(- u)
          (%i2) declare (o, oddfun);
          (%o2)                         done
          (%i3) o (- u) + o (u);
          (%o3)                           0
          (%i4) e (- u) - e (u);
          (%o4)                     e(- u) - e(u)
          (%i5) declare (e, evenfun);
          (%o5)                         done
          (%i6) e (- u) - e (u);
          (%o6)                           0

     Declaracedilhaão outative.

          (%i1) F1 (100 * x);
          (%o1)                       F1(100 x)
          (%i2) declare (F1, outative);
          (%o2)                         done
          (%i3) F1 (100 * x);
          (%o3)                       100 F1(x)
          (%i4) declare (zz, constant);
          (%o4)                         done
          (%i5) F1 (zz * y);
          (%o5)                       zz F1(y)

     Declaracedilhaão multiplicative.

          (%i1) F2 (a * b * c);
          (%o1)                       F2(a b c)
          (%i2) declare (F2, multiplicative);
          (%o2)                         done
          (%i3) F2 (a * b * c);
          (%o3)                   F2(a) F2(b) F2(c)

     Declaracedilhaão additive.

          (%i1) F3 (a + b + c);
          (%o1)                     F3(c + b + a)
          (%i2) declare (F3, additive);
          (%o2)                         done
          (%i3) F3 (a + b + c);
          (%o3)                 F3(c) + F3(b) + F3(a)

     Declaracedilhaão linear.

          (%i1) 'sum (F(k) + G(k), k, 1, inf);
                                 inf
                                 ====
                                 \
          (%o1)                   >    (G(k) + F(k))
                                 /
                                 ====
                                 k = 1
          (%i2) declare (nounify (sum), linear);
          (%o2)                         done
          (%i3) 'sum (F(k) + G(k), k, 1, inf);
                               inf          inf
                               ====         ====
                               \            \
          (%o3)                 >    G(k) +  >    F(k)
                               /            /
                               ====         ====
                               k = 1        k = 1

 -- Funcedilhaão: disolate (EXPR, X_1, ..., X_N)
     é similar a isolate (EXPR, X) excepto que essa funcedilhaão habilita ao utilizador isolar mais que uma variável simultâneamente.  Isso pode ser útil, por exemplo, se se tiver tentado mudar variáveis em uma integracedilhaão múltipla, e em mudancedilhaa de variável envolvendo duas ou mais das variáveis de integracedilhaão.  Essa funcedilhaão é chamada automaticamente de simplification/disol.mac.  Uma demostracedilhaão está disponível através de demo("disol")$.

 -- Funcedilhaão: dispform (EXPR)
     Retorna a representacedilhaão externa de EXPR com relacedilhaão a seu principal operador.  Isso pode ser útil em conjuncedilhaão com part que também lida com a representacedilhaão externa.  Suponha que EXPR seja -A . Então a representacedilhaão interna de EXPR é  "*"(-1,A), enquanto que a representacedilhaão externa é "-"(A). dispform (EXPR, all) converte a expressão inteira (não apenas o nível mais alto) para o formato externo.  Por exemplo, se expr: sin (sqrt (x)), então freeof (sqrt, expr) e freeof (sqrt, dispform (expr)) fornece true, enquanto freeof (sqrt, dispform (expr, all)) fornece false.

 -- Funcedilhaão: distrib (EXPR)
     Distribue adicedilhaões sobre produtos.  distrib difere de expand no facto de que distrib trabalha em somente no nível mais alto de uma expressão, i.e., distrib não é recursiva e distrib é mais rápida que expand.  distrib difere de multthru no que distrib expande todas as adicedilhaões naquele nível.

     Exemplos:

          (%i1) distrib ((a+b) * (c+d));
          (%o1)                 b d + a d + b c + a c
          (%i2) multthru ((a+b) * (c+d));
          (%o2)                 (b + a) d + (b + a) c
          (%i3) distrib (1/((a+b) * (c+d)));
                                          1
          (%o3)                    ---------------
                                   (b + a) (d + c)
          (%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                          1
          (%o4)                 ---------------------
                                b d + a d + b c + a c

 -- Funcedilhaão: dpart (EXPR, N_1, ..., N_K)
     Selecciona a mesma subexpressão que part, mas em lugar de apenas retornar aquela subexpressão como seu valor, isso retorna a expressão completa com a subexpressão seleccionada mostrada dentro de uma caixa.  A caixa é actualmente parte da expressão.

          (%i1) dpart (x+y/z^2, 1, 2, 1);
                                       y
          (%o1)                       ---- + x
                                         2
                                      """
                                      "z"
                                      """

 -- Funcedilhaão: exp (X)
     Representa funcedilhaão exponencial. Instâncias de exp (X) em uma entrada são simplificadas para %e^X; exp não aparece em expressões simplificadas.

     demoivre se true faz com que %e^(a + b %i) simplificar para %e^(a (cos(b) + %i sin(b))) se b for livre de %i. veja demoivre.

     %emode, quando true, faz com que %e^(%pi %i x) seja simplificado. Veja %emode.

     %enumer, quando true faz com que %e seja substituído por 2.718...  quando numer for true. Veja %enumer.

 -- Variável de opcedilhaão: %emode
     Valor por omissão: true

     Quando %emode for true, %e^(%pi %i x) é simplificado como segue.

     %e^(%pi %i x) simplifica para cos (%pi x) + %i sin (%pi x) se x for um inteiro ou um múltiplo de 1/2, 1/3, 1/4, ou 1/6, e então é adicionalmente simplificado.

     Para outro x numérico, %e^(%pi %i x) simplifica para %e^(%pi %i y) onde y é x - 2 k para algum inteiro k tal que abs(y) < 1.

     Quando %emode for false, nenhuma simplificacedilhaão adicional de %e^(%pi %i x) é realizada.

 -- Variável de opcedilhaão: %enumer
     Valor por omissão: false

     Quando %enumer for true, %e é substituido por seu valor numérico 2.718...  mesmo que numer seja true.

     Quando %enumer for false, essa substituicedilhaão é realizada somente se o expoente em %e^x avaliar para um número.

     Veja também ev e numer.

 -- Variável de opcedilhaão: exptisolate
     Valor por omissão: false

     exptisolate, quando true, faz com que isolate (expr, var) examine expoentes de átomos (tais como %e) que contenham var.

 -- Variável de opcedilhaão: exptsubst
     Valor por omissão: false

     exptsubst, quando true, permite substituicedilhaões tais como y para %e^x em %e^(a x).

 -- Funcedilhaão: freeof (X_1, ..., X_N, EXPR)
     freeof (X_1, EXPR) Retorna true se nenhuma subexpressão de EXPR for igual a X_1 ou se X_1 ocorrer somente uma variável que não tenha associacedilhaão fora da expressão EXPR, e retorna false de outra forma.

     freeof (X_1, ..., X_N, EXPR) é equivalente a freeof (X_1, EXPR) and ... and freeof (X_N, EXPR).

     Os argumentos X_1, ..., X_N podem ser nomes de funcedilhaões e variáveis, nomes subscritos, operadores (empacotados em aspas duplas), ou expressões gerais. freeof avalia seus argumentos.

     freeof opera somente sobre EXPR como isso representa (após simplificacedilhaão e avaliacedilhaão) e não tenta determinar se alguma expressão equivalente pode fornecer um resultado diferente. Em particular, simplificacedilhaão pode retornar uma expressão equivalente mas diferente que compreende alguns diferentes elementos da forma original de EXPR.

     Uma variável é uma variável dummy em uma expressão se não tiver associacedilhaão fora da expressão. Variáveis dummy recoreconhecidas através de freeof são o índice de um somatório ou produtório, o limite da variável em limit, a variável de integracedilhaão na forma de integral definida de integrate, a variável original em laplace, variáveis formais em expressoes at, e argumentos em expressões lambda. Variáveis locais em block não são reconhecidas por freeof como variáveis dummy; isso é um bug.

     A forma indefinida de integrate not é livre de suas variáveis de integracedilhaão.

       * Argumentos são nomes de funcedilhaões, variáveis, nomes subscritos, operadores, e expressões. freeof (a, b, expr) é equivalente a freeof (a, expr) and freeof (b, expr).

               (%i1) expr: z^3 * cos (a[1]) * b^(c+d);
                                                d + c  3
               (%o1)                   cos(a ) b      z
                                            1
               (%i2) freeof (z, expr);
               (%o2)                         false
               (%i3) freeof (cos, expr);
               (%o3)                         false
               (%i4) freeof (a[1], expr);
               (%o4)                         false
               (%i5) freeof (cos (a[1]), expr);
               (%o5)                         false
               (%i6) freeof (b^(c+d), expr);
               (%o6)                         false
               (%i7) freeof ("^", expr);
               (%o7)                         false
               (%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr);
               (%o8)                         true

       * freeof avalia seus argumentos.

               (%i1) expr: (a+b)^5$
               (%i2) c: a$
               (%i3) freeof (c, expr);
               (%o3)                         false

       * freeof não considera expressões equivalentes. Simplificacedilhaão pode retornar uma expressão equivalente mas diferente.

               (%i1) expr: (a+b)^5$
               (%i2) expand (expr);
                         5        4       2  3       3  2      4      5
               (%o2)    b  + 5 a b  + 10 a  b  + 10 a  b  + 5 a  b + a
               (%i3) freeof (a+b, %);
               (%o3)                         true
               (%i4) freeof (a+b, expr);
               (%o4)                         false
               (%i5) exp (x);
                                                x
               (%o5)                          %e
               (%i6) freeof (exp, exp (x));
               (%o6)                         true

       * Um somatório ou uma integral definida está livre de uma variável dummy. Uma integral indefinida não é livre de suas variáveis de integracedilhaão.

               (%i1) freeof (i, 'sum (f(i), i, 0, n));
               (%o1)                         true
               (%i2) freeof (x, 'integrate (x^2, x, 0, 1));
               (%o2)                         true
               (%i3) freeof (x, 'integrate (x^2, x));
               (%o3)                         false

 -- Funcedilhaão: genfact (X, Y, Z)
     Retorna o factorial generalizado, definido como x (x-z) (x - 2 z) ... (x - (y - 1) z).  Dessa forma, para integral X, genfact (x, x, 1) = x! e genfact (x, x/2, 2) = x!!.

 -- Funcedilhaão: imagpart (EXPR)
     Retorna a parte imaginária da expressão EXPR.

     imagpart é uma funcedilhaão computacional, não uma funcedilhaão de simplificacedilhaão.

     Veja também abs, carg, polarform, rectform, e realpart.

 -- Funcedilhaão: infix (OP)
 -- Funcedilhaão: infix (OP, LBP, RBP)
 -- Funcedilhaão: infix (OP, LBP, RBP, LPOS, RPOS, POS)
     Declara OP para ser um operador infixo. Um operador infixo é uma funcedilhaão de dois argumentos, com o nome da funcedilhaão escrito entre os argumentos. Por exemplo, o operador de subtracedilhaão - é um operador infixo.

     infix (OP) declara OP para ser um operador infixo com expoentes associados padrão (esquerdo e direito ambos iguais a 180) e podendo ser qualquer entre prefixado, infixado, posfixado, nário, matchfix e nofix (esquerdo e direito ambos iguais a any).

     infix (OP, LBP, RBP) declara OP para ser um operador infixo com expoentes associados esquerdo e directio equilibrados e podendo ser qualquer entre prefixado, infixado, posfixado, nário, matchfix e nofix (esquerdo e direito ambos iguais a any).

     infix (OP, LBP, RBP, LPOS, RPOS, POS) declara OP para ser um operdor infixo com expoentes associados padrão e podendo ser um entre prefixado, infixado, posfixado, nário, matchfix e nofix.

     A precedência de OP com relacedilhaão a outros operadores derivam dos expoentes associados directiro e esquerdo dos operadores em questão. Se os expoentes associados esquerdo e direito de OP forem ambos maiores que o expoente associado esquerdo e o direito de algum outro operador, então OP tem prededência sobre o outro operador. Se os expoentes associados não forem ambos maior ou menor, alguma relacedilhaão mais complicada ocorre.

     A associatividade de OP depende de seus expoentes associados. Maior expoente associado esquerdo (EAE) implica uma instância de OP é avaliadas antes de outros operadores para sua esquerda em uma expressão, enquanto maior expoente associado direito (EAD) implica uma instância de OP é avaliada antes de outros operadores para sua direita em uma expressão. Dessa forma maior EAE torna OP associativo à direita, enquanto maior EAD torna OP associativa à esquerda. Se EAE for igual a EAD, OP é associativa à esquerda.

     Veja também Syntax.

     Exemplos:

     Se os expoentes associados esquerdo e direito de OP forem ambos maiores que os expoentes associados à direita e à esquerda de algum outro operador, então OP tem precedência sobre o outro operador.

          (%i1) :lisp (get '$+ 'lbp)
          100
          (%i1) :lisp (get '$+ 'rbp)
          100
          (%i1) infix ("##", 101, 101);
          (%o1)                          ##
          (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
          (%o2)       (a ## b) := sconcat("(", a, ",", b, ")")
          (%i3) 1 + a ## b + 2;
          (%o3)                       (a,b) + 3
          (%i4) infix ("##", 99, 99);
          (%o4)                          ##
          (%i5) 1 + a ## b + 2;
          (%o5)                       (a+1,b+2)

     grande EAE torna OP associativa à direita, enquanto grande EAD torna OP associativa à esquerda.

          (%i1) infix ("##", 100, 99);
          (%o1)                          ##
          (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
          (%i3) foo ## bar ## baz;
          (%o3)                    (foo,(bar,baz))
          (%i4) infix ("##", 100, 101);
          (%o4)                          ##
          (%i5) foo ## bar ## baz;
          (%o5)                    ((foo,bar),baz)

 -- Variável de opcedilhaão: inflag
     Velor padrão: false

     Quando inflag for true, funcedilhaões para extracedilhaão de partes inspecionam a forma interna de expr.

     Note que o simplificador re-organiza expressões. Dessa forma first (x + y) retorna x se inflag for true e y se inflag for false. (first (y + x) fornece os mesmos resultados.)

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

     As funcedilhaões afectadas pela posicedilhaão do sinalizador inflag são: part, substpart, first, rest, last, length, a estrutura for ... in, map, fullmap, maplist, reveal e pickapart.

 -- Funcedilhaão: inpart (EXPR, N_1, ..., N_K)
     É similar a part mas trabalha sobre a representacedilhaão interna da expressão em lugar da forma de exibicedilhaão e dessa forma pode ser mais rápida uma vez que nenhuma formatacedilhaão é realizada.  Cuidado deve ser tomado com relacedilhaão à ordem de subexpressões em adicedilhaões e produtos (uma vez que a ordem das variáveis na forma interna é muitas vezes diferente daquela na forma mostrada) e no manuseio com menos unário, subtracedilhaão, e divisão (uma vez que esses operadores são removidos da expressão). part (x+y, 0) ou inpart (x+y, 0) retorna +, embora com o objectivo de referirse ao operador isso deva ser abracedilhaado por aspas duplas.  Por exemplo ... if inpart (%o9,0) = "+" then ....

     Exemplos:

          (%i1) x + y + w*z;
          (%o1)                      w z + y + x
          (%i2) inpart (%, 3, 2);
          (%o2)                           z
          (%i3) part (%th (2), 1, 2);
          (%o3)                           z
          (%i4) 'limit (f(x)^g(x+1), x, 0, minus);
                                            g(x + 1)
          (%o4)                 limit   f(x)
                                x -> 0-
          (%i5) inpart (%, 1, 2);
          (%o5)                       g(x + 1)

 -- Funcedilhaão: isolate (EXPR, X)
     Retorna EXPR com subexpressões que são adicedilhaões e que não possuem X substituido por rótulos de expressão intermédia (esses sendo símbolos atômicos como %t1, %t2, ...).  Isso é muitas vezes útil para evitar expansões desnecessárias de subexpressões que não possuam a variável de interesse.  Uma vez que os rótulos intermédios são associados às subexpressões eles podem todos ser substituídos de volta por avaliacedilhaão da expressão em que ocorrerem.

     exptisolate (valor padrão: false) se true fará com que isolate examine expoentes de átomos (como %e) que contenham X.

     isolate_wrt_times se true, então isolate irá também isolar com relacedilhaão a produtos. Veja isolate_wrt_times.

     Facedilhaa example (isolate) para exemplos.

 -- Variável de opcedilhaão: isolate_wrt_times
     Valor por omissão: false

     Quando isolate_wrt_times for true, isolate irá também isolar com relacedilhaão a produtos.  E.g. compare ambas as escolhas do comutador em

          (%i1) isolate_wrt_times: true$
          (%i2) isolate (expand ((a+b+c)^2), c);

          (%t2)                          2 a

          (%t3)                          2 b

                                    2            2
          (%t4)                    b  + 2 a b + a

                               2
          (%o4)               c  + %t3 c + %t2 c + %t4
          (%i4) isolate_wrt_times: false$
          (%i5) isolate (expand ((a+b+c)^2), c);
                               2
          (%o5)               c  + 2 b c + 2 a c + %t4

 -- Variável de opcedilhaão: listconstvars
     Valor por omissão: false

     Quando listconstvars for true, isso fará com que listofvars inclua %e, %pi, %i, e quaisquer variáveis declaradas contantes na lista seja retornado se aparecer na expressão que chamar listofvars. O comportamento padrão é omitir isso.

 -- Variável de opcedilhaão: listdummyvars
     Valor por omissão: true

     Quando listdummyvars for false, "variáveis dummy" na expressão não serão incluídas na lista retornada por listofvars. (O significado de "variável dummy" é o mesmo que em freeof. "Variáveis dummy" são conceitos matemáticos como o índice de um somatório ou produtório, a variável limite, e a variável da integral definida.) Exemplo:

          (%i1) listdummyvars: true$
          (%i2) listofvars ('sum(f(i), i, 0, n));
          (%o2)                        [i, n]
          (%i3) listdummyvars: false$
          (%i4) listofvars ('sum(f(i), i, 0, n));
          (%o4)                          [n]

 -- Funcedilhaão: listofvars (EXPR)
     Retorna uma lista de variáveis em EXPR.

     listconstvars se true faz com que listofvars inclua %e, %pi, %i, e quaisquer variáveis declaradas constantes na lista é retornada se aparecer em EXPR.  O comportamento padrão é omitir isso.

          (%i1) listofvars (f (x[1]+y) / g^(2+a));
          (%o1)                     [g, a, x , y]
                                            1

 -- Funcedilhaão: lfreeof (LISTA, EXPR)
     Para cada um dos membros M de lista, chama freeof (M, EXPR). Retorna false se qualquer chamada a freeof for feita e true de outra forma.

 -- Funcedilhaão: lopow (EXPR, X)
     Retorna o menor expoente de X que explicitamente aparecer em EXPR.  Dessa forma

          (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
          (%o1)                       min(a, 2)

 -- Funcedilhaão: lpart (RÓTULO, EXPR, N_1, ..., N_K)
     é similar a dpart mas usa uma caixa rotulada. Uma caixa rotulada é similar à que é produzida por dpart mas a produzida por lpart tem o nome na linha do topo.

 -- Funcedilhaão: multthru (EXPR)
 -- Funcedilhaão: multthru (EXPR_1, EXPR_2)
     Multiplica um factor (que pode ser uma adicedilhaão) de EXPR pelos outros factores de EXPR.  Isto é, EXPR é F_1 F_2 ... F_N onde ao menos um factor, digamos F_I, é uma soma de termos.  Cada termo naquela soma é multiplicado por outros factores no produto.  (A saber todos os factores excepto F_I).  multthru não expande somas exponenciais. Essa funcedilhaão é o caminho mais rápido para distribuir produtos (comutativos ou não) sobre adicedilhaões.  Uma vez que quocientes são representados como produtos multthru podem ser usados para dividir adicedilhaões por produtos também.

     multthru (EXPR_1, EXPR_2) multiplica cada termo em EXPR_2 (que pode ser uma adicedilhaão ou uma equcedilhaão) por EXPR_1.  Se EXPR_1 não for por si mesmo uma adicedilhaão então essa forma é equivalente a multthru (EXPR_1*EXPR_2).

          (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                                1        x         f(x)
          (%o1)             - ----- + -------- - --------
                              x - y          2          3
                                      (x - y)    (x - y)
          (%i2) multthru ((x-y)^3, %);
                                     2
          (%o2)             - (x - y)  + x (x - y) - f(x)
          (%i3) ratexpand (%);
                                     2
          (%o3)                   - y  + x y - f(x)
          (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                                  10  2              2  2
                           (b + a)   s  + 2 a b s + a  b
          (%o4)            ------------------------------
                                            2
                                       a b s
          (%i5) multthru (%);  /* note que isso não expande (b+a)^10 */
                                                  10
                                 2   a b   (b + a)
          (%o5)                  - + --- + ---------
                                 s    2       a b
                                     s
          (%i6) multthru (a.(b+c.(d+e)+f));
          (%o6)            a . f + a . c . (e + d) + a . b
          (%i7) expand (a.(b+c.(d+e)+f));
          (%o7)         a . f + a . c . e + a . c . d + a . b

 -- Funcedilhaão: nounify (F)
     Retorna a forma substantiva do nome da funcedilhaão F.  Isso é necessário se se quer referir ao nome de uma funcedilhaão verbo como se esse nome fosse um substantivo.  Note que algumas funcedilhaões verbos irão retornar sua forma substantiva senão puderem ser avaliadas para certos argumentos.  A forma substantiva é também a forma retornada se uma chamada de funcedilhaão é precedida por um apóstrofo.

 -- Funcedilhaão: nterms (EXPR)
     Retorna o número de termos que EXPR pode ter se for completamente expandida e nenhum cancelamento ou combinacedilhaão de termos acontecer. Note expressões como sin (EXPR), sqrt (EXPR), exp (EXPR), etc. contam como apenas um termo independentemente de quantos termos EXPR tenha (se EXPR for uma adicedilhaão).

 -- Funcedilhaão: op (EXPR)
     Retorna o operador principal da expressão EXPR. op (EXPR) é equivalente a part (EXPR, 0).

     op retorna uma sequência de caracteres se o operador principal for uma operador interno ou definido pelo utilizador como prefixado, binário ou n-ário infixo, posfixado, matchfix ou nofix. De outra forma, se EXPR for uma expressão de funcedilhaão subscrita, op retorna uma funcedilhaão subscrita; nesse caso o valor de retorno não é um átomo. De outro modo, EXPR é uma funcedilhaão de array ou uma expressão de funcedilhaão comum, e op retorna um símbolo.

     op observa o valor do sinalizador global inflag.

     op avalia seus argumentos.

     Veja também args.

     Exemplos:

          (%i1) stringdisp: true$
          (%i2) op (a * b * c);
          (%o2)                          "*"
          (%i3) op (a * b + c);
          (%o3)                          "+"
          (%i4) op ('sin (a + b));
          (%o4)                          sin
          (%i5) op (a!);
          (%o5)                          "!"
          (%i6) op (-a);
          (%o6)                          "-"
          (%i7) op ([a, b, c]);
          (%o7)                          "["
          (%i8) op ('(if a > b then c else d));
          (%o8)                         "if"
          (%i9) op ('foo (a));
          (%o9)                          foo
          (%i10) prefix (foo);
          (%o10)                        "foo"
          (%i11) op (foo a);
          (%o11)                        "foo"
          (%i12) op (F [x, y] (a, b, c));
          (%o12)                        F
                                         x, y
          (%i13) op (G [u, v, w]);
          (%o13)                          G

 -- Funcedilhaão: operatorp (EXPR, OP)
 -- Funcedilhaão: operatorp (EXPR, [OP_1, ..., OP_N])

     operatorp (EXPR, OP) retorna true se OP for igual ao operador de EXPR.

     operatorp (EXPR, [OP_1, ..., OP_N]) retorna true se algum elementos de OP_1, ..., OP_N for igual ao operador de EXPR.

 -- Funcedilhaão: optimize (EXPR)
     Retorna uma expressão que produz o mesmo valor e efeito que EXPR mas faz de forma mais eficientemente por evitar a recomputacedilhaão de subexpressões comuns.  optimize também tem o mesmo efeito de "colapsar" seus argumentos de forma que todas as subexpressões comuns são compartilhadas. Facedilhaa example (optimize) para exemplos.

 -- Variável de opcedilhaão: optimprefix
     Valor por omissão: %

     optimprefix é o prefixo usado para símbolos gerados pelo comando optimize.

 -- Funcedilhaão: ordergreat (V_1, ..., V_N)
     Escolhe aliases para as variáveis V_1, ..., V_N tais que V_1 > V_2 > ...  > V_N, e V_N > qualquer outra variável não mencionada como um argumento.

     Veja também orderless.

 -- Funcedilhaão: ordergreatp (EXPR_1, EXPR_2)
     Retorna true se EXPR_2 precede EXPR_1 na ordenacedilhaão escolhida com a funcedilhaão ordergreat.

 -- Funcedilhaão: orderless (V_1, ..., V_N)
     Escolhe aliases para as variáveis V_1, ..., V_N tais que V_1 < V_2 < ...  < V_N, and V_N < qualquer outra variável não mencionada como um argumento.

     Dessa forma a escala de ordenacedilhaão completa é: constantes numéricas < constantes declaradas < escalares declarados < primeiro argumento para orderless < ...  < último argumento para orderless < variáveis que comecedilhaam com A < ... < variáveis que comecedilhaam com Z < último argumento para ordergreat < ... < primeiro argumento para ordergreat < mainvars - variáveis principais declaradas.

     Veja também ordergreat e mainvar.

 -- Funcedilhaão: orderlessp (EXPR_1, EXPR_2)
     Retorna true se EXPR_1 precede EXPR_2 na ordenacedilhaão escolhida pelo comando orderless.

 -- Funcedilhaão: part (EXPR, N_1, ..., N_K)
     Retorna partes da forma exibida de expr. Essa funcedilhaão obtém a parte de expr como especificado pelos índices N_1, ..., N_K.  A primeira parte N_1 de expr é obtida, então a parte N_2 daquela  é obtida, etc.  O resultado é parte N_K de ... parte N_2 da parte N_1 da expr.

     part pode ser usada para obter um elemento de uma lista, uma linha de uma matriz, etc.

     Se o último argumento para uma funcedilhaão part for uma lista de índices então muitas subexpressões serão pincedilhaadas, cada uma correspondendo a um índice da lista.  Dessa forma part (x + y + z, [1, 3]) é z+x.

     piece mantém a última expressão seleccionada quando usando as funcedilhaões part.  Isso é escolhido durante a execucedilhaão da funcedilhaão e dessa forma pode referir-se à funcedilhaão em si mesma como mostrado abaixo.

     Se partswitch for escolhido para true então end é retornado quando uma parte seleccionada de uma expressão não existir, de outra forma uma mensagem de erro é forncecida.

     Exemplo: part (z+2*y, 2, 1) retorna 2.

     example (part) mostra exemplos adicionais.

 -- Funcedilhaão: partition (EXPR, X)
     Retorna uma lista de duas expressões.  Elas são (1) os factores de EXPR (se essa expressão for um produto), os termos de EXPR (se isso for uma adicedilhaão), ou a lista (se isso for uma lsita) que não contiver var e, (2) os factores, termos, ou lista que faz.

          (%i1) partition (2*a*x*f(x), x);
          (%o1)                     [2 a, x f(x)]
          (%i2) partition (a+b, x);
          (%o2)                      [b + a, 0]
          (%i3) partition ([a, b, f(a), c], a);
          (%o3)                  [[b, c], [a, f(a)]]

 -- Variável de opcedilhaão: partswitch
     Valor por omissão: false

     Quando partswitch for true, end é retornado quando uma parte seleccionada de uma expressão não existir, de outra forma uma mensagem de erro é fornecida.

 -- Funcedilhaão: pickapart (EXPR, N)
     Atribui rótulos de expressão intermédia a subexpressões de EXPR de comprimento N, um inteiro. A subexpressões maiores ou menores não são atribuidos rótulos. pickapart retorna uma expressão em termos de expressões intermédias equivalentes à expressão original EXPR.

     Veja também part, dpart, lpart, inpart, e reveal.

     Exemplos:

          (%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
                                                    2
                                               sin(x )   b + a
          (%o1)       - log(sqrt(x + 1) + 1) + ------- + -----
                                                  3        2
          (%i2) pickapart (expr, 0);

                                                    2
                                               sin(x )   b + a
          (%t2)       - log(sqrt(x + 1) + 1) + ------- + -----
                                                  3        2

          (%o2)                          %t2
          (%i3) pickapart (expr, 1);

          (%t3)                - log(sqrt(x + 1) + 1)

                                            2
                                       sin(x )
          (%t4)                        -------
                                          3

                                        b + a
          (%t5)                         -----
                                          2

          (%o5)                    %t5 + %t4 + %t3
          (%i5) pickapart (expr, 2);

          (%t6)                 log(sqrt(x + 1) + 1)

                                            2
          (%t7)                        sin(x )

          (%t8)                         b + a

                                   %t8   %t7
          (%o8)                    --- + --- - %t6
                                    2     3
          (%i8) pickapart (expr, 3);

          (%t9)                    sqrt(x + 1) + 1

                                          2
          (%t10)                         x

                            b + a              sin(%t10)
          (%o10)            ----- - log(%t9) + ---------
                              2                    3
          (%i10) pickapart (expr, 4);

          (%t11)                     sqrt(x + 1)

                                2
                           sin(x )   b + a
          (%o11)           ------- + ----- - log(%t11 + 1)
                              3        2
          (%i11) pickapart (expr, 5);

          (%t12)                        x + 1

                             2
                        sin(x )   b + a
          (%o12)        ------- + ----- - log(sqrt(%t12) + 1)
                           3        2
          (%i12) pickapart (expr, 6);
                            2
                       sin(x )   b + a
          (%o12)       ------- + ----- - log(sqrt(x + 1) + 1)
                          3        2

 -- Variável de sistema: piece
     Mantém a ultima expressão seleccionada quando usando funcedilhaões part. Isso é escolhido durante a execucedilhaão da funcedilhaão e dessa forma pode referir-se à funcedilhaão em si mesma.

 -- Funcedilhaão: polarform (EXPR)
     Retorna uma expressão r %e^(%i theta) equivalente a EXPR, tal que r e theta sejam puramente reais.

 -- Funcedilhaão: powers (EXPR, X)
     Fornece os expoentes de X que ocorrem em expressão EXPR.

     load (powers) chama essa funcedilhaão.

 -- Funcedilhaão: product (EXPR, I, I_0, I_1)
     Representa um produto dos velores de expr com o índice I variando de I_0 a I_1. A forma substantiva 'product é mostrada como um pi maiísculo.

     product avalia EXPR e os limites inferior e superior I_0 e I_1, product coloca um apóstrofo (não avalia) o índice I.

     Se os limites superiores e inferiores diferirem por um inteiro, EXPR é avaliada para cada valor do índice I, e o resultado  um produto explícito.

     de outra forma, o intervalo do índice é indefinido. Algumas regras são aplicads para simplificar o produto. Quando a variável global simpproduct for true, regras adicionais são aplicadas. Em alguns casos, simplificacedilhaão um resultado que não é um produto; de outra forma, o resultado é uma forma substantiva 'product.

     Veja também nouns e evflag.

     Exemplos:

          (%i1) product (x + i*(i+1)/2, i, 1, 4);
          (%o1)           (x + 1) (x + 3) (x + 6) (x + 10)
          (%i2) product (i^2, i, 1, 7);
          (%o2)                       25401600
          (%i3) product (a[i], i, 1, 7);
          (%o3)                 a  a  a  a  a  a  a
                                 1  2  3  4  5  6  7
          (%i4) product (a(i), i, 1, 7);
          (%o4)          a(1) a(2) a(3) a(4) a(5) a(6) a(7)
          (%i5) product (a(i), i, 1, n);
                                       n
                                     /===\
                                      ! !
          (%o5)                       ! !  a(i)
                                      ! !
                                     i = 1
          (%i6) product (k, k, 1, n);
                                         n
                                       /===\
                                        ! !
          (%o6)                         ! !  k
                                        ! !
                                       k = 1
          (%i7) product (k, k, 1, n), simpproduct;
          (%o7)                          n!
          (%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
                                       n
                                     /===\
                                      ! !    1
          (%o8)                       ! !  -----
                                      ! !  k + 1
                                     k = 1
          (%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
                                        15  40
          (%o9)                        a   b

 -- Funcedilhaão: realpart (EXPR)
     Retorna a parte real de EXPR. realpart e imagpart irão trabalhar sobre expressões envolvendo funcedilhaões trigonométricas e hiperbólicas, bem como raízes quadradas, logaritmos, e exponenciacedilhaão.

 -- Funcedilhaão: rectform (EXPR)
     Retorna uma expressão a + b %i equivalente a EXPR, tal que A e B sejam puramente reais.

 -- Funcedilhaão: rembox (EXPR, unlabelled)
 -- Funcedilhaão: rembox (EXPR, RÓTULO)
 -- Funcedilhaão: rembox (EXPR)
     Remove caixas de EXPR.

     rembox (EXPR, unlabelled) remove todas as caixas sem rótulos de EXPR.

     rembox (EXPR, RÓTULO) remove somente caixas contendo RÓTULO.

     rembox (EXPR) remove todas as caixas, rotuladas e nã rotuladas.

     Caixas são desenhadas pelas funcedilhaões box, dpart, e lpart.

     Exemplos:

          (%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
                                            a d - b c
          (%o1)                sin(%pi x) + ---------
                                                2
                                               h
          (%i2) dpart (dpart (expr, 1, 1), 2, 2);
                                  """""""    a d - b c
          (%o2)               sin("%pi x") + ---------
                                  """""""      """"
                                               " 2"
                                               "h "
                                               """"
          (%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
                            FOO"""""""""""   BAR""""""""
                            "    """"""" "   "a d - b c"
          (%o3)             "sin("%pi x")" + "---------"
                            "    """"""" "   "  """"   "
                            """"""""""""""   "  " 2"   "
                                             "  "h "   "
                                             "  """"   "
                                             """""""""""
          (%i4) rembox (expr2, unlabelled);
                                            BAR""""""""
                             FOO"""""""""   "a d - b c"
          (%o4)              "sin(%pi x)" + "---------"
                             """"""""""""   "    2    "
                                            "   h     "
                                            """""""""""
          (%i5) rembox (expr2, FOO);
                                            BAR""""""""
                                 """""""    "a d - b c"
          (%o5)              sin("%pi x") + "---------"
                                 """""""    "  """"   "
                                            "  " 2"   "
                                            "  "h "   "
                                            "  """"   "
                                            """""""""""
          (%i6) rembox (expr2, BAR);
                             FOO"""""""""""
                             "    """"""" "   a d - b c
          (%o6)              "sin("%pi x")" + ---------
                             "    """"""" "     """"
                             """"""""""""""     " 2"
                                                "h "
                                                """"
          (%i7) rembox (expr2);
                                            a d - b c
          (%o7)                sin(%pi x) + ---------
                                                2
                                               h

 -- Funcedilhaão: sum (EXPR, I, I_0, I_1)
     Representa um somatório dos valores de EXPR com o índice I variando de I_0 a I_1. A forma substantiva 'sum é mostrada com uma letra sigma maiúscula. sum avalia seu somando EXPR e limites inferior e superior I_0 e I_1, sum coloca apóstrofo (não avalia) o índice I.

     Se os limites superiores e inferiores diferirem de um número inteiro, o somatoriando EXPR é avaliado para cada valor do índice do somatório I, e o resultado é uma adicedilhaão explícita.

     De outra forma, o intervalo dos índices é indefinido. Algumas regras são aplicadas para simplificar o somatório. Quando a variável global simpsum for true, regras adicionais são aplicadas. Em alguns casos, simplificacedilhaões retornam um resultado que não é um somatório; de outra forma, o resultado é uma forma substantiva 'sum.

     Quando o evflag (sinalizador de avaliacedilhaão) cauchysum for true, um produto de somatórios é mostrado como um produto de Cauchy, no qual o índice do somatório mais interno é uma funcedilhaão de índice de um nível acima, em lugar de variar independentemente.

     A variável global genindex é o prefixo alfabético usado para gerar o próximo índice do somatório, quando um índice automaticamente gerado for necessário.

     gensumnum é o sufixo numérico usando para gerar o próximo índice do somatório, quando um índice gerado automaticamente for necessário. Quando gensumnum for false, um índice gerado automaticamente é somente genindex sem sufixo numérico.

     Veja também sumcontract, intosum, bashindices, niceindices, nouns, evflag, e zeilberger.

     Exemplos:

          (%i1) sum (i^2, i, 1, 7);
          (%o1)                          140
          (%i2) sum (a[i], i, 1, 7);
          (%o2)           a  + a  + a  + a  + a  + a  + a
                           7    6    5    4    3    2    1
          (%i3) sum (a(i), i, 1, 7);
          (%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
          (%i4) sum (a(i), i, 1, n);
                                      n
                                     ====
                                     \
          (%o4)                       >    a(i)
                                     /
                                     ====
                                     i = 1
          (%i5) sum (2^i + i^2, i, 0, n);
                                    n
                                   ====
                                   \       i    2
          (%o5)                     >    (2  + i )
                                   /
                                   ====
                                   i = 0
          (%i6) sum (2^i + i^2, i, 0, n), simpsum;
                                        3      2
                             n + 1   2 n  + 3 n  + n
          (%o6)             2      + --------------- - 1
                                            6
          (%i7) sum (1/3^i, i, 1, inf);
                                      inf
                                      ====
                                      \     1
          (%o7)                        >    --
                                      /      i
                                      ====  3
                                      i = 1
          (%i8) sum (1/3^i, i, 1, inf), simpsum;
                                          1
          (%o8)                           -
                                          2
          (%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                                        inf
                                        ====
                                        \     1
          (%o9)                      30  >    --
                                        /      2
                                        ====  i
                                        i = 1
          (%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                            2
          (%o10)                       5 %pi
          (%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                      n
                                     ====
                                     \       1
          (%o11)                      >    -----
                                     /     k + 1
                                     ====
                                     k = 1
          (%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10));
          Incorrect syntax: Too many )'s
          else b^k, k, 1, 10))
                            ^
          (%i12) linenum:11;
          (%o11)                         11
          (%i12) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                      n
                                     ====
                                     \       1
          (%o12)                      >    -----
                                     /     k + 1
                                     ====
                                     k = 1
          (%i13) sum (if k <= 5 then a^k else b^k, k, 1, 10);
                    10    9    8    7    6    5    4    3    2
          (%o13)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a

 -- Funcedilhaão: lsum (EXPR, X, L)
     Representas a adicedilhaão de EXPR a cada elemento X em L.

     Uma forma substantiva 'lsum é retornada se o argumento L não avaliar para uma lista.

     Exemplos:

          (%i1) lsum (x^i, i, [1, 2, 7]);
                                      7    2
          (%o1)                      x  + x  + x
          (%i2) lsum (i^2, i, rootsof (x^3 - 1));
                               ====
                               \      2
          (%o2)                 >    i
                               /
                               ====
                                             3
                               i in rootsof(x  - 1)

 -- Funcedilhaão: verbify (F)
     Retorna a forma verbal da funcedilhaão chamada F.

     Veja também verb, noun, e nounify.

     Exemplos:

          (%i1) verbify ('foo);
          (%o1)                          foo
          (%i2) :lisp $%
          $FOO
          (%i2) nounify (foo);
          (%o2)                          foo
          (%i3) :lisp $%
          %FOO