Introducedilhaão a Definicedilhaão de Funcedilhaão
==================================================

Funcedilhaão
============

Ordinary functions
------------------

Para definir uma funcedilhaão no Maxima usa-se o operador :=. Por exemplo,

     f(x) := sin(x)

define uma funcedilhaão f. Funcedilhaões anônimas podem também serem criadas usando lambda. Por exemplo

     lambda ([i, j], ...)

pode ser usada em lugar de f onde

     f(i,j) := block ([], ...);
     map (lambda ([i], i+1), l)

retornará uma lista com 1 adicionado a cada termo.

Pode também definir uma funcedilhaão com um número variável de argumentos, usando um argumento final que seja uma lista, na qual serão inseridos todos os argumentos adicionais:

     (%i1) f ([u]) := u;
     (%o1)                      f([u]) := u
     (%i2) f (1, 2, 3, 4);
     (%o2)                     [1, 2, 3, 4]
     (%i3) f (a, b, [u]) := [a, b, u];
     (%o3)               f(a, b, [u]) := [a, b, u]
     (%i4) f (1, 2, 3, 4, 5, 6);
     (%o4)                 [1, 2, [3, 4, 5, 6]]

O lado direito na definicedilhaão de uma funcedilhaão é uma expressão. Assim, quando quiser que a definicedilhaão seja uma sequência de expressões, poderá usar a forma

     f(x) := (expr1, expr2, ...., exprn);

e o valor de EXPRN é que é retornado pela funcedilhaão.

Se quiser introduzir um ponto de retorno em alguma expressão dentro da funcedilhaão, deverá usar block e return.

     block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)

é em si mesma uma expressão, e então poderá ocupar o lugar do lado direito de uma definicedilhaão de funcedilhaão.  Aqui pode acontecer que o retorno acontecedilhaa mais facilmente que no exemplo anterior a essa última expressão.

O primeiro [] no bloco, pode conter uma lista de variáveis e atribuicedilhaões de variáveis, tais como [a: 3, b, c:
[]], que farão com que as três variáveis a,b,e c não se refiram a seus valores globais, mas ao contrário tenham esses valores especiais enquanto o código estiver executando a parte dentro do bloco block, ou dentro da funcedilhaões chamadas de dentro do bloco block.  Isso é chamado associacedilhaão dynamic, uma vez que as variáveis permanecem do início do bloco pelo tempo que ele existir. Quando regressar do bloco block, ou o descartar, os valores antigos (quaisquer que sejam) das variáveis serão restaurados.  É certamente uma boa idéia para proteger as suas variáveis nesse caminho.  Note que as atribuicedilhaões em variáveis do bloco, são realizadas em paralelo.  Isso significa, que se tivesse usado c: a acima, o valor de c seria o valor que a tinha antes do bloco, antes de ter obtido o seu novo valor atribuído no bloco.  Dessa forma fazendo alguma coisa como

     block ([a: a], expr1, ...  a: a+3, ..., exprn)

