@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /Input.texi/1.56/Sat Jun  9 01:31:19 2007/-ko/
@menu
* Coment@'{a}rios::
* Arquivos::                       
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Entrada e Sa@'{i}da::  
@end menu

@node Coment@'{a}rios, Arquivos, Entrada e Sa@'{i}da, Entrada e Sa@'{i}da
@section Coment@'{a}rios

Um coment@'{a}rio na entrada do Maxima @'{e} qualquer texto entre @code{/*} e @code{*/}.

O analisador do Maxima trata um coment@'{a}rio como espa@value{cedilha}@~{a}o em branco para o prop@'{o}sito de
encontrar indica@value{cedilha}@~{o}es no fluxo de entrada;
uma indica@value{cedilha}@~{a}o sempre termina um coment@'{a}rio.
Uma entrada tal como @code{a/* foo */b} cont@'{e}m duas indica@value{cedilha}@~{o}es, @code{a} e @code{b},
e n@~{a}o uma indica@value{cedilha}@~{a}o simples @code{ab}.
Coment@'{a}rios s@~{a}o de outra ignorados pelo Maxima;
nem o conte@'{u}do nem a localiza@value{cedilha}@~{a}o dos coment@'{a}rios s@~{a}o armazenados pelo analisador de express@~{o}es de entrada.

Coment@'{a}rios podem ser aninhados de forma a terem um n@'{i}vel de estratifica@value{cedilha}@~{a}o arbitrario.
O delimitador @code{/*} e o delimitador @code{*/} formam pares.
A quantidade de @code{/*} deve ser a mesma quantidade de @code{*/}.

Exemplos:

@c ===beg===
@c /* aa is a variable of interest */  aa : 1234;
@c /* Value of bb depends on aa */  bb : aa^2;
@c /* User-defined infix operator */  infix ("b");
@c /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
@c /* Comments /* can be nested /* to arbitrary depth */ */ */  1 + xyz;
@c ===end===
@example
(%i1) /* aa is a variable of interest */  aa : 1234;
(%o1)                         1234
(%i2) /* Value of bb depends on aa */  bb : aa^2;
(%o2)                        1522756
(%i3) /* User-defined infix operator */  infix ("b");
(%o3)                           b
(%i4) /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
(%o4)                         a b c
(%i5) /* Comments /* can be nested /* to arbitrary depth */ */ */  1 + xyz;
(%o5)                        xyz + 1
@end example


@node Arquivos, Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Entrada e Sa@'{i}da, Coment@'{a}rios, Entrada e Sa@'{i}da
@section Arquivos
Um arquivo @'{e} simplesmente uma @'{a}rea sobre um dispositivo particular de armazenagem que cont@'{e}m dados ou texto.
Arquivos em disco s@~{a}o figurativamente agrupados dentro de "diret@'{o}rios".
Um diret@'{o}rio @'{e} apenas uma lista de arquivos.
Comandos que lidam com arquivos s@~{a}o:
@code{save},
@code{load},
@code{loadfile},
@code{stringout},
@code{batch},
@code{demo},
@code{writefile},
@code{closefile},
e
@code{appendfile}.

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Entrada e Sa@'{i}da,  , Arquivos, Entrada e Sa@'{i}da
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Entrada e Sa@'{i}da de Dados

