Lisp e Maxima
=============

Maxima é escrito na liguagem de programacedilhaão Lisp, e é fácil acessar funcedilhaões Lisp e variáveis a partir do Maxima e vice-versa. Símbolos Lisp e Maxima são distinguidos através de uma convencedilhaão de nome. Um símbolo Lisp que comecedilhaa com um sinal de dólar $ corresponde a um símbolo Maxima sem o sinal de dólar. Um símbolo Maxima que comecedilhaa com um ponto de interrogacedilhaão ? corresponde a um símbolo Lisp sem o ponto de interrogacedilhaão. Por exemplo, o símbolo Maxima foo corresponde ao símbolo Lisp $foo, enquanto o símbolo Maxima ?foo corresponde ao símbolo Lisp foo, Note que ?foo é escrito sem um espacedilhao entre ? e foo; de outra forma pode ser uma chamada errônea para describe ("foo").

Hífen -, asterisco *, ou outro caractere especial em símbolos Lisp deve ser precedido por uma barra invertida \ onde ele aparecer no código Maxima. Por exemplo, o identificador Lisp *foo-bar* é escrito ?\*foo\-bar\* no Maxima.

Código Lisp pode ser executado dentro de uma sessão Maxima. Uma linha simples de Lisp (contendo uma ou mais formas) pode ser executada através do comando especial :lisp. Por exemplo,

     (%i1) :lisp (foo $x $y)

chama a funcedilhaão Lisp foo com variáveis Maxima x e y como argumentos. A constucedilhaão :lisp pode aparecer na linha de comando interativa ou em um ficheiro processado por batch ou demo, mas não em um ficheiro processado por load, batchload, translate_file, ou compile_file.

A funcedilhaão to_lisp() abre uma sessão interativa Lisp. Digitando (to-maxima) fecha a sessão Lisp e retorna para o Maxima.

Funcedilhaões Lisp e variáveis que são para serem visíveis no Maxima como funcedilhaões e variáveis com nomes comuns (sem pontuacedilhaão especial) devem ter nomes Lisp comecedilhaando com o sinal de dólar $.

Maxima é sensível à caixa, distingue entre letras em caixa alta (maiúsculas) e letras em caixa baixa (minúsculas) em identificadores, enquanto Lisp não é sensível à caixa. Existem algumas regras governando a traducedilhaão de nomes entre o Lisp e o Maxima.

 1. Um identificador Lisp não contido entre barras verticais corresponde a um identificador Maxima em caixa baixa. Se o identificador Lisp estiver em caixa alta, caixa baixa, ou caixa mista, é ignorado. E.g., Lisp $foo, $FOO, e $Foo todos correspondem a Maxima foo.

 2. Um identificador Lisp que está todo em caixa alta ou todo em caixa baixa e contido em barras verticais corresponde a um identificador Maxima com caixa invertida. Isto é, caixa alta é alterada para caixa baixa e caixa baixa para caixa alta. E.g., Lisp |$FOO| e |$foo| corresponde a Maxima foo e FOO, respectivamente.

 3. Um identificador Lisp que é misto de caixa alta e caixa baixa e contido entre barras verticais corresponde a um identificador Maxima com o mesma caixa. E.g., Lisp |$Foo| corresponde a Maxima Foo.

