doc/info/pt/Contexts.texi

   1 @c /Contexts.texi/1.12/Thu Feb  9 00:55:29 2006/-ko/
   2 @c end concepts Contexts
   3 @menu
   4 * Definições para Contextos::
   5 @end menu
   6
   7 @node Definições para Contextos,  , Contextos, Contextos
   8 @section Definições para Contextos
   9
  10 @deffn {Função} activate (@var{context_1}, ..., @var{context_n})
  11 Ativa os contextos @var{context_1}, ..., @var{context_n}.
  12 Os factos nesses contextos estão então disponíveis para
  13 fazer deduções e recuperar informação.
  14 Os factos nesses contextos não são listadas através de @code{facts ()}.
  15
  16 A variável @code{activecontexts} é a lista
  17 de contextos que estão activos pelo caminho da função @code{activate}.
  18
  19 @end deffn
  20
  21 @defvr {Variável de sistema} activecontexts
  22 Valor por omissão: @code{[]}
  23
  24 @code{activecontexts} é a lista de contextos que estão activos
  25 pelo caminho da função @code{activate}, em oposição a sendo activo porque
  26 eles são subcontextos do contexto corrente.
  27
  28 @end defvr
  29
  30 @deffn {Função} assume (@var{pred_1}, ..., @var{pred_n})
  31 Adiciona predicados @var{pred_1}, ..., @var{pred_n} ao contexto corrente.
  32 Se um predicado for incossistente ou redundante
  33 com os predicados no contexto corrente,
  34 esses predicados não são adicionados ao contexto.
  35 O contexto acumula predicados de cada chamada a @code{assume}.
  36
  37 @code{assume} retorna uma lista cujos elementos são os predicados adicionados ao contexto
  38 ou os átomos @code{redundant} ou @code{inconsistent} onde for aplicável.
  39
  40 Os predicados @var{pred_1}, ..., @var{pred_n} podem somente ser expressões
  41 com os operadores relacionais @code{< <= equal notequal >=} e @code{>}.
  42 Predicados não podem ser expressões de igualdades literais @code{=} ou expressões de desigualdades literais @code{#},
  43 nem podem elas serem funções de predicado tais como @code{integerp}.
  44
  45 Predicados combinados da forma @code{@var{pred_1} and ... and @var{pred_n}}
  46 são reconhecidos,
  47 mas não @code{@var{pred_1} or ... or @var{pred_n}}.
  48 @code{not @var{pred_k}} é reconhecidos se @var{pred_k} for um predicado relacional.
  49 Expressões da forma @code{not (@var{pred_1} e @var{pred_2})}
  50 and @code{not (@var{pred_1} or @var{pred_2})}
  51 não são reconhecidas.
  52
  53 O mecanismo de dedução do Maxima não é muito forte;
  54 exitem consequências muito óbvias as quais não podem ser determinadas por meio de @code{is}.
  55 Isso é uma fraqueza conhecida.
  56
  57 @code{assume} avalia seus argumentos.
  58
  59 Veja também @code{is}, @code{facts}, @code{forget}, @code{context}, e @code{declare}.
  60
  61 Exemplos:
  62
  63 @c ===beg===
  64 @c assume (xx > 0, yy < -1, zz >= 0);
  65 @c assume (aa < bb and bb < cc);
  66 @c facts ();
  67 @c is (xx > yy);
  68 @c is (yy < -yy);
  69 @c is (sinh (bb - aa) > 0);
  70 @c forget (bb > aa);
  71 @c prederror : false;
  72 @c is (sinh (bb - aa) > 0);
  73 @c is (bb^2 < cc^2);
  74 @c ===end===
  75
  76 @example
  77 (%i1) assume (xx > 0, yy < -1, zz >= 0);
  78 (%o1)              [xx > 0, yy < - 1, zz >= 0]
  79 (%i2) assume (aa < bb and bb < cc);
  80 (%o2)                  [bb > aa, cc > bb]
  81 (%i3) facts ();
  82 (%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
  83 (%i4) is (xx > yy);
  84 (%o4)                         true
  85 (%i5) is (yy < -yy);
  86 (%o5)                         true
  87 (%i6) is (sinh (bb - aa) > 0);
  88 (%o6)                         true
  89 (%i7) forget (bb > aa);
  90 (%o7)                       [bb > aa]
  91 (%i8) prederror : false;
  92 (%o8)                         false
  93 (%i9) is (sinh (bb - aa) > 0);
  94 (%o9)                        unknown
  95 (%i10) is (bb^2 < cc^2);
  96 (%o10)                       unknown
  97 @end example
  98
  99 @end deffn
 100
 101 @defvr {Variável de opção} assumescalar
 102 Valor por omissão: @code{true}
 103
 104 @code{assumescalar} ajuda a governar se expressões @code{expr}
 105 para as quais @code{nonscalarp (expr)} for @code{false}
 106 são assumidas comportar-se como escalares
 107 para certas transformações.
 108
 109 Tomemos @code{expr} representando qualquer expressão outra que não uma lista ou uma matriz,
 110 e tomemos @code{[1, 2, 3]} representando qualquer lista ou matriz.
 111 Então @code{expr . [1, 2, 3]} retorna @code{[expr, 2 expr, 3 expr]}
 112 se @code{assumescalar} for @code{true}, ou @code{scalarp (expr)} for
 113 @code{true}, ou @code{constantp (expr)} for @code{true}.
 114
 115 Se @code{assumescalar} for @code{true}, tais
 116 expressões irão comportar-se como escalares somente para operadores
 117 comutativos, mas não para multiplicação não comutativa @code{.}.
 118
 119 Quando @code{assumescalar} for @code{false}, tais
 120 expressões irão comportar-se como não escalares.
 121
 122 Quando @code{assumescalar} for @code{all},
 123 tais expressões irão comportar-se como escalares para todos os operadores listados
 124 acima.
 125
 126 @end defvr
 127
 128
 129 @defvr {Variável de opção} assume_pos
 130 Valor por omissão: @code{false}
 131
 132 Quando @code{assume_pos} for @code{true}
 133 e o sinal de um parâmetro @var{x} não pode ser determinado a partir do contexto corrente
 134 ou outras considerações,
 135 @code{sign} e @code{asksign (@var{x})} retornam @code{true}.
 136 Isso pode impedir algum questionamento de @code{asksign} gerado automaticamente,
 137 tal como pode surgir de @code{integrate} ou de outros cálculos.
 138
 139 Por padrão, um parâmetro é @var{x} tal como @code{symbolp (@var{x})}
 140 or @code{subvarp (@var{x})}.
 141 A classe de expressões consideradas parâmetros pode ser modificada para alguma abrangência
 142 através da variável @code{assume_pos_pred}.
 143
 144 @code{sign} e @code{asksign} tentam deduzir o sinal de expressões
 145 a partir de sinais de operandos dentro da expressão.
 146 Por exemplo, se @code{a} e @code{b} são ambos positivos,
 147 então @code{a + b} é também positivo.
 148
 149 Todavia, não existe caminho para desviar todos os questionamentos de @code{asksign}.
 150 Particularmente, quando o argumento de @code{asksign} for uma
 151 diferença @code{@var{x} - @var{y}} ou um logaritmo @code{log(@var{x})},
 152 @code{asksign} sempre solicita uma entrada ao utilizador,
 153 mesmo quando @code{assume_pos} for @code{true} e @code{assume_pos_pred} for
 154 uma função que retorna @code{true} para todos os argumentos.
 155
 156 @c NEED EXAMPLES HERE
 157 @end defvr
 158
 159
 160 @defvr {Variável de opção} assume_pos_pred
 161 Valor por omissão: @code{false}
 162
 163 Quando @code{assume_pos_pred} for atribuído o nome de uma função
 164 ou uma expressão lambda de um argumento @var{x},
 165 aquela função é chamada para determinar
 166 se @var{x} é considerado um parâmetro para o propósito de @code{assume_pos}.
 167 @code{assume_pos_pred} é ignorado quando @code{assume_pos} for @code{false}.
 168
 169 A função @code{assume_pos_pred} é chamada através de @code{sign} e de @code{asksign}
 170 com um argumento @var{x}
 171 que é ou um átomo, uma variável subscrita, ou uma expressão de chamada de função.
 172 Se a função @code{assume_pos_pred} retorna @code{true},
 173 @var{x} é considerado um parâmetro para o propósito de @code{assume_pos}.
 174
 175 Por padrão, um parâmetro é @var{x} tal que @code{symbolp (x)} ou @code{subvarp (x)}.
 176
 177 Veja também @code{assume} e @code{assume_pos}.
 178
 179 Exemplos:
 180 @c EXAMPLE OUTPUT GENERATED FROM:
 181 @c assume_pos: true$
 182 @c assume_pos_pred: symbolp$
 183 @c sign (a);
 184 @c sign (a[1]);
 185 @c assume_pos_pred: lambda ([x], display (x), true)$
 186 @c asksign (a);
 187 @c asksign (a[1]);
 188 @c asksign (foo (a));
 189 @c asksign (foo (a) + bar (b));
 190 @c asksign (log (a));
 191 @c asksign (a - b);
 192
 193 @example
 194 (%i1) assume_pos: true$
 195 (%i2) assume_pos_pred: symbolp$
 196 (%i3) sign (a);
 197 (%o3)                          pos
 198 (%i4) sign (a[1]);
 199 (%o4)                          pnz
 200 (%i5) assume_pos_pred: lambda ([x], display (x), true)$
 201 (%i6) asksign (a);
 202                               x = a
 203
 204 (%o6)                          pos
 205 (%i7) asksign (a[1]);
 206                              x = a
 207                                   1
 208
 209 (%o7)                          pos
 210 (%i8) asksign (foo (a));
 211                            x = foo(a)
 212
 213 (%o8)                          pos
 214 (%i9) asksign (foo (a) + bar (b));
 215                            x = foo(a)
 216
 217                            x = bar(b)
 218
 219 (%o9)                          pos
 220 (%i10) asksign (log (a));
 221                               x = a
 222
 223 Is  a - 1  positive, negative, or zero?
 224
 225 p;
 226 (%o10)                         pos
 227 (%i11) asksign (a - b);
 228                               x = a
 229
 230                               x = b
 231
 232                               x = a
 233
 234                               x = b
 235
 236 Is  b - a  positive, negative, or zero?
 237
 238 p;
 239 (%o11)                         neg
 240 @end example
 241
 242 @end defvr
 243
 244
 245 @defvr {Variável de opção} context
 246 Valor por omissão: @code{initial}
 247
 248 @code{context} nomeia a colecção de factos mantida através de @code{assume} e @code{forget}.
 249 @code{assume} adiciona factos à colecção nomeada através de @code{context},
 250 enquanto @code{forget} remove factos.
 251
 252 Associando @code{context} para um nome @var{foo} altera o contexto corrente para @var{foo}.
 253 Se o contexto especificado @var{foo} não existe ainda,
 254 ele é criado automaticamente através de uma chamada a @code{newcontext}.
 255 @c ISN'T THIS NEXT BIT EQUIVALENT TO THE FIRST ??
 256 O contexto especificado é activado automaticamente.
 257
 258 Veja @code{contexts} para uma descrição geral do mecanismo de contexto.
 259
 260 @end defvr
 261
 262 @c UMM, I'M HAVING TROUBLE GETTING THE CONTEXT-SWITCHING STUFF TO BEHAVE AS EXPECTED
 263 @c SOME EXAMPLES WILL HELP A LOT HERE
 264 @defvr {Variável de opção} contexts
 265 Valor por omissão: @code{[initial, global]}
 266
 267 @code{contexts} é uma lista dos contextos que
 268 existem actualmente, incluindo o contexto activo actualmente.
 269
 270 O mecanismo de contexto torna possível para um utilizador associar
 271 e nomear uma porção seleccionada de factos, chamada um contexto.
 272 Assim que isso for concluído, o utilizador pode ter o Maxima assumindo ou esquecendo grande quantidade
 273 de factos meramente através da activação ou desativação seu contexto.
 274
 275 Qualquer átomo simbólico pode ser um contexto, e os factos contidos naquele
 276 contexto irão ser retidos em armazenamento até que sejam destruídos um por um
 277 através de chamadas a @code{forget} ou destruídos com um conjunto através de uma chamada a @code{kill}
 278 para destruir o contexto que eles pertencem.
 279
 280 Contextos existem em uma hierarquía, com o raíz sempre sendo
 281 o contexto @code{global}, que contém informações sobre Maxima que alguma
 282 função precisa.  Quando em um contexto dado, todos os factos naquele
 283 contexto estão "ativos" (significando que eles são usados em deduções e
 284 recuperados) como estão também todos os factos em qualquer contexto que for um subcontexto
 285 do contexto activo.
 286
 287 Quando um novo Maxima for iniciado, o utilizador está em um
 288 contexto chamado @code{initial}, que tem @code{global} como um subcontexto.
 289
 290 Veja também @code{facts}, @code{newcontext},
 291 @code{supcontext}, @code{killcontext}, @code{activate}, @code{deactivate}, @code{assume}, e @code{forget}.
 292
 293 @end defvr
 294
 295 @deffn {Função} deactivate (@var{context_1}, ..., @var{context_n})
 296 Desativa os contextos especificados @var{context_1}, ..., @var{context_n}.
 297
 298 @end deffn
 299
 300 @deffn {Função} facts (@var{item})
 301 @deffnx {Função} facts ()
 302 Se @var{item} for o nome de um contexto,
 303 @code{facts (@var{item})} retorna uma lista
 304 de factos no contexto especificado.
 305
 306 Se @var{item} não for o nome de um contexto,
 307 @code{facts (@var{item})} retorna uma lista de factos conhecidos sobre @var{item} no contexto
 308 actual.  Fatos que estão atuvos, mas em um diferente contexto, não são listados.
 309
 310 @code{facts ()} (i.e., sem argumento) lista o contexto actual.
 311
 312 @end deffn
 313
 314 @defvr {Declaração} features
 315 Maxima recnhece ceertas propriedades matemáticas de funções e variáveis.
 316 Essas são chamadas "recursos".
 317
 318 @code{declare (@var{x}, @var{foo})} fornece a propriedade @var{foo} para a função ou variável @var{x}.
 319
 320 @code{declare (@var{foo}, recurso)} declara um novo recurso @var{foo}.
 321 Por exemplo,
 322 @code{declare ([red, green, blue], feature)}
 323 declara três novos recursos, @code{red}, @code{green}, e @code{blue}.
 324
 325 O predicado @code{featurep (@var{x}, @var{foo})}
 326 retorna @code{true} se @var{x} possui a propriedade @var{foo},
 327 e @code{false} de outra forma.
 328
 329 A infolista @code{features} é uma lista de recursos conhecidos.
 330 São esses
 331 @code{integer}, @code{noninteger}, @code{even}, @code{odd}, @code{rational},
 332 @code{irrational}, @code{real}, @code{imaginary}, @code{complex},
 333 @code{analytic}, @code{increasing}, @code{decreasing}, @code{oddfun},
 334 @code{evenfun}, @code{posfun}, @code{commutative}, @code{lassociative},
 335 @code{rassociative}, @code{symmetric}, e @code{antisymmetric},
 336 mais quaisquer recursos definidos pelo utilizador.
 337
 338 @code{features} é uma lista de recursos matemáticos.
 339 Existe também uma lista de recursos não matemáticos, recursos dependentes do sistema. Veja @code{status}.
 340
 341 @end defvr
 342
 343 @deffn {Função} forget (@var{pred_1}, ..., @var{pred_n})
 344 @deffnx {Função} forget (@var{L})
 345 Remove predicados estabelecidos através de @code{assume}.
 346 Os predicados podem ser expressões equivalentes a (mas não necessáriamente idênticas a)
 347 esses prevamentes assumidos.
 348
 349 @code{forget (@var{L})}, onde @var{L} é uma lista de predicados,
 350 esquece cada item da lista.
 351
 352 @end deffn
 353
 354 @deffn {Função} killcontext (@var{context_1}, ..., @var{context_n})
 355 Mata os contextos @var{context_1}, ..., @var{context_n}.
 356
 357 Se um dos contextos estiver for o contexto actual, o novo contexto
 358 actual irá tornar-se o primeiro subcontexto disponível do contexto
 359 actual que não tiver sido morto.  Se o primeiro contexto disponível
 360 não morto for @code{global} então @code{initial} é usado em seu lugar.  Se o contexto
 361 @code{initial} for morto, um novo, porém vazio contexto @code{initial} é criado.
 362
 363 @code{killcontext} recusa-se a matar um contexto que estiver
 364 ativo actualmente, ou porque ele é um subcontexto do contexto
 365 actual, ou através do uso da função @code{activate}.
 366
 367 @code{killcontext} avalia seus argumentos.
 368 @code{killcontext} retorna @code{done}.
 369
 370 @end deffn
 371
 372 @deffn {Função} newcontext (@var{nome})
 373 Cria um novo contexto, porém vazio, chamado @var{nome}, que
 374 tem @code{global} como seu único subcontexto.  O contexto recentemente criado
 375 torna-se o contexto activo actualmente.
 376
 377 @code{newcontext} avalia seu argumento.
 378 @code{newcontext} retorna @var{nome}.
 379
 380 @end deffn
 381
 382 @deffn {Função} supcontext (@var{nome}, @var{context})
 383 @deffnx {Função} supcontext (@var{nome})
 384 Cria um novo contexto, chamado @var{nome},
 385 que tem @var{context} como um subcontexto.
 386 @var{context} deve existir.
 387
 388 Se @var{context} não for especificado, o contexto actual é assumido.
 389
 390 @end deffn
 391