@defvr {Vari@'{a}vel de sistema} __
@ifinfo
@vrindex Express@~{a}o de entrada atual
@end ifinfo
@code{__} @'{e} a express@~{a}o de entrada atualmente sendo avaliada.
Isto @'{e}, enquanto um express@~{a}o de entrada @var{expr} est@'{a} sendo avaliada, @code{__} @'{e} @var{expr}.

@code{__} @'{e} atribu@'{i}da @`a express@~{a}o de entrada antes de a entrada ser simplificada ou avaliada.
Todavia, o valor de @code{__} @'{e} simplificado (mas n@~{a}o avaliado) quando for mostrado.

@code{__} @'{e} reconhecido por @code{batch} e @code{load}.
Em um arquivo processado por @code{batch},
@code{__} tem o mesmo significado que na linha de comando interativa.
Em um arquivo processado por @code{load},
@code{__} est@'{a} associado @`a express@~{a}o de entrada mais recentemente informada no prompt interativo
ou em um arquivo de lote (batch);
@code{__} n@~{a}o @'{e} associado @`a express@~{o}es de entrada no arquivo que est@'{a} sendo processado.
Em particular, quando @code{load (@var{nomearquivo})} for chamado a partir da linha de comando interativa,
@code{__} @'{e} associado a @code{load (@var{nomearquivo})}
enquanto o arquivo est@'{a} sendo processado.

Veja tamb@'{e}m @code{_} e @code{%}.

Exemplos:

@c ===beg===
@c print ("Eu fui chamada como", __);
@c foo (__);
@c g (x) := (print ("Express@~{a}o atual de entrada =", __), 0);
@c [aa : 1, bb : 2, cc : 3];
@c (aa + bb + cc)/(dd + ee + g(x));
@c ===end===
@example
(%i1) print ("Eu fui chamada como", __);
Eu fui chamada como print(Eu fui chamada como, __) 
(%o1)              print(Eu fui chamada como, __)
(%i2) foo (__);
(%o2)                     foo(foo(__))
(%i3) g (x) := (print ("Express@~{a}o atual de entrada =", __), 0);
(%o3) g(x) := (print("Express@~{a}o atual de entrada =", __), 0)
(%i4) [aa : 1, bb : 2, cc : 3];
(%o4)                       [1, 2, 3]
(%i5) (aa + bb + cc)/(dd + ee + g(x));
                               cc + bb + aa
Express@~{a}o atual de entrada = -------------- 
                              g(x) + ee + dd
                                6
(%o5)                        -------
                             ee + dd
@end example

@end defvr

@defvr {Vari@'{a}vel de sistema} _
@ifinfo
@vrindex Entrada anterior
@end ifinfo

@code{_} @'{e} a mais recente express@~{a}o de  entrada (e.g., @code{%i1}, @code{%i2}, @code{%i3}, ...).

A @code{_} @'{e} atribu@'{i}da @`a express@~{a}o de entrada antes dela ser simplificada ou avaliada.
Todavia, o valor de @code{_} @'{e} simplificado (mas n@~{a}o avaliado) quando for mostrado.

@code{_} @'{e} reconhecido por @code{batch} e @code{load}.
Em um arquivo processado por @code{batch},
@code{_} tem o mesmo significado que na linha de comando interativa.
Em um arquivo processado por load @code{load},
@code{_} est@'{a} associado @`a express@~{a}o de entrada mais recentemente avaliada na linha de comando interativa
ou em um arquivo de lote;
@code{_} n@~{a}o est@'{a} associada a express@~{o}es de entrada no arquivo que est@'{a} sendo processado.

Veja tamb@'{e}m @code{__} e @code{%}.

Exemplos:

@c ===beg===
@c 13 + 29;
@c :lisp $_
@c _;
@c sin (%pi/2);
@c :lisp $_
@c _;
@c a: 13$
@c b: 29$
@c a + b;
@c :lisp $_
@c _;
@c a + b;
@c ev (_);
@c ===end===
@example
(%i1) 13 + 29;
(%o1)                          42
(%i2) :lisp $_
((MPLUS) 13 29)
(%i2) _;
(%o2)                          42
(%i3) sin (%pi/2);
(%o3)                           1
(%i4) :lisp $_
((%SIN) ((MQUOTIENT) $%PI 2))
(%i4) _;
(%o4)                           1
(%i5) a: 13$
(%i6) b: 29$
(%i7) a + b;
(%o7)                          42
(%i8) :lisp $_
((MPLUS) $A $B)
(%i8) _;
(%o8)                         b + a
(%i9) a + b;
(%o9)                          42
(%i10) ev (_);
(%o10)                         42
@end example

@end defvr

@defvr {Vari@'{a}vel de sistema} %
@ifinfo
@vrindex Sa@'{i}da anterior
@end ifinfo
@code{%} @'{e} a express@~{a}o de sa@'{i}da (e.g., @code{%o1}, @code{%o2}, @code{%o3}, ...)
mais recentemente calculada pelo Maxima,
pode ou n@~{a}o ser mostrada.

@code{%} @'{e} reconhecida por @code{batch} e @code{load}.
Em um arquivo processado por @code{batch},
@code{%} tem o mesmo significado que na linha de comando interativa.
Em um arquivo processado por @code{load},
@code{%} @'{e} associado @`a express@~{a}o de entrada mais recentemente calculada na linha de comando interativa 
ou em um arquivo de lote;
@code{%} n@~{a}o est@'{a} associada a express@~{o}es de sa@'{i}da no arquivo que est@'{a} sendo processado.

Veja tamb@'{e}m @code{_}, @code{%%}, e @code{%th}

@end defvr

@defvr {Vari@'{a}vel de sistema} %%
@ifinfo
@vrindex Resultado anterior em express@~{a}o composta
@end ifinfo
Em declara@value{cedilha}@~{a}o composta,
a saber @code{block}, @code{lambda}, ou @code{(@var{s_1}, ..., @var{s_n})},
@code{%%} @'{e} os valor da declara@value{cedilha}@~{a}o anterior.
Por exemplo,

@example
block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
block ([prev], prev: integrate (x^5, x), ev (prev, x=2) - ev (prev, x=1));
@end example

retornam o mesmo resultado, a saber @code{21/2}.

Uma declara@value{cedilha}@~{a}o composta pode compreender outras declara@value{cedilha}@~{o}es compostas.
Pode uma declara@value{cedilha}@~{a}o ser simples ou composta, 
@code{%%} @'{e} o valor da declara@value{cedilha}@~{a}o anterior.
Por exemplo,

@example
block (block (a^n, %%*42), %%/6)
@end example

retorna @code{7*a^n}.

Dentro da declara@value{cedilha}@~{a}o composta, o valor de @code{%%} pode ser inspecionado em uma parada de linha de comando,
que @'{e} aberta pela execu@value{cedilha}@~{a}o da fun@value{cedilha}@~{a}o @code{break}.
Por exemplo, na parada de linha de comando aberta por

@example
block (a: 42, break ())$
@end example

digitando @code{%%;} retorna @code{42}.

Na primeira declara@value{cedilha}@~{a}o em uma declara@value{cedilha}@~{a}o composta,
ou fora de uma declara@value{cedilha}@~{a}o composta,
@code{%%} @'{e} indefinido.

@code{%%}  reconhecido por @code{batch} e @code{load},
e possem o mesmo significao que na linha de comando interativa.

Veja tamb@'{e}m @code{%}.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} %edispflag
Valor padr@~{a}o: @code{false}

Quando @code{%edispflag} for @code{true},
Maxima mostra @code{%e} para um expoente negativo como um quociente.
Por exemplo, @code{%e^-x} @'{e} mostrado como @code{1/%e^x}.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} %th (@var{i})
@ifinfo
@fnindex N'@'{e}sima sa@'{i}da anterior
@end ifinfo
O valor da @var{i}'@'{e}sima express@~{a}o pr@'{e}via de sa@'{i}da.
Isto @'{e}, se a pr@'{o}xima express@~{a}o a ser calculada for a @var{n}'@'{e}sima sa@'{i}da,
@code{%th (@var{m})} ser@'{a} a (@var{n} - @var{m})'@'{e}sima sa@'{i}da.

@code{%th} @'{e} @'{u}til em arquivos @code{batch} ou para referir-se a um grupo de express@~{o}es de sa@'{i}da.
Por exemplo,

@example
block (s: 0, for i:1 thru 10 do s: s + %th (i))$
@end example

atribui @`a vari@'{a}vel @code{s} a soma das @'{u}ltimas dez express@~{o}es de sa@'{i}da.

@code{%th} @'{e} reconhecido por @code{batch} e @code{load}.
Em um arquivo processado por @code{batch},
@code{%th} possue o mesmo significado que na linha de comando interativa.
Em um arquivo processado por @code{load},
@code{%th} refere-se a express@~{o}es de sa@'{i}da mais recentemente calculadas na linha de comando interativa
ou em um arquivo de lote;
@code{%th} n@~{a}o se refere a express@~{o}es de sa@'{i}da no arquivo que est@'{a} sendo processado.

Veja tamb@'{e}m @code{%}.

@end deffn

@deffn {S@'{i}mbolo especial} ?
@ifinfo
@fnindex Consulta documenta@value{cedilha}@~{a}o
@end ifinfo
Como prefixo para uma fun@value{cedilha}@~{a}o ou nome de vari@'{a}vel, @code{?} significa que
o nome @'{e} um nome Lisp, n@~{a}o um nome Maxima.
Por exemplo, @code{?round} significa a fun@value{cedilha}@~{a}o Lisp @code{ROUND}.
Veja @ref{Lisp e Maxima} para mais sobre esse ponto.

A nota@value{cedilha}@~{a}o @code{? palavra} (um ponto de interroga@value{cedilha}@~{a}o seguido de uma palavra e separado desta por um espa@value{cedilha}o em branco)
@'{e} equivalente a @code{describe("palavra")}.
O ponto de interroga@value{cedilha}@~{a}o deve aparecer no in@'{i}cio de uma linha de entrada;
de outra forma o ponto de interroga@value{cedilha}@~{a}o n@~{a}o @'{e} reconhecido com um pedido de documenta@value{cedilha}@~{a}o.

@end deffn

@deffn {S@'{i}mbolo especial} ??
@ifinfo
@fnindex Consulta documenta@value{cedilha}@~{a}o (busca inexata)
@end ifinfo

A nota@value{cedilha}@~{a}o @code{?? palavra} (@code{??} seguido de um espa@value{cedilha}o em branco e uma palavra)
@'{e} equivalente a @code{describe("palavra", inexact)}.
O ponto de interroga@value{cedilha}@~{a}o deve ocorrer no in@'{i}cio de uma linha de entrada;
de outra forma n@~{a}o @'{e} reconhecido com um pedido de documenta@value{cedilha}@~{a}o.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} absboxchar
Valor padr@~{a}o: @code{!}

@code{absboxchar} @'{e} o caracter usado para para desenhar o sinal de valor
absoluto em torno de express@~{o}es que s@~{a}o maiores que uma linha de altura.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} file_output_append
Valor padr@~{a}o: @code{false}

@code{file_output_append} governa se fun@value{cedilha}@~{o}es de sa@'{i}da de arquivo
anexam ao final ou truncam seu arquivo de sa@'{i}da.
Quando @code{file_output_append} for @code{true},
tais fun@value{cedilha}@~{o}es anexam ao final de seu arquivo de sa@'{i}da.
De outra forma, o arquivo de sa@'{i}da @'{e} truncado.

@code{save}, @code{stringout}, e @code{with_stdout} respeitam @code{file_output_append}.
Outras fun@value{cedilha}@~{o}es que escrevem arquivos de sa@'{i}da n@~{a}o respeitam @code{file_output_append}.
Em particular, montagem de gr@'{a}ficos e tradu@value{cedilha}@~{o}es de fun@value{cedilha}@~{o}es sempre truncam seu arquivo de sa@'{i}da,
e @code{tex} e @code{appendfile} sempre anexam ao final.
@c WHAT ABOUT WRITEFILE ??

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} appendfile (@var{nomearquivo})
Adiciona ao final de @var{nomearquivo} uma transcri@value{cedilha}@~{a}o do console.
@code{appendfile} @'{e} o mesmo que @code{writefile}, 
exceto que o arquivo transcrito, se j@'{a} existe, ter@'{a} sempre alguma coisa adicionada ao seu final.

@code{closefile} fecha o arquivo transcrito que foi aberto anteriormente por @code{appendfile} ou por @code{writefile}.

@end deffn

@c batch CAN TAKE 'test AS AN OPTIONAL ARGUMENT IN WHICH CASE IT CALLS test-batch
@c (SAME AS run_testsuite) -- SHOULD DOCUMENT batch (file, 'test)
@c FIX BUG WHICH CAUSES batch (<file>, 'test) TO FAIL, THEN DOCUMENT IT HERE
@deffn {Fun@value{cedilha}@~{a}o} batch (@var{nomearquivo})
L@^{e} express@~{o}es Maxima do arquivo @var{nomearquivo} e as avalia.
@code{batch} procura pelo arquivo @var{nomearquivo} na lista @code{file_search_maxima}.
Veja @code{file_search}.

@var{nomearquivo} compreende uma seq@"{u}@^{e}ncia de express@~{o}es Maxima,
cada uma terminada com @code{;} ou @code{$}.
A var@'{a}vel especial @code{%} e a fun@value{cedilha}@~{a}o @code{%th}
referem-se a resultados pr@'{e}vios dentro do arquivo.
O arquivo pode incluir constru@value{cedilha}@~{o}es @code{:lisp}.
Espa@value{cedilha}os, tabula@value{cedilha}@~{o}es, e o caracter de nova linha no arquivo ser@~{a}o ignorados.
um arquivo de entrada conveniente pode ser criado por um editor de texto ou pela fun@value{cedilha}@~{a}o @code{stringout}.

@code{batch} l@^{e} cada express@~{a}o de entrada de @var{nomearquivo},
mostra a entrada para o console, 
calcula a correspondente express@~{a}o de sa@'{i}da,
e mostra a express@~{a}o de sa@'{i}da.
R@'{o}tulos de entrada s@~{a}o atribu@'{i}dos para express@~{o}es de entrada
e r@'{o}tulos de sa@'{i}da s@~{a}o atribu@'{i}dos para express@~{o}es de sa@'{i}da.
@code{batch} avalia toda express@~{a}o de entrada no arquivo
a menos que exista um erro.
Se uma entrada de usu@'{a}rio for requisitada (por @code{asksign} ou por @code{askinteger}, por exemplo)
@code{batch} interrompe para coletar a entrada requisitada e ent@~{a}o continua.

@c CTRL-C BREAKS batch IN CMUCL, BUT CLISP (ALTHO IT SHOWS "User break") KEEPS GOING !!!
@c DON'T KNOW ABOUT GCL !!!
O recurso de requisi@value{cedilha}@~{a}o de entrada ao usu@'{a}rio possibilita interromper @code{batch} pela digita@value{cedilha}@~{a}o de @code{control-C} no console.
O efeito de @code{control-C} depende da subjacente implementa@value{cedilha}@~{a}o do Lisp.

@code{batch} tem muitos usos,
tais como fornecer um reservat@'{o}rio para trabalhar linhas de comando,
para fornecer demonstra@value{cedilha}@~{o}es livres de erros,
ou para ajudar a organizar alguma coisa na solu@value{cedilha}@~{a}o de problemas complexos.

@code{batch} avalia seu argumento.
@c LACK OF A RETURN VALUE IS A BUG; THE INTENT IS TO RETURN THE FILE PATH, TO JUDGE BY THE SOURCE CODE
@code{batch} n@~{a}o possui valor de retorno.

Veja tamb@'{e}m @code{load}, @code{batchload}, e @code{demo}.

@end deffn

@c RECOMMEND CUTTING THIS ITEM, AS THE load SUBSUMES FUNCTIONALITY OF batchload
@deffn {Fun@value{cedilha}@~{a}o} batchload (@var{nomearquivo})
L@^{e} express@~{o}es Maxima de @var{nomearquivo} e as avalia,
sem mostrar a entrada ou express@~{o}es de sa@'{i}da
e sem atribuir r@'{o}tulos para express@~{o}es de sa@'{i}da.
Sa@'{i}das impressas (tais como produzidas por @code{print} ou @code{describe})
s@~{a}o mostradas, todavia.

A vari@'{a}vel especial @code{%} e a fun@value{cedilha}@~{a}o @code{%th}
referem-se a resultados anteriores do interpretador interativo,
n@~{a}o a resultados dentro do arquivo.
O arquivo n@~{a}o pode incluir constru@value{cedilha}@~{o}es @code{:lisp}.

@code{batchload} retorna o caminho de @var{nomearquivo}, como uma seq@"{u}@^{e}ncia de caracteres.
@code{batchload} avalia seu argumento.

Veja tamb@'{e}m @code{batch} e @code{load}.
@c batchload APPEARS TO HAVE THE SAME EFFECT AS load.  WHY NOT GET RID OF batchload ???

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} closefile ()
Fecha o arquivo transcrito aberto por @code{writefile} ou @code{appendfile}.

@end deffn

@c NEEDS CLARIFICATION !!!
@deffn {Fun@value{cedilha}@~{a}o} collapse (@var{expr})
Reduz @var{expr} fazendo com que todas as suas
subexpress@~{o}es comuns (i.e., iguais)  sejam compartilhadas (i.e., usam a mesma c@'{e}lulas),
dessa forma economizando espa@value{cedilha}o.  (@code{collapse} @'{e} uma subrotina usada pelo comando
@code{optimize}.)  Dessa forma, chamar @code{collapse} pode ser @'{u}til
ap@'{o}s um @code{save} arquivo.  Voc@^{e} pode diminuir muitas express@~{o}es
juntas pelo uso de @code{collapse ([@var{expr_1}, ..., @var{expr_n}])}.  Similarmente, voc@^{e} pode
diminuir os elementos de um array @code{A} fazendo
@code{collapse (listarray ('A))}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} concat (@var{arg_1}, @var{arg_2}, ...)
Concatena seus argumentos.
Os argumentos devem obrigat@'{o}riamente serem avaliados para atomos.
O valor de retorno ou @'{e} um s@'{i}mbolo se o primeiro argumento for um s@'{i}mbolo
ou @'{e} uma seq@"{u}@^{e}ncia de caracteres no formato do Maxima em caso contr@'{a}rio.

@code{concat} avalia seus argumentos.
O ap@'{o}strofo @code{'} evita avalia@value{cedilha}@~{a}o.

@example
(%i1) y: 7$
(%i2) z: 88$
(%i3) concat (y, z/2);
(%o3)                          744
(%i4) concat ('y, z/2);
(%o4)                          y44
@end example

Um s@'{i}mbolo constru@'{i}do por @code{concat} pode
ser atribu@'{i}do a um valor e aparecer em express@~{o}es.
O operador de atribui@value{cedilha}@~{a}o @code{::} (duplo dois pontos) avalia seu lado esquerdo.

@example
(%i5) a: concat ('y, z/2);
(%o5)                          y44
(%i6) a:: 123;
(%o6)                          123
(%i7) y44;
(%o7)                          123
(%i8) b^a;
                               y44
(%o8)                         b
(%i9) %, numer;
                               123
(%o9)                         b
@end example

Note que embora @code{concat (1, 2)} seja visto como n@'{u}meros no console, na realidade @'{e} uma seq@"{u}@^{e}ncia de caracteres no formato do Maxima.

@example
(%i10) concat (1, 2) + 3;
(%o10)                       12 + 3
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sconcat (@var{arg_1}, @var{arg_2}, ...)

Concatena seus argumentos em uma seq@"{u}@^{e}ncia de caracteres.
Ao contr@'{a}rio de @code{concat}, os argumentos arrumados @i{n@~{a}o} precisam ser at@^{o}micos.

O resultado @'{e} uma seq@"{u}@^{e}ncia de caracteres no format do Lisp.
@c THAT'S ODD; WHY NOT A MAXIMA STRING ??

@example
(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
(%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
@end example

@end deffn

@c AFTER REVIEWING src/displa.lisp, IT LOOKS LIKE THIS VARIABLE HAS NO EFFECT
@c CUT IT ON THE NEXT PASS
@c @defvar cursordisp
@c Default value: @code{true}
@c 
@c When @code{cursordisp} is @code{true}, express@~{o}es are drawn by
@c the displayer in logical sequence.  This only works with a console
@c which can do cursor movement.  If @code{false}, express@~{o}es are
@c printed line by line.
@c 
@c @code{cursordisp} is always @code{false} when a @code{writefile} is in
@c effect.
@c 
@c @end defvar

@c REPHRASE, NEEDS EXAMPLES
@deffn {Fun@value{cedilha}@~{a}o} disp (@var{expr_1}, @var{expr_2}, ...)
@'{e} como @code{display} mas somente os valores dos
argumentos s@~{a}o mostrados em lugar de equa@value{cedilha}@~{o}es.  A fun@value{cedilha}@~{a}o @code{disp} @'{e} @'{u}til para
argumentos complicados que n@~{a}o possuem nomes ou onde somente o valor
do argumento @'{e} de interesse e n@~{a}o o nome.

@end deffn

@c HMM, THIS NEXT ITEM IS DEFINED IN A SHARE FILE (itensor.lisp); 
@c DOES ITS DESCRIPTION WANT TO BE ELSEWHERE ???
@deffn {Fun@value{cedilha}@~{a}o} dispcon (@var{tensor_1}, @var{tensor_2}, ...)
@deffnx {Fun@value{cedilha}@~{a}o} dispcon (all)
Mostra as propriedades de contra@value{cedilha}@~{a}o de
seus argumentos da forma que foram dadas para @code{defcon}.  @code{dispcon (all)} mostra todas as
propriedades de contra@value{cedilha}@~{a}o que foram definidas.

@end deffn

@c REPHRASE, MORE EXAMPLES
@deffn {Fun@value{cedilha}@~{a}o} display (@var{expr_1}, @var{expr_2}, ...)
Mostra equa@value{cedilha}@~{o}es cujo lado esquerdo @'{e}
@var{expr_i} n@~{a}o avaliado, e cujo lado direito @'{e} o valor da express@~{a}o
centrada na linha.  Essa fun@value{cedilha}@~{a}o @'{e} @'{u}til em blocos e em @code{for}
declara@value{cedilha}@~{o}es com o objetivo de ter resultados intermedi@'{a}rios mostrados.  Os
argumentos para @code{display} s@~{a}o usualmente @'{a}tomos, vari@'{a}veis com subscritos, ou
chamadas de fun@value{cedilha}@~{a}o.  Veja tamb@'{e}m @code{disp}.

@example
(%i1) display(B[1,2]);
                                      2
                         B     = X - X
                          1, 2
(%o1)                            done
@end example

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} display2d
Valor padr@~{a}o: @code{true}

Quando @code{display2d} for @code{false},
O console visualizador @'{e} da forma de uma seq@"{u}@^{e}ncia de caracteres (unidimensional) ao inv@'{e}s da
forma bidimensional.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} display_format_internal
Valor padr@~{a}o: @code{false}

Quando @code{display_format_internal} @'{e} @code{true},
express@~{o}es s@~{a}o mostradas sem ser por caminhos que
escondam a representa@value{cedilha}@~{a}o matem@'{a}tica interna.  O visualizador ent@~{a}o
corresponde ao que @code{inpart} retorna em lugar de @code{part}.

Exemplos:

@example
User     part       inpart
a-b;      A - B     A + (- 1) B

           A            - 1
a/b;       -         A B
           B
                       1/2
sqrt(x);   sqrt(X)    X

          4 X        4
X*4/3;    ---        - X
           3         3
@end example

@end defvr

@c IS THIS FUNCTION STILL USEFUL ???
@c REPHRASE, NEEDS EXAMPLES
@deffn {Fun@value{cedilha}@~{a}o} dispterms (@var{expr})
Mostra @var{expr} em partes uma abaixo da outra.
Isto @'{e}, primeiro o operador de @var{expr} @'{e} mostrado, ent@~{a}o cada parcela em
uma adi@value{cedilha}@~{a}o, ou fatores em um produto, ou parte de uma express@~{a}o mais geral @'{e}
mostrado separadamente.  Isso @'{e} @'{u}til se @var{expr} @'{e} muito larga para ser
mostrada de outra forma.  Por exemplo se @code{P1}, @code{P2}, ...  s@~{a}o express@~{o}es
muito largas ent@~{a}o o programa visualizador pode sair fora do espa@value{cedilha}o de armazenamento na
tentativa de mostrar @code{P1 + P2 + ...}  tudo de uma vez.  Todavia,
@code{dispterms (P1 + P2 + ...)} mostra @code{P1}, ent@~{a}o abaixo disso @code{P2}, etc.  Quando n@~{a}o
usando @code{dispterms}, se uma express@~{a}o exponencial @'{e} muito alta para ser
mostrada como @code{A^B} isso aparece como @code{expt (A, B)} (ou como @code{ncexpt (A, B)} no
caso de @code{A^^B}).

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} error_size
Valor padr@~{a}o: 10

@code{error_size} modifica mensagens de erro conforme o tamanho das express@~{o}es que aparecem nelas.
Se o tamanho de uma express@~{a}o (como determinado pela fun@value{cedilha}@~{a}o Lisp @code{ERROR-SIZE})
@'{e} maior que @code{error_size},
a express@~{a}o @'{e} substitu@'{i}da na mensagem por um s@'{i}mbolo,
e o o s@'{i}mbolo @'{e} atribu@'{i}do @`a express@~{a}o.
Os s@'{i}mbolos s@~{a}o obtidos da lista @code{error_syms}.

De outra forma, a express@~{a}o @'{e} menor que @code{error_size},
e a express@~{a}o @'{e} mostrada na mensagem.

Veja tamb@'{e}m @code{error} e @code{error_syms}.

Exemplo:
@c OUTPUT GENERATED BY THE FOLLOWING
@c U: (C^D^E + B + A)/(cos(X-1) + 1)$
@c error_size: 20$
@c error ("Express@~{a}o exemplo @'{e}", U);
@c errexp1;
@c error_size: 30$
@c error ("Express@~{a}o exemplo @'{e}", U);

O tamanho de @code{U}, como determinado por @code{ERROR-SIZE}, @'{e} 24.

@example
(%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$

(%i2) error_size: 20$

(%i3) error ("Express@~{a}o exemplo @'{e}", U);

Express@~{a}o exemplo @'{e} errexp1
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i4) errexp1;
                            E
                           D
                          C   + B + A
(%o4)                    --------------
                         cos(X - 1) + 1
(%i5) error_size: 30$

(%i6) error ("Express@~{a}o exemplo @'{e}", U);

                           E
                          D
                         C   + B + A
Express@~{a}o exemplo @'{e} --------------
                        cos(X - 1) + 1
 -- an error.  Quitting.  To debug this try debugmode(true);
@end example

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} error_syms
Valor padr@~{a}o: @code{[errexp1, errexp2, errexp3]}

Em mensagens de erro,
express@~{o}es mais largas que @code{error_size} s@~{a}o substitu@'{i}das por s@'{i}mbolos, e os
s@'{i}mbolos s@~{a}o escolhidos para as express@~{o}es.  Os s@'{i}mbolos s@~{a}o obtidos da
lista @code{error_syms}.
A primeira express@~{a}o muito larga @'{e} substitu@'{i}da por @code{error_syms[1]},
a segunda por @code{error_syms[2]}, e assim por diante.

Se houverem mais express@~{o}es muito largas que h@'{a} elementos em @code{error_syms},
s@'{i}mbolos s@~{a}o constru@'{i}dos automaticamente,
com o @var{n}-@'{e}simo s@'{i}mbolo equivalente a @code{concat ('errexp, @var{n})}.

Veja tamb@'{e}m @code{error} e @code{error_size}.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} expt (@var{a}, @var{b})
Se uma express@~{a}o exponencial @'{e} muito alta para ser mostrada
cmo @code{@var{a}^@var{b}} isso aparece como @code{expt (@var{a}, @var{b})} (ou como @code{ncexpt (@var{a}, @var{b})} no caso de
@code{@var{a}^^@var{b}}).

@c THIS SEEMS LIKE A BUG TO ME.  expt, ncexpt SHOULD BE RECOGNIZED SINCE MAXIMA
@c ITSELF PRINTS THEM SOMETIMES.  THESE SHOULD JUST SIMPLIFY TO ^ AND ^^, RESPECTIVELY.
@code{expt} e @code{ncexpt} n@~{a}o s@~{a}o reconhecidas em entradas.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} exptdispflag
Valor padr@~{a}o: @code{true}

Quando @code{exptdispflag} @'{e} @code{true}, Maxima mostra express@~{o}es
com expoente negativo usando quocientes, e.g., @code{X^(-1)} como @code{1/X}.

@end defvr

@c NEEDS EXAMPLES
@deffn {Fun@value{cedilha}@~{a}o} filename_merge (@var{path}, @var{nomearquivo})
Constroem um caminho modificado de @var{path} e @var{nomearquivo}.
Se o componente final de @var{path} @'{e} da forma @code{###.@var{algumacoisa}},
o componente @'{e} substitu@'{i}do com @code{@var{nomearquivo}.@var{algumacoisa}}.
De outra forma, o componente final @'{e} simplesmente substitu@'{i}do por @var{nomearquivo}.

@c SAY SOMETHING ABOUT ARG TYPE -- LISP STRINGS WORK BETTER THAN MAXIMA STRINGS
@c SAY SOMETHING ABOUT RETURN TYPE
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} file_search (@var{nomearquivo})
@deffnx {Fun@value{cedilha}@~{a}o} file_search (@var{nomearquivo}, @var{listacaminho})

@code{file_search} procura pelo arquivo @var{nomearquivo} e retorna o caminho para o arquivo
(como uma seq@"{u}@^{e}ncia de caracteres) se ele for achado; de outra forma @code{file_search} retorna @code{false}.
@code{file_search (@var{nomearquivo})} procura nos diret@'{o}rios padr@~{o}es de busca,
que s@~{a}o especificados pelas vari@'{a}veis @code{file_search_maxima}, @code{file_search_lisp}, e @code{file_search_demo}.

@code{file_search} primeiro verifica se o nome atual passado existe,
antes de tentar coincidir esse nome atual com o modelo ``coringa'' de busca do arquivo.
Veja @code{file_search_maxima} concernente a modelos de busca de arquivos.

O argumento @var{nomearquivo} pode ser um caminho e nome de arquivo,
ou apenas um nome de arquivo, ou, se um diret@'{o}rio de busca de arquivo inclui um modelo de busca de arquivo,
apenas a base do nome de arquivo (sem uma extens@~{a}o).
Por exemplo,

@example
file_search ("/home/wfs/special/zeta.mac");
file_search ("zeta.mac");
file_search ("zeta");
@end example

todos encontram o mesmo arquivo, assumindo que o arquivo exista e @code{/home/wfs/special/###.mac}
est@'{a} em @code{file_search_maxima}.

@code{file_search (@var{nomearquivo}, @var{listacaminho})} procura somente nesses diret@'{o}rios
especificados por @var{listacaminho},
que @'{e} uma lista de seq@"{u}@^{e}ncias de caracteres.
O argumento @var{listacaminho} substitui os diret@'{o}rios de busca padr@~{a}o,
ent@~{a}o se a lista do caminho @'{e} dada, @code{file_search} procura somente nesses especificados,
e n@~{a}o qualquer dos diret@'{o}rios padr@~{a}o de busca.
Mesmo se existe somente um diret@'{o}rio em @var{listacaminho}, esse deve ainda ser dado como uma lista de um @'{u}nico elemento.

O usu@'{a}rio pode modificar o diret@'{o}rio de busca padr@~{a}o.  Veja @code{file_search_maxima}.

@code{file_search} @'{e} invocado por @code{load} com @code{file_search_maxima} e @code{file_search_lisp}
como diret@'{o}rios de busca.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} file_search_maxima
@defvrx {Vari@'{a}vel de op@value{cedilha}@~{a}o} file_search_lisp
@defvrx {Vari@'{a}vel de op@value{cedilha}@~{a}o} file_search_demo
Essas vari@'{a}veis especificam listas de diret@'{o}rios a serem procurados
por @code{load}, @code{demo}, e algumas outras fun@value{cedilha}@~{o}es do Maxima.
O valor padr@~{a}o dessas vari@'{a}veis
nomeia v@'{a}rios diret@'{o}rios na instala@value{cedilha}@~{a} padr@~{a}o do Maxima.

O usu@'{a}ro pode modificar essas vari@'{a}veis,
quer substituindo os valores padr@~{a}o ou colocando no final diret@'{o}rios adicionais.
Por exemplo,

@example
file_search_maxima: ["/usr/local/foo/###.mac",
    "/usr/local/bar/###.mac"]$
@end example

substitui o valor padr@~{a}o de @code{file_search_maxima},
enquanto

@example
file_search_maxima: append (file_search_maxima,
    ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$
@end example

adiciona no final da lista dois diret@'{o}rios adicionais.
Isso pode ser conveniente para colocar assim uma express@~{a}o no arquivo @code{maxima-init.mac}
de forma que o caminho de busca de arquivo @'{e} atribu@'{i}do automaticamente quando o Maxima inicia.

Multiplas extens@~{o}es de arquivo e e multiplos caminhos podem ser especificados por
constru@value{cedilha}@~{o}es ``coringa'' especiais.
A seq@"{u}@^{e}ncia de caracteres @code{###} expande a busca para al@'{e}m do nome b@'{a}sico,
enquanto uma lista separada por v@'{i}rgulas e entre chaves @code{@{foo,bar,baz@}} expande
em multiplas seq@"{u}@^{e}ncias de caracteres.
Por exemplo, supondo que o nome b@'{a}sico a ser procurado seja @code{neumann},

@example
"/home/@{wfs,gcj@}/###.@{lisp,mac@}"
@end example

expande em @code{/home/wfs/neumann.lisp}, @code{/home/gcj/neumann.lisp}, @code{/home/wfs/neumann.mac}, e @code{/home/gcj/neumann.mac}.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} file_type (@var{nomearquivo})
Retorna uma suposta informa@value{cedilha}@~{a}o sobre o conte@'{u}do de @var{nomearquivo},
baseada na extens@~{a}o do arquivo.
@var{nomearquivo} n@~{a}o precisa referir-se a um arquivo atual;
nenhuma tentativa @'{e} feita para abrir o arquivo e inspecionar seu conte@'{u}do.

O valor de retorno @'{e} um s@'{i}mbolo, qualquer um entre @code{object}, @code{lisp}, ou @code{maxima}.
Se a extens@~{a}o come@value{cedilha}a com @code{m} ou @code{d}, @code{file_type} retorna @code{maxima}.
Se a extens@~{a}o come@value{cedilha}a om @code{l}, @code{file_type} retorna @code{lisp}.
Se nenhum dos acima, @code{file_type} retorna @code{object}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} grind (@var{expr})
@deffnx {Vari@'{a}vel de op@value{cedilha}@~{a}o} grind
A fun@value{cedilha}@~{a}o @code{grind} imprime @var{expr}
para o console em uma forma adequada de entrada para Maxima.
@code{grind} sempre retorna @code{done}.

Quando @var{expr} for um nome de uma fun@value{cedilha}@~{a}o ou o nome de uma macro,
@code{grind} mostra na tela a defini@value{cedilha}@~{a}o da fun@value{cedilha}@~{a}o ou da macro em lugar de apenas o nome.

Veja tamb@'{e}m @code{string}, que retorna uma seq@"{u}@^{e}ncia de caracteres em lugar de imprimir sua sa@'{i}da.
@code{grind} tenta imprimir a express@~{a}o de uma maneira que a faz
levemente mais f@'{a}cil para ler que a sa@'{i}da de @code{string}.

Quando a vari@'{a}vel @code{grind} @'{e} @code{true},
a sa@'{i}da de @code{string} e @code{stringout} tem o mesmo formato que @code{grind};
de outra forma nenhuma tentativa @'{e} feita para formatar especialmente a sa@'{i}da dessas fun@value{cedilha}@~{o}es.
O valor padr@~{a}o da vari@'{a}vel @code{grind} @'{e} @code{false}.

@code{grind} pode tamb@'{e}m ser especificado como um argumento de @code{playback}.
Quando @code{grind} est@'{a} presente,
@code{playback} imprime express@~{o}es de entrada no mesmo formato que a fun@value{cedilha}@~{a}o @code{grind}.
De outra forma, nenhuma tentativa @'{e} feita para formatar especialmente as express@~{o}es de entrada.

@code{grind} avalia seus argumentos.

Exemplos:

@c ===beg===
@c aa + 1729;
@c grind (%);
@c [aa, 1729, aa + 1729];
@c grind (%);
@c matrix ([aa, 17], [29, bb]);
@c grind (%);
@c set (aa, 17, 29, bb);
@c grind (%);
@c exp (aa / (bb + 17)^29);
@c grind (%);
@c expr: expand ((aa + bb)^10);
@c grind (expr);
@c string (expr);
@c cholesky (A):= block ([n : length (A), L : copymatrix (A),
@c p : makelist (0, i, 1, length (A))], for i thru n do for j : i thru n do
@c (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1), if i = j then
@c p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]), for i thru n do L[i, i] : 1 / p[i],
@c for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
@c grind (cholesky);
@c string (fundef (cholesky));
@c ===end===
@example
(%i1) aa + 1729;
(%o1)                       aa + 1729
(%i2) grind (%);
aa+1729$
(%o2)                         done
(%i3) [aa, 1729, aa + 1729];
(%o3)                 [aa, 1729, aa + 1729]
(%i4) grind (%);
[aa,1729,aa+1729]$
(%o4)                         done
(%i5) matrix ([aa, 17], [29, bb]);
                           [ aa  17 ]
(%o5)                      [        ]
                           [ 29  bb ]
(%i6) grind (%);
matrix([aa,17],[29,bb])$
(%o6)                         done
(%i7) set (aa, 17, 29, bb);
(%o7)                   @{17, 29, aa, bb@}
(%i8) grind (%);
@{17,29,aa,bb@}$
(%o8)                         done
(%i9) exp (aa / (bb + 17)^29);
                                aa
                            -----------
                                     29
                            (bb + 17)
(%o9)                     %e
(%i10) grind (%);
%e^(aa/(bb+17)^29)$
(%o10)                        done
(%i11) expr: expand ((aa + bb)^10);
         10           9        2   8         3   7         4   6
(%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
         5   5         6   4         7   3        8   2
 + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
        9        10
 + 10 aa  bb + aa
(%i12) grind (expr);
bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
     +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
     +10*aa^9*bb+aa^10$
(%o12)                        done
(%i13) string (expr);
(%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
bb+aa^10
(%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
p : makelist (0, i, 1, length (A))], for i thru n do for j : i thru n do
(x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1), if i = j then
p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]), for i thru n do L[i, i] : 1 / p[i],
for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
(%i15) grind (cholesky);
cholesky(A):=block(
         [n:length(A),L:copymatrix(A),
          p:makelist(0,i,1,length(A))],
         for i thru n do
             (for j from i thru n do
                  (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
                   if i = j then p[i]:1/sqrt(x)
                       else L[j,i]:x*p[i])),
         for i thru n do L[i,i]:1/p[i],
         for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
(%o15)                        done
(%i16) string (fundef (cholesky));
(%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
n do (for j from i+1 thru n do L[i,j]:0),L)
@end example

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} ibase
Valor padr@~{a}o: 10

Inteiros fornecidos dentro do Maxima s@~{a}o interpretados
com respeito @`a base @code{ibase}.

A @code{ibase} pode ser atribu@'{i}do qualquer inteiro entre 2 e 35 (decimal), inclusive.
@c WHY NOT 36, BY THE WAY ??
Quando @code{ibase} @'{e} maior que 10, os numerais compreendem aos numerais decimais de 0 at@'{e} 9
@c UPPERCASE/LOWERCASE DISTINCTION HERE ??
mais as letras mai@'{u}sculas do alfabeto A, B, C, ..., como necess@'{a}rio.
Os numerais para a base 35, a maior base aceit@'{a}vel,
compreendem de 0 at@'{e} 9 e de A at@'{e} Y.
@c HOW, EXACTLY, DOES ONE TYPE IN THE LETTERS ??
@c ibase: 11$ 1A; YIELDS AN ERROR
@c \1A; #1A; \#1A; DON'T WORK EITHER

Veja tamb@'{e}m @code{obase}.

@c NEED EXAMPLES HERE
@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} inchar
Valor padr@~{a}o: @code{%i}

@code{inchar} @'{e} o prefixo dos r@'{o}tulos de express@~{o}es fornecidas pelo usu@'{a}rio.
Maxima automaticamente constr@'{o}i um r@'{o}tulo para cada express@~{a}o de entrada
por concatena@value{cedilha}@~{a}o de @code{inchar} e @code{linenum}.
A @code{inchar} pode ser atribu@'{i}do qualquer seq@"{u}@^{e}ncia de caracteres ou s@'{i}mbolo, n@~{a}o necessariamente um caracter simples.

@example
(%i1) inchar: "input";
(%o1)                                input
(input1) expand ((a+b)^3);
                            3        2      2      3
(%o1)                      b  + 3 a b  + 3 a  b + a
(input2)
@end example

Veja tamb@'{e}m @code{labels}.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} ldisp (@var{expr_1}, ..., @var{expr_n})
Mostra express@~{o}es @var{expr_1}, ..., @var{expr_n} para o console
como sa@'{i}da impressa na tela.
@code{ldisp} atribue um r@'{o}tulo de express@~{a}o intermedi@'{a}ria a cada argumento
e retorna a lista de r@'{o}tulos.

Veja tamb@'{e}m @code{disp}.

@example
(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)
(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisp (e, f);
                                   3
(%t3)                       (b + a)

                     3        2      2      3
(%t4)               b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                   3
(%o4)                       (b + a)
(%i5) %t4;
                     3        2      2      3
(%o5)               b  + 3 a b  + 3 a  b + a
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ldisplay (@var{expr_1}, ..., @var{expr_n})
Mostra express@~{o}es @var{expr_1}, ..., @var{expr_n} para o console
como sa@'{i}da impressa na tela.
Cada express@~{a}o @'{e} impressa como uma equa@value{cedilha}@~{a}o da forma @code{lhs = rhs}
na qual @code{lhs} @'{e} um dos argumentos de @code{ldisplay}
e @code{rhs} @'{e} seu valor.
Tipicamente cada argumento @'{e} uma vari@'{a}vel.
@code{ldisp} atribui um r@'{o}tulo de express@~{a}o intermedi@'{a}ia a cada equa@value{cedilha}@~{a}o
e retorna a lista de r@'{o}tulos.

Veja tamb@'{e}m @code{display}.

@example
(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)
(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisplay (e, f);
                                     3
(%t3)                     e = (b + a)

                       3        2      2      3
(%t4)             f = b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                     3
(%o4)                     e = (b + a)
(%i5) %t4;
                       3        2      2      3
(%o5)             f = b  + 3 a b  + 3 a  b + a
@end example

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} linechar
Valor padr@~{a}o: @code{%t}

@code{linechar} @'{e} o refixo de r@'{o}tulos de express@~{o}es intermedi@'{a}rias gerados pelo Maxima.
Maxima constr@'{o}i um r@'{o}tulo para cada express@~{a}o intermedi@'{a}ria (se for mostrada)
pela concatena@value{cedilha}@~{a}o de @code{linechar} e @code{linenum}.
A @code{linechar} pode ser atribu@'{i}do qualquer seq@"{u}@^{e}ncia de caracteres ou s@'{i}mbolo, n@~{a}o necess@'{a}riamente um caractere simples.

Express@~{o}es intermedi@'{a}rias podem ou n@~{a}o serem mostradas.
See @code{programmode} e @code{labels}.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} linel
Valor padr@~{a}o: 79

@code{linel} @'{e} a largura assumida (em caracteres) do console
para o prop@'{o}sito de mostrar express@~{o}es.
A @code{linel} pode ser atribu@'{i}do qualquer valor pelo usu@'{a}rio,
embora valores muio pequenos ou muito grandes possam ser impratic@'{a}veis.
Textos impressos por fun@value{cedilha}@~{o}es internas do Maxima, tais como mensagens de erro e a sa@'{i}da de @code{describe},
n@~{a}o s@~{a}o afetadas por @code{linel}.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} lispdisp
Valor padr@~{a}o: @code{false}

Quando @code{lispdisp} for @code{true},
s@'{i}mbolos Lisp s@~{a}o mostrados com um ponto de interroga@value{cedilha}@~{a}o @code{?} na frente.
De outra forma,
s@'{i}mbolos Lisp ser@~{a}o mostrados sem o ponto de interroga@value{cedilha}@~{o} na frente.

Exemplos:

@c ===beg===
@c lispdisp: false$
@c ?foo + ?bar;
@c lispdisp: true$
@c ?foo + ?bar;
@c ===end===
@example
(%i1) lispdisp: false$
(%i2) ?foo + ?bar;
(%o2)                       foo + bar
(%i3) lispdisp: true$
(%i4) ?foo + ?bar;
(%o4)                      ?foo + ?bar
@end example

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} load (@var{nomearquivo})
Avalia express@~{o}es em @var{nomearquivo}, 
dessa forma conduzindo vari@'{a}veis, fun@value{cedilha}@~{o}es, e outros objetos dentro do Maxima.
A associa@value{cedilha}@~{a}o de qualquer objeto existente @'{e} substitu@'{i}da pela associa@value{cedilha}@~{a}o recuperada de @var{nomearquivo}.  
Para achar o arquivo,
@code{load} chama @code{file_search} com @code{file_search_maxima} e @code{file_search_lisp}
como diret@'{o}rios de busca.
Se @code{load} obt@'{e}m sucesso, isso retorna o nome do arquivo.
De outra forma @code{load} imprime uma mensagem e erro.

@code{load} trabalha igualmente bem para c@'{o}digos Lisp e c@'{o}digos Maxima.
Arquivos criados por @code{save}, @code{translate_file}, e @code{compile_file}, que criam c@'{o}digos Lisp,
e @code{stringout}, que criam c@'{o}digos Maxima,
podem ser processadas por @code{load}.
@code{load} chama @code{loadfile} para carregar arquivos Lisp e @code{batchload} para carregar arquivos Maxima.

@code{load} n@~{a}o reconhece constru@value{cedilha}@~{o}es @code{:lisp} em arquivos do Maxima,
e quando processando @var{nomearquivo},
as vari@'{a}veis globais @code{_}, @code{__}, @code{%}, e @code{%th} possuem as mesmas associa@value{cedilha}@~{o}es
que possuiam quando @code{load} foi chamada.

Veja tamb@'{e}m @code{loadfile}, @code{batch}, @code{batchload}, e @code{demo}.
@code{loadfile} processa arquivos Lisp;
@code{batch}, @code{batchload}, e @code{demo} processam arquivos Maxima.

Veja @code{file_search} para mais detalhes sobre o mecanismo de busca de arquivos.

@code{load} avalia seu argumento.

@end deffn

@c RECOMMEND CUTTING THIS ITEM, AS THE load SUBSUMES FUNCTIONALITY OF loadfile
@deffn {Fun@value{cedilha}@~{a}o} loadfile (@var{nomearquivo})
Avalia express@~{o}es Lisp em @var{nomearquivo}.
@code{loadfile} n@~{a}o invoca @code{file_search}, ent@~{a}o @code{nomearquivo} deve obrigat@'{o}riamente incluir
a extens@~{a}o do arquivo e tanto quanto o caminho como necess@'{a}rio para achar o arquivo.

@code{loadfile} pode processar arquivos criados por @code{save}, @code{translate_file}, e @code{compile_file}.
O usu@'{a}rio pode achar isso mais conveniente para usar @code{load} em lugar de @code{loadfile}.

@end deffn

@c loadprint DOESN'T EXACTLY WORK LIKE THIS, BUT IT HARDLY SEEMS WORTH FIXING
@c I GUESS THIS COULD BE UPDATED TO DESCRIBE THE WAY IT ACTUALLY WORKS
@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} loadprint
Valor padr@~{a}o: @code{true}

@code{loadprint} diz se deve imprimir uma mensagem quando um arquivo @'{e} chamado.

@itemize @bullet
@item
Quando @code{loadprint} @'{e} @code{true}, sempre imprime uma mensagem.
@item
Quando @code{loadprint} @'{e} @code{'loadfile}, imprime uma mensagem somente se
um arquivo @'{e} chamado pela fun@value{cedilha}@~{a}o @code{loadfile}.
@item
Quando @code{loadprint} @'{e} @code{'autoload},
imprime uma mensagem somente se um arquivo @'{e} automaticamente carregado.
Veja @code{setup_autoload}.
@item
Quando @code{loadprint} @'{e} @code{false}, nunca imprime uma mensagem.
@end itemize

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} obase
Valor padr@~{a}o: 10

@code{obase} @'{e} a base para inteiros mostrados pelo Maxima.

A @code{obase} poode ser atribu@'{i}do qualquer inteiro entre 2 e 35 (decimal), inclusive.
@c WHY NOT 36, BY THE WAY ??
Quando @code{obase} @'{e} maior que 10, os numerais compreendem os numerais decimais de 0 at@'{e} 9
e letras mai@'{u}sulas do alfabeto A, B, C, ..., quando necess@'{a}rio.
Os numerais para a base 35, a maior base aceit@'{a}vel,
compreendem de 0 at@'{e} 9, e de A at@'{e} Y.

Veja tamb@'{e}m @code{ibase}.

@c NEED EXAMPLES HERE
@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} outchar
Valor padr@~{a}o: @code{%o}

@code{outchar} @'{e} o prefixo dos r@'{o}tulos de express@~{o}es calculadas pelo Maxima.
Maxima automaticamente constr@'{o}i um r@'{o}tulo para cada express@~{a}o calculada
pela concatena@value{cedilha}@~{a}o de @code{outchar} e @code{linenum}.
A @code{outchar} pode ser atribu@'{i}do qualquer seq@"{u}@^{e}ncia de caracteres ou s@'{i}mbolo, n@~{a}o necess@'{a}riamente um caractere simples.

@example
(%i1) outchar: "output";
(output1)                           output
(%i2) expand ((a+b)^3);
                            3        2      2      3
(output2)                  b  + 3 a b  + 3 a  b + a
(%i3)
@end example

Veja tamb@'{e}m @code{labels}.

@end defvr

@c STILL EXISTS, NEEDS CLARIFICATION !!!
@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} packagefile
Valor padr@~{a}o: @code{false}

Projetistas de pacotes que usam @code{save}
ou @code{translate} para criar pacotes (arquivos) para outros
usarem podem querer escolher @code{packagefile: true} para prevenir qu informa@value{cedilha}@~{o}es
sejam acrescentadas @`a lista de informa@value{cedilha}@~{o}es do Maxima (e.g. @code{values},
@code{fun@value{cedilha}@~{o}es}) exceto onde necess@'{a}rio quando o arquivo @'{e} carregado.
Nesse caminho, o conte@'{u}do do pacote n@~{a}o pegar@'{a} no
caminho do usu@'{a}rio quando ele adicionar seus pr@'{o}prios dados.  Note que isso n@~{a}o
resolve o problema de poss@'{i}veis conflitos de nome.  Tamb@'{e}m note que
o sinalizador simplesmente afeta o que @'{e} sa@'{i}da para o arquivo pacote.
Escolhendo o sinalizador para @code{true} @'{e} tamb@'{e}m @'{u}til para criar arquivos de
init do Maxima.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} pfeformat
Valor padr@~{a}o: @code{false}

Quando @code{pfeformat} @'{e} @code{true}, uma raz@~{a}o de inteiros @'{e}
mostrada com o caractere s@'{o}lido (barra normal),
e um denominador inteiro @code{n}
@'{e} mostrado como um termo multiplicativo em primeiro lugar @code{1/n}.

@example
(%i1) pfeformat: false$
(%i2) 2^16/7^3;
                              65536
(%o2)                         -----
                               343
(%i3) (a+b)/8;
                              b + a
(%o3)                         -----
                                8
(%i4) pfeformat: true$ 
(%i5) 2^16/7^3;
(%o5)                       65536/343
(%i6) (a+b)/8;
(%o6)                      1/8 (b + a)
@end example

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} print (@var{expr_1}, ..., @var{expr_n})
Avalia e mostra @var{expr_1}, ..., @var{expr_n}
uma ap@'{o}s a outra, da esquerda para a direita,
iniciando no lado esquerdo do console.

O valor retornado por @code{print} @'{e} o valor de seu @'{u}ltimo argumento.
@code{print} n@~{a}o gera r@'{o}tulos de express@~{a}o intermedi@'{a}ria.

Veja tamb@'{e}m @code{display}, @code{disp}, @code{ldisplay}, e @code{ldisp}.
Essas fun@value{cedilha}@~{o}es mostram uma express@~{a}o por linha, enquanto @code{print} tenta
mostrar duas ou mais express@~{o}es por linha.

Para mostrar o conte@'{u}do de um arquivo, veja @code{printfile}.

@example
(%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$
            3        2      2      3
(a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is 

                                              10 log(a) - log(b) 
(%i2) r;
(%o2)                  10 log(a) - log(b)
(%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$
                           (a+b)^3 is

                     3        2      2      3
                    b  + 3 a b  + 3 a  b + a

                         log (a^10/b) is

                       10 log(a) - log(b)
@end example

@end deffn

@c RECOMMEND CUTTING THIS ITEM AND CUTTING $tcl_output IN src/plot.lisp
@c THIS REALLY, REALLY SEEMS LIKE CRUFT:
@c $tcl_output IS NEVER CALLED WITHIN MAXIMA SOURCE,
@c AND THIS EXTREMELY NARROW, LIMITED FUNCTIONALITY ISN'T USEFUL TO USERS
@c AND IT'S BROKEN: INCORRECT OUTPUT FOR CLISP, DIES ON GCL
@deffn {Fun@value{cedilha}@~{a}o} tcl_output (@var{list}, @var{i0}, @var{skip})
@deffnx {Fun@value{cedilha}@~{a}o} tcl_output (@var{list}, @var{i0})
@deffnx {Fun@value{cedilha}@~{a}o} tcl_output ([@var{list_1}, ..., @var{list_n}], @var{i})

Imprime os elementos de uma lista entre chaves @code{@{ @}},
conveniente como parte de um programa na linguagem Tcl/Tk.

@code{tcl_output (@var{list}, @var{i0}, @var{skip})}
imprime @var{list}, come@value{cedilha}ando com o elemento @var{i0} e imprimindo elementos
@code{@var{i0} + @var{skip}}, @code{@var{i0} + 2 @var{skip}}, etc.

@code{tcl_output (@var{list}, @var{i0})}
@'{e} equivalente a @code{tcl_output (@var{list}, @var{i0}, 2)}.

@code{tcl_output ([@var{list_1}, ..., @var{list_n}], @var{i})}
imprime os @var{i}'@'{e}simos elementos de @var{list_1}, ..., @var{list_n}.

Exemplos:
@c EXAMPLE INPUT
@c tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$
@c tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$
@c tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$
@c tcl_output ([x1, y1, x2, y2, x3, y3], 2)$
@c tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$

@c EXAMPLE OUTPUT: CLISP
@c OUTPUT IS OK FOR FIRST TWO, BROKEN FOR OTHERS
@c GCL OUTPUT: SAME FOR FIRST TWO
@c GCL FAILS ON OTHERS (IN EACH CASE COMPLAINING ELEMENTS ARE "not of type (OR RATIONAL LISP:FLOAT)"
@example
(%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$

 @{1.000000000     4.000000000     
 @}
(%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$

 @{2.000000000     5.000000000     
 @}
(%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$

 @{((RAT SIMP) 3 7) ((RAT SIMP) 11 13) 
 @}
(%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$

 @{$Y1 $Y2 $Y3 
 @}
(%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$

 @{SIMP 1.000000000     11.00000000     
 @}
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} read (@var{expr_1}, ..., @var{expr_n})
Imprime @var{expr_1}, ..., @var{expr_n}, ent@~{a}o l@^{e} uma express@~{a}o do console
e retorna a express@~{a}o avaliada.
A express@~{a}o @'{e} terminada com um ponto e v@'{i}rgula @code{;} ou o sinal de d@'{o}lar @code{$}.

Veja tamb@'{e}m @code{readonly}.

@example
(%i1) foo: 42$ 
(%i2) foo: read ("foo is", foo, " -- enter new value.")$
foo is 42  -- enter new value.  
(a+b)^3;
(%i3) foo;
                                     3
(%o3)                         (b + a)
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} readonly (@var{expr_1}, ..., @var{expr_n})
Imprime @var{expr_1}, ..., @var{expr_n}, ent@~{a}o l@^{e} uma express@~{a}o do console
e retorna a express@~{a}o (sem avalia@value{cedilha}@~{a}o).
A express@~{a}o @'{e} terminada com um @code{;} (ponto e v@'{i}rgula) ou @code{$} (sinal de d@'{o}lar).

@example
(%i1) aa: 7$
(%i2) foo: readonly ("Forne@value{cedilha}a uma express@~{a}o:");
Enter an express@~{a}o: 
2^aa;
                                  aa
(%o2)                            2
(%i3) foo: read ("Forne@value{cedilha}a uma express@~{a}o:");
Enter an express@~{a}o: 
2^aa;
(%o3)                            128
@end example

Veja tamb@'{e}m @code{read}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} reveal (@var{expr}, @var{depth})
Substitue partes de @var{expr} no inteiro especificado @var{depth}
com sum@'{a}rio descritivo.

@itemize @bullet
@item
Somas e diferen@value{cedilha}as s@~{a}o substitu@'{i}das por @code{sum(@var{n})}
onde @var{n} @'{e} o n@'{u}mero de operandos do produto.
@item
Produtos s@~{a}o substitu@'{i}dos por @code{product(@var{n})}
onde @var{n} @'{e} o n@'{u}mero de operandos da multiplica@value{cedilha}@~{a}o.
@item
Exponenciais s@~{a}o substitu@'{i}dos por @code{expt}.  
@item
Quocientes s@~{a}o substitu@'{i}dos por @code{quotient}.
@item
Nega@value{cedilha}@~{a}o un@'{a}ria @'{e} substitu@'{i}da por @code{negterm}.
@end itemize

Quando @var{depth} @'{e} maior que ou igual @`a m@'{a}xima intensidade de @var{expr},
@code{reveal (@var{expr}, @var{depth})} retornam @var{expr} sem modifica@value{cedilha}@~{o}es.

@code{reveal} avalia seus argumentos.
@code{reveal} retorna express@~{a}o sumarizada.

Exemplo:

@example
(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
                          2            2
                         b  - 2 a b + a
(%o1)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e
(%i2) reveal (e, 1);
(%o2)                       quotient
(%i3) reveal (e, 2);
                             sum(3)
(%o3)                        ------
                             sum(3)
(%i4) reveal (e, 3);
                     expt + negterm + expt
(%o4)               ------------------------
                    product(2) + expt + expt
(%i5) reveal (e, 4);
                       2                 2
                      b  - product(3) + a
(%o5)         ------------------------------------
                         product(2)     product(2)
              2 expt + %e           + %e
(%i6) reveal (e, 5);
                         2            2
                        b  - 2 a b + a
(%o6)              --------------------------
                       sum(2)     2 b     2 a
                   2 %e       + %e    + %e
(%i7) reveal (e, 6);
                          2            2
                         b  - 2 a b + a
(%o7)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e
@end example

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} rmxchar
Valor padr@~{a}o: @code{]}

@code{rmxchar} @'{e} the caractere desenhado lado direito de uma matriz.

Veja tamb@'{e}m @code{lmxchar}.

@end defvr

@c NEEDS EXAMPLES
@deffn {Fun@value{cedilha}@~{a}o} save (@var{nomearquivo}, @var{nome_1}, @var{nome_2}, @var{nome_3}, ...)
@deffnx {Fun@value{cedilha}@~{a}o} save (@var{nomearquivo}, values, functions, labels, ...)
@deffnx {Fun@value{cedilha}@~{a}o} save (@var{nomearquivo}, [@var{m}, @var{n}])
@deffnx {Fun@value{cedilha}@~{a}o} save (@var{nomearquivo}, @var{nome_1}=@var{expr_1}, ...)
@deffnx {Fun@value{cedilha}@~{a}o} save (@var{nomearquivo}, all)
@deffnx {Fun@value{cedilha}@~{a}o} save (@var{nomearquivo}, @var{nome_1}=@var{expr_1}, @var{nome_2}=@var{expr_2}, ...)

Armazena os valores correntes de @var{nome_1}, @var{nome_2}, @var{nome_3}, ..., em @var{nomearquivo}.
Os argumentos s@~{a}o os nomes das vari@'{a}veis, fun@value{cedilha}@~{o}es, ou outros objetos.
Se um nome n@~{a}o possui valore ou fun@value{cedilha}@~{a}o associada a ele, esse nome sem nenhum valor ou fun@value{cedilha}@~{a}o associado ser@'{a} ignorado.
@code{save} retorna @var{nomearquivo}.

@code{save} armazena dados na forma de express@~{o}es Lisp.
Os dados armazenados por @code{save} podem ser recuperados por @code{load (@var{nomearquivo})}.

O sinalizador global @code{file_output_append} governa
se @code{save} anexa ao final ou trunca o arquivo de sa@'{i}da.
Quando @code{file_output_append} for @code{true},
@code{save} anexa ao final doarquivo de sa@'{i}da.
De outra forma, @code{save} trunca o arquivo de sa@'{i}da.
Nesse caso, @code{save} cria o arquivo se ele n@~{a}o existir ainda.

A forma especial @code{save (@var{nomearquivo}, values, functions, labels, ...)}
armazena os @'{i}tens nomeados por @code{values}, @code{fun@value{cedilha}@~{o}es}, @code{labels}, etc.
Os nomes podem ser quaisquer especificados pela vari@'{a}vel @code{infolists}.
@code{values} compreende todas as vari@'{a}veis definidas pelo usu@'{a}rio.

A forma especial @code{save (@var{nomearquivo}, [@var{m}, @var{n}])} armazena os valores de
r@'{o}tulos de entrada e sa@'{i}da de @var{m} at@'{e} @var{n}.
Note que @var{m} e @var{n} devem obrigat@'{o}riamente ser inteiros literais.
R@'{o}tulos de entrada e sa@'{i}da podem tamb@'{e}m ser armazenados um a um, e.g., @code{save ("foo.1", %i42, %o42)}.
@code{save (@var{nomearquivo}, labels)} armazena todos os r@'{o}tulos de entrada e sa@'{i}da.
Quando r@'{o}tulos armazenados s@~{a}o recuperados, eles substituem r@'{o}tulos existentes.

A forma especial @code{save (@var{nomearquivo}, @var{nome_1}=@var{expr_1}, @var{nome_2}=@var{expr_2}, ...)}
armazena os valores de @var{expr_1}, @var{expr_2}, ...,
com nomes @var{nome_1}, @var{nome_2}, ....
Isso @'{e} @'{u}til para aplicar essa forma para r@'{o}tulos de entrada e sa@'{i}da, e.g., @code{save ("foo.1", aa=%o88)}.
O lado direito dessa igualdade nessa forma pode ser qualquer express@~{a}o, que @'{e} avaliada.
Essa forma n@~{a}o introduz os novos nomes no ambiente corrente do Maxima,
mas somente armazena-os em @var{nomearquivo}.

Essa forma especial e a forma geral de @code{save} podem ser misturados.
Por exemplo, @code{save (@var{nomearquivo}, aa, bb, cc=42, fun@value{cedilha}@~{o}es, [11, 17])}.

A forma especial @code{save (@var{nomearquivo}, all)} armazena o estado corrente do Maxima.
Isso inclui todas as vari@'{a}veis definidas pelo usu@'{a}rio, fun@value{cedilha}@~{o}es, arrays, etc., bem como
alguns @'{i}tens definidos automaticamente.
Os @'{i}tes salvos incluem vari@'{a}veis de sistema,
tais como @code{file_search_maxima} ou @code{showtime}, se a elas tiverem sido atribu@'{i}dos novos valores pelo usu@'{a}rio;
veja @code{myoptions}.

@code{save} avalia @var{nomearquivo} e n@~{a}o avalia todos os outros argumentos.

@end deffn

@c NEEDS MORE WORK !!!
@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} savedef
Valor padr@~{a}o: @code{true}

Quando @code{savedef} @'{e} @code{true}, a ves@~{a}o Maxima de uma
fun@value{cedilha}@~{a}o de usu@'{a}rio @'{e} preservada quando a fun@value{cedilha}@~{a}o @'{e} traduzida.
Isso permite que a defini@value{cedilha}@~{a}o seja mostrada por @code{dispfun} e autoriza a fun@value{cedilha}@~{a}o a
ser editada.

Quando @code{savedef} @'{e} @code{false}, os nomes de fun@value{cedilha}@~{o}es traduzidas s@~{a}o
removidos da lista de @code{fun@value{cedilha}@~{o}es}.

@end defvr

@c THIS FUNCTION IS IN THE SHARE PACKAGE itensor.lisp
@c MOVE THIS DESCRIPTION TO Itensor.texi
@deffn {Fun@value{cedilha}@~{a}o} show (@var{expr})
Mostra @code{expr} com os objetos indexados
tendo @'{i}ndices covariantes como subscritos, @'{i}ndices contravariantes como
sobrescritos.  Os @'{i}ndices derivativos s@~{a}o mostrados como subscritos,
separados dos @'{i}ndices covariantes por uma v@'{i}rgula.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} showratvars (@var{expr})
Retorna uma lista de vari@'{a}veis express@~{a}o racional can@^{o}nica (CRE) na express@~{a}o @code{expr}.

Veja tamb@'{e}m @code{ratvars}.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} stardisp
Valor padr@~{a}o: @code{false}

Quando @code{stardisp} @'{e} @code{true}, multiplica@value{cedilha}@~{a}o @'{e}
mostrada com um asterisco @code{*} entre os operandos.

@end defvr

@c NEEDS CLARIFICATION AND EXAMPLES
@deffn {Fun@value{cedilha}@~{a}o} string (@var{expr})
Converte @code{expr} para a nota@value{cedilha}@~{a}o linear do Maxima
apenas como se tivesse sido digitada.

O valor de retorno de @code{string} @'{e} uma seq@"{u}@^{e}ncia de caracteres,
e dessa forma n@~{a}o pode ser usada em um c@'{a}lculo.

@end deffn

@c SHOULD BE WRITTEN WITH LEADING ? BUT THAT CONFUSES CL-INFO SO WORK AROUND
@c @defvr {Vari@~{a}vel de op@value{cedilha}@~{a}o} stringdisp
@defvr {Vari@~{a}vel de op@value{cedilha}@~{a}o} stringdisp
Valor padr@~{a}o: @code{false}

Quando @code{stringdisp} for @code{true},
seq@"{u}@^{e}ncias de caracteres ser@~{a}o mostradas contidas em aspas duplas.
De outra forma,
aspas n@~{a}o s@~{a}o mostradas.

@code{stringdisp} @'{e} sempre @code{true} quando mostrando na tela uma defini@value{cedilha}@~{a}o de fun@value{cedilha}@~{a}o.

Exemplos:

@c ===beg===
@c stringdisp: false$
@c "This is an example string.";
@c foo () := print ("This is a string in a function definition.");
@c stringdisp: true$
@c "This is an example string.";
@c ===end===
@example
(%i1) stringdisp: false$
(%i2) "This is an example string.";
(%o2)              This is an example string.
(%i3) foo () := print ("This is a string in a function definition.");
(%o3) foo() := 
              print("This is a string in a function definition.")
(%i4) stringdisp: true$
(%i5) "This is an example string.";
(%o5)             "This is an example string."
@end example

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} stringout (@var{nomearquivo}, @var{expr_1}, @var{expr_2}, @var{expr_3}, ...)
@deffnx {Fun@value{cedilha}@~{a}o} stringout (@var{nomearquivo}, [@var{m}, @var{n}])
@deffnx {Fun@value{cedilha}@~{a}o} stringout (@var{nomearquivo}, input)
@deffnx {Fun@value{cedilha}@~{a}o} stringout (@var{nomearquivo}, functions)
@deffnx {Fun@value{cedilha}@~{a}o} stringout (@var{nomearquivo}, values)

@code{stringout} escreve express@~{o}es para um arquivo na mesma forma de
express@~{o}es que foram digitadas para entrada.  O arquivo pode ent@~{a}o ser usado
como entrada para comandos @code{batch} ou @code{demo}, e isso pode ser editado para
qualquer prop@'{o}sito.  @code{stringout} pode ser executado enquanto @code{writefile} est@'{a} em progresso.

O sinalizador global @code{file_output_append} governa
se @code{stringout} anexa ao final ou trunca o arquivo de sa@'{i}da.
Quando @code{file_output_append} for @code{true},
@code{stringout} anexa ao final do arquivo de sa@'da.
De outra forma, @code{stringout} trunca o arquivo de sa@'{i}da.
Nesse caso, @code{stringout} cria o arquivo de sa@'{i}da se ele n@~{a}o existir ainda.

A forma geral de @code{stringout} escreve os valores de um ou mais 
express@~{o}es para o arquivo de sa@'{i}da.  Note que se uma express@~{a}o @'{e} uma
vari@'{a}vel, somente o valor da vari@'{a}vel @'{e} escrito e n@~{a}o o nome
da vari@'{a}vel.  Como um @'{u}til caso especial, as express@~{o}es podem ser
r@'{o}tulos de entrada (@code{%i1}, @code{%i2}, @code{%i3}, ...) ou r@'{o}tulos de sa@'{i}da (@code{%o1}, @code{%o2}, @code{%o3}, ...).

Se @code{grind} @'{e} @code{true}, @code{stringout} formata a sa@'{i}da usando o formato 
@code{grind}.  De outra forma o formato @code{string} @'{e} usado.  Veja @code{grind} e @code{string}.

A forma especial @code{stringout (@var{nomearquivo}, [@var{m}, @var{n}])} escreve os
valores dos r@'{o}tulos de entrada de m at@'{e} n, inclusive.  

A forma especial @code{stringout (@var{nomearquivo}, input)} escreve todos
os r@'{o}tulos de entrada para o arquivo.

A forma especial @code{stringout (@var{nomearquivo}, functions)} escreve todas
as fun@value{cedilha}@~{o}es definidas pelo usu@'{a}rio (nomeadas pela lista global @code{functions}) para o arquivo.

A forma especial @code{stringout (@var{nomearquivo}, values)} escreve todas as
vari@'{a}veis atribu@'{i}das pelo usu@'{a}rio (nomeadas pela lista global @code{values})
para o arquivo.  Cada vari@'{a}vel @'{e} impressa como uma
declara@value{cedilha}@~{a}o de atribui@value{cedilha}@~{a}o, com o nome da vari@'{a}vel seguida de dois pontos, e seu
valor.  Note que a forma geral de @code{stringout} n@~{a}o imprime 
vari@'{a}veis como declara@value{cedilha}@~{o}es de atribui@value{cedilha}@~{a}o.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} tex (@var{expr})
@deffnx {Fun@value{cedilha}@~{a}o} tex (@var{r@'{o}tulo})
@deffnx {Fun@value{cedilha}@~{a}o} tex (@var{expr}, @var{momearquivo})
@deffnx {Fun@value{cedilha}@~{a}o} tex (@var{label}, @var{nomearquivo})

Imprime uma representa@value{cedilha}@~{a}o de uma express@~{a}o
adequada para o sistema TeX  de prepara@value{cedilha}@~{a}o de documento.
O resultado @'{e} um fragmento de um documento,
que pode ser copiado dentro de um documento maior
Esse fragmento n@~{a}o pode ser processado de forma direta e isolada.

@code{tex (@var{expr})} imprime uma representa@value{cedilha}@~{a}o TeX da @var{expr} no console.

@code{tex (@var{r@'{o}tulo})} imprime uma representa@value{cedilha}@~{a}o TeX de uma express@~{a}o chamada @var{r@'{o}tulo}
e atribui a essa um r@'{o}tulo de equa@value{cedilha}@~{a}o (a ser mostrado @`a esquerda da express@~{a}o).
O r@'{o}tulo de equa@value{cedilha}@~{a}o TeX @'{e} o mesmo que o r@'{o}tulo da equa@value{cedilha}@~{a}o no Maxima.

@code{tex (@var{expr}, @var{nomearquivo})} anexa ao final uma representa@value{cedilha}@~{a}o TeX de @var{expr}
no arquivo @var{nomearquivo}.

@code{tex (@var{r@'{o}tulo}, @var{nomearquivo})} anexa ao final uma representa@value{cedilha}@~{a}o TeX da
express@~{a}o chamada de @var{r@'{o}tulo}, com um r@'{o}tulo de equa@value{cedilha}@~{a}o, ao arquivo @var{nomearquivo}.

@code{tex} avalia seu primeiro argumento ap@'{o}s testar esse argumento para ver se @'{e} um r@'{o}tulo.
duplo ap@'{o}strofo @code{''} for@value{cedilha}a a avalia@value{cedilha}@~{a}o do argumento, desse modo frustrando o teste
e prevenindo o r@'{o}tulo.

Veja tamb@'{e}m @code{texput}.

Exemplos:

@example
(%i1) integrate (1/(1+x^3), x);
                                    2 x - 1
                  2            atan(-------)
             log(x  - x + 1)        sqrt(3)    log(x + 1)
(%o1)      - --------------- + ------------- + ----------
                    6             sqrt(3)          3
(%i2) tex (%o1);
$$-@{@{\log \left(x^2-x+1\right)@}\over@{6@}@}+@{@{\arctan \left(@{@{2\,x-1
 @}\over@{\sqrt@{3@}@}@}\right)@}\over@{\sqrt@{3@}@}@}+@{@{\log \left(x+1\right)
 @}\over@{3@}@}\leqno@{\tt (\%o1)@}$$
(%o2)                          (\%o1)
(%i3) tex (integrate (sin(x), x));
$$-\cos x$$
(%o3)                           false
(%i4) tex (%o1, "foo.tex");
(%o4)                          (\%o1)
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} texput (@var{a}, @var{s})
@deffnx {Fun@value{cedilha}@~{a}o} texput (@var{a}, @var{s}, @var{operator_type})
@deffnx {Fun@value{cedilha}@~{a}o} texput (@var{a}, [@var{s_1}, @var{s_2}], matchfix)
@deffnx {Fun@value{cedilha}@~{a}o} texput (@var{a}, [@var{s_1}, @var{s_2}, @var{s_3}], matchfix)

Atribui a sa@'{i}da TeX para o @'{a}tomo @var{a},
que pode ser um s@'{i}mbolo ou o nome de um operador.

@code{texput (@var{a}, @var{s})} faz com que a fun@value{cedilha}@~{a}o @code{tex}
interpole a seq@"{u}@^{e}ncia de caracteres @var{s} dentro da sa@'{i}da TeX em lugar de @var{a}.

@code{texput (@var{a}, @var{s}, @var{operator_type})},
onde @var{operator_type} @'{e} @code{prefix}, @code{infix}, @code{postfix}, @code{nary}, ou @code{nofix},
faz com que a fun@value{cedilha}@~{a}o @code{tex} interpole @var{s} dentro da sa@'{i}da TeX em lugar de @var{a},
e coloca o texto interpolado na posi@value{cedilha}@~{a}o apropriada.

@code{texput (@var{a}, [@var{s_1}, @var{s_2}], matchfix)}
faz com que a fun@value{cedilha}@~{a}o @code{tex} interpole @var{s_1} e @var{s_2} dentro da sa@'{i}da TeX
sobre qualquer lado dos argumentos de @var{a}.
Os argumentos (se mais de um) s@~{a}o separados por v@'{i}rgulas.

@code{texput (@var{a}, [@var{s_1}, @var{s_2}, @var{s_3}], matchfix)}
faz com que a fun@value{cedilha}@~{a}o @code{tex} interpole @var{s_1} e @var{s_2} dentro da sa@'{i}da TeX
sobre qualquer lado dos argumentos de @var{a},
com @var{s_3} separando os argumentos.

Exemplos:

Atribui sa@'{i}da TeX a uma vari@'{a}vel.
@c ===beg===
@c texput (me,"\\mu_e");
@c tex (me);
@c ===end===

@example
(%i1) texput (me,"\\mu_e");
(%o1)                         \mu_e
(%i2) tex (me);
$$\mu_e$$
(%o2)                         false
@end example

Atribui sa@'{i}da TeX a uma fun@value{cedilha}@~{a}o comum (n@~{a}o a um operador).
@c ===beg===
@c texput (lcm, "\\mathrm{lcm}");
@c tex (lcm (a, b));
@c ===end===

@example
(%i1) texput (lcm, "\\mathrm@{lcm@}");
(%o1)                     \mathrm@{lcm@}
(%i2) tex (lcm (a, b));
$$\mathrm@{lcm@}\left(a , b\right)$$
(%o2)                         false
@end example

Atribui sa@'{i}da TeX a um operador prefixado.
@c ===beg===
@c prefix ("grad");
@c texput ("grad", " \\nabla ", prefix);
@c tex (grad f);
@c ===end===

@example
(%i1) prefix ("grad");
(%o1)                         grad
(%i2) texput ("grad", " \\nabla ", prefix);
(%o2)                        \nabla 
(%i3) tex (grad f);
$$ \nabla f$$
(%o3)                         false
@end example

Atribui sa@'{i}da TeX a um operador infixado.
@c ===beg===
@c infix ("~");
@c texput ("~", " \\times ", infix);
@c tex (a ~ b);
@c ===end===

@example
(%i1) infix ("~");
(%o1)                           ~
(%i2) texput ("~", " \\times ", infix);
(%o2)                        \times 
(%i3) tex (a ~ b);
$$a \times b$$
(%o3)                         false
@end example

Atribui sa@'{i}da TeX a um operadro p@'{o}sfixado.
@c ===beg===
@c postfix ("##");
@c texput ("##", "!!", postfix);
@c tex (x ##);
@c ===end===

@example
(%i1) postfix ("##");
(%o1)                          ##
(%i2) texput ("##", "!!", postfix);
(%o2)                          !!
(%i3) tex (x ##);
$$x!!$$
(%o3)                         false
@end example

Atribui sa@'{i}da TeX a um operador n-@'{a}rio.
@c ===beg===
@c nary ("@@");
@c texput ("@@", " \\circ ", nary);
@c tex (a @@ b @@ c @@ d);
@c ===end===

@example
(%i1) nary ("@@@@");
(%o1)                          @@@@
(%i2) texput ("@@@@", " \\circ ", nary);
(%o2)                         \circ 
(%i3) tex (a @@@@ b @@@@ c @@@@ d);
$$a \circ b \circ c \circ d$$
(%o3)                         false
@end example

Atribui sa@'{i}da TeX a um operador nofix.
@c ===beg===
@c nofix ("foo");
@c texput ("foo", "\\mathsc{foo}", nofix);
@c tex (foo);
@c ===end===

@example
(%i1) nofix ("foo");
(%o1)                          foo
(%i2) texput ("foo", "\\mathsc@{foo@}", nofix);
(%o2)                     \mathsc@{foo@}
(%i3) tex (foo);
$$\mathsc@{foo@}$$
(%o3)                         false
@end example

Atribui sa@'{i}da TeX a um operadro matchfix.
@c ===beg===
@c matchfix ("<<", ">>");
@c texput ("<<", [" \\langle ", " \\rangle "], matchfix);
@c tex (<<a>>);
@c tex (<<a, b>>);
@c texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"], matchfix);
@c tex (<<a>>);
@c tex (<<a, b>>);
@c ===end===

@example
(%i1) matchfix ("<<", ">>");
(%o1)                          <<
(%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
(%o2)                [ \langle ,  \rangle ]
(%i3) tex (<<a>>);
$$ \langle a \rangle $$
(%o3)                         false
(%i4) tex (<<a, b>>);
$$ \langle a , b \rangle $$
(%o4)                         false
(%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"], matchfix);
(%o5)           [ \langle ,  \rangle ,  \, | \,]
(%i6) tex (<<a>>);
$$ \langle a \rangle $$
(%o6)                         false
(%i7) tex (<<a, b>>);
$$ \langle a \, | \,b \rangle $$
(%o7)                         false
@end example

@end deffn

@c NEEDS CLARIFICATION
@deffn {Fun@value{cedilha}@~{a}o} system (@var{comando})
Executa @var{comando} como um processo separado.
O comando @'{e} passado ao shell padra@~{o} para execu@value{cedilha}@~{a}o.
@code{system} n@~{a}o @'{e} suportado por todos os sistemas
operacionais, mas geralmente existe em ambientes Unix e Unix-like.

Supondo que @code{_hist.out}
@'{e} uma lista de freq@"{u}@^{e}ncia que voc@^{e} deseja imprimir como um gr@'{a}fico em barras
usando @code{xgraph}.  

@example
(%i1) (with_stdout("_hist.out",
           for i:1 thru length(hist) do (
             print(i,hist[i]))),
       system("xgraph -bar -brw .7 -nl < _hist.out"));
@end example

Com o objetivo de fazer com que a impress@~{a}o do gr@'{a}fico seja conclu@'{i}da em segundo plano (retornando o controle para o Maxima)
e remover o arquivo tempor@'{a}rio ap@'{o}s isso ter sido conclu@'{i}do fa@value{cedilha}a:

@example
system("(xgraph -bar -brw .7 -nl < _hist.out;  rm -f _hist.out)&")
@end example

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} ttyoff
Valor padr@~{a}o: @code{false}

Quando @code{ttyoff} @'{e} @code{true}, express@~{o}es de sa@'{i}da n@~{a}o s@~{a}o mostradas.
Express@~{o}es de sa@'{i}da s@~{a}o ainda calculadas e atribu@'{i}das r@'{o}tulos.  Veja @code{labels}.

Textos impresso por fun@value{cedilha}@~{o}es internas do Maxima, tais como mensagens de erro e a sa@'{i}da de @code{describe},
n@~{a}o s@~{a}o afetadas por @code{ttyoff}.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} with_stdout (@var{nomearquivo}, @var{expr_1}, @var{expr_2}, @var{expr_3}, ...)
Abre @var{nomearquivo} e ent@~{a}o avalia @var{expr_1}, @var{expr_2}, @var{expr_3}, ....
Os valores dos argumentos n@~{a}o s@~{a}o armazenados em @var{nomearquivo},
mas qualquer sa@'{i}da impressa gerada pela avalia@value{cedilha}@~{a}o dos argumentos
(de @code{print}, @code{display}, @code{disp}, ou @code{grind}, por exemplo)
vai para @var{nomearquivo} em lugar do console.

O sinalizador global @code{file_output_append} governa
se @code{with_stdout} anexa ao final ou trunca o arquivo de sa@'{i}da.
Quando @code{file_output_append} for @code{true},
@code{with_stdout} anexa ao final do arquivo de sa@'{i}da.
De outra forma, @code{with_stdout} trunca o arquivo de sa@'{i}da.
Nesse caso, @code{with_stdout} cria o arquivo se ele n@~{a}o existir ainda.

@code{with_stdout} retorna o valor do seu argumento final.

Veja tamb@'{e}m @code{writefile}.

@c THIS DOESN'T SEEM VERY IMPORTANT TO MENTION ...
@c Note the binding of display2d to be
@c false, otherwise the printing will have things like "- 3" instead
@c of "-3".
@c
@example
@c THIS EXAMPLE USES SOME UNIX-ISH CONSTRUCTS -- WILL IT WORK IN WINDOWS ???
@c ALSO IT'S SORT OF COMPLICATED AND THE SIMPLER SECOND EXAMPLE ILLUSTRATES with_stdout BETTER !!!
@c mygnuplot (f, var, range, number_ticks) :=
@c  block ([numer:true, display2d:false],
@c  with_stdout("tmp.out",
@c    dx: (range[2]-range[1])/number_ticks,
@c    for x: range[1] thru range[2] step dx
@c       do print (x, at (f, var=x))),
@c  system ("echo \"set data style lines; set title '", f,"' ;plot '/tmp/gnu'
@c ;pause 10 \" | gnuplot"))$
(%i1) with_stdout ("tmp.out", for i:5 thru 10 do print (i, "! yields", i!))$
(%i2) printfile ("tmp.out")$
5 ! yields 120 
6 ! yields 720 
7 ! yields 5040 
8 ! yields 40320 
9 ! yields 362880 
10 ! yields 3628800
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} writefile (@var{nomearquivo})
Come@value{cedilha}a escrevendo uma transcri@value{cedilha}@~{a}o da sess@~{a}o Maxima para @var{nomearquivo}.
Toda intera@value{cedilha}@~{a}o entre o usu@'{a}rio e Maxima @'{e} ent@~{a}o gravada nesse arquivo,
@c FOLLOWING CLAIM PROBABLY NEEDS TO BE QUALIFIED
da mesma forma que aparece no console.

Como a transcri@value{cedilha}@~{a}o @'{e} impressa no formato de sa@'{i}da do console,
isso n@~{a}o pode ser reaproveitado pelo Maxima.
Para fazer um arquivo contendo express@~{o}es que podem ser reaproveitadas,
veja @code{save} e @code{stringout}.
@code{save} armazena express@~{o}es no formato Lisp, enquanto @code{stringout} armazena express@~{o}es no formato Maxima.

O efeito de executar @code{writefile} quando @var{nomearquivo} ainda existe
depende da implementa@value{cedilha}@~{a}o Lisp subjacente;
o arquivo transcrito pode ser substitu@'{i}do, ou o arquivo pode receber um anexo.
@code{appendfile} sempre anexa para o arquivo transcrito.

Isso pode ser conveniente para executar @code{playback} ap@'{o}s
@code{writefile} para salvar a visualiza@value{cedilha}@~{a}o de intera@value{cedilha}@~{o}es pr@'{e}vias.
Como @code{playback} mostra somente as vari@'{a}veis de entrada e sa@'{i}da (@code{%i1}, @code{%o1}, etc.),
qualquer sa@'{i}da gerada por uma declara@value{cedilha}@~{a}o de impress@~{a}o em uma fun@value{cedilha}@~{a}o
(como oposi@value{cedilha}@~{a}o a um valor de retorno) n@~{a}o @'{e} mostrada por @code{playback}.

@code{closefile} fecha o arquivo transcrito aberto por @code{writefile} ou @code{appendfile}.

@end deffn