protegerá o valor externo de a de ser alterado, mas impedirá aceder ao valor antigo. Assim, o lado direito de atribuicedilhaões, é avaliado no contexto inserido, antes que qualquer avaliacedilhaão ocorra.  Usando apenas block ([x], ... faremos com que o x tenho como valor a si próprio; esse é o mesmo valor que teria no início de uma sessão do Maxima.

Os actuais argumentos para uma funcedilhaão são tratados exactamente da mesma que as variáveis em um bloco.  Dessa forma em

     f(x) := (expr1, ..., exprn);

e

     f(1);

teremos um contexto similar para avaliacedilhaão de expressões como se tivéssemos concluído

     block ([x: 1], expr1, ..., exprn)

Dentro de funcedilhaões, quando o lado direito de uma definicedilhaão, pode ser calculado em tempo de execucedilhaão, isso é úti para usar define e possivelmente buildq.

Funcedilhaão de Array
---------------------

Uma funcedilhaão de Array armazena o valor da funcedilhaão na primeira vez que ela for chamada com um argumento dado, e retorna o valor armazenado, sem recalcular esse valor, quando o mesmo argumento for fornecido. De modo que uma funcedilhaão é muitas vezes chamada uma funcedilhaão de memorizacedilhaão.

Nomes de funcedilhaões de Array são anexados ao final da lista global arrays (não na lista global functions). O comando arrayinfo retorna a lista de argumentos para os quais exite valores armazenados, e listarray retorna os valores armazenados. Os comandos dispfun e fundef retornam a definicedilhaão da funcedilhaão de array.

O comando arraymake contrói uma chamada de funcedilhaão de array, análogamente a funmake para funcedilhaões comuns. O comando arrayapply aplica uma funcedilhaão de array a seus argmentos, análogamente a apply para funcedilhaões comuns. Não existe nada exactamente análogo a map para funcedilhaões de array, embora map(lambda([X], A[X]), L) ou makelist(A[X], X, L), onde L é uma lista, não estejam tão longe disso.

O comando remarray remove uma definicedilhaão de funcedilhaão de array (incluindo qualquer valor armazenado pela funcedilhaão removida), análogo a remfunction para funcedilhaões comuns.

o comando kill(A[X]) remove o valor da funcedilhaão de array A armazenado para o argumento X; a próxima vez que A foor chamada com o argumento X, o valor da funcedilhaão é recomputado. Todavia, não exite caminho para remover todos os valores armazenados de uma vez, excepto para kill(A) ou remarray(A), o qual remove também remove a definicedilhaão da funcedilhaão de array.

Macros
======

 -- Funcedilhaão: buildq (L, EXPR)
     Substitue variáveis nomeadas pela lista L dentro da expressão EXPR, paralelamente, sem avaliar EXPR. A expressão resultante é simplificada, mas não avaliada, após buildq realizar a substituicedilhaão.

     Os elementos de L são símbolos ou expressões de atribuicedilhaão SÍMBOLO: VALOR, avaliadas paralelamente. Isto é, a associacedilhaão de uma variável sobre o lado direito de uma atribuicedilhaão é a associacedilhaão daquela variável no contexto do qual buildq for chamada, não a associacedilhaão daquela variável na lista L de variáveis. Se alguma variável em L não dada como uma atribuicedilhaão explícita, sua associacedilhaão em buildq é a mesma que no contexto no qual buildq for chamada.

     Então as variáveis nomeadas em L são substituidas em EXPR paralelamente. Isto é, a substituicedilhaão para cada variável é determinada antes que qualquer substituicedilhaão seja feita, então a substituicedilhaão para uma variável não tem efeito sobre qualquer outra.

     Se qualquer variável X aparecer como splice (X) em EXPR, então X deve estar associada para uma lista, e a lista recebe uma aplicacedilhaão da funcedilhaão splice (é interpolada) na EXPR em lugar de substituída.

     Quaisquer variáveis em EXPR não aparecendo em L são levados no resultado tal como foram escritos, mesmo se elas tiverem associacedilhaões no contexto do qual buildq tiver sido chamada.

     Exemplos

     a é explicitamente associada a x, enquanto b tem a mesma associacedilhaão (nomeadamente 29) como no contexto chamado, e c é levada do comecedilhao ao fim da forma como foi escrita. A expressão resultante não é avaliada até a avaliacedilhaão explícita ( com duplo apóstrofo - não com aspas - ''%.

          (%i1) (a: 17, b: 29, c: 1729)$
          (%i2) buildq ([a: x, b], a + b + c);
          (%o2)                      x + c + 29
          (%i3) ''%;
          (%o3)                       x + 1758

     e está associado a uma lista, a qual aparece também como tal nos argumentos de foo, e interpolada nos argumentos de bar.

          (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
          (%o1)                 foo(x, [a, b, c], y)
          (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
          (%o2)                  bar(x, a, b, c, y)

     O resultado é simplificado após substituicedilhaão. Se a simplificacedilhaão for aplicada antes da substituicedilhaão, esses dois resultados podem ser iguais.

          (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
          (%o1)                    2 c + 2 b + 2 a
          (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
          (%o2)                        2 a b c

     As variáveis em L são associadas em paralelo; se associadas sequêncialmente, o primeiro resultado pode ser foo (b, b). Substituicedilhaões são realizadas em paralelo; compare o segundo resultado com o resultado de subst, que realiza substituicedilhaões sequêncialmente.

          (%i1) buildq ([a: b, b: a], foo (a, b));
          (%o1)                       foo(b, a)
          (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u], bar (u, v, w, x, y, z));
          (%o2)                 bar(v, w, x, y, z, u)
          (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u], bar (u, v, w, x, y, z));
          (%o3)                 bar(u, u, u, u, u, u)

     Constrói uma lista de euqcedilhaões com algumas variáveis ou expressões sobre o lado esquerdo e seus valores sobre o lado direito. macroexpand mostra a expressão retornada por show_values.

          (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
          (%o1)   show_values([L]) ::= buildq([L], map("=", 'L, L))
          (%i2) (a: 17, b: 29, c: 1729)$
          (%i3) show_values (a, b, c - a - b);
          (%o3)              [a = 17, b = 29, c = 1729]

 -- Funcedilhaão: macroexpand (EXPR)
     Retorna a expansão da macro de EXPR sem avaliar a expressão, quando expr for uma chamada de funcedilhaão de macro. De outra forma, macroexpand retorna EXPR.

     Se a expansão de EXPR retorna outra chamada de funcedilhaão de macro, aquela chamada de funcedilhaão de macro é também expandida.

     macroexpand coloca apóstrofo em seus argumentos, isto é, não os avalia. Todavia, se a expansão de uma chamada de funcedilhaão de macro tiver algum efeito, esse efeito colateral é executado.

     Veja também ::=, macros, e macroexpand1.

     Exemplos

          (%i1) g (x) ::= x / 99;
                                              x
          (%o1)                      g(x) ::= --
                                              99
          (%i2) h (x) ::= buildq ([x], g (x - a));
          (%o2)            h(x) ::= buildq([x], g(x - a))
          (%i3) a: 1234;
          (%o3)                         1234
          (%i4) macroexpand (h (y));
                                        y - a
          (%o4)                         -----
                                         99
          (%i5) h (y);
                                      y - 1234
          (%o5)                       --------
                                         99

 -- Funcedilhaão: macroexpand1 (EXPR)
     Retorna a expansão de macro de EXPR sem avaliar a expressão, quando expr for uma chamada de funcedilhaão de macro. De outra forma, macroexpand1 retorna EXPR.

     macroexpand1 não avalia seus argumentos. Todavia, se a expansão de uma chamada de funcedilhaão de macro tiver algum efeito, esse efeito colateral é executado.

     Se a expansão de EXPR retornar outra chamada de funcedilhaão de macro, aquela chamada de funcedilhaão de macro não é expandida.

     Veja também ::=, macros, e macroexpand.

     Examples

          (%i1) g (x) ::= x / 99;
                                              x
          (%o1)                      g(x) ::= --
                                              99
          (%i2) h (x) ::= buildq ([x], g (x - a));
          (%o2)            h(x) ::= buildq([x], g(x - a))
          (%i3) a: 1234;
          (%o3)                         1234
          (%i4) macroexpand1 (h (y));
          (%o4)                       g(y - a)
          (%i5) h (y);
                                      y - 1234
          (%o5)                       --------
                                         99

 -- Global variable: macros
     Default value: []

     macros é a lista de funcedilhaões de macro definidas pelo utilizador. O operador de definicedilhaão de funcedilhaão de macro ::= coloca uma nova funcedilhaão de macro nessa lista, e kill, remove, e remfunction removem funcedilhaões de macro da lista.

     Veja também infolists.

 -- Funcedilhaão: splice (A)
     Une como se fosse um elo de ligacedilhaão (interpola) a lista nomeada através do átomo A em uma expressão, mas somente se splice aparecer dentro de buildq; de outra forma, splice é tratada como uma funcedilhaão indefinida. Se aparecer dentro de buildq com A sozinho (sem splice), A é substituido (não interpolado) como uma lista no resultado. O argumento de splice pode somente ser um átomo; não pode ser uma lista lateral ou uma expressão que retorna uma lista.

     Tipicamente splice fornece os argumentos para uma funcedilhaão ou operador. Para uma funcedilhaão f, a expressão f (splice (A)) dentro de buildq expande para f (A[1], A[2], A[3], ...). Para um operador o, a expressão "o" (splice (A) dentro de buildq expande para "o" (A[1], A[2], A[3], ...), onde o pode ser qualquer tipo de operador (tipicamente um que toma múltiplos argumentos). Note que o operador deve ser contido dentro de aspas duplas ".

     Exemplos

          (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
                                 foo(1, %pi, z - y)
          (%o1)                -----------------------
                               length([1, %pi, z - y])
          (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
                                          1
          (%o2)                          ---
                                         %pi
          (%i3) matchfix ("<>", "<>");
          (%o3)                          <>
          (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
          (%o4)                   <>1, %pi, z - y<>

Definicedilhaões para Definicedilhaão de Funcedilhaão
=====================================================

 -- Funcedilhaão: apply (F, [X_1, ..., X_N])
     Constrói e avalia uma expressãp F(ARG_1, ..., ARG_N).

     apply não tenta distinguir funcedilhaões de array de funcedilhaões comuns; quando F for o nome de uma funcedilhaão de array, apply avalia F(...) (isto é, uma chamada de funcedilhaão com parêntesis em lugar de colchêtes). arrayapply avalia uma chamada de funcedilhaão com colchêtes nesse caso.

     Exemplos:

     apply avalia seus argumentos. Nesse exemplo, min é aplicado a L.

          (%i1) L : [1, 5, -10.2, 4, 3];
          (%o1)                 [1, 5, - 10.2, 4, 3]
          (%i2) apply (min, L);
          (%o2)                        - 10.2

     apply avalia argumentos, mesmo se a funcedilhaão F disser que os argumentos não devem ser avaliados.

          (%i1) F (x) := x / 1729;
                                             x
          (%o1)                     F(x) := ----
                                            1729
          (%i2) fname : F;
          (%o2)                           F
          (%i3) dispfun (F);
                                             x
          (%t3)                     F(x) := ----
                                            1729

          (%o3)                         [%t3]
          (%i4) dispfun (fname);
          fname is not the name of a user function.
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) apply (dispfun, [fname]);
                                             x
          (%t5)                     F(x) := ----
                                            1729

          (%o5)                         [%t5]

     apply avalia o nome de funcedilhaão F. Apóstrofo ' evita avaliacedilhaão. demoivre é o nome de uma variável global e também de uma funcedilhaão.

          (%i1) demoivre;
          (%o1)                         false
          (%i2) demoivre (exp (%i * x));
          (%o2)                  %i sin(x) + cos(x)
          (%i3) apply (demoivre, [exp (%i * x)]);
          demoivre evaluates to false
          Improper name or value in functional position.
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) apply ('demoivre, [exp (%i * x)]);
          (%o4)                  %i sin(x) + cos(x)

 -- Funcedilhaão: block ([V_1, ..., V_M], EXPR_1, ..., EXPR_N)
 -- Funcedilhaão: block (EXPR_1, ..., EXPR_N)
     block avalia EXPR_1, ..., EXPR_N em sequência e retorna o valor da última expressão avaliada. A sequência pode ser modificada pelas funcedilhaões go, throw, e return. A última expressão é EXPR_N a menos que return ou uma expressão contendo throw seja avaliada. Algumas variáveis V_1, ..., V_M podem ser declaradas locais para o bloco; essas são distinguidas das variáveis globais dos mesmos nomes. Se variáveis não forem declaradas locais então a lista pode ser omitida. Dentro do bloco, qualquer variável que não V_1, ..., V_M é uma variável global.

     block salva os valores correntes das variáveis V_1, ..., V_M (quaisquer valores) na hora da entrada para o bloco, então libera as variáveis dessa forma eles avaliam para si mesmos. As variáveis locais podem ser associadas a valores arbitrários dentro do bloco mas quando o bloco é encerrado o valores salvos são restaurados, e os valores atribuídos dentro do bloco são perdidos.

     block pode aparecer dentro de outro block. Variáveis locais são estabelecidas cada vez que um novo block é avaliado. Variáveis locais parecem ser globais para quaisquer blocos fechados. Se uma variável é não local em um bloco, seu valor é o valor mais recentemente atribuído por um bloco fechado, quaisquer que sejam, de outra forma, seu valor é o valor da variável no ambiente global. Essa política pode coincidir com o entendimento usual de "escopo dinâmico".

     Se isso for desejado para salvar e restaurar outras propriedades locais ao lado de value, por exemplo array (excepto para arrays completos), function, dependencies, atvalue, matchdeclare, atomgrad, constant, e nonscalar então a funcedilhaão local pode ser usada dentro do bloco com argumentos sendo o nome das variáveis.

     O valor do bloco é o valor da última declaracedilhaão ou o valor do argumento para a funcedilhaão return que pode ser usada para sair explicitamente do bloco.  A funcedilhaão go pode ser usada para transferir o controle para a declaracedilhaão do bloco que é identificada com o argumento para go.  Para identificar uma declaracedilhaão, coloca-se antes dela um argumento atômico como outra declaracedilhaão no bloco.  Por exemplo: block ([x], x:1, loop, x: x+1, ..., go(loop), ...).  O argumento para go deve ser o nome de um identificador que aparece dentro do bloco.  Não se deve usar go para transferir para um identificador em um outro bloco a não ser esse que contém o go.

     Blocos tipicamente aparecem do lado direito de uma definicedilhaão de funcedilhaão mas podem ser usados em outros lugares também.

 -- Funcedilhaão: break (EXPR_1, ..., EXPR_N)
     Avalia e imprime EXPR_1, ..., EXPR_N e então causa uma parada do Maxima nesse ponto e o utilizador pode examinar e alterar seu ambiente.  Nessa situacedilhaão digite exit; para que o cálculo seja retomado.

 -- Funcedilhaão: catch (EXPR_1, ..., EXPR_N)
     Avalia EXPR_1, ..., EXPR_N uma por uma; se qualquer avaliacedilhaão levar a uma avaliacedilhaão de uma expressão da forma throw (arg), então o valor de catch é o valor de throw (arg), e expressões adicionais não são avaliadas. Esse "retorno não local" atravessa assim qualquer profundidade de aninhar para o mais próximo contendo catch. Se não existe nenhum catch contendo um throw, uma mensagem de erro é impressa.

     Se a avaliacedilhaão de argumentos não leva para a avaliacedilhaão de qualquer throw então o valor de catch é o valor de EXPR_N.

          (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
          (%i2) g(l) := catch (map (''%, l))$
          (%i3) g ([1, 2, 3, 7]);
          (%o3)               [f(1), f(2), f(3), f(7)]
          (%i4) g ([1, 2, -3, 7]);
          (%o4)                          - 3

     A funcedilhaão g retorna uma lista de f de cada elemento de l se l consiste somente de números não negativos; de outra forma, g "captura" o primeiro elemento negativo de l e "arremessa-o".

 -- Funcedilhaão: compfile (NOMEFICHEIRO, F_1, ..., F_N)
 -- Funcedilhaão: compfile (NOMEFICHEIRO, funcedilhaões)
 -- Funcedilhaão: compfile (NOMEFICHEIRO, all)

     Traduz fucedilhaões Maxima para Lisp e escreve o código traduzido no ficheiro NOMEFICHEIRO.

     compfile(NOMEFICHEIRO, F_1, ..., F_N) traduz as funcedilhaões especificadas. compfile(NOMEFICHEIRO, functions) e compfile(NOMEFICHEIRO, all) traduz todas as funcedilhaões definidas pelo utilizador.

     As traducedilhaões Lisp não são avaliadas, nem é o ficheiro de saída processado pelo compilador Lisp. translate cria e avalia traducedilhaões Lisp. compile_file traduz Maxima para Lisp, e então executa o compilador Lisp.

     Veja também translate, translate_file, e compile_file.

 -- Funcedilhaão: compile (F_1, ..., F_N)
 -- Funcedilhaão: compile (funcedilhaões)
 -- Funcedilhaão: compile (all)
     Traduz funcedilhaões Maxima F_1, ..., F_N para Lisp, avalia a traducedilhaão Lisp, e chama a funcedilhaão Lisp COMPILE sobre cada funcedilhaão traduzida. compile retorna uma lista de nomes de funcedilhaões compiladas.

     compile (all) ou compile (funcedilhaões) compila todas as funcedilhaões definidas pelo utilizador.

     compile não avalia seus argumentos; o operador apóstrofo-apóstrofo '' faz com que ocorra avaliacedilhaão sobrepondo-se ao apóstrofo.

 -- Funcedilhaão: define (F(X_1, ..., X_N), EXPR)
 -- Funcedilhaão: define (F[X_1, ..., X_N], EXPR)
 -- Funcedilhaão: define (funmake (F, [X_1, ..., X_N]), EXPR)
 -- Funcedilhaão: define (arraymake (F, [X_1, ..., X_N]), EXPR)
 -- Funcedilhaão: define (ev (EXPR_1), EXPR_2)

     Define uma funcedilhaão chamada F com argumentos X_1, ..., X_N e corpo da funcedilhaão EXPR. define sempre avalia seu segundo argumento (a menos que explícitamente receba um apostrofo de forma a evitar a avaliacedilhaão). A funcedilhaão então definida pode ser uma funcedilhaão comum do Maxima (com argumentos contidos entre parêtesis) ou uma funcedilhaão de array (com argumentos contidos entre colchêtes).

     Quando o último ou único argumento da funcedilhaão X_N for uma lista de um elemento, a funcedilhaão definida por define aceita um número variável de argumentos. Os argumentos actuais são atribuídos um a um a argumentos formais X_1, ..., X_(N - 1), e quaisquer argumentos adicionais actuais, se estiverem presentes, são atribuídos a X_N como uma lista.

     Quando o primeiro argumento de define for uma expressão da forma F(X_1, ..., X_N) or F[X_1, ..., X_N], os argumentos são avaliados mas F não é avaliada, mesmo se já existe anteriormente uma funcedilhaão ou variável com aquele nome. Quando o primeiro argumento for uma expressão com operador funmake, arraymake, ou ev, o primeiro argumento será avaliado; isso permite para o nome da funcedilhaão seja calculado, também como o corpo.

     Todas as definicedilhaões de funcedilhaão aparecem no mesmo nível de escopo e visibilidade; definindo uma funcedilhaão f dentro de outra funcedilhaão g não limita o escopo de f a g.

     Se algum argumento formal X_K for um símbolo com apóstrofo (após ter sido feita uma avaliacedilhaão), a funcedilhaão definida por define não avalia o correspondente actual argumento. de outra forma todos os argumentos actuais são avaliados.

     Veja também := and ::=.

     Exemplos:

     define sempre avalia seu segundo argumento (a menos que explícitamente receba um apostrofo de forma a evitar a avaliacedilhaão).

          (%i1) expr : cos(y) - sin(x);
          (%o1)                    cos(y) - sin(x)
          (%i2) define (F1 (x, y), expr);
          (%o2)              F1(x, y) := cos(y) - sin(x)
          (%i3) F1 (a, b);
          (%o3)                    cos(b) - sin(a)
          (%i4) F2 (x, y) := expr;
          (%o4)                   F2(x, y) := expr
          (%i5) F2 (a, b);
          (%o5)                    cos(y) - sin(x)

     A funcedilhaão definida por define pode ser uma funcedilhaão comum do Maxima ou uma funcedilhaão de array.

          (%i1) define (G1 (x, y), x.y - y.x);
          (%o1)               G1(x, y) := x . y - y . x
          (%i2) define (G2 [x, y], x.y - y.x);
          (%o2)                G2     := x . y - y . x
                                 x, y

     Quando o último ou único argumento da funcedilhaão X_N for uma lista de um único elemento, a funcedilhaão definida por define aceita um número variável de argumentos.

          (%i1) define (H ([L]), '(apply ("+", L)));
          (%o1)                H([L]) := apply("+", L)
          (%i2) H (a, b, c);
          (%o2)                       c + b + a

     When the first argument is an expression with operator funmake, arraymake, or ev, the first argument is evaluated.

          (%i1) [F : I, u : x];
          (%o1)                        [I, x]
          (%i2) funmake (F, [u]);
          (%o2)                         I(x)
          (%i3) define (funmake (F, [u]), cos(u) + 1);
          (%o3)                  I(x) := cos(x) + 1
          (%i4) define (arraymake (F, [u]), cos(u) + 1);
          (%o4)                   I  := cos(x) + 1
                                   x
          (%i5) define (foo (x, y), bar (y, x));
          (%o5)                foo(x, y) := bar(y, x)
          (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
          (%o6)             bar(y, x) := sin(x) - cos(y)

 -- Funcedilhaão: define_variable (NAME, DEFAULT_VALUE, MODE)

     Introduz uma variável global dentro do ambiente Maxima. define_variable é útil em pacotes escritos pelo utilizador, que são muitas vezes traduzidos ou compilados.

     define_variable realiza os seguintes passos:

      1. mode_declare (NAME, MODE) declara o modo de NAME para o tradutor. Veja mode_declare para uma lista dos modos possíveis.

      2. Se a variável é não associada, DEFAULT_VALUE é atribuído para NAME.

      3. declare (NAME, special) declara essa variável especial.

      4. Associa NAME com uma funcedilhaão de teste para garantir que a NAME seja somente atribuído valores do modo declarado.

     A propriedade value_check pode ser atribuída a qualquer variável que tenha sido definida via define_variable com um outro modo que não any. A propriedade value_check é uma expressão lambda ou o nome de uma funcedilhaão de uma variável, que é chamada quando uma tentativa é feita para atribuir um valor a uma variável. O argumento da  funcedilhaão value_check é o valor que será atribuído.

     define_variable avalia default_value, e não avalia name e mode. define_variable retorna o valor corrente de name, que é default_value se name não tiver sido associada antes, e de outra forma isso é o valor prévio de name.

     Exemplos:

     foo é uma variável Booleana, com o valor inicial true.

          (%i1) define_variable (foo, true, boolean);
          (%o1)                         true
          (%i2) foo;
          (%o2)                         true
          (%i3) foo: false;
          (%o3)                         false
          (%i4) foo: %pi;
          Error: foo was declared mode boolean, has value: %pi
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) foo;
          (%o5)                         false

     bar é uma variável inteira, que deve ser um número primo.

          (%i1) define_variable (bar, 2, integer);
          (%o1)                           2
          (%i2) qput (bar, prime_test, value_check);
          (%o2)                      prime_test
          (%i3) prime_test (y) := if not primep(y) then error (y, "is not prime.");
          (%o3) prime_test(y) := if not primep(y)

                                             then error(y, "is not prime.")
          (%i4) bar: 1439;
          (%o4)                         1439
          (%i5) bar: 1440;
          1440 é not prime.
          #0: prime_test(y=1440)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i6) bar;
          (%o6)                         1439

     baz_quux é uma variável que não pode receber a atribuicedilhaão de um valor. O modo any_check é como any, mas any_check habilita o mecanismo value_check, e any não habilita.

          (%i1) define_variable (baz_quux, 'baz_quux, any_check);
          (%o1)                       baz_quux
          (%i2) F: lambda ([y], if y # 'baz_quux then error ("Cannot assign to `baz_quux'."));
          (%o2) lambda([y], if y # 'baz_quux

                                  then error(Cannot assign to `baz_quux'.))
          (%i3) qput (baz_quux, ''F, value_check);
          (%o3) lambda([y], if y # 'baz_quux

                                  then error(Cannot assign to `baz_quux'.))
          (%i4) baz_quux: 'baz_quux;
          (%o4)                       baz_quux
          (%i5) baz_quux: sqrt(2);
          Cannot assign to `baz_quux'.
          #0: lambda([y],if y # 'baz_quux then error("Cannot assign to `baz_quux'."))(y=sqrt(2))
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i6) baz_quux;
          (%o6)                       baz_quux

 -- Funcedilhaão: dispfun (F_1, ..., F_N)
 -- Funcedilhaão: dispfun (all)
     Mostra a definicedilhaão de funcedilhaões definidas pelo utilizador F_1, ..., F_N. Cada argumento pode ser o nome de uma macro (definida com ::=), uma funcedilhaão comum (definida com := ou define), uma funcedilhaão array (definida com := ou com define, mas contendo argumentos entre colchêtes [ ]), uma funcedilhaão subscrita, (definida com := ou define, mas contendo alguns argumentos entre colchêtes e outros entre parêntesis ( )) uma da família de funcedilhaões subscritas seleccionadas por um valor subscrito particular, ou uma funcedilhaão subscrita definida com uma constante subscrita.

     dispfun (all) mostra todas as funcedilhaões definidas pelo utilizador como dadas pelas functions, arrays, e listas de macros, omitindo funcedilhaões subscritas definidas com constantes subscritas.

     dispfun cria um Rótulo de expressão intermédia (%t1, %t2, etc.) para cada funcedilhaão mostrada, e atribui a definicedilhaão de funcedilhaão para o rótulo. Em contraste, fundef retorna a definicedilhaão de funcedilhaão.

     dispfun não avalia seus argumentos; O operador apóstrofo-apóstrofo '' faz com que ocorra avaliacedilhaão.

     dispfun retorna a lista de rótulos de expressões intermédias correspondendo às funcedilhaões mostradas.

     Exemplos:

          (%i1) m(x, y) ::= x^(-y);
                                               - y
          (%o1)                   m(x, y) ::= x
          (%i2) f(x, y) :=  x^(-y);
                                               - y
          (%o2)                    f(x, y) := x
          (%i3) g[x, y] :=  x^(-y);
                                              - y
          (%o3)                     g     := x
                                     x, y
          (%i4) h[x](y) :=  x^(-y);
                                              - y
          (%o4)                     h (y) := x
                                     x
          (%i5) i[8](y) :=  8^(-y);
                                              - y
          (%o5)                     i (y) := 8
                                     8
          (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
                                               - y
          (%t6)                   m(x, y) ::= x

                                               - y
          (%t7)                    f(x, y) := x

                                              - y
          (%t8)                     g     := x
                                     x, y

                                              - y
          (%t9)                     h (y) := x
                                     x

                                              1
          (%t10)                     h (y) := --
                                      5        y
                                              5

                                               1
          (%t11)                    h  (y) := ---
                                     10         y
                                              10

                                              - y
          (%t12)                    i (y) := 8
                                     8

          (%o12)       [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
          (%i12) ''%;
                               - y              - y            - y
          (%o12) [m(x, y) ::= x   , f(x, y) := x   , g     := x   ,
                                                      x, y
                            - y           1              1             - y
                  h (y) := x   , h (y) := --, h  (y) := ---, i (y) := 8   ]
                   x              5        y   10         y   8
                                          5             10

 -- Variável de sistema: functions
     Valor por omissão: []

     functions é uma lista de todas as funcedilhaões comuns do Maxima na sessão corrente. Uma funcedilhaão comum é uma funcedilhaão construída através de define ou de := e chamada com parêntesis (). Uma funcedilhaão pode ser definida pela linha de comando do Maxima de forma interativa com o utilizador ou em um ficheiro Maxima chamado por load ou batch.

     Funcedilhaões de array (chamadas com colchêtes, e.g., F[x]) e funcedilhaões com subscritos (chamadas com colchêtes e parêntesis, e.g., F[x](y)) são lsitados através da variável global arrays, e não por meio de functions.

     Funcedilhaões Lisp não são mantidas em nenhuma lista.

     Exemplos:

          (%i1) F_1 (x) := x - 100;
          (%o1)                   F_1(x) := x - 100
          (%i2) F_2 (x, y) := x / y;
                                                x
          (%o2)                    F_2(x, y) := -
                                                y
          (%i3) define (F_3 (x), sqrt (x));
          (%o3)                   F_3(x) := sqrt(x)
          (%i4) G_1 [x] := x - 100;
          (%o4)                    G_1  := x - 100
                                      x
          (%i5) G_2 [x, y] := x / y;
                                               x
          (%o5)                     G_2     := -
                                       x, y    y
          (%i6) define (G_3 [x], sqrt (x));
          (%o6)                    G_3  := sqrt(x)
                                      x
          (%i7) H_1 [x] (y) := x^y;
                                                y
          (%o7)                     H_1 (y) := x
                                       x
          (%i8) functions;
          (%o8)              [F_1(x), F_2(x, y), F_3(x)]
          (%i9) arrays;
          (%o9)                 [G_1, G_2, G_3, H_1]

 -- Funcedilhaão: fundef (F)
     Retorna a definicedilhaão da funcedilhaão F.

     O argumento pode ser o nome de uma macro (definida com ::=), uma funcedilhaão comum (definida com := ou define), uma funcedilhaão array (definida com := ou define, mas contendo argumentos entre colchêtes [ ]), Uma funcedilhaão subscrita, (definida com := ou define, mas contendo alguns argumentos entre colchêtes e parêntesis ( )) uma da família de funcedilhaões subscritas seleccionada por um valor particular subscrito, ou uma funcedilhaão subscrita definida com uma constante subscrita.

     fundef não avalia seu argumento; o operador apóstrofo-apóstrofo '' faz com que ocorra avaliacedilhaão.

     fundef (F) retorna a definicedilhaão de F. Em contraste, dispfun (F) cria um rótulo de expressão intermédia e atribui a definicedilhaão para o rótulo.

 -- Funcedilhaão: funmake (F, [ARG_1, ..., ARG_N])
     Retorna uma expressão F(ARG_1, ..., ARG_N). O valor de retorno é simplificado, mas não avaliado, então a funcedilhaão F não é chamada, mesmo se essa funcedilhaão F existir.

     funmake não tenta distinguir funcedilhaões de array de funcedilhaões comuns; quando F for o nome de uma funcedilhaão de array, funmake retorna F(...) (isto é, uma chamada de funcedilhaão com parêntesis em lugar de colchêtes). arraymake retorna uma chamada de funcedilhaão com colchêtes nesse caso.

     funmake avalia seus argumentos.

     Exemplos:

     funmake aplicada a uma funcedilhaão comum do Maxima.

          (%i1) F (x, y) := y^2 - x^2;
                                             2    2
          (%o1)                  F(x, y) := y  - x
          (%i2) funmake (F, [a + 1, b + 1]);
          (%o2)                    F(a + 1, b + 1)
          (%i3) ''%;
                                        2          2
          (%o3)                  (b + 1)  - (a + 1)

     funmake aplicada a uma macro.

          (%i1) G (x) ::= (x - 1)/2;
                                            x - 1
          (%o1)                    G(x) ::= -----
                                              2
          (%i2) funmake (G, [u]);
          (%o2)                         G(u)
          (%i3) ''%;
                                        u - 1
          (%o3)                         -----
                                          2

     funmake aplicada a uma funcedilhaão subscrita.

          (%i1) H [a] (x) := (x - 1)^a;
                                                  a
          (%o1)                   H (x) := (x - 1)
                                   a
          (%i2) funmake (H [n], [%e]);
                                                 n
          (%o2)               lambda([x], (x - 1) )(%e)
          (%i3) ''%;
                                              n
          (%o3)                       (%e - 1)
          (%i4) funmake ('(H [n]), [%e]);
          (%o4)                        H (%e)
                                        n
          (%i5) ''%;
                                              n
          (%o5)                       (%e - 1)

     funmake aplicada a um símbolo que não é uma funcedilhaão definida de qualquer tipo.

          (%i1) funmake (A, [u]);
          (%o1)                         A(u)
          (%i2) ''%;
          (%o2)                         A(u)

     funmake avalia seus argumentos, mas não o valor de retorno.

          (%i1) det(a,b,c) := b^2 -4*a*c;
                                              2
          (%o1)              det(a, b, c) := b  - 4 a c
          (%i2) (x : 8, y : 10, z : 12);
          (%o2)                          12
          (%i3) f : det;
          (%o3)                          det
          (%i4) funmake (f, [x, y, z]);
          (%o4)                    det(8, 10, 12)
          (%i5) ''%;
          (%o5)                         - 284

     Maxima simplifica o valor de retorno de funmake.

          (%i1) funmake (sin, [%pi / 2]);
          (%o1)                           1

 -- Funcedilhaão: lambda ([X_1, ..., X_M], EXPR_1, ..., EXPR_N)
 -- Funcedilhaão: lambda ([[L]], EXPR_1, ..., EXPR_N)
 -- Funcedilhaão: lambda ([X_1, ..., X_M, [L]], EXPR_1, ..., EXPR_N)
     Define e retorna uma expressão lambda (que é, uma funcedilhaão anônima) A funcedilhaão pode ter argumentos que sejam necessários X_1, ..., X_M e/ou argumentos opcionais L, os quais aparecem dentro do corpo da funcedilhaão como uma lista. O valor de retorno da funcedilhaão é EXPR_N. Uma expressão lambda pode ser atribuída para uma variável e avaliada como uma funcedilhaão comum. Uma expressão lambda pode aparecer em alguns contextos nos quais um nome de funcedilhaão é esperado.

     Quando a funcedilhaão é avaliada, variáveis locais não associadas X_1, ..., X_M são criadas. lambda pode aparecer dentro de block ou outra funcedilhaão lambda; variáveis locais são estabelecidas cada vez que outro block ou funcedilhaão lambda é avaliada. Variáveis locais parecem ser globais para qualquer coisa contendo block ou lambda. Se uma variável é não local, seu valor é o valor mais recentemente atribuído em alguma coisa contendo block ou lambda, qualquer que seja, de outra forma, seu valor é o valor da variável no ambiente global. Essa política pode coincidir com o entendimento usual de "escopo dinâmico".

     Após variáveis locais serem estabelecidas, EXPR_1 até EXPR_N são avaliadas novamente. a variável especial %%, representando o valor da expressão precedente, é reconhecida. throw e catch pode também aparecer na lista de expressões.

     return não pode aparecer em uma expressão lambda a menos que contendo block, nesse caso return define o valor de retorno do  bloco e não da expressão lambda, a menos que o bloco seja EXPR_N. Da mesma forma, go não pode aparecer em uma expressão lambda a menos que contendo block.

     lambda não avalia seus argumentos; o operador apóstrofo-apóstrofo '' faz com que ocorra avaliacedilhaão.

     Exemplos:

       * A expressão lambda pode ser atribuída para uma variável e avaliada como uma funcedilhaão comum.

          (%i1) f: lambda ([x], x^2);
                                                2
          (%o1)                    lambda([x], x )
          (%i2) f(a);
                                          2
          (%o2)                          a

       * Uma expressão lambda pode aparecer em contextos nos quais uma avaliacedilhaão de funcedilhaão é esperada como resposta.

          (%i3) lambda ([x], x^2) (a);
                                          2
          (%o3)                          a
          (%i4) apply (lambda ([x], x^2), [a]);
                                          2
          (%o4)                          a
          (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
                                  2   2   2   2   2
          (%o5)                 [a , b , c , d , e ]

       * Variáveis argumento são variáveis locais. Outras variáveis aparecem para serem variáveis globais. Variáveis globais são avaliadas ao mesmo tempo em que a expressão lambda é avaliada, a menos que alguma avaliacedilhaão especial seja forcedilhaada por alguns meios, tais como ''.

          (%i6) a: %pi$
          (%i7) b: %e$
          (%i8) g: lambda ([a], a*b);
          (%o8)                   lambda([a], a b)
          (%i9) b: %gamma$
          (%i10) g(1/2);
                                       %gamma
          (%o10)                       ------
                                         2
          (%i11) g2: lambda ([a], a*''b);
          (%o11)                lambda([a], a %gamma)
          (%i12) b: %e$
          (%i13) g2(1/2);
                                       %gamma
          (%o13)                       ------
                                         2

       * Expressões lambda podem ser aninhadas. Variáveis locais dentro de outra expressão lambda parece ser global para a expressão interna a menos que mascarada por variáveis locais de mesmos nomes.

          (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
                                                             1
          (%o14)    lambda([a, b], h2 : lambda([a], a b), h2(-))
                                                             2
          (%i15) h(%pi, %gamma);
                                       %gamma
          (%o15)                       ------
                                         2

       * Uma vez que lambda não avalia seus argumentos, a expressão lambda i abaixo não define uma funcedilhaão "multiplicacedilhaão por a". Tanto uma funcedilhaão pode ser definida via buildq, como na expressão lambda i2 abaixo.

          (%i16) i: lambda ([a], lambda ([x], a*x));
          (%o16)            lambda([a], lambda([x], a x))
          (%i17) i(1/2);
          (%o17)                  lambda([x], a x)
          (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
          (%o18)    lambda([a], buildq([a : a], lambda([x], a x)))
          (%i19) i2(1/2);
                                               x
          (%o19)                   lambda([x], -)
                                               2
          (%i20) i2(1/2)(%pi);
                                         %pi
          (%o20)                         ---
                                          2

       * Uma expressão lambda pode receber um número variável de argumentos, os quais são indicados por meio de [L] como o argumento único ou argumento final. Os argumentos aparecem dentro do corpo da funcedilhaão como uma lista.

          (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
          (%o1)          lambda([aa, bb, [cc]], aa cc + bb)
          (%i2) f (foo, %i, 17, 29, 256);
          (%o2)       [17 foo + %i, 29 foo + %i, 256 foo + %i]
          (%i3) g : lambda ([[aa]], apply ("+", aa));
          (%o3)             lambda([[aa]], apply(+, aa))
          (%i4) g (17, 29, x, y, z, %e);
          (%o4)                  z + y + x + %e + 46

 -- Funcedilhaão: local (V_1, ..., V_N)
     Declara as variáveis V_1, ..., V_N para serem locais com relacedilhaão a todas as propriedades na declaracedilhaão na qual essa funcedilhaão é usada.

     local não avalia seus argumentos. local retorna done.

     local pode somente ser usada em block, no corpo de definicedilhaões de funcedilhaão ou expressões lambda, ou na funcedilhaão ev, e somente uma ocorrêcia é permitida em cada.

     local é independente de context.

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

     macroexpansion controla recursos avancedilhaados que afectam a eficiência de macros.  Escolhas possíveis:

       * false -- Macros expandem normalmente cada vez que são chamadas.

       * expand -- A primeira vez de uma chamada particular é avaliada, a expansão é lembrada internamente, dessa forma não tem como ser recalculada em chamadas subsequênte rapidamente.  A macro chama ainda chamadas grind e display normalmente.  Todavia, memória extra é requerida para lembrar todas as expansões.

       * displace -- A primeira vez de uma chamada particular é avaliada, a expansão é substituída pela chamada.  Isso requer levemente menos armazenagem que quando macroexpansion é escolhida para expand e é razoávelmente rápido, mas tem a desvantagem de a macro original ser lentamente lembrada e daí a expansão será vista se display ou grind for chamada.  Veja a documentacedilhaão para translate e macros para maiores detalhes.

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

     Quando mode_checkp é true, mode_declare verifica os modos de associacedilhaão de variáveis.

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

     Quando mode_check_errorp é true, mode_declare chama a funcedilhaão "error".

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

     Quando mode_check_warnp é true, modo "errors" são descritos.

 -- Funcedilhaão: mode_declare (Y_1, MODE_1, ..., Y_N, MODE_N)
     mode_declare é usado para declarar os modos de variáveis e funcedilhaões para subsequênte traducedilhaão ou compilacedilhaão das funcedilhaões. mode_declare é tipicamente colocada no início de uma definicedilhaão de funcedilhaão, no início de um script Maxima, ou executado através da linha de comando de forma interativa.

     Os argumentos de mode_declare são pares consistindo de  uma variável e o modo que é um de boolean, fixnum, number, rational, ou float. Cada variável pode também ser uma lista de variáveis todas as quais são declaradas para ter o mesmo modo.

     Se uma variável é um array, e se todo elemento do array que é referenciado tiver um valor então array (yi, complete, dim1, dim2, ...) em lugar de

          array(yi, dim1, dim2, ...)

     deverá ser usado primeiro declarando as associacedilhaões do array. Se todos os elementos do array estão no modo fixnum (float), use fixnum (float) em lugar de complete. Também se todo elemento do array está no mesmo modo, digamos m, então

          mode_declare (completearray (yi), m))

     deverá ser usado para uma traducedilhaão eficiente.

     Código numéricos usando arrays podem rodar mais rápidamente se for decladado o tamanho esperado do array, como em:

          mode_declare (completearray (a [10, 10]), float)

     para um array numérico em ponto flutuante que é 10 x 10.

     Pode-se declarar o modo do resultado de uma funcedilhaão usando function (f_1, f_2, ...) como um argumento; aqui f_1, f_2, ...  são nomes de funcedilhaões.  Por exemplo a expressão,

          mode_declare ([function (f_1, f_2, ...)], fixnum)

     declara que os valores retornados por f_1, f_2, ...  são inteiros palavra simples.

     modedeclare é um sinônimo para mode_declare.

 -- Funcedilhaão: mode_identity (ARG_1, ARG_2)
     Uma forma especial usada com mode_declare e macros para declarar, e.g., uma lista de listas de números em ponto flutuante ou outros objectos de dados.  O primeiro argumento para mode_identity é um valor primitivo nome de modo como dado para mode_declare (i.e., um de float, fixnum, number, list, ou any), e o segundo argumento é uma expressão que é avaliada e retornada com o valor de mode_identity. No entanto, se o valor de retorno não é permitido pelo modo declarado no primeiro argumento, um erro ou alerta é sinalizado.  Um ponto importante é que o modo da expressão como determinado pelo Maxima para o tradutor Lisp, será aquele dado como o primeiro argumento, independente de qualquer coisa que vá no segundo argumento.  E.g., x: 3.3; mode_identity (fixnum, x); retorna um erro.  mode_identity (flonum, x) returns 3.3 .  Isto tem númerosas utilidades, por exemplo, se souber que first (l) retornou um número então poderá escrever mode_identity (number, first (l)). No entanto, um caminho mais eficiente para fazer a mesma coisa é definir uma nova primitiva,

          firstnumb (x) ::= buildq ([x], mode_identity (number, x));

     e usar firstnumb sempre que obtiver o primeiro de uma lista de números.

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

     Quando transcompile é true, translate e translate_file geram declaracedilhaões para fazer o código traduzido mais adequado para compilacedilhaão.

     compfile escolhe transcompile: true para a duracedilhaão.

 -- Funcedilhaão: translate (F_1, ..., F_N)
 -- Funcedilhaão: translate (funcedilhaões)
 -- Funcedilhaão: translate (all)
     Traduz funcedilhaões definidas pelo utilizador F_1, ..., F_N da linguagem de Maxima para Lisp e avalia a traducedilhaão Lisp. Tipicamente as funcedilhaões traduzidas executam mais rápido que as originais.

     translate (all) ou translate (funcedilhaões) traduz todas as funcedilhaões definidas pelo utilizador.

     Funcedilhaões a serem traduzidas incluir~ao uma chamada para mode_declare no início quando possível com o objectivo de produzir um código mais eficiente.  Por exemplo:

          f (x_1, x_2, ...) := block ([v_1, v_2, ...],
              mode_declare (v_1, mode_1, v_2, mode_2, ...), ...)

     quando X_1, X_2, ...  são parâmetros para a funcedilhaão e V_1, V_2, ...  são variáveis locais.

     Os nomes de funcedilhaões traduzidas são removidos da lista functions se savedef é false (veja abaixo) e são adicionados nas listas props.

     Funcedilhaões não poderão ser traduzidas a menos que elas sejam totalmente depuradas.

     Expressões são assumidas simplificadas; se não forem, um código correcto será gerado mas não será um código óptimo.  Dessa forma, o utilizador não poderá escolher o comutador simp para false o qual inibe simplificacedilhaão de expressões a serem traduzidas.

     O comutador translate, se true, causa traducedilhaão automatica de uma funcedilhaão de utilizador para Lisp.

     Note que funcedilhaões traduzidas podem não executar identicamente para o caminho que elas faziam antes da traducedilhaão como certas incompatabilidades podem existir entre o Lisp e versões do Maxima.  Principalmente, a funcedilhaão  rat com mais de um argumento e a funcedilhaão ratvars não poderá ser usada se quaisquer variáveis são declaradas com mode_declare como sendo expressões rotacionais canónicas(CRE). Também a escolha prederror: false não traduzirá.

     savedef - se true fará com que a versão Maxima de uma funcedilhaão utilizador permanecedilhaa quando a funcedilhaão é traduzida com translate.  Isso permite a que definicedilhaão seja mostrada por dispfun e autoriza a funcedilhaão a ser editada.

     transrun - se false fará com que a versão interpretada de todas as funcedilhaões sejam executadas (desde que estejam ainda disponíveis) em lugar da versão traduzida.

     O resultado retornado por translate é uma lista de nomes de funcedilhaões traduzidas.

 -- Funcedilhaão: translate_file (MAXIMA_NOMEFICHEIRO)
 -- Funcedilhaão: translate_file (MAXIMA_NOMEFICHEIRO, LISP_NOMEFICHEIRO)
     Traduz um ficheiro com código Maxima para um ficheiro com código Lisp. translate_file retorna uma lista de três nomes de ficheiro: O nome do ficheiro Maxima, o nome do ficheiro Lisp, e o nome do ficheiro contendo informacedilhaões adicionais sobre a traducedilhaão. translate_file avalia seus argumentos.

     translate_file ("foo.mac"); load("foo.LISP") é o mesmo que batch ("foo.mac") excepto por certas restricedilhaões, o uso de '' e %, por exemplo.

     translate_file (MAXIMA_NOMEFICHEIRO) traduz um ficheiro Maxima MAXIMA_NOMEFICHEIRO para um similarmente chamado ficheiro Lisp. Por exemplo, foo.mac é traduzido em foo.LISP. O nome de ficheiro Maxima pod incluir nome ou nomes de directório(s), nesse caso o ficheiro de saída Lisp é escrito para o mesmo directório que a entrada Maxima.

     translate_file (MAXIMA_NOMEFICHEIRO, LISP_NOMEFICHEIRO) traduz um ficheiro Maxima MAXIMA_NOMEFICHEIRO em um ficheiro Lisp LISP_NOMEFICHEIRO. translate_file ignora a extensão do nome do ficheiro, se qualquer, de lisp_nomeficheiro; a extensão do ficheiro de saída Lisp é sempre LISP. O nome de ficheiro Lisp pode incluir um nome ou nomes de directórios), nesse caso o ficheiro de saída Lisp é escrito para o directório especificado.

     translate_file também escreve um ficheiro de mensagens de alerta do tradutor em vários graus de severidade. A extensão do nome de ficheiro desse ficheiro é UNLISP. Esse ficheiro pode conter informacedilhaão valiosa, apesar de possivelmente obscura, para rastrear erros no código traduzido. O ficheiro UNLISP é sempre escrito para o mesmo directório que a entrada Maxima.

     translate_file emite código Lisp o qual faz com que algumas definicedilhaões tenham efeito tão logo o código Lisp é compilado. Veja compile_file para mais sobre esse tópico.

     Veja também tr_array_as_ref, tr_bound_function_applyp, tr_exponent, tr_file_tty_messagesp, tr_float_can_branch_complex, tr_function_call_default, tr_numer, tr_optimize_max_loop, tr_semicompile, tr_state_vars, tr_warnings_get, tr_warn_bad_function_calls, tr_warn_fexpr, tr_warn_meval, tr_warn_mode, tr_warn_undeclared, tr_warn_undefined_variable, and tr_windy.

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

     Quando transrun é false fará com que a versão interpretada de todas as funcedilhaões sejam executadas (desde que estejam ainda disponíveis) em lugar de versão traduzidas.

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

     Se translate_fast_arrays for false, referências a arrays no Código Lisp emitidas por translate_file são afectadas por tr_array_as_ref. Quando tr_array_as_ref é true, nomes de arrays são avaliados, de outra forma nomes de arrays aparecem como símbolos literais no código traduzido.

     tr_array_as_ref não terão efeito se translate_fast_arrays for true.

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

     Quando tr_bound_function_applyp for true, Maxima emite um alerta se uma associacedilhaão de variável (tal como um argumento de funcedilhaão) é achada sendo usada como uma funcedilhaão. tr_bound_function_applyp não afecta o código gerado em tais casos.

     Por exemplo, uma expressão tal como g (f, x) := f (x+1) irá disparar a mensagem de alerta.

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

     Quando tr_file_tty_messagesp é true, messagens geradas por translate_file durante a traducedilhaão de um ficheiro são mostradas sobre o console e inseridas dentro do ficheiro UNLISP. Quando false, messagens sobre traducedilhaões de ficheiros são somente inseridas dentro do ficheiro UNLISP.

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

     Diz ao tradutor Maxima-para-Lisp assumir que as funcedilhaões acos, asin, asec, e acsc podem retornar resultados complexos.

     O efeito ostensivo de tr_float_can_branch_complex é mostrado adiante. Todavia, parece que esse sinalizador não tem efeito sobre a saída do tradutor.

     Quando isso for true então acos(x) será do modo any sempre que x for do modo float (como escolhido por mode_declare). Quando false então acos(x) será do modo float se e somente se x for do modo float.

 -- Variável de opcedilhaão: tr_function_call_default
     Valor por omissão: general

     false significa abandonando e chamando meval, expr significa que Lisp assume funcedilhaão de argumento fixado.  general, o código padrão dado como sendo bom para mexprs e mlexprs mas não macros. general garante que associacedilhaões de variável são correctas em códigos compilados.  No modo general, quando traduzindo F(X), se F for uma variável associada, então isso assumirá que apply (f, [x]) é significativo, e traduz como tal, com o alerta apropriado.  Não é necessário desabilitar isso.  Com as escolhas padrão, sem mensagens de alerta implica compatibilidade total do código traduzido e compilado com o interpretador Maxima.

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

     Quando tr_numer for true propriedades numer são usadas para átomos que possuem essa propriedade, e.g. %pi.

 -- Variável de opcedilhaão: tr_optimize_max_loop
     Valor por omissão: 100

     tr_optimize_max_loop é número máximo de vezes do passo de macro-expansão e optimizacedilhaão que o tradutor irá executar considerando uma forma.  Isso é para capturar erros de expansão de macro, e propriedades de optimizacedilhaão não terminadas.

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

     Quando tr_semicompile for true, as formas de saída de translate_file e compfile serão macroexpandidas mas não compiladas em código de máquina pelo compilador Lisp.

 -- Variável de sistema: tr_state_vars
     Valor por omissão:

          [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
          tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
          tr_function_call_default, tr_array_as_ref,tr_numer]

     A lista de comutadores que afectam a forma de saída da traducedilhaão. Essa informacedilhaão é útil para sistemas populares quando tentam depurar o tradutor.  Comparando o produto traduzido para o qual pode ter sido produzido por um dado estado, isso é possível para rastrear erros.

 -- Funcedilhaão: tr_warnings_get ()
     Imprime uma lista de alertas que podem ter sido dadas pelo tradutor durante a traducedilhaão corrente.

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

     - Emite um alerta quando chamadas de funcedilhaão estão sendo feitas por um caminho que pode não ser correcto devido a declaracedilhaões impróprias que foram feitas em tempo de traducedilhaão.

 -- Variável de opcedilhaão: tr_warn_fexpr
     Valor por omissão: compfile

     - Emite um alerta se quaisquer FEXPRs forem encontradas.  FEXPRs não poderão normalmente ser saída em código traduzido, todas as formas de programa especial legítimo são traduzidas.

 -- Variável: tr_warn_meval
     Valor por omissão: compfile

     - Emite um alerta se a funcedilhaão meval recebe chamadas.  Se meval é chamada isso indica problemas na traducedilhaão.

 -- Variável: tr_warn_mode
     Valor por omissão: all

     - Emite um alerta quando a variáveis forem atribuídos valores inapropriados para seu modo.

 -- Variável de opcedilhaão: tr_warn_undeclared
     Valor por omissão: compile

     - Determina quando enviar alertas sobre variáveis não declaradas para o TTY.

 -- Variável de opcedilhaão: tr_warn_undefined_variable
     Valor por omissão: all

     - Emite um alerta quando variáveis globais indefinidas forem vistas.

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

     - Gera comentários "de grande ajuda" e dicas de programacedilhaão.

 -- Funcedilhaão: compile_file (NOMEFICHEIRO)
 -- Funcedilhaão: compile_file (NOMEFICHEIRO, NOMEFICHEIRO_COMPILADO)
 -- Funcedilhaão: compile_file (NOMEFICHEIRO, NOMEFICHEIRO_COMPILADO, LISP_NOMEFICHEIRO)
     Traduz o ficheiro Maxima NOMEFICHEIRO para Lisp, executa o compilador Lisp, e, se a traducedilhaão e a compilacedilhaão obtiverem sucesso, chama o código compilado dentro do Maxima.

     compile_file retorna uma lista dos nomes de quatro ficheiros: o ficheiro original do Maxima, o nome da traducedilhaão Lisp, uma ficheiro de notas sobre a traducedilhaão, e o nome do ficheiro que contém o código compilado. Se a compilacedilhaão falhar, o quarto item é false.

     Algumas declaracedilhaões e definicedilhaões passam a ter efeito tão logo o código Lisp seja compilado (sem que seja necessário chamar o código compilado). Isso inclui funcedilhaões definidas com o operador :=, macros definidas com o operador ::=, alias, declare, define_variable,  mode_declare, e infix, matchfix, nofix, postfix, prefix, e compfile.

     Atribuicedilhaões e chamadas de funcedilhaão não serão avaliadas até que o código compilado seja carregado. Em particular, dentro do ficheiro Maxima, atribuicedilhaões para sinalizadores traduzidos (tr_numer, etc.) não têm efeito sobre a traducedilhaão.

     NOMEFICHEIRO pode não conter declaracedilhaões :lisp.

     compile_file avalia seus argumentos.

 -- Funcedilhaão: declare_translated (F_1, F_2, ...)
     Quando traduzindo um ficheiro do código Maxima para Lisp, é importante para o programa tradutor saber quais funcedilhaões no ficheiro são para serem chamadas como funcedilhaões traduzidas ou compiladas, e quais outras são apenas funcedilhaões Maxima ou indefinidas.  Colocando essa declaracedilhaão no topo do ficheiro, faremos conhecido que embora um símbolo diga que não temos ainda um valor de funcedilhaão Lisp, teremos uma em tempo de chamada.  (MFUNCTION-CALL fn arg1 arg2 ...) é gerado quando o tradutor n~ao sabe que fn está sendo compilada para ser uma funcedilhaão Lisp.