Manual do Maxima 5.37.3: 6. Expressões

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 6. Expressões

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.1 Introduçã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 separaçã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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.2 Complexo

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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.3 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 função são verbos. Um verbo pode ser mudado em um substantivo através da adição de um apóstrofo no início do nome da função ou aplicando a função `nounify`. Um substantivo pode ser mudado em um verbo através da aplicação da função `verbify`. O sinalizador de avaliaçã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 exibição, tais como `'integrate` e `'derivative` (retornado por `diff`), mas muitos não. Por padrão, as formas substantiva e verbal de uma funçã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)

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.4 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 funçã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 começa com um sinal de dólar `$`. Qualquer outro símbolo Lisp é precedido por um ponto de interrogaçã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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.5 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 tabulações (tab), nova linha (ou fim de linha), e caracteres de retorno da cabeça 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 terminaçã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 combinaçã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 tabulação, nova linha, ou retorno da cabeça 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 operações (por exemplo, testes de igualdade) possam falhar.

O pacote adicional `stringproc` contém muitas funçõ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."

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.6 Desigualdade

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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.7 Sintaxe

É possível definir novos operadores com precedência especificada, remover a definiçã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 abraçam 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

  negação `- a`

unário posfixado

  factorial `a!`

binário infixado

  exponenciação `a^b`

n-ário infixado

  adição `a + b`

matchfix

  construçã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 função como um operador; a funçã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 função `"dd" (a)` é equivalente a `dd a`, da mesma forma `"<-" (a, b)` é equivalente a `a <- b`. Note também que as funçõ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 funçõ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). (Associação de expoentes determina a precedência do operador. todavia, uma vez que os expoentes esquerdo e direito podem ser diferentes, associação de expoentes é até certo ponto mais complicado que precedência.) Alguma das funções de definição de operações tomam argumentos adicionais; veja as descrições de função para maiores detalhes.

`prefixado`

  ead=180

`posfixado`

  eae=180

`infixado`

  eae=180, ead=180

`nário`

  eae=180, ead=180

`matchfix`

  (associação de expoentes não é aplicável)

`nofix`

  (associação de expoentes não é aplicável)

Para comparaçã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 abraçado 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)

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 6.8 Definições para Expressões

Função: at (expr, [eqn_1, ..., eqn_n])
Função: at (expr, eqn)

  Avalia a expressão expr com as variáveis assumindo os valores como especificado para elas na lista de equações `[eqn_1, ..., eqn_n]` ou a equaçã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 substituições em série, não em paralelo.

  Veja também `atvalue`. Para outras funções que realizam substituiçõ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

Função: box (expr)
Funçã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 funçõ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 opção: boxchar

  Valor por omissão: `"`

  `boxchar` é o caractere usado para desenhar a caixa por `box` e nas funçõ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.

Funçã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 função computacional, não uma função de simplificação.

  `carg` ignora a declaraçã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`.

Funçã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 funçõ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)

Funçã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 descrição para cada sinalizador de declaraçã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 funçã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 função `ev` de forma que a_i é associado a `true` durante a execuçã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 associaçã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 ordenaçã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 função n-ária (com muitos argumentos).

    A declaração `nary` não tem o mesmo objectivo que uma chamada à funçã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 função simétrica ou antisimétrica. `commutative` é o mesmo que `symmetric`.

  `oddfun`, `evenfun`

    Diz ao Maxima para reconhecer a_i como uma função par ou uma funçã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 substituição `a_i(x * y * z * ...)` `-->` `a_i(x) * a_i(y) * a_i(z) * ...`. A substituição é realizada no primeiro argumento somente.

  `additive`

    Diz ao Maxima para simplificar expressões do tipo a_i através da substituição `a_i(x + y + z + ...)` `-->` `a_i(x) + a_i(y) + a_i(z) + ...`. A substituiçã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 função de incremento ou decremento.

  `posfun`

    Diz ao Maxima para reconhecer a_i como uma função positiva.

  `integervalued`

    Diz ao Maxima para reconhecer a_i como uma função de valores inteiros.

  Exemplos:

  Declaraçõ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))

  Declaraçã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

  Declaraçã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

  Declarações `constant`, `scalar`, `nonscalar`, e `mainvar`.

  Declaraçã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~]

  Declaração `feature`.

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

  Declarações `rassociative` e `lassociative`.

  Declaraçã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)

  Declaraçõ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)

  Declaraçõ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

  Declaraçã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)

  Declaraçã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)

  Declaraçã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)

  Declaraçã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

Função: disolate (expr, x_1, ..., x_n)

  é similar a `isolate (expr, x)` excepto que essa funçã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 integração múltipla, e em mudança de variável envolvendo duas ou mais das variáveis de integração. Essa função é chamada automaticamente de ``simplification/disol.mac'`. Uma demostração está disponível através de `demo("disol")$`.

Função: dispform (expr)

  Retorna a representação externa de expr com relação a seu principal operador. Isso pode ser útil em conjunção com `part` que também lida com a representação externa. Suponha que expr seja -A . Então a representação interna de expr é "*"(-1,A), enquanto que a representaçã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`.

Função: distrib (expr)

  Distribue adiçõ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 adiçõ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

Funçã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"
                                  """

Função: exp (x)

  Representa funçã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 opçã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 simplificação adicional de `%e^(%pi %i x)` é realizada.

Variável de opçã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 substituição é realizada somente se o expoente em `%e^x` avaliar para um número.

  Veja também `ev` e `numer`.

Variável de opçã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 opção: exptsubst

  Valor por omissão: `false`

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

Funçã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 associaçã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 funçõ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 simplificação e avaliação) e não tenta determinar se alguma expressão equivalente pode fornecer um resultado diferente. Em particular, simplificaçã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 associaçã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 integraçã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 integração.

  - Argumentos são nomes de funçõ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. Simplificaçã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 integraçã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

Funçã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!!`.

