@c /Help.texi/1.21/Thu Mar  8 03:54:16 2007/-ko/
@iftex
@hyphenation{cor-res-pon-de}
@end iftex
@menu
* Lisp e Maxima::            
* Descartando::          
* Documentação::               
* Definições para Ajuda::        
@end menu

@node Lisp e Maxima, Descartando, Ajuda, Ajuda
@section Lisp e Maxima
Maxima é escrito na liguagem de programação Lisp, e é fácil acessar funções Lisp e variáveis
a partir do Maxima e vice-versa.
Símbolos Lisp e Maxima são distinguidos através de uma convenção de nome.
Um símbolo Lisp que começa com um sinal de dólar @code{$} corresponde a
um símbolo Maxima sem o sinal de dólar.
@c NEED TO MENTION THIS OR IS IT JUST CLUTTERING ??
@c This includes special Maxima variables such as @code{%} and input and output labels,
@c which appear as @code{$%}, @code{$%i1}, @code{$%o1}, etc., in Lisp.
Um símbolo Maxima que começa com um ponto de interrogação @code{?} corresponde a
um símbolo Lisp sem o ponto de interrogação.
Por exemplo, o símbolo Maxima @code{foo} corresponde ao símbolo Lisp @code{$foo},
enquanto o símbolo Maxima @code{?foo} corresponde ao símbolo Lisp @code{foo},
Note que @code{?foo} é escrito sem um espaço entre @code{?} e @code{foo};
de outra forma pode ser uma chamada err@^onea para @code{describe ("foo")}.

Hífen @code{-}, asterisco @code{*}, ou outro caractere especial em símbolos Lisp
deve ser precedido por uma barra invertida @code{\} onde ele aparecer no código Maxima.
Por exemplo, o identificador Lisp @code{*foo-bar*} é escrito @code{?\*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 @code{:lisp}. Por exemplo,

@example
(%i1) :lisp (foo $x $y)
@end example

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

A função @code{to_lisp()} abre uma sessão interativa Lisp.
Digitando @code{(to-maxima)} fecha a sessão Lisp e retorna para o Maxima.
@c I DON'T EVEN WANT TO MENTION USING CTRL-C TO OPEN A LISP SESSION.
@c (1) IT TAKES EXTRA SET UP TO GET STARTED NAMELY :lisp (setq *debugger-hook* nil)
@c (2) IT GETS SCREWED UP EASILY -- TYPE SOMETHING WRONG AND YOU CAN'T GET BACK TO MAXIMA
@c (3) IT DOESN'T OFFER FUNCTIONALITY NOT PRESENT IN THE to_lisp() SESSION

Funções Lisp e variáveis que são para serem visíveis no Maxima como
funções e variáveis com nomes comuns (sem pontuação especial)
devem ter nomes Lisp começando com o sinal de dólar @code{$}.

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 tradução de nomes entre o Lisp e o Maxima.

@enumerate
@item
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 @code{$foo}, @code{$FOO}, e @code{$Foo} todos correspondem a Maxima @code{foo}.
@item
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 @code{|$FOO|} e @code{|$foo|}
corresponde a Maxima @code{foo} e @code{FOO}, respectivamente.
@item
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 @code{|$Foo|} corresponde a Maxima @code{Foo}.
@end enumerate

A macro Lisp @code{#$} permite o uso de expressões Maxima em código Lisp.
@code{#$@var{expr}$} expande para uma expressão Lisp equivalente à expressão Maxima @var{expr}.

@example
(msetq $foo #$[x, y]$)
@end example

@noindent
Isso tem o mesmo efeito que digitar

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

@noindent
A função Lisp @code{displa} imprime uma expressão em formato Maxima.

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

Funções definidas em Maxima não são funções comuns em Lisp.
A função Lisp @code{mfuncall} chama uma função Maxima.
Por exemplo:

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

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

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


@node Descartando, Documentação, Lisp e Maxima, Ajuda
@section Descartando
Computaçã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.

@c HOW MUCH OF THE FOLLOWING STILL HOLDS ??
@c WHAT ABOUT GC IN GCL ON MS WINDOWS ??
@c SHOULD WE SAY SOMETHING ABOUT GC FOR OTHER LISPS ??
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 organização de ficheiros temporários
estratificada está disponível.  Isso limita a
organização para páginas que tenham sido recentemente
escritas.  Veja a documentaçã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
espaço.

@node Documentação, Definições para Ajuda, Descartando, Ajuda
@section Documentação

@c SHOULD TALK ABOUT OTHER FORMS OF DOCUMENTATION ASIDE FROM ON-LINE MANUAL.

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 @code{?} (i.e., a função @code{describe} ).
O manual de utilizador é visto como hipertexto @code{info} através do programa visualizador @code{info}
e como uma web page através de qualquer navegador web comum.

@code{example} mostra exemplos de muitas funções do Maxima.
Por exemplo,

@example
(%i1) example (integrate);
@end example

retorna

@example
(%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
@end example

e saída adicional.

@node Definições para Ajuda,  , Documentação, Ajuda
@section Definições para Ajuda

@deffn {Função} demo (@var{nomeficheiro})
Avalia expressões Maxima em @var{nomeficheiro} e mostra os resultados.
@code{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, @code{demo} pode precisar ver um ponto e vírgula @code{;}
seguido por um enter.)

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

@code{demo} avalia seus argumento.
@code{demo} retorna o nome do ficheiro de demonstração.

Exemplo:

@example
(%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) 
@end example

@end deffn

@deffn {Função} describe (@var{string})
@deffnx {Função} describe (@var{string}, exact)
@deffnx {Função} describe (@var{string}, inexact)
@ifinfo
@fnindex Ajuda
@end ifinfo

@code{describe(@var{string})} é equivalente a @code{describe(@var{string}, exact)}.

@code{describe(@var{string}, exact)} encontra um item com título igual
(case-insensitive)
a @var{string}, se existir tal item.

@code{describe(@var{string}, inexact)} encontra todos os itens documentados que contiverem @var{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,
@code{? foo} (com um espaço entre @code{?} e @code{foo})
é equivalente a @code{describe("foo", exact)}.
e @code{?? foo} é equivalente a @code{describe("foo", inexact)}.

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

@code{describe} não avalia seu argumento.
@code{describe} retorna @code{true} se alguma documentação for encontrada, de outra forma retorna @code{false}.

Veja também @emph{Documentação}.

Exemplo:

@example
(%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, [...]
@end example

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

@end deffn

@deffn {Função} example (@var{tópico})
@deffnx {Função} example ()
@code{example (@var{topic})} mostra alguns exemplos de @var{tópico},
que é um símbolo (não uma sequência de caracteres).
A maioria dos tópicos são nomes de função.
@code{example ()} retorna a lista de todos os tópicos reconhecidos.

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

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

Exemplos:

@example
(%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
@end example

@end deffn


