@c /Contexts.texi/1.12/Thu Feb  9 00:55:29 2006/-ko/
@c end concepts Contexts
@menu
* Definições para Contextos::    
@end menu

@node Definições para Contextos,  , Contextos, Contextos
@section Definições para Contextos

@deffn {Função} activate (@var{context_1}, ..., @var{context_n})
Ativa os contextos @var{context_1}, ..., @var{context_n}.
Os factos nesses contextos estão então disponíveis para
fazer deduções e recuperar informação.
Os factos nesses contextos não são listadas através de @code{facts ()}.

A variável @code{activecontexts} é a lista
de contextos que estão activos pelo caminho da função @code{activate}.

@end deffn

@defvr {Variável de sistema} activecontexts
Valor por omissão: @code{[]}

@code{activecontexts} é a lista de contextos que estão activos
pelo caminho da função @code{activate}, em oposição a sendo activo porque
eles são subcontextos do contexto corrente.

@end defvr

@deffn {Funçã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ão são adicionados ao contexto.
O contexto acumula predicados de cada chamada a @code{assume}.

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

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

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

O mecanismo de dedução do Maxima não é muito forte;
exitem consequências muito óbvias as quais não podem ser determinadas por meio de @code{is}.
Isso é uma fraqueza conhecida.

@code{assume} avalia seus argumentos.

Veja també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ável de opção} assumescalar
Valor por omissão: @code{true}

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

Tomemos @code{expr} representando qualquer expressão outra que não uma lista ou uma matriz,
e tomemos @code{[1, 2, 3]} representando qualquer lista ou matriz.
Entã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ões irão comportar-se como escalares somente para operadores
comutativos, mas não para multiplicação não comutativa @code{.}.

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

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

@end defvr


@defvr {Variável de opção} assume_pos
Valor por omissão: @code{false}

Quando @code{assume_pos} for @code{true}
e o sinal de um parâmetro @var{x} não pode ser determinado a partir do contexto corrente
ou outras consideraçõ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álculos.

Por padrão, um parâmetro é @var{x} tal como @code{symbolp (@var{x})}
or @code{subvarp (@var{x})}.
A classe de expressões consideradas parâmetros pode ser modificada para alguma abrangência
através da variável @code{assume_pos_pred}.

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

Todavia, não existe caminho para desviar todos os questionamentos de @code{asksign}.
Particularmente, quando o argumento de @code{asksign} for uma
diferença @code{@var{x} - @var{y}} ou um logaritmo @code{log(@var{x})},
@code{asksign} sempre solicita uma entrada ao utilizador,
mesmo quando @code{assume_pos} for @code{true} e @code{assume_pos_pred} for
uma função que retorna @code{true} para todos os argumentos.

@c NEED EXAMPLES HERE
@end defvr


@defvr {Variável de opção} assume_pos_pred
Valor por omissão: @code{false}

Quando @code{assume_pos_pred} for atribuído o nome de uma função
ou uma expressão lambda de um argumento @var{x},
aquela função é chamada para determinar
se @var{x} é considerado um parâmetro para o propósito de @code{assume_pos}.
@code{assume_pos_pred} é ignorado quando @code{assume_pos} for @code{false}.

A função @code{assume_pos_pred} é chamada através de @code{sign} e de @code{asksign}
com um argumento @var{x}
que é ou um átomo, uma variável subscrita, ou uma expressão de chamada de função.
Se a função @code{assume_pos_pred} retorna @code{true},
@var{x} é considerado um parâmetro para o propósito de @code{assume_pos}.

Por padrão, um parâmetro é @var{x} tal que @code{symbolp (x)} ou @code{subvarp (x)}.

Veja també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ável de opção} context
Valor por omissão: @code{initial}

@code{context} nomeia a colecção de factos mantida através de @code{assume} e @code{forget}.
@code{assume} adiciona factos à colecção nomeada através de @code{context},
enquanto @code{forget} remove factos.

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

Veja @code{contexts} para uma descriçã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ável de opção} contexts
Valor por omissão: @code{[initial, global]}

@code{contexts} é uma lista dos contextos que
existem actualmente, incluindo o contexto activo actualmente.

O mecanismo de contexto torna possível para um utilizador associar
e nomear uma porção seleccionada de factos, chamada um contexto.
Assim que isso for concluído, o utilizador pode ter o Maxima assumindo ou esquecendo grande quantidade
de factos meramente através da activação ou desativação seu contexto.

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

Contextos existem em uma hierarquía, com o raíz sempre sendo
o contexto @code{global}, que contém informações sobre Maxima que alguma
função precisa.  Quando em um contexto dado, todos os factos naquele
contexto estão "ativos" (significando que eles são usados em deduções e
recuperados) como estão também todos os factos em qualquer contexto que for um subcontexto
do contexto activo.

Quando um novo Maxima for iniciado, o utilizador está em um
contexto chamado @code{initial}, que tem @code{global} como um subcontexto.

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

@end defvr

@deffn {Função} deactivate (@var{context_1}, ..., @var{context_n})
Desativa os contextos especificados @var{context_1}, ..., @var{context_n}.

@end deffn

@deffn {Função} facts (@var{item})
@deffnx {Função} facts ()
Se @var{item} for o nome de um contexto,
@code{facts (@var{item})} retorna uma lista
de factos no contexto especificado.

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

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

@end deffn

@defvr {Declaração} features
Maxima recnhece ceertas propriedades matemáticas de funções e variáveis.
Essas são chamadas "recursos".

@code{declare (@var{x}, @var{foo})} fornece a propriedade @var{foo} para a função ou variável @var{x}.

@code{declare (@var{foo}, recurso)} declara um novo recurso @var{foo}.
Por exemplo,
@code{declare ([red, green, blue], feature)}
declara trê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} é uma lista de recursos conhecidos.
Sã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 utilizador.

@code{features} é uma lista de recursos matemáticos.
Existe também uma lista de recursos não matemáticos, recursos dependentes do sistema. Veja @code{status}.

@end defvr

@deffn {Função} forget (@var{pred_1}, ..., @var{pred_n})
@deffnx {Função} forget (@var{L})
Remove predicados estabelecidos através de @code{assume}.
Os predicados podem ser expressões equivalentes a (mas não necessáriamente idênticas a)
esses prevamentes assumidos.

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

@end deffn

@deffn {Funçã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 actual, o novo contexto
actual irá tornar-se o primeiro subcontexto disponível do contexto
actual que não tiver sido morto.  Se o primeiro contexto disponível
não morto for @code{global} então @code{initial} é usado em seu lugar.  Se o contexto
@code{initial} for morto, um novo, porém vazio contexto @code{initial} é criado.

@code{killcontext} recusa-se a matar um contexto que estiver
ativo actualmente, ou porque ele é um subcontexto do contexto
actual, ou através do uso da função @code{activate}.

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

@end deffn

@deffn {Função} newcontext (@var{nome})
Cria um novo contexto, porém vazio, chamado @var{nome}, que
tem @code{global} como seu único subcontexto.  O contexto recentemente criado
torna-se o contexto activo actualmente.

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

@end deffn

@deffn {Função} supcontext (@var{nome}, @var{context})
@deffnx {Funçã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ão for especificado, o contexto actual é assumido.

@end deffn

