@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /Contexts.texi/1.13/Sat Jun  2 00:12:34 2007/-ko/
@c end concepts Contexts
@menu
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Contextos::    
@end menu

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Contextos,  , Contextos, Contextos
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Contextos

@deffn {Fun@value{cedilha}@~{a}o} activate (@var{context_1}, ..., @var{context_n})
Ativa os contextos @var{context_1}, ..., @var{context_n}.
Os fatos nesses contextos est@~{a}o ent@~{a}o dispon@'{i}veis para
fazer dedu@value{cedilha}@~{o}es e recuperar informa@value{cedilha}@~{a}o.
Os fatos nesses contextos n@~{a}o s@~{a}o listadas atrav@'{e}s de @code{facts ()}.

A vari@'{a}vel @code{activecontexts} @'{e} a lista
de contextos que est@~{a}o ativos pelo caminho da fun@value{cedilha}@~{a}o @code{activate}.

@end deffn

@defvr {Vari@'{a}vel de sistema} activecontexts
Valor padr@~{a}o: @code{[]}

@code{activecontexts} @'{e} a lista de contextos que est@~{a}o ativos
pelo caminho da fun@value{cedilha}@~{a}o @code{activate}, em oposi@value{cedilha}@~{a}o a sendo ativo porque
eles s@~{a}o subcontextos do contexto corrente.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} assume (@var{pred_1}, ..., @var{pred_n})
Adiciona predicados @var{pred_1}, ..., @var{pred_n} ao contexto corrente.
Se um predicado for incossistente ou redundante 
com os predicados no contexto corrente,
esses predicados n@~{a}o s@~{a}o adicionados ao contexto.
O contexto acumula predicados de cada chamada a @code{assume}.

@code{assume} retorna uma lista cujos elementos s@~{a}o os predicados adicionados ao contexto
ou os @'{a}tomos @code{redundant} ou @code{inconsistent} onde for aplic@'{a}vel.