Função: imagpart (expr)

  Retorna a parte imaginária da expressão expr.

  `imagpart` é uma função computacional, não uma função de simplificação.

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

Função: infix (op)
Função: infix (op, lbp, rbp)
Função: infix (op, lbp, rbp, lpos, rpos, pos)

  Declara op para ser um operador infixo. Um operador infixo é uma função de dois argumentos, com o nome da função escrito entre os argumentos. Por exemplo, o operador de subtraçã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 relaçã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 relaçã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 opção: inflag

  Velor padrão: `false`

  Quando `inflag` for `true`, funções para extraçã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 funções afectadas pela posição do sinalizador `inflag` são: `part`, `substpart`, `first`, `rest`, `last`, `length`, a estrutura `for` ... `in`, `map`, `fullmap`, `maplist`, `reveal` e `pickapart`.

Função: inpart (expr, n_1, ..., n_k)

  É similar a `part` mas trabalha sobre a representação interna da expressão em lugar da forma de exibição e dessa forma pode ser mais rápida uma vez que nenhuma formatação é realizada. Cuidado deve ser tomado com relação à ordem de subexpressões em adiçõ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, subtraçã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 abraçado 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)

Função: isolate (expr, x)

  Retorna expr com subexpressões que são adiçõ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 avaliaçã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 relação a produtos. Veja `isolate_wrt_times`.

  Faça `example (isolate)` para exemplos.

Variável de opção: isolate_wrt_times

  Valor por omissão: `false`

  Quando `isolate_wrt_times` for `true`, `isolate` irá também isolar com relaçã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 opçã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 opçã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]

Funçã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

Funçã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.

Funçã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)

Funçã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.

Função: multthru (expr)
Função: multthru (expr_1, expr_2)

  Multiplica um factor (que pode ser uma adiçã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 função é o caminho mais rápido para distribuir produtos (comutativos ou não) sobre adições. Uma vez que quocientes são representados como produtos `multthru` podem ser usados para dividir adições por produtos também.

  `multthru (expr_1, expr_2)` multiplica cada termo em expr_2 (que pode ser uma adição ou uma equção) por expr_1. Se expr_1 não for por si mesmo uma adiçã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

Função: nounify (f)

  Retorna a forma substantiva do nome da função f. Isso é necessário se se quer referir ao nome de uma função verbo como se esse nome fosse um substantivo. Note que algumas funçõ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 função é precedida por um apóstrofo.

Função: nterms (expr)

  Retorna o número de termos que expr pode ter se for completamente expandida e nenhum cancelamento ou combinaçã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 adição).

Funçã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 função subscrita, `op` retorna uma função subscrita; nesse caso o valor de retorno não é um átomo. De outro modo, expr é uma função de array ou uma expressão de funçã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

Função: operatorp (expr, op)
Funçã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.

Funçã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 recomputaçã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. Faça `example (optimize)` para exemplos.

Variável de opção: optimprefix

  Valor por omissão: `%`

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

Funçã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`.

Função: ordergreatp (expr_1, expr_2)

  Retorna `true` se expr_2 precede expr_1 na ordenação escolhida com a função `ordergreat`.

Funçã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 ordenação completa é: constantes numéricas < constantes declaradas < escalares declarados < primeiro argumento para `orderless` < ... < último argumento para `orderless` < variáveis que começam com A < ... < variáveis que começam com Z < último argumento para `ordergreat` < ... < primeiro argumento para `ordergreat` < `mainvar`s - variáveis principais declaradas.

  Veja também `ordergreat` e `mainvar`.

Função: orderlessp (expr_1, expr_2)

  Retorna `true` se expr_1 precede expr_2 na ordenação escolhida pelo comando `orderless`.

Função: part (expr, n_1, ..., n_k)

  Retorna partes da forma exibida de `expr`. Essa funçã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 função `part` for uma lista de índices então muitas subexpressões serão pinçadas, 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 funções `part`. Isso é escolhido durante a execução da função e dessa forma pode referir-se à funçã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.

Funçã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 adiçã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 opçã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.

Funçã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 funções `part`. Isso é escolhido durante a execução da função e dessa forma pode referir-se à função em si mesma.

Função: polarform (expr)

  Retorna uma expressão `r %e^(%i theta)` equivalente a expr, tal que `r` e `theta` sejam puramente reais.

Função: powers (expr, x)

  Fornece os expoentes de x que ocorrem em expressão expr.

  `load (powers)` chama essa função.

Funçã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, simplificaçã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

Função: realpart (expr)

  Retorna a parte real de expr. `realpart` e `imagpart` irão trabalhar sobre expressões envolvendo funções trigonométricas e hiperbólicas, bem como raízes quadradas, logaritmos, e exponenciação.

Função: rectform (expr)

  Retorna uma expressão `a + b %i` equivalente a expr, tal que a e b sejam puramente reais.

Função: rembox (expr, unlabelled)
Função: rembox (expr, rótulo)
Funçã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 funçõ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

Funçã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 adiçã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, simplificações retornam um resultado que não é um somatório; de outra forma, o resultado é uma forma substantiva `'sum`.

  Quando o `evflag` (sinalizador de avaliaçã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 funçã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

Função: lsum (expr, x, L)

  Representas a adiçã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)

Função: verbify (f)

  Retorna a forma verbal da funçã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

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by U-CYGWINX\ASSI on diciembre, 18 2015 using texi2html 1.76.