In documentation for lreduce and rreduce, supply second argument as an explicit list

[maxima.git] / doc / info / pt_BR / Help.texi

@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /Help.texi/1.23/Sat Jun  2 00:12:47 2007/-ko/
@iftex
@hyphenation{cor-res-pon-de}
@end iftex
@menu
* Lisp e Maxima::            
* Descartando::          
* Documentação::               
* Funções e Variáveis Definidas 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 disting@"{u}idos 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ônea 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 arquivo processado por @code{batch} ou @code{demo}, mas não em um arquivo 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 arquivos temporários, e o efetivo 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 arquivos 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á ajudar você a determinar quais
áreas podem precisar de mais espaço.

@node Documentação, Funções e Variáveis Definidas 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 usuário do Maxima pode ser visto em diferentes formas.
A partir da linha de comando interativa do Maxima, o manual de usuário
é visto em texto plano através do comando @code{?} (i.e., a função @code{describe} ).
O manual de usuário é 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 Funções e Variáveis Definidas para Ajuda,  , Documentação, Ajuda
@section Funções e Variáveis Definidas para Ajuda

@deffn {Função} demo (@var{nomearquivo})
Avalia expressões Maxima em @var{nomearquivo} 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 usuário.
(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 diretórios
@code{file_search_demo} para achar @code{nomearquivo}.
Se o arquivo 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 arquivo 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 usuário selecionar
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 @ref{Documentação}.

Exemplo:

@example
(%i1) ?? integ
 0: Functions and Variables for Elliptic Integrals
 1: Functions and Variables for Integration
 2: Introduction to Elliptic Functions and Integrals
 3: Introduction to Integration
 4: askinteger  (Functions and Variables for Simplification)
 5: integerp  (Functions and Variables for Miscellaneous Options)
 6: integer_partitions  (Functions and Variables for Sets)
 7: integrate  (Functions and Variables for Integration)
 8: integrate_use_rootsof  (Functions and Variables for Integration)
 9: integration_constant_counter  (Functions and Variables for Integration)
 10: nonnegintegerp  (Functions and Variables for linearalgebra)
Enter space-separated numbers, `all' or `none': 7 8

 -- Function: integrate (<expr>, <x>)
 -- Function: integrate (<expr>, <x>, <a>, <b>)
     Attempts to symbolically compute the integral of <expr> with
     respect to <x>.  `integrate (<expr>, <x>)' is an indefinite
     integral, while `integrate (<expr>, <x>, <a>, <b>)' is a definite
     integral, [...]
     
 -- Option variable: integrate_use_rootsof
     Default value: `false'

     When `integrate_use_rootsof' is `true' and the denominator of a
     rational function cannot be factored, `integrate' returns the
     integral in a form which is a sum over the roots (not yet known)
     of the denominator.
     [...]
@end example

Nesse exemplo, ítens 7 e 8 foram selecionados
(a saída foi encurtada por razões tipográficas e economico-financeiras como indicado por @code{[...]}.
Todos ou nenhum dos ítens poderia ter sido selecionado 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 seq@"{u}ê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 arquivo 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 usuário, 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