Os predicados @var{pred_1}, ..., @var{pred_n} podem somente ser express@~{o}es
com os operadores relacionais @code{< <= equal notequal >=} e @code{>}.
Predicados n@~{a}o podem ser express@~{o}es de igualdades literais @code{=} ou express@~{o}es de desigualdades literais @code{#},
nem podem elas serem fun@value{cedilha}@~{o}es de predicado tais como @code{integerp}.

Predicados combinados da forma @code{@var{pred_1} and ... and @var{pred_n}}
s@~{a}o reconhecidos,
mas n@~{a}o @code{@var{pred_1} or ... or @var{pred_n}}.
@code{not @var{pred_k}} @'{e} reconhecidos se @var{pred_k} for um predicado relacional.
Express@~{o}es da forma @code{not (@var{pred_1} e @var{pred_2})}
and @code{not (@var{pred_1} or @var{pred_2})}
n@~{a}o s@~{a}o reconhecidas.

O mecanismo de dedu@value{cedilha}@~{a}o do Maxima n@~{a}o @'{e} muito forte;
exitem conseq@"{u}@^{e}ncias muito @'{o}bvias as quais n@~{a}o podem ser determinadas por meio de @code{is}.
Isso @'{e} uma fraqueza conhecida.

@code{assume} avalia seus argumentos.

Veja tamb@'{e}m @code{is}, @code{facts}, @code{forget}, @code{context}, e @code{declare}.

Exemplos:

@c ===beg===
@c assume (xx > 0, yy < -1, zz >= 0);
@c assume (aa < bb and bb < cc);
@c facts ();
@c is (xx > yy);
@c is (yy < -yy);
@c is (sinh (bb - aa) > 0);
@c forget (bb > aa);
@c prederror : false;
@c is (sinh (bb - aa) > 0);
@c is (bb^2 < cc^2);
@c ===end===

@example
(%i1) assume (xx > 0, yy < -1, zz >= 0);
(%o1)              [xx > 0, yy < - 1, zz >= 0]
(%i2) assume (aa < bb and bb < cc);
(%o2)                  [bb > aa, cc > bb]
(%i3) facts ();
(%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
(%i4) is (xx > yy);
(%o4)                         true
(%i5) is (yy < -yy);
(%o5)                         true
(%i6) is (sinh (bb - aa) > 0);
(%o6)                         true
(%i7) forget (bb > aa);
(%o7)                       [bb > aa]
(%i8) prederror : false;
(%o8)                         false
(%i9) is (sinh (bb - aa) > 0);
(%o9)                        unknown
(%i10) is (bb^2 < cc^2);
(%o10)                       unknown
@end example

@end deffn

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

@code{assumescalar} ajuda a governar se express@~{o}es @code{expr}
para as quais @code{nonscalarp (expr)} for @code{false}
s@~{a}o assumidas comportar-se como escalares
para certas transforma@value{cedilha}@~{o}es.

Tomemos @code{expr} representando qualquer express@~{a}o outra que n@~{a}o uma lista ou uma matriz,
e tomemos @code{[1, 2, 3]} representando qualquer lista ou matriz.
Ent@~{a}o @code{expr . [1, 2, 3]} retorna @code{[expr, 2 expr, 3 expr]}
se @code{assumescalar} for @code{true}, ou @code{scalarp (expr)} for
@code{true}, ou @code{constantp (expr)} for @code{true}.

Se @code{assumescalar} for @code{true}, tais
express@~{o}es ir@~{a}o comportar-se como escalares somente para operadores
comutativos, mas n@~{a}o para multiplica@value{cedilha}@~{a}o n@~{a}o comutativa @code{.}.

Quando @code{assumescalar} for @code{false}, tais
express@~{o}es ir@~{a}o comportar-se como n@~{a}o escalares.

Quando @code{assumescalar} for @code{all},
tais express@~{o}es ir@~{a}o comportar-se como escalares para todos os operadores listados
acima.

@end defvr


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

Quando @code{assume_pos} for @code{true}
e o sinal de um par@^{a}metro @var{x} n@~{a}o pode ser determinado a partir do contexto corrente
ou outras considera@value{cedilha}@~{o}es,
@code{sign} e @code{asksign (@var{x})} retornam @code{true}.
Isso pode impedir algum questionamento de @code{asksign} gerado automaticamente,
tal como pode surgir de @code{integrate} ou de outros c@'{a}lculos.

Por padr@~{a}o, um par@^{a}metro @'{e} @var{x} tal como @code{symbolp (@var{x})}
or @code{subvarp (@var{x})}.
A classe de express@~{o}es consideradas par@^{a}metros pode ser modificada para alguma abrang@^{e}ncia
atrav@'{e}s da vari@'{a}vel @code{assume_pos_pred}.

@code{sign} e @code{asksign} tentam deduzir o sinal de express@~{o}es
a partir de sinais de operandos dentro da express@~{a}o.
Por exemplo, se @code{a} e @code{b} s@~{a}o ambos positivos,
ent@~{a}o @code{a + b} @'{e} tamb@'{e}m positivo.

Todavia, n@~{a}o existe caminho para desviar todos os questionamentos de @code{asksign}.
Particularmente, quando o argumento de @code{asksign} for uma
diferen@value{cedilha}a @code{@var{x} - @var{y}} ou um logar@'{i}tmo @code{log(@var{x})},
@code{asksign} sempre solicita uma entrada ao usu@'{a}rio,
mesmo quando @code{assume_pos} for @code{true} e @code{assume_pos_pred} for
uma fun@value{cedilha}@~{a}o que retorna @code{true} para todos os argumentos.

@c NEED EXAMPLES HERE
@end defvr


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

Quando @code{assume_pos_pred} for atribu@'{i}do o nome de uma fun@value{cedilha}@~{a}o
ou uma express@~{a}o lambda de um argumento @var{x},
aquela fun@value{cedilha}@~{a}o @'{e} chamada para determinar
se @var{x} @'{e} considerado um par@^{a}metro para o prop@'{o}sito de @code{assume_pos}.
@code{assume_pos_pred} @'{e} ignorado quando @code{assume_pos} for @code{false}.

A fun@value{cedilha}@~{a}o @code{assume_pos_pred} @'{e} chamada atrav@'{e}s de @code{sign} e de @code{asksign}
com um argumento @var{x}
que @'{e} ou um @'{a}tomo, uma vari@'{a}vel subscrita, ou uma express@~{a}o de chamada de fun@value{cedilha}@~{a}o.
Se a fun@value{cedilha}@~{a}o @code{assume_pos_pred} retorna @code{true},
@var{x} @'{e} considerado um par@^{a}metro para o prop@'{o}sito de @code{assume_pos}.

Por padr@~{a}o, um par@^{a}metro @'{e} @var{x} tal que @code{symbolp (x)}
ou @code{subvarp (x)}.

Veja tamb@'{e}m @code{assume} e @code{assume_pos}.

Exemplos:
@c EXAMPLE OUTPUT GENERATED FROM:
@c assume_pos: true$
@c assume_pos_pred: symbolp$
@c sign (a);
@c sign (a[1]);
@c assume_pos_pred: lambda ([x], display (x), true)$
@c asksign (a);
@c asksign (a[1]);
@c asksign (foo (a));
@c asksign (foo (a) + bar (b));
@c asksign (log (a));
@c asksign (a - b);

@example
(%i1) assume_pos: true$
(%i2) assume_pos_pred: symbolp$
(%i3) sign (a);
(%o3)                          pos
(%i4) sign (a[1]);
(%o4)                          pnz
(%i5) assume_pos_pred: lambda ([x], display (x), true)$
(%i6) asksign (a);
                              x = a

(%o6)                          pos
(%i7) asksign (a[1]);
                             x = a
                                  1

(%o7)                          pos
(%i8) asksign (foo (a));
                           x = foo(a)

(%o8)                          pos
(%i9) asksign (foo (a) + bar (b));
                           x = foo(a)

                           x = bar(b)

(%o9)                          pos
(%i10) asksign (log (a));
                              x = a

Is  a - 1  positive, negative, or zero?

p;
(%o10)                         pos
(%i11) asksign (a - b);
                              x = a

                              x = b

                              x = a

                              x = b

Is  b - a  positive, negative, or zero?

p;
(%o11)                         neg
@end example

@end defvr


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

@code{context} nomeia a cole@value{cedilha}@~{a}o de fatos mantida atrav@'{e}s de @code{assume} e @code{forget}.
@code{assume} adiciona fatos @`a cole@value{cedilha}@~{a}o nomeada atrav@'{e}s de @code{context},
enquanto @code{forget} remove fatos.

Associando @code{context} para um nome @var{foo} altera o contexto corrente para @var{foo}.
Se o contexto especificado @var{foo} n@~{a}o existe ainda,
ele @'{e} criado automaticamente atrav@'{e}s de uma chamada a @code{newcontext}.
@c ISN'T THIS NEXT BIT EQUIVALENT TO THE FIRST ??
O contexto especificado @'{e} ativado automaticamente.

Veja @code{contexts} para uma descri@value{cedilha}@~{a}o geral do mecanismo de contexto.

@end defvr

@c UMM, I'M HAVING TROUBLE GETTING THE CONTEXT-SWITCHING STUFF TO BEHAVE AS EXPECTED
@c SOME EXAMPLES WILL HELP A LOT HERE
@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} contexts
Valor padr@~{a}o: @code{[initial, global]}

@code{contexts} @'{e} uma lista dos contextos que
existem atualmente, incluindo o contexto ativo atualmente.

O mecanismo de contexto torna poss@'{i}vel para um usu@'{a}rio associar
e nomear uma por@value{cedilha}@~{a}o selecionada de fatos, chamada um contexto.
Assim que isso for conclu@'{i}do, o usu@'{a}rio pode ter o Maxima assumindo ou esquecendo grande quantidade
de fatos meramente atrav@'{e}s da ativa@value{cedilha}@~{a}o ou desativa@value{cedilha}@~{a}o seu contexto.

Qualquer @'{a}tomo simb@'{o}lico pode ser um contexto, e os fatos contidos naquele
contexto ir@~{a}o ser retidos em armazenamento at@'{e} que sejam destru@'{i}dos um por um
atrav@'{e}s de chamadas a @code{forget} ou destru@'{i}dos com um conjunto atrav@'{e}s de uma chamada a @code{kill}
para destruir o contexto que eles pertencem.

Contextos existem em uma hierarqu@'{i}a, com o ra@'{i}z sempre sendo
o contexto @code{global}, que cont@'{e}m informa@value{cedilha}@~{o}es sobre Maxima que alguma
fun@value{cedilha}@~{a}o precisa.  Quando em um contexto dado, todos os fatos naquele
contexto est@~{a}o "ativos" (significando que eles s@~{a}o usados em dedu@value{cedilha}@~{o}es e
recuperados) como est@~{a}o tamb@'{e}m todos os fatos em qualquer contexto que for um subcontexto
do contexto ativo.

Quando um novo Maxima for iniciado, o usu@'{a}rio est@'{a} em um
contexto chamado @code{initial}, que tem @code{global} como um subcontexto.

Veja tamb@'{e}m @code{facts}, @code{newcontext},
@code{supcontext}, @code{killcontext}, @code{activate}, @code{deactivate}, @code{assume}, e @code{forget}.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} deactivate (@var{context_1}, ..., @var{context_n})
Desativa os contextos especificados @var{context_1}, ..., @var{context_n}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} facts (@var{item})
@deffnx {Fun@value{cedilha}@~{a}o} facts ()
Se @var{item} for o nome de um contexto,
@code{facts (@var{item})} retorna uma lista
de fatos no contexto especificado.

Se @var{item} n@~{a}o for o nome de um contexto,
@code{facts (@var{item})} retorna uma lista de fatos conhecidos sobre @var{item} no contexto
atual.  Fatos que est@~{a}o atuvos, mas em um diferente contexto, n@~{a}o s@~{a}o listados.

@code{facts ()} (i.e., sem argumento) lista o contexto atual.

@end deffn

@defvr {Declara@value{cedilha}@~{a}o} features
Maxima recnhece ceertas propriedades matem@'{a}ticas de fun@value{cedilha}@~{o}es e vari@'{a}veis.
Essas s@~{a}o chamadas "recursos".

@code{declare (@var{x}, @var{foo})} fornece a propriedade @var{foo} para a fun@value{cedilha}@~{a}o ou vari@'{a}vel @var{x}.

@code{declare (@var{foo}, recurso)} declara um novo recurso @var{foo}.
Por exemplo,
@code{declare ([red, green, blue], feature)}
declara tr@^{e}s novos recursos, @code{red}, @code{green}, e @code{blue}.

O predicado @code{featurep (@var{x}, @var{foo})}
retorna @code{true} se @var{x} possui a propriedade @var{foo},
e @code{false} de outra forma.

A infolista @code{features} @'{e} uma lista de recursos conhecidos.
S@~{a}o esses
@code{integer}, @code{noninteger}, @code{even}, @code{odd}, @code{rational},
@code{irrational}, @code{real}, @code{imaginary}, @code{complex},
@code{analytic}, @code{increasing}, @code{decreasing}, @code{oddfun},
@code{evenfun}, @code{posfun}, @code{commutative}, @code{lassociative},
@code{rassociative}, @code{symmetric}, e @code{antisymmetric},
mais quaisquer recursos definidos pelo usu@'{a}rio.

@code{features} @'{e} uma lista de recursos matem@'{a}ticos.
Existe tamb@'{e}m uma lista de recursos n@~{a}o matem@'{a}ticos, recursos dependentes do sistema. Veja @code{status}.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} forget (@var{pred_1}, ..., @var{pred_n})
@deffnx {Fun@value{cedilha}@~{a}o} forget (@var{L})
Remove predicados estabelecidos atrav@'{e}s de @code{assume}.
Os predicados podem ser express@~{o}es equivalentes a (mas n@~{a}o necess@'{a}riamente id@^{e}nticas a)
esses prevamentes assumidos.

@code{forget (@var{L})}, onde @var{L} @'{e} uma lista de predicados,
esquece cada item da lista.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} killcontext (@var{context_1}, ..., @var{context_n})
Mata os contextos @var{context_1}, ..., @var{context_n}.

Se um dos contextos estiver for o contexto atual, o novo contexto
atual ir@'{a} tornar-se o primeiro subcontexto dispon@'{i}vel do contexto
atual que n@~{a}o tiver sido morto.  Se o primeiro contexto dispon@'{i}vel
n@~{a}o morto for @code{global} ent@~{a}o @code{initial} @'{e} usado em seu lugar.  Se o contexto
@code{initial} for morto, um novo, por@'{e}m vazio contexto @code{initial} @'{e} criado.

@code{killcontext} recusa-se a matar um contexto que estiver
ativo atualmente, ou porque ele @'{e} um subcontexto do contexto
atual, ou atrav@'{e}s do uso da fun@value{cedilha}@~{a}o @code{activate}.

@code{killcontext} avalia seus argumentos.
@code{killcontext} retorna @code{done}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} newcontext (@var{nome})
Cria um novo contexto, por@'{e}m vazio, chamado @var{nome}, que
tem @code{global} como seu @'{u}nico subcontexto.  O contexto recentemente criado
torna-se o contexto ativo atualmente.

@code{newcontext} avalia seu argumento.
@code{newcontext} retorna @var{nome}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} supcontext (@var{nome}, @var{context})
@deffnx {Fun@value{cedilha}@~{a}o} supcontext (@var{nome})
Cria um novo contexto, chamado @var{nome},
que tem @var{context} como um subcontexto.
@var{context} deve existir.

Se @var{context} n@~{a}o for especificado, o contexto atual @'{e} assumido.

@end deffn
