Introducedilhaão a Linha de Comando
===================================

 -- Operador: '
     O operador apóstrofo ' evita avaliacedilhaão.

     Aplicado a um símbolo, o apóstrofo evita avaliacedilhaão do símbolo.

     Aplicado a uma chamada de funcedilhaão, o apóstrofo evita avaliacedilhaão da chamada de funcedilhaão, embora os argumentos da funcedilhaão sejam ainda avaliados (se a avaliacedilhaão não for de outra forma evitada). O resultado é a forma substantiva da chamada de funcedilhaão.

     Aplicada a uma espressão com parêntesis, o apóstrofo evita avaliacedilhaão de todos os símbolos e chamadas de funcedilhaão na expressão. E.g., '(f(x)) significa não avalie a expressão f(x). 'f(x) (com apóstrofo aplicado a f em lugar de f(x)) retorna a forma substantiva de f aplicada a [x].

     O apóstrofo nao evita simplificacedilhaão.

     Quando o sinalizador global noundisp for true, substantivos são mostrados com um apóstrofo. Esse comutador é sempre true quando mostrando definicedilhaões de funcedilhaões.

     Veja também operador apóstrofo-apóstrofo '' e nouns.

     Exemplos:

     Aplicado a um símbolo, o apóstrofo evita avaliacedilhaão do símbolo.

          (%i1) aa: 1024;
          (%o1)                         1024
          (%i2) aa^2;
          (%o2)                        1048576
          (%i3) 'aa^2;
                                           2
          (%o3)                          aa
          (%i4) ''%;
          (%o4)                        1048576

     Aplicado a uma chamada de funcedilhaão, o apóstrofo evita avaliacedilhaão da chamada de funcedilhaão. O resultado é a forma substantiva da chamada de funcedilhaão.

          (%i1) x0: 5;
          (%o1)                           5
          (%i2) x1: 7;
          (%o2)                           7
          (%i3) integrate (x^2, x, x0, x1);
                                         218
          (%o3)                          ---
                                          3
          (%i4) 'integrate (x^2, x, x0, x1);
                                       7
                                      /
                                      [   2
          (%o4)                       I  x  dx
                                      ]
                                      /
                                       5
          (%i5) %, nouns;
                                         218
          (%o5)                          ---
                                          3

     Aplicado a uma expressão com parêntesis, o apóstrofo evita avaliacedilhaão de todos os símbolos e chamadas de funcedilhaão na expressão.

          (%i1) aa: 1024;
          (%o1)                         1024
          (%i2) bb: 19;
          (%o2)                          19
          (%i3) sqrt(aa) + bb;
          (%o3)                          51
          (%i4) '(sqrt(aa) + bb);
          (%o4)                     bb + sqrt(aa)
          (%i5) ''%;
          (%o5)                          51

     O apóstrofo não evita simplificacedilhaão.

          (%i1) sin (17 * %pi) + cos (17 * %pi);
          (%o1)                          - 1
          (%i2) '(sin (17 * %pi) + cos (17 * %pi));
          (%o2)                          - 1

 -- Operador: ''
     O operador apóstrofo-apóstrofo '' (dois apóstrofost) modifica avaliacedilhaão em expressões de entrada.

     Aplicado a uma expressão geral EXPR, apóstrofo-apóstrofo faz com que o valor de EXPR seja substituído por EXPR na expressão de entrada.

     Aplicado ao operadro de uma expressão, apóstrofo-apóstrofo modifica o operadro de um susbstantivo para um verbo (se esse operador não for já um verbo).

     O operador apóstrofo-apóstrofo é aplicado através do passador de entrada; o apóstrofo-apóstrofo não é armazenado como parte de uma expressão de entrada passada. O operador apóstrofo-apóstrofo é sempre aplicado tão rapidamente quanto for passado, e não pode receber um terceiro apóstrofo. Dessa forma faz com que ocorra avaliacedilhaão quando essa avaliacedilhaão for de outra forma suprimida, da mesma forma que em definicedilhaões de funcedilhaão, definicedilhaões de expressãoes lambda, e expressões que recebem um apóstrofo simples '.

     Apóstrofo-apóstrofo é reconhecido por batch e load.

     Veja também o operador apóstrofo ' e nouns.

     Exemplos:

     Aplicado a uma expressão geral EXPR, apóstrofo-apóstrofo fazem com que o valor de EXPR seja substituido por EXPR na expressão de entrada.

          (%i1) expand ((a + b)^3);
                               3        2      2      3
          (%o1)               b  + 3 a b  + 3 a  b + a
          (%i2) [_, ''_];
                                   3    3        2      2      3
          (%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
          (%i3) [%i1, ''%i1];
                                   3    3        2      2      3
          (%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
          (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
          (%o4)                   [cc, dd, 17, 29]
          (%i5) foo_1 (x) := aa - bb * x;
          (%o5)                 foo_1(x) := aa - bb x
          (%i6) foo_1 (10);
          (%o6)                      cc - 10 dd
          (%i7) ''%;
          (%o7)                         - 273
          (%i8) ''(foo_1 (10));
          (%o8)                         - 273
          (%i9) foo_2 (x) := ''aa - ''bb * x;
          (%o9)                 foo_2(x) := cc - dd x
          (%i10) foo_2 (10);
          (%o10)                        - 273
          (%i11) [x0 : x1, x1 : x2, x2 : x3];
          (%o11)                    [x1, x2, x3]
          (%i12) x0;
          (%o12)                         x1
          (%i13) ''x0;
          (%o13)                         x2
          (%i14) '' ''x0;
          (%o14)                         x3

     Aplicado ao operador de uma expressão, apóstrofo-apóstrofo muda o operadro de um substantivo para um verbo (se esse operadro não for já um verbo).

          (%i1) sin (1);
          (%o1)                        sin(1)
          (%i2) ''sin (1);
          (%o2)                    0.8414709848079
          (%i3) declare (foo, noun);
          (%o3)                         done
          (%i4) foo (x) := x - 1729;
          (%o4)                 ''foo(x) := x - 1729
          (%i5) foo (100);
          (%o5)                       foo(100)
          (%i6) ''foo (100);
          (%o6)                        - 1629

     O operador apóstrofo-apóstrofo é aplicado por meio de um passador de entrada; operador-apóstrofo não é armazenado como parte da expressão de entrada.

          (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
          (%o1)                 [bb, dd, 1234, 5678]
          (%i2) aa + cc;
          (%o2)                        dd + bb
          (%i3) display (_, op (_), args (_));
                                     _ = cc + aa

                                   op(cc + aa) = +

                              args(cc + aa) = [cc, aa]

          (%o3)                         done
          (%i4) ''(aa + cc);
          (%o4)                         6912
          (%i5) display (_, op (_), args (_));
                                     _ = dd + bb

                                   op(dd + bb) = +

                              args(dd + bb) = [dd, bb]

          (%o5)                         done

     Apóstrofo apóstrofo faz com que ocorra avaliacedilhaão quando a avaliacedilhaão tiver sido de outra forma suprimida, da mesma forma que em definicedilhaões de funcedilhaão, da mesma forma que em definicedilhaões de funcedilhaão lambda expressions, E expressões que recebem o apóstrofo simples '.

          (%i1) foo_1a (x) := ''(integrate (log (x), x));
          (%o1)               foo_1a(x) := x log(x) - x
          (%i2) foo_1b (x) := integrate (log (x), x);
          (%o2)           foo_1b(x) := integrate(log(x), x)
          (%i3) dispfun (foo_1a, foo_1b);
          (%t3)               foo_1a(x) := x log(x) - x

          (%t4)           foo_1b(x) := integrate(log(x), x)

          (%o4)                      [%t3, %t4]
          (%i4) integrate (log (x), x);
          (%o4)                     x log(x) - x
          (%i5) foo_2a (x) := ''%;
          (%o5)               foo_2a(x) := x log(x) - x
          (%i6) foo_2b (x) := %;
          (%o6)                    foo_2b(x) := %
          (%i7) dispfun (foo_2a, foo_2b);
          (%t7)               foo_2a(x) := x log(x) - x

          (%t8)                    foo_2b(x) := %

          (%o8)                      [%t7, %t8]
          (%i8) F : lambda ([u], diff (sin (u), u));
          (%o8)             lambda([u], diff(sin(u), u))
          (%i9) G : lambda ([u], ''(diff (sin (u), u)));
          (%o9)                  lambda([u], cos(u))
          (%i10) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
          (%o10)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                              k                  k
          (%i11) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
          (%o11)             b  + a  + b  + a  + b  + a
                              3    3    2    2    1    1

Funcedilhaões e Variáveis Definidas para Linha de Comando
=========================================================

 -- Funcedilhaão: alias (NEW_NAME_1, OLD_NAME_1, ..., NEW_NAME_N, OLD_NAME_N)
     provê um nome alternativo para uma funcedilhaão (de usuário ou de sistema), variável, array, etc. Qualquer número de argumentos pode ser usado.

 -- Variável de opcedilhaão: debugmode
     Valor padrão: false

     Quando um erro do Maxima ocorre, Maxima iniciará o depurador se debugmode for true. O usuário pode informar comandos para examinar o histórico de chamadas, marcar pontos de parada, percorrer uma linha por vez o código do Maxima, e assim por diante.  Veja debugging para uma lista de opcedilhaões do depurador.

     Habilitando debugmode por meio da alteracedilhaão de seu valor para true, não serão capturados erros do Lisp.

 -- Funcedilhaão: ev (EXPR, ARG_1, ..., ARG_N)
     Avalia a expressão EXPR no ambiente especificado pelos argumentos ARG_1, ..., ARG_N. Os argumentos são comutadores (sinalizadores Booleanos), atribuicedilhaões, equacedilhaões, e funcedilhaões. ev retorna o resultado (outra expressão) da avaliacedilhaão.

     A avaliacedilhaão é realizada em passos, como segue.

      1. Primeiro o ambiente é preparado examinando os argumentos que podem ser quaisquer ou todos os seguintes.

            * simp faz com que EXPR seja simplificado independentemente da posicedilhaão do comutador simp que inibe simplificacedilhaão se false.

            * noeval suprime a fase de avaliacedilhaão de ev (veja passo (4) adiante). Isso é útil juntamente com outros comutadores e faz com que EXPR seja simplificado novamente sem ser reavaliado.

            * nouns causa a avaliacedilhaão de formas substantivas (tipicamente funcedilhaões não avaliadas tais como 'integrate ou 'diff) em EXPR.

            * expand causa expansão.

            * expand (M, N) causa expansão, alterando os valores de maxposex e maxnegex para M e N respectivamente.

            * detout faz com que qualquer matriz inversa calculada em EXPR tenha seu determinante mantido fora da inversa ao invés de dividindo a cada elemento.

            * diff faz com que todas as diferenciacedilhaões indicadas em EXPR sejam executadas.

            * derivlist (X, Y, Z, ...) causa somente diferenciacedilhaões referentes às variáveis indicadas.

            * float faz com que números racionais não inteiros sejam convertidos para ponto flutuante.

            * numer faz com que algumas funcedilhaões matemáticas (incluindo a exponenciacedilhaão) com argumentos sejam valiadas em ponto flutuante.  Isso faz com que variávels em EXPR que tenham sido dados numervals (valores numéricos) sejam substituídas por seus valores.  Isso também modifica o comutador float para ativado.

            * pred faz com que predicados (expressões que podem ser avaliados em true ou false) sejam avaliadas.

            * eval faz com que uma avaliacedilhaão posterior de EXPR ocorra.  (Veja passo (5) adiante.) eval pode ocorrer multiplas vezes. Para cada instância de eval, a expressão é avaliada novamente.

            * A onde A é um átomo declarado seja um sinalizador de avaliacedilhaão (veja evflag) faz com que A seja associado a true durante a avaliacedilhaão de EXPR.

            * V: expresão (ou alternativamente V=expressão) faz com que V seja associado ao valor de expressão durante a avaliacedilhaão de EXPR.  Note que se V é uma opcedilhaão do Maxima, então expression é usada para seu valor durante a avaliacedilhaão de EXPR.  Se mais que um argumento para ev é desse tipo então a associacedilhaão termina em paralelo.  Se V é uma expressão não atômica então a substituicedilhaão, ao invés de uma associacedilhaão, é executada.

            * F onde F, um nome de funcedilhaão, tenha sido declarado para ser uma funcedilhaão de avaliacedilhaão (veja evfun) faz com que F seja aplicado a EXPR.

            * Qualquer outro nome de funcedilhaão (e.g., sum) causa a avaliacedilhaão de ocorrências desses nomes em EXPR mesmo que eles tenham sido verbos.

            * De forma adicional uma funcedilhaão ocorrendo em EXPR (digamos F(x)) pode ser definida localmente para o propósito dessa avaliacedilhaão de EXPR dando F(x) := expressão como um argumento para ev.

            * Se um átomo não mensionado acima ou uma variável subscrita ou expressão subscrita for dada como um argumento, isso é avaliado e se o resultado for uma equacedilhaão ou uma atribuicedilhaão então a associacedilhaão indicada ou substituicedilhaão é executada.  Se o resultado for uma lista então os membros da lista serão tratados  como se eles fossem argumentos adicionais dados para ev.  Isso permite que uma lista de equacedilhaões seja dada (e.g. [X=1, Y=A**2]) ou que seja dado uma lista de nomes de equacedilhaões (e.g., [%t1, %t2] onde %t1 e %t2 são equacedilhaões) tais como aquelas listas retornadas por solve.

          Os argumentos de ev podem ser dados em qualquer ordem com excecedilhaão de substituicedilhaões de equacedilhaões que são manuseadas em seqüência, da esquerda para a direita, e funcedilhaões de avaliacedilhaão que são compostas, e.g., ev (EXPR, ratsimp, realpart) são manuseadas como realpart (ratsimp (EXPR)).

          Os comutadores simp, numer, float, e pred podem também ser alterados localmente em um bloco, ou globalmente no Maxima dessa forma eles irã permanecer em efeito até serem resetados ao término da execucedilhaão do bloco.

          Se EXPR for uma expressão racional canônica (CRE), então a expressão retornada por ev é também uma CRE, contanto que os comutadores numer e float não sejam ambos true.

      2. Durante o passo (1), é feito uma lista  de variáveis não subscritas aparecendo do lado esquerdo das equacedilhaões nos argumentos ou nos valores de alguns argumentos se o valor for uma equacedilhaão.  As variáveis (variáveis subscritas que não possuem funcedilhaões array associadas bem como variáveis não subscritas) na expressão EXPR são substituídas por seus valores globais, exceto para esse aparecendo nessa lista.  Usualmente, EXPR é apenas um rótulo ou % (como em %i2 no exemplo adiante), então esse passo simplesmente repete a expressão nomeada pelo rótulo, de modo que ev possa trabalhar sobre isso.

      3. Se quaisquer substituicedilhaões tiveem sido indicadas pelos argumentos, elas serão realizadas agora.

      4. A expressão resultante é então reavaliada (a menos que um dos argumentos seja noeval) e simplificada conforme os argumentos.  Note que qualquer chamada de funcedilhaão em EXPR será completada depois das variáveis nela serem avalidas e que ev(F(x)) dessa forma possa comportar-se como F(ev(x)).

      5. Para cada instância de eval nos argumentos, os passos (3) e (4) são repetidos.

     Exemplos

          (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
                                               d                    2
          (%o1)              cos(y) + sin(x) + -- (sin(w)) + (w + 1)
                                               dw
          (%i2) ev (%, sin, expand, diff, x=2, y=1);
                                    2
          (%o2)           cos(w) + w  + 2 w + cos(1) + 1.909297426825682

     Uma sintaxe alternativa de alto nível tem sido provida por ev, por meio da qual se pode apenas digitar seus argumentos, sem o ev().  Isto é, se pode escrever simplesmente

          EXPR, ARG_1, ..., ARG_N

     Isso não é permitido como parte de outra expressão, e.g., em funcedilhaões, blocos, etc.

     Observe o processo de associacedilhaão paralela no seguinte exemplo.

          (%i3) programmode: false;
          (%o3)                                false
          (%i4) x+y, x: a+y, y: 2;
          (%o4)                              y + a + 2
          (%i5) 2*x - 3*y = 3$
          (%i6) -3*x + 2*y = -4$
          (%i7) solve ([%o5, %o6]);
          Solution

                                                    1
          (%t7)                               y = - -
                                                    5

                                                   6
          (%t8)                                x = -
                                                   5
          (%o8)                            [[%t7, %t8]]
          (%i8) %o6, %o8;
          (%o8)                              - 4 = - 4
          (%i9) x + 1/x > gamma (1/2);
                                             1
          (%o9)                          x + - > sqrt(%pi)
                                             x
          (%i10) %, numer, x=1/2;
          (%o10)                      2.5 > 1.772453850905516
          (%i11) %, pred;
          (%o11)                               true

 -- Propriedade: evflag
     Quando um símbolo X tem a propriedade evflag, as expressões ev(EXPR, X) e EXPR, X (na linha de comando interativa) são equivalentes a ev(EXPR, X = true). Isto é, X está associada a true enquanto EXPR for avaliada.

     A expressão declare(X, evflag) fornece a propriedade evflag para a variável X.

     Os sinalizadores que possuem a propriedade evflag por padrão são os seguintes: algebraic, cauchysum, demoivre, dotscrules, %emode, %enumer, exponentialize, exptisolate, factorflag, float, halfangles, infeval, isolate_wrt_times, keepfloat, letrat, listarith, logabs, logarc, logexpand, lognegint, lognumer, m1pbranch, numer_pbranch, programmode, radexpand, ratalgdenom, ratfac, ratmx, ratsimpexpons, simp, simpsum, sumexpand, e trigexpand.

     Exemplos:

          (%i1) sin (1/2);
                                           1
          (%o1)                        sin(-)
                                           2
          (%i2) sin (1/2), float;
          (%o2)                   0.479425538604203
          (%i3) sin (1/2), float=true;
          (%o3)                   0.479425538604203
          (%i4) simp : false;
          (%o4)                         false
          (%i5) 1 + 1;
          (%o5)                         1 + 1
          (%i6) 1 + 1, simp;
          (%o6)                           2
          (%i7) simp : true;
          (%o7)                         true
          (%i8) sum (1/k^2, k, 1, inf);
                                      inf
                                      ====
                                      \     1
          (%o8)                        >    --
                                      /      2
                                      ====  k
                                      k = 1
          (%i9) sum (1/k^2, k, 1, inf), simpsum;
                                           2
                                        %pi
          (%o9)                         ----
                                         6
          (%i10) declare (aa, evflag);
          (%o10)                        done
          (%i11) if aa = true then SIM else NÃO;
          (%o11)                         NÃO
          (%i12) if aa = true then SIM else NÃO, aa;
          (%o12)                         SIM

 -- Propriedade: evfun
     Quando uma funcedilhaão F tem a propriedade evfun, as expressões ev(EXPR, F) e EXPR, F (na linha de comando interativa) são equivalentes a F(ev(EXPR)).

     Se duas ou mais funcedilhaões F, G, etc., que possuem a propriedade evfun forem especificadas, as funcedilhaões serão aplicadas na ordem em que forem especificadas.

     A expressão declare(F, evfun) fornece a propriedade evfun para a funcedilhaão F.

     As funcedilhaões que possuem a propriedade evfun por padrão são as seguintes: bfloat, factor, fullratsimp, logcontract, polarform, radcan, ratexpand, ratsimp, rectform, rootscontract, trigexpand, e trigreduce.

     Exemplos:

          (%i1) x^3 - 1;
                                        3
          (%o1)                        x  - 1
          (%i2) x^3 - 1, factor;
                                          2
          (%o2)                 (x - 1) (x  + x + 1)
          (%i3) factor (x^3 - 1);
                                          2
          (%o3)                 (x - 1) (x  + x + 1)
          (%i4) cos(4 * x) / sin(x)^4;
                                      cos(4 x)
          (%o4)                       --------
                                         4
                                      sin (x)
          (%i5) cos(4 * x) / sin(x)^4, trigexpand;
                           4           2       2         4
                        sin (x) - 6 cos (x) sin (x) + cos (x)
          (%o5)         -------------------------------------
                                          4
                                       sin (x)
          (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
                                     2         4
                                6 cos (x)   cos (x)
          (%o6)               - --------- + ------- + 1
                                    2          4
                                 sin (x)    sin (x)
          (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
                                     2         4
                                6 cos (x)   cos (x)
          (%o7)               - --------- + ------- + 1
                                    2          4
                                 sin (x)    sin (x)
          (%i8) declare ([F, G], evfun);
          (%o8)                         done
          (%i9) (aa : bb, bb : cc, cc : dd);
          (%o9)                          dd
          (%i10) aa;
          (%o10)                         bb
          (%i11) aa, F;
          (%o11)                        F(cc)
          (%i12) F (aa);
          (%o12)                        F(bb)
          (%i13) F (ev (aa));
          (%o13)                        F(cc)
          (%i14) aa, F, G;
          (%o14)                      G(F(cc))
          (%i15) G (F (ev (aa)));
          (%o15)                      G(F(cc))

 -- Variável de opcedilhaão: infeval
     Habilita o modo "avaliacedilhaão infinita".  ev repetidamente avalia uma expressão até que ela permanecedilhaa invariante.  Para prevenir uma variável, digamos X, seja demoradamente avaliada nesso modo, simplesmente inclua X='X como um argumento para ev.  Certamente expressões tais como ev (X, X=X+1, infeval) irão gerar um ciclo infinito.

 -- Funcedilhaão: kill (A_1, ..., A_N)
 -- Funcedilhaão: kill (labels)
 -- Funcedilhaão: kill (inlabels, outlabels, linelabels)
 -- Funcedilhaão: kill (N)
 -- Funcedilhaão: kill ([M, N])
 -- Funcedilhaão: kill (values, functions, arrays, ...)
 -- Funcedilhaão: kill (all)
 -- Funcedilhaão: kill (allbut (A_1, ..., A_N))

     Remove todas as associacedilhaões (valor, funcedilhaões, array, ou regra) dos argumentos A_1, ..., A_N. Um argumento A_K pode ser um símbolo ou um elemento de array simples. Quando A_K for um elemento de array simples, kill remove a associacedilhaão daquele elemento sem afetar qualquer outro elemento do array.

     Muitos argumentos especiais são reconhecidos. Diferentes famílias de argumentos podem ser combinadas, e.g., kill (inlabels, functions, allbut (foo, bar))

     todos os rótulos de entrada, de saída, e de expressões intermediárias criados até então. kill (inlabels) libera somente rótudos de entrada que comecedilhaam com o valor corrente de inchar. De forma semelhante, kill (outlabels) libera somente rótulos de saída que comecedilhaam com o valor corrente de outchar, e kill (linelabels) libera somente rótulos de expressões intermediárias que comecedilhaam com o valor corrente de linechar.

     kill (N), onde N é um inteiro, libera os N mais recentes rótulos de entrada e saída.

     kill ([M, N]) libera rótulos de entrada e saída de M até N.

     kill (INFOLIST), onde INFOLIST é um item em infolists (tais como values, functions, ou arrays) libera todos os ítens em INFOLIST. Veja também infolists.

     kill (all) liberar todos os ítens em todas as infolists. kill (all) não retorna variáveis globais para seus valores padrões; Veja reset sobre esse ponto.

     kill (allbut (A_1, ..., A_N)) remove a associacedilhaão de todos os itens sobre todas as infolistas exceto para A_1, ..., A_N. kill (allbut (INFOLIST)) libera todos os ítens exceto para si próprio em INFOLIST, onde INFOLIST é values, functions, arrays, etc.

     A memória usada por uma propriedade de associacedilhaão não será liberada até que todos os símbolos sejam liberados disso. Em particular, para liberar a memória usada pelo valor de um símbolo, deve-se liberar o rótulo de saída que mosta o valor associado, bem como liberando o próprio símbolo.

     kill coloca um apóstro em seus argumentos (não os avalia). O operador apóstrofo-apóstrofo, '', faz com que ocorra avaliacedilhaão.

     kill (SÍMBOLO) libera todas as propriedades de SÍMBOLO. Em oposicedilhaão, remvalue, remfunction, remarray, e remrule liberam uma propriedade específica.

     kill sempre retorna done, igualmente se um argumento não tem associacedilhaões.

 -- Funcedilhaão: labels (SÍMBOLO)
 -- Variável de sistema: labels
     Retorna a lista de rótulos de entradas, de saída, de expressões intermediárias que comecedilhaam com SÍMBOLO. Tipicamente SÍMBOLO é o valor de inchar, outchar, ou linechar. O caracter rótulo pode ser dado com ou sem o sinal de porcentagem, então, por exemplo, i e %i retornam o mesmo resultado.

     Se nenhum rótulo comecedilhaa com SÍMBOLO, labels retorna uma lista vazia.

     A funcedilhaão labels não avalia seu argumento. O operador apóstrofo-apóstrofo '' faz com que ocorra avaliacedilhaão. Por exemplo, labels (''inchar) retorna os rótulos de entrada que comecedilhaam com o caractere corrente do rótulo de entrada.

     A variável labels é uma lista de rótulos de entrada, saída, e de expressões intermediárias, incluindo todos os rótulos anteriores se inchar, outchar, ou linechar que tiverem sido redefinidos.

     Por padrão, Maxima mostra o resultado de cada expressão de entrada do usuário, dando ao resultado um rótulo de saída. A exibicedilhaão da saída é suprimida pelo encerramento da entrada com $ (sinal de dolar) em lugar de ; (ponto e vírgula). Um rótulo de saída é construido e associado ao resultado, mas não é mostrado, e o rótulo pode ser referenciado da mesma forma que rótulos de saída mostrados. Veja também %, %%, e %th.

     Rótulos de expressões intermediárias podem ser gerados por algumas funcedilhaões. O sinalizador programmode controla se solve e algumas outras funcedilhaões geram rótulos de expressões intermediárias em lugar de retornar uma lista de expressões. Algumas outras funcedilhaões, tais como ldisplay, sempre geram rótulos de expressões intermediárias.

     Veja também inchar, outchar, linechar, e infolists.

 -- Variável de sistema: linenum
     Retorna o número da linha do par corrente de expressões de entrada e saída.

 -- Variável de sistema: myoptions
     Valor padrão: []

     myoptions é a lista de todas as opcedilhaões alguma vez alteradas pelo usuário, tenha ou não ele retornado a alteracedilhaão para o seu valor padrão.

 -- Variável de opcedilhaão: nolabels
     Valor padrão: false

     Quando nolabels for true, rótulos de entrada e saída (%i e %o, respectivamente) são mostrados, mas os rótulos não são associados aos resultados, e os rótulos não são anexados ao final da lista labels. Uma vez que rótulos não são associados aos resultados, a reciclagem pode recuperar a memória tomada pelos resultados.

     De outra forma rótulos de entrada e saída são associados aos resultados, e os rótulos são anexados ao final da lista labels.

     Veja também batch, batchload, e labels.

 -- Variável de opcedilhaão: optionset
     Valor padrão: false

     Quando optionset for true, Maxima mostrará uma mensagem sempre que uma opcedilhaão do Maxima for alterada.  Isso é útil se o usuário está incerto sobre a ortografia de alguma opcedilhaão e quer ter certeza que a variável por ele atribuído um valor foi realmente uma variável de opcedilhaão.

 -- Funcedilhaão: playback ()
 -- Funcedilhaão: playback (N)
 -- Funcedilhaão: playback ([M, N])
 -- Funcedilhaão: playback ([M])
 -- Funcedilhaão: playback (input)
 -- Funcedilhaão: playback (slow)
 -- Funcedilhaão: playback (time)
 -- Funcedilhaão: playback (grind)
     Mostra expressões de entrada, de saída, e expressões intermediárias, sem refazer os cálculos. playback somente mostra as expressões associadas a rótulos; qualquer outra saída (tais como textos impressos por print ou describe, ou messagens de erro) não é mostrada. Veja também labels.

     playback não avalia seus argumentos. O operador apóstrofo-apóstrofo, '', sobrepõe-se às aspas. playback sempre retorna done.

     playback () (sem argumentos) mostra todas as entradas, saídas e expressões intermediárias geradas até então. Uma expressão de saída é mostrada mesmo se for suprimida pelo terminador $ quando ela tiver sido originalmente calculada.

     playback (N) mostra as mais recentes N expressões. Cada entrada, saída e expressão intermediária conta como um.

     playback ([M, N]) mostra entradas, saídas e expressões intermediárias com os números de M até N, inclusive.

     playback ([M]) é equivalente a playback ([M, M]); isso usualmente imprime um par de expressões de entrada e saída.

     playback (input) mostra todas as expressões de entrada geradas até então.

     playback (slow) insere pausas entre expressões e espera que o usuário pressione enter. Esse comportamento é similar a demo. playback (slow) é útil juntamente com save ou stringout quando criamos um arquivo secundário de armazenagem com a finalidade de capturar expressões úteis.

     playback (time) mostra o tempo de computacedilhaão de cada expressão.

     playback (grind) mostra expressões de entrada no mesmo formato da funcedilhaão grind. Expressões de saída não são afetadas pela opcedilhaão grind. Veja grind.

     Argumentos podem ser combinados, e.g., playback ([5, 10], grind, time, slow).

 -- Funcedilhaão: printprops (A, I)
 -- Funcedilhaão: printprops ([A_1, ..., A_N], I)
 -- Funcedilhaão: printprops (all, I)
     Mostra a propriedade como o indicador I associada com o átomo A.  A pode também ser uma lista de átomos ou o átomo all nesse caso todos os átomos com a propriedade dada serão usados.  Por exemplo, printprops ([f, g], atvalue).  printprops é para propriedades que não podem  ser mostradas de outra forma, i.e. para atvalue, atomgrad, gradef, e matchdeclare.

 -- Variável de opcedilhaão: prompt
     Valor padrão: _

     prompt é o símbolo de linha de comando da funcedilhaão demo, modo playback (slow), e da interrupcedilhaão de ciclos do Maxima (como invocado por break).

 -- Funcedilhaão: quit ()
     Encerra a sessão do Maxima. Note que a funcedilhaão pode ser invocada como quit(); ou quit()$, não por sí mesma quit.

     Para parar um cálculo muito longo, digite control-C. A acedilhaão padrão é retornar à linha de comando do Maxima. Se *debugger-hook* é nil, control-C abre o depurador Lisp. Veja também debugging.

 -- Funcedilhaão: remfunction (F_1, ..., F_N)
 -- Funcedilhaão: remfunction (all)
     Desassocia as definicedilhaões de funcedilhaão dos síbolos F_1, ..., F_N. Os argumentos podem ser os nomes de funcedilhaões comuns (criadas por meio de := ou define) ou funcedilhaões macro (criadas por meio de ::=).

     remfunction (all) desassocia todas as definicedilhaões de funccedilhaão.

     remfunction coloca um ap'ostrofo em seus argumentos (não os avalia).

     remfunction retorna uma lista de símbolos para a qual a definicedilhaão de funcedilhaão foi desassociada. false é retornado em lugar de qualquer símbolo para o qual não exista definicedilhaão de funcedilhaão.

 -- Funcedilhaão: reset ()
     Retorna muitas variáveis globais e opcedilhaões, e algumas outras variáveis, para seus valores padrões.

     reset processa as variáveis na lista Lisp *variable-initial-values*. A macro Lisp defmvar coloca variáveis nessa lista (entre outras acedilhaões). Muitas, mas não todas, variáveis globais e opcedilhaões são definidas por defmvar, e algumas variáveis definidas por defmvar não são variáveis globais ou variáveis de opcedilhaão.

 -- Variável de opcedilhaão: showtime
     Valor padrão: false

     Quando showtime for true, o tempo de computacedilhaão e o tempo decorrido são impressos na tela com cada expressão de saída.

     O tempo de cálculo é sempre gravado, então time e playback podem mostrar o tempo de cálculo mesmo quando showtime for false.

     Veja também timer.

 -- Funcedilhaão: sstatus (RECURSO, PACOTE)
     Altera o status de RECURSO em PACOTE. Após sstatus (RECURSO, PACOTE) ser executado, status (RECURSO, PACOTE) retorna true. Isso pode ser útil para quem escreve pacotes, para manter um registro de quais recursos os pacotes usam.

 -- Funcedilhaão: to_lisp ()
     Insere o sistema Lisp dentro do Maxima.  (to-maxima) retorna para o Maxima.

 -- Variável de sistema: values
     Valor inicial: []

     values é uma lista de todas as varáveis de usuário associadas (não opcedilhaões Maxima ou comutadores). A lista compreende símbolos associados por : , ::, ou :=.