A macro Lisp #$ permite o uso de expressões Maxima em código Lisp. #$EXPR$ expande para uma expressão Lisp equivalente à expressão Maxima EXPR.

     (msetq $foo #$[x, y]$)

Isso tem o mesmo efeito que digitar

     (%i1) foo: [x, y];

A funcedilhaão Lisp displa imprime uma expressão em formato Maxima.

     (%i1) :lisp #$[x, y, z]$
     ((MLIST SIMP) $X $Y $Z)
     (%i1) :lisp (displa '((MLIST SIMP) $X $Y $Z))
     [x, y, z]
     NIL

Funcedilhaões definidas em Maxima não são funcedilhaões comuns em Lisp. A funcedilhaão Lisp mfuncall chama uma funcedilhaão Maxima. Por exemplo:

     (%i1) foo(x,y) := x*y$
     (%i2) :lisp (mfuncall '$foo 'a 'b)
     ((MTIMES SIMP) A B)

Algumas funcedilhaões Lisp possuem o mesmo nome que no pacote Maxima, a saber as seguintes.

complement, continue, //, float, functionp, array, exp, listen, signum, atan, asin, acos, asinh, acosh, atanh, tanh, cosh, sinh, tan, break, e gcd.

Descartando
===========

Computacedilhaão simbólica tende a criar um bom volume de ficheiros temporários, e o efectivo manuseio disso pode ser crucial para sucesso completo de alguns programas.

Sob GCL, nos sistemas UNIX onde a chamada de sistema mprotect ( controle de acessso autorizado a uma região de memória) está disponível (incluindo SUN OS 4.0 e algumas variantes de BSD) uma organizacedilhaão de ficheiros temporários estratificada está disponível.  Isso limita a organizacedilhaão para páginas que tenham sido recentemente escritas.  Veja a documentacedilhaão da GCL sob ALLOCATE e GBC.  No ambiente Lisp fazendo (setq si::*notify-gbc* t) irá ajudá-lo a determinar quais áreas podem precisar de mais espacedilhao.

Documentacedilhaão
==================

O manual on-line de utilizador do Maxima pode ser visto em diferentes formas. A partir da linha de comando interativa do Maxima, o manual de utilizador é visto em texto plano através do comando ? (i.e., a funcedilhaão describe ). O manual de utilizador é visto como hipertexto info através do programa visualizador info e como uma web page através de qualquer navegador web comum.

example mostra exemplos de muitas funcedilhaões do Maxima. Por exemplo,

     (%i1) example (integrate);

retorna

     (%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x)))
     (%o2) test(f) := block([u], u : integrate(f, x),

                                              ratsimp(f - diff(u, x)))
     (%i3) test(sin(x))
     (%o3)                           0
     (%i4) test(1/(x+1))
     (%o4)                           0
     (%i5) test(1/(x^2+1))
     (%o5)                           0

e saída adicional.

Definicedilhaões para Ajuda
===========================

 -- Funcedilhaão: demo (NOMEFICHEIRO)
     Avalia expressões Maxima em NOMEFICHEIRO e mostra os resultados. demo faz uma pausa após avaliar cada expressão e continua após a conclusão com um enter das entradas de utilizador. (Se executando em Xmaxima, demo pode precisar ver um ponto e vírgula ; seguido por um enter.)

     demo procura na lista de directórios file_search_demo para achar nomeficheiro. Se o ficheiro tiver o sufixo dem, o sufixo pode ser omitido. Veja também file_search.

     demo avalia seus argumento. demo retorna o nome do ficheiro de demonstracedilhaão.

     Exemplo:

          (%i1) demo ("disol");

          batching /home/wfs/maxima/share/simplification/disol.dem
           At the _ prompt, type ';' followed by enter to get next demo
          (%i2)                      load(disol)

          _
          (%i3)           exp1 : a (e (g + f) + b (d + c))
          (%o3)               a (e (g + f) + b (d + c))

          _
          (%i4)                disolate(exp1, a, b, e)
          (%t4)                         d + c

          (%t5)                         g + f

          (%o5)                   a (%t5 e + %t4 b)

          _
          (%i5) demo ("rncomb");

          batching /home/wfs/maxima/share/simplification/rncomb.dem
           At the _ prompt, type ';' followed by enter to get next demo
          (%i6)                     load(rncomb)

          _
                                       z         x
          (%i7)               exp1 : ----- + ---------
                                     y + x   2 (y + x)
                                    z         x
          (%o7)                   ----- + ---------
                                  y + x   2 (y + x)

          _
          (%i8)                     combine(exp1)
                                    z         x
          (%o8)                   ----- + ---------
                                  y + x   2 (y + x)

          _
          (%i9)                     rncombine(%)
                                       2 z + x
          (%o9)                       ---------
                                      2 (y + x)

          _
                                       d   c   b   a
          (%i10)                exp2 : - + - + - + -
                                       3   3   2   2
                                    d   c   b   a
          (%o10)                    - + - + - + -
                                    3   3   2   2

          _
          (%i11)                    combine(exp2)
                                2 d + 2 c + 3 (b + a)
          (%o11)                ---------------------
                                          6

          _
          (%i12)                   rncombine(exp2)
                                2 d + 2 c + 3 b + 3 a
          (%o12)                ---------------------
                                          6

          _
          (%i13)

 -- Funcedilhaão: describe (STRING)
 -- Funcedilhaão: describe (STRING, exact)
 -- Funcedilhaão: describe (STRING, inexact)

     describe(STRING) é equivalente a describe(STRING, exact).

     describe(STRING, exact) encontra um item com título igual (case-insensitive) a STRING, se existir tal item.

     describe(STRING, inexact) encontra todos os itens documentados que contiverem STRING em seus títulos. Se existe mais de um de tal item, Maxima solicita ao utilizador seleccionar um item ou ítens para mostrar.

     Na linha de comando interativa, ? foo (com um espacedilhao entre ? e foo) é equivalente a describe("foo", exact). e ?? foo é equivalente a describe("foo", inexact).

     describe("", inexact) retorna uma lista de todos os tópicos documentados no manual on-line.

     describe não avalia seu argumento. describe retorna true se alguma documentacedilhaão for encontrada, de outra forma retorna false.

     Veja também Documentacedilhaão.

     Exemplo:

          (%i1) ?? integ
           0: (maxima.info)Introduction to Elliptic Functions and Integrals.
           1: Definitions for Elliptic Integrals.
           2: Integration.
           3: Introduction to Integration.
           4: Definitions for Integration.
           5: askinteger :Definitions for Simplification.
           6: integerp :Definitions for Miscellaneous Options.
           7: integrate :Definitions for Integration.
           8: integrate_use_rootsof :Definitions for Integration.
           9: integration_constant_counter :Definitions for Integration.
          Enter space-separated numbers, `all' or `none': 7 8

          Info from file /use/local/maxima/doc/info/maxima.info:
           - Function: integrate (expr, var)
           - Function: integrate (expr, var, a, b)
               Attempts to symbolically compute the integral of `expr' with
               respect to `var'.  `integrate (expr, var)' is an indefinite
               integral, while `integrate (expr, var, a, b)' is a definite
               integral, [...]

     Nesse , ítens 7 e 8 foram seleccionados. Todos ou nenhum dos ítens poderia ter sido seleccionado através da insercedilhaão de all ou none, que podem ser abreviado para a ou para n, respectivamente.

 -- Funcedilhaão: example (TÓPICO)
 -- Funcedilhaão: example ()
     example (TOPIC) mostra alguns exemplos de TÓPICO, que é um símbolo (não uma sequência de caracteres). A maioria dos tópicos são nomes de funcedilhaão. example () retorna a lista de todos os tópicos reconhecidos.

     O nome do ficheiro contendo os exemplos é dado pela variável global manual_demo, cujo valor padrão é "manual.demo".

     example não avalia seu argumento. example retorna done a menos que ocorra um erro ou não exista o argumento fornecido pelo utilizador, nesse caso example retorna uma lista de todos os tópicos reconhecidos.

     Exemplos:

          (%i1) example (append);
          (%i2) append([x+y,0,-3.2],[2.5E+20,x])
          (%o2)             [y + x, 0, - 3.2, 2.5E+20, x]
          (%o2)                         done
          (%i3) example (coeff);
          (%i4) coeff(b+tan(x)+2*a*tan(x) = 3+5*tan(x),tan(x))
          (%o4)                      2 a + 1 = 5
          (%i5) coeff(1+x*%e^x+y,x,0)
          (%o5)                         y + 1
          (%o5)                         done