| blob | e846e63536ea82ac4e13f2ea6f8a7a1dbc2dc336 |
1 @c
2 @c versao pt_BR baseada no md5sum abaixo:
3 @c 7c21c62201e67b87f01e60715413bfaf Database.texi
4 @c
5 @menu
6 * Introduction to Maximas Database::
7 * Functions and Variables for Properties::
8 * Functions and Variables for Facts::
9 * Functions and Variables for Predicates::
10 @end menu
12 @c -----------------------------------------------------------------------------
13 @node Introduction to Maximas Database, Functions and Variables for Properties, Maximas Database, Maximas Database
14 @section Introduction to Maximas Database
15 @c -----------------------------------------------------------------------------
17 @c -----------------------------------------------------------------------------
18 @node Functions and Variables for Properties, Functions and Variables for Facts, Introduction to Maximas Database, Maximas Database
19 @section Functions and Variables for Properties
20 @c -----------------------------------------------------------------------------
22 @c -----------------------------------------------------------------------------
23 @anchor{alphabetic}
24 @defvr {Propriedade} alphabetic
26 A propriedade @code{alphabetic} @'{e} um tipo de propriedade reconhecido por @mrefdot{declare}@w{}
27 A express@~{a}o @code{declare(@var{s}, alphabetic)} diz ao Maxima para reconhecer
28 como alfab@'{e}ticos tos os caracteres em @var{s}, que deve ser uma sequ@^{e}ncia de caracteres.
30 Veja tamb@'{e}m @ref{Identifiers}.
32 Exemplo:
34 @c ===beg===
35 @c xx\~yy\`\@ : 1729;
36 @c declare ("~`@", alphabetic);
37 @c xx~yy`@ + @yy`xx + `xx@@yy~;
38 @c listofvars (%);
39 @c ===end===
40 @example
41 (%i1) xx\~yy\`\@@ : 1729;
42 (%o1) 1729
43 (%i2) declare ("~`@@", alphabetic);
44 (%o2) done
45 (%i3) xx~yy`@@ + @@yy`xx + `xx@@@@yy~;
46 (%o3) `xx@@@@yy~ + @@yy`xx + 1729
47 (%i4) listofvars (%);
48 (%o4) [@@yy`xx, `xx@@@@yy~]
49 @end example
51 @opencatbox
52 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
53 @closecatbox
54 @end defvr
56 @c -----------------------------------------------------------------------------
57 @anchor{bindtest}
58 @defvr {Propriedade} bindtest
60 O comando @code{declare(@var{x}, bindtest)} dis ao Maxima para disparar um erro
61 quando o s@'{i}mbolo @var{x} for avaliado como n@~{a}o associado.
63 @c ===beg===
64 @c aa + bb;
65 @c declare (aa, bindtest);
66 @c aa + bb;
67 @c aa : 1234;
68 @c aa + bb;
69 @c ===end===
70 @example
71 (%i1) aa + bb;
72 (%o1) bb + aa
73 (%i2) declare (aa, bindtest);
74 (%o2) done
75 (%i3) aa + bb;
76 aa unbound variable
77 -- an error. Quitting. To debug this try debugmode(true);
78 (%i4) aa : 1234;
79 (%o4) 1234
80 (%i5) aa + bb;
81 (%o5) bb + 1234
82 @end example
83 @end defvr
85 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
86 @c CROSS REF declare, properties, ETC
88 @c -----------------------------------------------------------------------------
89 @anchor{constant}
90 @deffn {Propriedade} constant
92 O comando @code{declare(@var{a}, constant)} declara que @var{a} seja reconhecido como uma constante. A
93 declara@,{c}@~{a}o de um s@'{i}mbolo para que esse s@'{i}mbolo seja uma constante n@~{a}o impede a atribui@,{c}@~{a}o de um
94 valor n@~{a}o constante para o s@'{i}mbolo.
96 Veja @mref{constantp} e @mrefdot{declare}
97 @c WHAT EXACTLY ARE THE CONSEQUENCES OF DECLARING AN ATOM TO BE CONSTANT ??
99 Exemplo:
101 @example
102 (%i1) declare(c, constant);
103 (%o1) done
104 (%i2) constantp(c);
105 (%o2) true
106 (%i3) c : x;
107 (%o3) x
108 (%i4) constantp(c);
109 (%o4) false
110 @end example
112 @opencatbox
113 @category{Declara@,{c}@~{o}es e infer@^{e}ncias} @category{Constantes}
114 @closecatbox
115 @end deffn
117 @c -----------------------------------------------------------------------------
118 @anchor{constantp}
119 @deffn {Fun@,{c}@~{a}o} constantp (@var{expr})
121 Retorna @code{true} se @var{expr} for uma express@~{a}o constante, de outra forma retorna
122 @code{false}.
123 @c WHAT DOES MAXIMA KNOW ABOUT CONSTANT EXPRESSIONS ??
125 Uma express@~{a}o @'{e} considerada uma express@~{a}o constante se seus argumentos forem
126 n@'{u}meros (incluindo n@'{u}meros racionais, como mostrado com @code{/R/}),
127 constantes simb@'{o}licas tais como @mrefcomma{%pi} @mrefcomma{%e} e @mrefcomma{%i}@w{}
128 vari@'{a}veis associadas a uma constante ou declaradamente constante por meio de @mrefcomma{declare}@w{}
129 ou fun@,{c}@~{o}es cujos argumentos forem constantes.
131 A fun@,{c}@~{a}o @code{constantp} avalia seus argumentos.
133 Veja a propriedade @mref{constant} que declara um s@'{i}mbolo como sendo constante.
135 Exemplos:
137 @c ===beg===
138 @c constantp (7 * sin(2));
139 @c constantp (rat (17/29));
140 @c constantp (%pi * sin(%e));
141 @c constantp (exp (x));
142 @c declare (x, constant);
143 @c constantp (exp (x));
144 @c constantp (foo (x) + bar (%e) + baz (2));
145 @c ===end===
146 @example
147 (%i1) constantp (7 * sin(2));
148 (%o1) true
149 (%i2) constantp (rat (17/29));
150 (%o2) true
151 (%i3) constantp (%pi * sin(%e));
152 (%o3) true
153 (%i4) constantp (exp (x));
154 (%o4) false
155 (%i5) declare (x, constant);
156 (%o5) done
157 (%i6) constantp (exp (x));
158 (%o6) true
159 (%i7) constantp (foo (x) + bar (%e) + baz (2));
160 (%o7) false
161 (%i8)
162 @end example
164 @opencatbox
165 @category{Fun@,{c}@~{o}es predicado} @category{Constantes}
166 @closecatbox
167 @end deffn
169 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
170 @c THIS ITEM IS EXTREMELY IMPORTANT
171 @c ENSURE THAT ALL KEYWORDS RECOGNIZED BY declare HAVE THEIR OWN DOCUMENTATION ITEMS !!
172 @c ALSO: HOW TO FIND THE LIST OF ALL SYMBOLS WHICH HAVE A GIVEN PROPERTY ??
174 @c -----------------------------------------------------------------------------
175 @anchor{declare}
176 @deffn {Fun@,{c}@~{a}o} declare (@var{a_1}, @var{p_1}, @var{a_2}, @var{p_2}, @dots{})
178 Atribui ao @'{a}tomo ou @`{a} lista de @'{a}tomos @var{a_i} a propriedade ou lista de propriedades
179 @var{p_i}. Quando @var{a_i} e/ou @var{p_i} forem listas, cada um dos @'{a}tomos recebe
180 todas as propiedades.
182 A fun@,{c}@~{a}o @code{declare} n@~{a}o avalia seus argumentos. A fun@,{c}@~{a}o @code{declare} sempre retorna @code{done}.
184 Como notado na descri@,{c}@~{a}o para cada sinalizador de declara@,{c}@~{a}o, para alguns sinalizadores
185 @code{featurep(@var{objeto}, @var{caracter@'{i}stica})} retorna @code{true} se @var{objeto}
186 tiver sido declarado como tendo @var{caracter@'{i}stica}.
188 Para mais informa@,{c}@~{a}o sobre as caracter@'{i}sticas do sistema, veja @mrefdot{features} Para
189 remover uma propriedade de um @'{a}tomo, use @mrefdot{remove}
191 A fun@,{c}@~{a}o @code{declare} reconhece as seguintes propriedades:
193 @table @code
194 @item additive
195 Diz ao Maxima para simplificar express@~{o}es @var{a_i} atrav@'{e}s da substitui@,{c}@~{a}o
196 @code{@var{a_i}(x + y + z + ...)} @code{-->}
197 @code{@var{a_i}(x) + @var{a_i}(y) + @var{a_i}(z) + ...}.
198 A substitui@,{c}@~{a}o @'{e} realizada somente sobre o primeiro argumento.
200 @item alphabetic
201 Diz ao Maxima para reconhecer todos os caracteres em @var{a_i} (que deve ser uma
202 sequ@^{e}ncia de caracteres) como caracteres alfab@'{e}ticos.
204 @item antisymmetric, commutative, symmetric
205 Diz ao Maxima para reconhecer @var{a_i} como uma fun@,{c}@~{a}o sim@'{e}trica ou
206 antissim@'{e}trica. Ter a propriedade @mref{commutative} @'{e} o mesmo que
207 ter a propriedade @code{symmetric}.
209 @item bindtest
210 Diz ao Maxima para disparar um erro quando @var{a_i} for avaliado como
211 sendo n@~{a}o associado.
213 @item constant
214 Diz ao Maxima para considerar @var{a_i} uma constante simb@'{o}lica.
215 @c WHAT MAXIMA KNOWS ABOUT SYMBOLIC CONSTANTS IS PRETTY LIMITED
216 @c DUNNO IF WE WANT TO GET INTO DETAILS HERE.
217 @c MAYBE IN THE DOCUMENTATION FOR CONSTANT (IF THERE IS SUCH)
219 @item even, odd
220 Diz ao Maxima para reconhecer @var{a_i} como uma vari@'{a}vel inteira par ou inteira @'{i}mpar.
222 @item evenfun, oddfun
223 Diz ao Maxima para reconhecer @var{a_i} como uma fun@,{c}@~{a}o @'{i}mpar ou uma fun@,{c}@~{a}o par.
225 @item evflag
226 Torna @var{a_i} conhecido para a fun@,{c}@~{a}o @code{ev} de forma que @var{a_i} seja associado a
227 @code{true} durante a execu@,{c}@~{a}o de @code{ev} quando @var{a_i} aparecer como
228 um argumento sinalizador de @code{ev}. Veja @mrefdot{evflag}
230 @item evfun
231 Torna @var{a_i} conhecido de @code{ev} de forma que a fun@,{c}@~{a}o chamada por @var{a_i}
232 seja aplicada quando @var{a_i} aparecer como um argumento sinalizador de @code{ev}.
233 Veja @mrefdot{evfun}
235 @item feature
236 Diz ao Maxima para reconhecer @var{a_i} como o nome de uma caracter@'{i}stica.
237 Outros @'{a}tomos podem ser declarados terem a propriedade @var{a_i}.
239 @item increasing, decreasing
240 Diz ao Maxima para reconhecer @var{a_i} como uma fun@,{c}@~{a}o crescente
241 ou como uma fun@,{c}@~{a}o crescente.
242 @c MAXIMA FAILS TO DEDUCE F(2) > F(1) FOR INCREASING FUNCTION F
243 @c AND FAILS TO DEDUCE ANYTHING AT ALL ABOUT DECREASING FUNCTIONS
244 @c REPORTED AS SF BUG # 1483194
246 @item integer, noninteger
247 Diz ao Maxima para reconhecer @var{a_i} como uma vari@'{a}vel inteira ou uma vari@'{a}vel n@~{a}o inteira.
249 @item integervalued
250 Diz ao Maxima para reconhecer @var{a_i} cumo uma fun@,{c}@~{a}o cujo valor de retorno @'{e} um inteiro.
252 @item lassociative, rassociative
253 Diz ao Maxima para reconhecer @var{a_i} como uma fun@,{c}@~{a}o associativa @`{a} direita ou
254 uma fun@,{c}@~{a}o associativa @`{a} esquerda.
256 @item linear
257 Equivale a declarar @var{a_i} simult@^{a}neamente @code{outative} e
258 @code{additive}.
260 @item mainvar
261 Diz ao Maxima para considerar @var{a_i} uma "vari@'{a}vel principal". Uma vari@'{a}vel principal
262 prevalesce sobre todas as outras vari@'{a}veis e constantes na ordena@,{c}@~{a}o can@^{o}nica de
263 express@~{o}es do Maxima, como determinado por @code{ordergreatp}.
265 @item multiplicative
266 Diz ao Maxima para simplificar as express@~{o}es @var{a_i} atrav@'{e}s da substitui@,{c}@~{a}o
267 @code{@var{a_i}(x * y * z * ...)} @code{-->}
268 @code{@var{a_i}(x) * @var{a_i}(y) * @var{a_i}(z) * ...}.
269 A substitui@,{c}@~{a}o @'{e} realizada sobre o primeiro argumento somente.
271 @item nary
272 Diz ao Maxima para reconhecer @var{a_i} como uma fun@,{c}@~{a}o de n argumentos.
274 A declara@,{c}@~{a}o @code{nary} n@~{a}o @'{e} o mesmo que a fun@,{c}@~{a}o
275 @code{nary}. O @'{u}nico efeito de @code{declare(qualquercoisa, nary)} @'{e} instruir o
276 simplificador do Maxima a melhorar express@~{a}o aninhadas, por exemplo, para simplificar
277 @code{foo(x, foo(y, z))} para @code{foo(x, y, z)}.
279 @item nonarray
280 Diz ao Maxima para considerar @var{a_i} um n@~{a}o vetor est@'{a}tico. Essa declara@,{c}@~{a}o
281 evita m@'{u}ltiplas avalia@,{c}@~{a}oes de um nome de vari@'{a}vel subscrita.
283 @item nonscalar
284 Diz ao Maxima para considerar @var{a_i} uma vari@'{a}vel n@~{a}o escalar. O uso comum
285 @'{e} declarar uma vari@'{a}vel como um vetor simbĺico ou uma matriz.
287 @item noun
288 Diz ao Maxima para analizar @var{a_i} como substantivo. O efeito disso @'{e}
289 substituir inst@^{a}ncias de @var{a_i} com @code{'@var{a_i}} ou
290 @code{nounify(@var{a_i})}, dependendo do contexto.
292 @item outative
293 Diz ao Maxima para simplificar express@~{o}es @var{a_i} puxando fatores constantes
294 para fora do primeiro argumento.
296 Quando @var{a_i} tem um argumento, um fator @'{e} considerado constante se for
297 um literal ou constante explicitamente declarado.
299 Quando @var{a_i} tem dois ou mais argumentos, um fator @'{e} considerado contante
300 se o segundo argumentofor um s@'{i}mbolo e o fator for independente do segundo
301 argumento.
303 @item posfun
304 Diz ao Maxima para reconhecer @var{a_i} como uma fun@,{c}@~{a}o positiva.
306 @item rational, irrational
307 Diz ao Maxima para reconhecer @var{a_i} como uma vari@'{a}vel real racional ou
308 irracional.
310 @item real, imaginary, complex
311 Diz ao Maxima para reconhecer @var{a_i} como uma vari@'{a}vel real, imagin@'{a}ria pura, ou
312 complexa.
314 @item scalar
315 Diz ao Maxima para considerar @var{a_i} uma vari@'{a}vel escalar.
317 @c OBSOLETE @code{special} (RECOGNIZED BY DECLARE BUT NEVER USED ANYWHERE)
318 @c OBSOLETE @code{analytic} (RECOGNIZED BY DECLARE BUT NEVER USED ANYWHERE)
319 @end table
321 Exemplos de usodas propriedades est@~{a}o dispon@'{i}veis nadocumenta@,{c}@~{a}o
322 de cada descri@,{c}@~{a}o separada de uma propriedade.
324 @opencatbox
325 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
326 @closecatbox
327 @end deffn
329 @c -----------------------------------------------------------------------------
330 @anchor{decreasing}
331 @anchor{increasing}
332 @defvr {Propriedade} decreasing
333 @defvrx {Propriedade} increasing
335 Os comandos @code{declare(@var{f}, decreasing)} ou
336 @code{declare(@var{f}, increasing)} dizem ao Maxima para reconhecer a fun@,{c}@~{a}o
337 @var{f} como uma fun@,{c}@~{a}o decrescente ou uma fun@,{c}@~{a}o crescente.
339 Veja tamb@'{e}m @mref{declare} para mais propriedades.
341 Exemplo:
343 @example
344 (%i1) assume(a > b);
345 (%o1) [a > b]
346 (%i2) is(f(a) > f(b));
347 (%o2) unknown
348 (%i3) declare(f, increasing);
349 (%o3) done
350 (%i4) is(f(a) > f(b));
351 (%o4) true
352 @end example
354 @opencatbox
355 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
356 @closecatbox
357 @end defvr
359 @c -----------------------------------------------------------------------------
360 @anchor{even}
361 @anchor{odd}
362 @defvr {Propriedade} even
363 @defvrx {Propriedade} odd
365 Os comandos @code{declare(@var{a}, even)} ou @code{declare(@var{a}, odd)} dizem ao Maxima para
366 reconhecer o s@'{i}mbolo @var{a} como uma vari@'{a}vel inteira par ou uma vari@'{a}vel inteira @'{i}mpar. As
367 propriedades @code{even} e @code{odd} n@~{a}o s@~{a}o reconhecidas pelas fun@,{c}@~{o}es
368 @mrefcomma{evenp} @mrefcomma{oddp} e @mrefdot{integerp}
370 Veja tamb@'{e}m @mref{declare} e @mrefdot{askinteger}
372 Exemplo:
374 @example
375 (%i1) declare(n, even);
376 (%o1) done
377 (%i2) askinteger(n, even);
378 (%o2) yes
379 (%i3) askinteger(n);
380 (%o3) yes
381 (%i4) evenp(n);
382 (%o4) false
383 @end example
385 @opencatbox
386 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
387 @closecatbox
388 @end defvr
390 @c NEEDS EXPANSION AND CLARIFICATION
392 @c -----------------------------------------------------------------------------
393 @anchor{feature}
394 @defvr {Propriedade} feature
396 Maxima entende dois distintos tipos de caracter@'{i}sticas, caracter@'{i}sticas de sistema e caracter@'{i}sticas
397 aplicados a express@~{o}es matem@'{a}ticas. Veja tamb@'{e}m @mref{status} para informa@,{c}@~{a}o
398 sobre caracter@'{i}sticas de sistema. Veja tamb@'{e}m @mref{features} e @mref{featurep} para
399 informa@,{c}@~{a}o sobre caracter@'{i}sticas matem@'{a}ticas.
400 @c PROPERTIES, DECLARATIONS FALL UNDER THIS HEADING AS WELL
401 @c OTHER STUFF ??
403 O nome @code{feature} propriamente dito n@~{a}o @'{e} o nome de uma fun@,{c}@~{a}o ou de uma vari@'{a}vel.
404 @end defvr
406 @c NEEDS CLARIFICATION, ESPECIALLY WRT THE EXTENT OF THE FEATURE SYSTEM
407 @c (I.E. WHAT KINDS OF THINGS ARE FEATURES ACCORDING TO featurep)
409 @c -----------------------------------------------------------------------------
410 @anchor{featurep}
411 @deffn {Fun@,{c}@~{a}o} featurep (@var{a}, @var{f})
413 Tenta determinar se o objeto @var{a} tem a caracter@'{i}stica @var{f} na
414 base de fatos na base de dados atual. Se tiver, a fun@,{c}@~{a}o featurep retorna @code{true},
415 em caso contr@'{a}rio retorna @code{false}.
417 Note que @code{featurep} retorna @code{false} quando nem @var{f}
418 nem a nega@,{c}@~{a}o de @var{f} puder ser estabelecida.
420 A fun@,{c}@~{a}o @code{featurep} avalia seus argumentos.
422 Veja tamb@'{e}m @mref{declare} e @mrefdot{features}
424 @example
425 (%i1) declare (j, even)$
426 (%i2) featurep (j, integer);
427 (%o2) true
428 @end example
430 @opencatbox
431 @category{Fun@,{c}@~{o}es predicado} @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
432 @closecatbox
433 @end deffn
435 @c -----------------------------------------------------------------------------
436 @anchor{features}
437 @defvr {Declara@,{c}@~{a}o} features
439 Maxima reconhece certas propriedades matem@'{a}ticas de vari@'{a}veis e fun@,{c}@~{o}es.
440 S@~{a}o aqui chamadas "features" @footnote{Nota do tradutor: caracter@'{i}stica.}.
442 O comando @code{declare (@var{x}, @var{qualquercoisa})} fornece a propriedade @var{qualquercoisa}
443 @`{a} fun@,{c}@~{a}o ou vari@'{a}vel @var{x}.
445 O comando @code{declare (@var{qualquercoisa}, feature)} declara uma nova caracter@'{i}stica @var{qualquercoisa}.
446 Por exemplo,
447 @code{declare ([vermelho, verde, azul], feature)}
448 declara tr@^{e}s novas caracter@'{i}sticas, @code{vemelho}, @code{verde}, e @code{azul}.
450 O predicado @code{featurep (@var{x}, @var{qualquercoisa})}
451 retorna @code{true} se @var{x} tiver a propriedade @var{qualquercoisa},
452 e @code{false} de outra forma.
454 A infolista @code{features} @'{e} uma lista das caracter@'{i}sticas conhecidas. S@~{a}o elas
456 @verbatim
457 integer noninteger even
458 odd rational irrational
459 real imaginary complex
460 analytic increasing decreasing
461 oddfun evenfun posfun
462 constant commutative lassociative
463 rassociative symmetric antisymmetric
464 integervalued
465 @end verbatim
467 al@'{e}m de quaisquer outras caracter@'{i}sticas definidas pelo usu@'{a}rio.
469 A infolista @code{features} @'{e} uma lista de caracter@'{i}sticas matem@'{a}ticas. Existe tamb@'{e}m uma lista de
470 caracter@'{i}sticas n@~{a}o-matem@'{a}ticas e dependentes do sistema operacional no qual o Maxima est@'{a} instalado. Veja @mrefdot{status}
472 Exemplo:
474 @c ===beg===
475 @c declare (QUALQUERCOISA, feature);
476 @c declare (x, QUALQUERCOISA);
477 @c featurep (x, QUALQUERCOISA);
478 @c ===end===
479 @example
480 (%i1) declare (QUALQUERCOISA, feature);
481 (%o1) done
482 (%i2) declare (x, QUALQUERCOISA);
483 (%o2) done
484 (%i3) featurep (x, QUALQUERCOISA);
485 (%o3) true
486 @end example
488 @opencatbox
489 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
490 @closecatbox
491 @end defvr
493 @c -----------------------------------------------------------------------------
494 @anchor{get}
495 @deffn {Fun@,{c}@~{a}o} get (@var{a}, @var{i})
497 Recupera a propriedade de usu@'{a}rio indicada atrav@'{e}s de @var{i} associada ao
498 @'{a}tomo @var{a} ou retorna @code{false} se @var{a} n@~{a}o tiver a propriedade @var{i}.
500 A fun@,{c}@~{a}o @code{get} avalia seus argumentos.
502 Veja tamb@'{e}m @mref{put} e @mrefdot{qput}
504 @c ===beg===
505 @c put (%e, 'transcendental, 'type);
506 @c put (%pi, 'transcendental, 'type)$
507 @c put (%i, 'algebraic, 'type)$
508 @c typeof (expr) := block ([q],
509 @c if numberp (expr)
510 @c then return ('algebraic),
511 @c if not atom (expr)
512 @c then return (maplist ('typeof, expr)),
513 @c q: get (expr, 'type),
514 @c if q=false
515 @c then errcatch (error(expr,"is not numeric.")) else q)$
516 @c typeof (2*%e + x*%pi);
517 @c typeof (2*%e + %pi);
518 @c ===end===
519 @example
520 (%i1) put (%e, 'transcendental, 'type);
521 (%o1) transcendental
522 (%i2) put (%pi, 'transcendental, 'type)$
523 (%i3) put (%i, 'algebraic, 'type)$
524 (%i4) typeof (expr) := block ([q],
525 if numberp (expr)
526 then return ('algebraic),
527 if not atom (expr)
528 then return (maplist ('typeof, expr)),
529 q: get (expr, 'type),
530 if q=false
531 then errcatch (error(expr,"is not numeric.")) else q)$
532 (%i5) typeof (2*%e + x*%pi);
533 x is not numeric.
534 (%o5) [[transcendental, []], [algebraic, transcendental]]
535 (%i6) typeof (2*%e + %pi);
536 (%o6) [transcendental, [algebraic, transcendental]]
537 @end example
539 @opencatbox
540 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
541 @closecatbox
542 @end deffn
544 @c -----------------------------------------------------------------------------
545 @anchor{integer}
546 @anchor{noninteger}
547 @defvr {Propriedade} integer
548 @defvrx {Propriedade} noninteger
550 O comando @code{declare(@var{a}, integer)} ou o comando @code{declare(@var{a}, noninteger)} diz
551 Maxima para reconhecer @var{a} como uma vari@'{a}vel inteira ou n@~{a}o inteira.
553 Veja tamb@'{e}m @mrefdot{declare}
555 Exemplo:
557 @example
558 (%i1) declare(n, integer, x, noninteger);
559 (%o1) done
560 (%i2) askinteger(n);
561 (%o2) yes
562 (%i3) askinteger(x);
563 (%o3) no
564 @end example
566 @opencatbox
567 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
568 @closecatbox
569 @end defvr
571 @c -----------------------------------------------------------------------------
572 @anchor{integervalued}
573 @defvr {Propriedade} integervalued
575 @code{declare(@var{f}, integervalued)} diz ao Maxima para reconhecer @var{f} como uma
576 fun@,{c}@~{a}o que retorna um n@'{u}mero inteiro.
578 Veja tamb@'{e}m @mrefdot{declare}
580 Exemplo:
582 @example
583 (%i1) exp(%i)^f(x);
584 %i f(x)
585 (%o1) (%e )
586 (%i2) declare(f, integervalued);
587 (%o2) done
588 (%i3) exp(%i)^f(x);
589 %i f(x)
590 (%o3) %e
591 @end example
593 @opencatbox
594 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
595 @closecatbox
596 @end defvr
598 @c -----------------------------------------------------------------------------
599 @anchor{nonarray}
600 @deffn {Propriedade} nonarray
602 O comando @code{declare(a, nonarray)} diz ao Maxima para considerar @var{a} n@~{a}o
603 um vetor est@'{a}tico. Essa declara@,{c}@~{a}o evita avalia@,{c}@~{o}es m@'{u}ltiplas, se @var{a} for uma
604 vari@'{a}vel de subscrito.
606 Veja tamb@'{e}m @mrefdot{declare}
608 Exemplo:
610 @c ===beg===
611 @c a:'b$ b:'c$ c:'d$
612 @c a[x];
613 @c declare(a, nonarray);
614 @c a[x];
615 @c ===end===
616 @example
617 (%i1) a:'b$ b:'c$ c:'d$
619 (%i4) a[x];
620 (%o4) d
621 x
622 (%i5) declare(a, nonarray);
623 (%o5) done
624 (%i6) a[x];
625 (%o6) a
626 x
627 @end example
629 @opencatbox
630 @category{Express@~{o}es}
631 @closecatbox
632 @end deffn
634 @c NEEDS CLARIFICATION AND EXAMPLES
636 @c -----------------------------------------------------------------------------
637 @anchor{nonscalar}
638 @defvr {Propriedade} nonscalar
640 Faz com que @'{a}tomos comportem-se como se faz com uma lista ou uma matriz com rela@,{c}@~{a}o ao operador ponto.
642 Veja tamb@'{e}m @mrefdot{declare}
644 @opencatbox
645 @category{Declara@,{c}@~{o}es e infer@^{e}ncias} @category{Vectors} @category{Matrices}
646 @closecatbox
647 @end defvr
649 @c -----------------------------------------------------------------------------
650 @anchor{nonscalarp}
651 @deffn {Fun@,{c}@~{a}o} nonscalarp (@var{expr})
653 Retorna @code{true} se @var{expr} for um n@~{a}o escalar, i.e., se contiver
654 @'{a}tomos declarados como n@~{a}o escalares, listas, ou matrizes.
656 Veja tamb@'{e}m a fun@,{c}@~{a}o de predicado @mref{scalarp} e @mrefdot{declare}
658 @opencatbox
659 @category{Fun@,{c}@~{o}es predicado} @category{Vectors} @category{Matrices}
660 @closecatbox
661 @end deffn
663 @c NEEDS EXAMPLES
665 @c -----------------------------------------------------------------------------
666 @anchor{posfun}
667 @defvr {Propriedade} posfun
669 O comando @code{declare (f, posfun)} declara que @code{f} seja uma fun@,{c}@~{a}o positiva.
670 O comando @code{is (f(x) > 0)} retorna @code{true}.
672 Veja tamb@'{e}m @mrefdot{declare}
674 @opencatbox
675 @category{Declara@,{c}@~{o}es e infer@^{e}ncias} @category{Operadores}
676 @closecatbox
677 @end defvr
679 @c NEEDS WORK ESPECIALLY EXAMPLES
680 @c WHOLE BUSINESS WITH PROPERTIES IS PRETTY CONFUSING, TRY TO CLEAR IT UP
682 @c -----------------------------------------------------------------------------
683 @anchor{printprops}
684 @deffn {Fun@,{c}@~{a}o} printprops (@var{a}, @var{i})
685 @deffnx {Fun@,{c}@~{a}o} printprops ([@var{a_1}, @dots{}, @var{a_n}], @var{i})
686 @deffnx {Fun@,{c}@~{a}o} printprops (all, @var{i})
688 Mostra a propriedade com o indicador @var{i} associado ao @'{a}tomo
689 @var{a}. A entidade @var{a} pode tamb@'{e}m ser uma lista de @'{a}tomos ou o @'{a}tomo @code{all} onde
690 todos os @'{a}tomos com a dada propriedade ir@~{a}o ser usados. Por exemplo,
691 @code{printprops ([f, g], atvalue)}. A fun@,{c}@~{a}o @code{printprops} @'{e} para ser usada em propriedades que
692 n@~{a}o puderem ser mostradas de outra forma, i.e. para @mrefcomma{atvalue}@w{}
693 @mrefcomma{atomgrad} @mrefcomma{gradef} e @mrefdot{matchdeclare}
695 @opencatbox
696 @category{Declara@,{c}@~{o}es e infer@^{e}ncias} @category{Fun@,{c}@~{o}es de exibi@,{c}@~{a}o}
697 @closecatbox
698 @end deffn
700 @c CROSS REF TO WHICH FUNCTION OR FUNCTIONS ESTABLISH PROPERTIES !! (VERY IMPORTANT)
701 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
703 @c -----------------------------------------------------------------------------
704 @anchor{properties}
705 @deffn {Fun@,{c}@~{a}o} properties (@var{a})
707 Retorna uma lista de nomes de todas as propriedades associadas ao @'{a}tomo
708 @var{a}.
710 @opencatbox
711 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
712 @closecatbox
713 @end deffn
715 @c CROSS REF TO WHICH FUNCTION OR FUNCTIONS ESTABLISH PROPERTIES !! (VERY IMPORTANT)
716 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
717 @c WHAT IS HIDDEN IN THE "etc" HERE ??
719 @c -----------------------------------------------------------------------------
720 @anchor{props}
721 @defvr {Vari@'{a}vel de sistema} props
722 Valor padr@~{a}o: @code{[]}
724 Os @code{props} s@~{a}o @'{a}tomos que possuem qualquer propriedade outra que n@~{a}o aquelas explicitamente
725 mencionadas em @mrefcomma{infolists} tais como as especificadas atrav@'{e}s de @mrefcomma{atvalue}@w{}
726 @mrefcomma{matchdeclare} etc., bem como propriedades especificadas na
727 fun@,{c}@~{a}o @mref{declare}.
729 @opencatbox
730 @category{Declara@,{c}@~{o}es e infer@^{e}ncias} @category{Vari@'{a}veis globais}
731 @closecatbox
732 @end defvr
734 @c CROSS REF TO WHICH FUNCTION OR FUNCTIONS ESTABLISH PROPERTIES !! (VERY IMPORTANT)
735 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
737 @c -----------------------------------------------------------------------------
738 @anchor{propvars}
739 @deffn {Fun@,{c}@~{a}o} propvars (@var{prop})
741 Retorna uma lista daqueles @'{a}tomos na lista @mref{props} que
742 possuem a propriedade indicada por @var{prop}. Dessa forma @code{propvars (atvalue)}
743 retorna uma lista de @'{a}tomos que possuem atvalues.
745 @opencatbox
746 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
747 @closecatbox
748 @end deffn
750 @c CROSS REF TO OTHER FUNCTIONS WHICH PUT/GET PROPERTIES !! (VERY IMPORTANT)
751 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
752 @c ARE PROPERTIES ESTABLISHED BY put THE SAME AS PROPERTIES ESTABLISHED BY declare OR OTHER FUNCTIONS ??
753 @c IS put (foo, true, integer) EQUIVALENT TO declare (foo, integer) FOR EXAMPLE ??
755 @c -----------------------------------------------------------------------------
756 @anchor{put}
757 @deffn {Fun@,{c}@~{a}o} put (@var{atom}, @var{valor}, @var{indicador})
759 Atribui @var{valor} @`{a} propriedade (especificada por @var{indicador}) de
760 @var{atom}. O @var{indicador} pode ser o nome de qualquer propriedade, n@~{a}o apenas uma
761 propriedade definida pelo sistema.
763 A fun@,{c}@~{a}o @mref{rem} reverte o efeito de @code{put}.
765 A fun@,{c}@~{a}o @code{put} avalia seus argumentos.
766 A fun@,{c}@~{a}o @code{put} retorna @var{valor}.
768 Veja tamb@'{e}m @mref{qput} e @mrefdot{get}
770 Exemplos:
772 @example
773 (%i1) put (foo, (a+b)^5, expr);
774 5
775 (%o1) (b + a)
776 (%i2) put (foo, "Hello", str);
777 (%o2) Hello
778 (%i3) properties (foo);
779 (%o3) [[user properties, str, expr]]
780 (%i4) get (foo, expr);
781 5
782 (%o4) (b + a)
783 (%i5) get (foo, str);
784 (%o5) Hello
785 @end example
787 @opencatbox
788 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
789 @closecatbox
790 @end deffn
792 @c -----------------------------------------------------------------------------
793 @anchor{qput}
794 @deffn {Fun@,{c}@~{a}o} qput (@var{atom}, @var{valor}, @var{indicador})
796 Atribui @var{valor} @`{a} propriedade (especificada por @var{indicador}) de
797 @var{atom}. @'{E} o mesmo que @mrefcomma{put} exceto que os argumentos recebem
798 um ap@'{o}strofo inicial (n@~{a}o s@~{a}o avaliados).
800 Veja tamb@'{e}m @mrefdot{get}
802 Exemplo:
804 @example
805 (%i1) foo: aa$
806 (%i2) bar: bb$
807 (%i3) baz: cc$
808 (%i4) put (foo, bar, baz);
809 (%o4) bb
810 (%i5) properties (aa);
811 (%o5) [[user properties, cc]]
812 (%i6) get (aa, cc);
813 (%o6) bb
814 (%i7) qput (foo, bar, baz);
815 (%o7) bar
816 (%i8) properties (foo);
817 (%o8) [value, [user properties, baz]]
818 (%i9) get ('foo, 'baz);
819 (%o9) bar
820 @end example
822 @opencatbox
823 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
824 @closecatbox
825 @end deffn
827 @c -----------------------------------------------------------------------------
828 @anchor{rational}
829 @anchor{irrational}
830 @defvr {Propriedade} rational
831 @defvrx {Propriedade} irrational
833 O comando @code{declare(@var{a}, rational)} ou o comando @code{declare(@var{a}, irrational)} diz ao
834 Maxima para reconhecer @var{a} como uma vari@'{a}vel real racional ou irracional.
836 Veja tamb@'{e}m @mrefdot{declare}
838 @opencatbox
839 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
840 @closecatbox
841 @end defvr
843 @c -----------------------------------------------------------------------------
844 @anchor{real}
845 @anchor{imaginary}
846 @anchor{complex}
847 @defvr {Propriedade} real
848 @defvrx {Propriedade} imaginary
849 @defvrx {Propriedade} complex
851 Os comandos @code{declare(@var{a}, real)}, @code{declare(@var{a}, imaginary)}, ou
852 @code{declare(@var{a}, complex)} dizem ao Maxima para reconhecer @var{a} como uma vari@'{a}vel real,
853 uma vari@'{a}vel imagin@'{a}ria pura, ou uma vari@'{a}vel complexa.
855 Veja tamb@'{e}m @mrefdot{declare}
857 @opencatbox
858 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
859 @closecatbox
860 @end defvr
862 @c CROSS REF TO OTHER FUNCTIONS WHICH PUT/GET PROPERTIES !! (VERY IMPORTANT)
863 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
864 @c HOW DOES THIS INTERACT WITH declare OR OTHER PROPERTY-ESTABLISHING FUNCTIONS ??
865 @c HOW IS THIS DIFFERENT FROM remove ??
867 @c -----------------------------------------------------------------------------
868 @anchor{rem}
869 @deffn {Fun@,{c}@~{a}o} rem (@var{atom}, @var{indicador})
871 Remove a propriedade indicada por @var{indicador} de @var{atom}.
872 A fun@,{c}@~{a}o @code{rem} reverte o efeito de @mrefdot{put}
874 A fun@,{c}@~{a}o @code{rem} retorna @code{done} se @var{atom} tiver a propriedade @var{indicador}
875 quando @code{rem} for chamada, ou @code{false} se o @var{atom} n@~{a}o tiver tal propriedade.
877 @opencatbox
878 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
879 @closecatbox
880 @end deffn
882 @c CROSS REF TO OTHER FUNCTIONS WHICH PUT/GET PROPERTIES !! (VERY IMPORTANT)
883 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
884 @c HOW DOES THIS INTERACT WITH declare OR OTHER PROPERTY-ESTABLISHING FUNCTIONS ??
885 @c HOW IS THIS DIFFERENT FROM rem ??
887 @c -----------------------------------------------------------------------------
888 @anchor{remove}
889 @deffn {Fun@,{c}@~{a}o} remove (@var{a_1}, @var{p_1}, @dots{}, @var{a_n}, @var{p_n})
890 @deffnx {Fun@,{c}@~{a}o} remove ([@var{a_1}, @dots{}, @var{a_m}], [@var{p_1}, @dots{}, @var{p_n}], @dots{})
891 @deffnx {Fun@,{c}@~{a}o} remove ("@var{a}", operator)
892 @deffnx {Fun@,{c}@~{a}o} remove (@var{a}, transfun)
893 @deffnx {Fun@,{c}@~{a}o} remove (all, @var{p})
895 Remove propriedades associadas a @'{a}tomos.
897 O comando @code{remove (@var{a_1}, @var{p_1}, ..., @var{a_n}, @var{p_n})}
898 remove a propriedade @code{p_k} do @'{a}tomo @code{a_k}.
900 O comando @code{remove ([@var{a_1}, ..., @var{a_m}], [@var{p_1}, ..., @var{p_n}], ...)}
901 remove as propriedades @code{@var{p_1}, ..., @var{p_n}}
902 dos @'{a}tomos @var{a_1}, @dots{}, @var{a_m}.
903 Pode existir mais que um par de listas.
905 @c VERIFY THAT THIS WORKS AS ADVERTISED
906 O comando @code{remove (all, @var{p})} remove a propriedade @var{p} de todos os @'{a}tomos que
907 a possu@'{i}rem.
909 @c SHOULD REFER TO A LIST OF ALL SYSTEM-DEFINED PROPERTIES HERE.
910 As propriedades removidas podem ser propriedades definidas pelo sistema tais como
911 @code{function}, @code{macro}, ou @code{mode_declare}.
912 A fun@,{c}@~{a}o @code{remove} n@~{a}o remove propriedades defiinidas por @mrefdot{put}
914 @c VERIFY THAT THIS WORKS AS ADVERTISED
915 @c IS transfun PECULIAR TO remove ?? IF SO, SHOW SPECIAL CASE AS @defunx
916 Uma propriedade pode ser @code{transfun} para remover
917 a vers@~{a}o traduzida do Lisp de uma fun@,{c}@~{a}o.
918 Ap@'{o}s a execu@,{c}@~{a}o da fun@,{c}@~{a}o @code{remove} com a propriedade @code{transfun}, a vers@~{a}o do Maxima da fun@,{c}@~{a}o @'{e} executada
919 ao inv@'{e}s da vers@~{a}o traduzida.
921 O comando @code{remove ("@var{a}", operador)} ou, equivalentemente,
922 @code{remove ("@var{a}", op)} remove de @var{a} as propriedes de operador
923 declaradas por @mrefcomma{prefix} @mrefcomma{infix}@w{}
924 @mxrefcomma{function_nary, nary} @mrefcomma{postfix} @mrefcomma{matchfix} ou por
925 @mrefdot{nofix} Note que o nome do operador deve ser escrito como uma sequ@^{e}ncia de caracteres entre
926 aspas duplas.
928 A fun@,{c}@~{a}o @code{remove} sempre retorna @code{done} independente de um @'{a}tomo ter ou n@~{a}o a propriedade
929 especificada. Esse comportamento @'{e} diferente das fun@,{c}@~{o}es de remo@,{c}@~{a}o mais espec@'{i}ficas
930 @mrefcomma{remvalue} @mrefcomma{remarray} @mrefcomma{remfunction} e
931 @mrefdot{remrule}
933 A fun@,{c}@~{a}o @code{remove} n@~{a}o avalia seus argumentos (coloca ap@'{o}strofo inicial).
935 @c IN SERIOUS NEED OF EXAMPLES HERE
936 @opencatbox
937 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
938 @closecatbox
939 @end deffn
941 @c -----------------------------------------------------------------------------
942 @anchor{scalar}
943 @defvr {Propriedade} scalar
945 O comando @code{declare(@var{a}, scalar)} diz ao Maxima para considerar @var{a} uma vari@'{a}vel
946 escalar.
948 Veja tamb@'{e}m @mrefdot{declare}
950 @opencatbox
951 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
952 @closecatbox
953 @end defvr
955 @c NEEDS CLARIFICATION AND EXAMPLES
957 @c -----------------------------------------------------------------------------
958 @anchor{scalarp}
959 @deffn {Fun@,{c}@~{a}o} scalarp (@var{expr})
961 Retorna @code{true} se @var{expr} for um n@'{u}mero, constante, ou vari@'{a}vel declarada como sendo
962 @mref{scalar} com @mrefcomma{declare} ou composta inteiramente por n@'{u}meros,
963 constantes, e vari@'{a}veis escalares, mas n@~{a}o contendo matrizes ou listas.
965 Veja tamb@'{e}m fun@,{c}@~{a}o predicado @mrefdot{nonscalarp}
967 @opencatbox
968 @category{Fun@,{c}@~{o}es predicado} @category{Vectors} @category{Matrices}
969 @closecatbox
970 @end deffn
972 @c -----------------------------------------------------------------------------
973 @node Functions and Variables for Facts, Functions and Variables for Predicates, Functions and Variables for Properties, Maximas Database
974 @section Functions and Variables for Facts
975 @c -----------------------------------------------------------------------------
977 @c -----------------------------------------------------------------------------
978 @anchor{activate}
979 @deffn {Fun@,{c}@~{a}o} activate (@var{context_1}, @dots{}, @var{context_n})
981 Ativa os contextos @var{context_1}, @dots{}, @var{context_n}.
982 Os fatos nesses contextos estar@~{a}o dispon@'{i}veis para
983 fazer dedu@,{c}@~{o}es e recuperar informa@,{c}@~{a}o.
984 Os fatos nesses contextos n@~{a}o s@~{a}o listados por @code{facts ()}.
986 A vari@'{a}vel @mref{activecontexts} @'{e} a lista
987 de contextos que est@'{a} ativa por meio da fun@,{c}@~{a}o @code{activate}.
989 @opencatbox
990 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
991 @closecatbox
992 @end deffn
994 @c -----------------------------------------------------------------------------
995 @anchor{activecontexts}
996 @defvr {Vari@'{a}vel de sistema} activecontexts
997 Valor padr@~{a}o: @code{[]}
999 A vari@'{a}vel de sistema @code{activecontexts} @'{e} uma lista de contextos que est@~{a}o ativos
1000 por meio da fun@,{c}@~{a}o @mref{activate}, em oposi@,{c}@~{a}o aos que est@~{a}o ativos por
1001 serem subcontextos do contexto atual.
1003 @opencatbox
1004 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1005 @closecatbox
1006 @end defvr
1008 @c THERE IS PROBABLY MORE TO THE STORY THAN WHAT IS INDICATED HERE ...
1010 @c -----------------------------------------------------------------------------
1011 @anchor{askinteger}
1012 @deffn {Fun@,{c}@~{a}o} askinteger (@var{expr}, integer)
1013 @deffnx {Fun@,{c}@~{a}o} askinteger (@var{expr})
1014 @deffnx {Fun@,{c}@~{a}o} askinteger (@var{expr}, even)
1015 @deffnx {Fun@,{c}@~{a}o} askinteger (@var{expr}, odd)
1017 O comando @code{askinteger (@var{expr}, integer)} tenta determinar a partir da
1018 base de dados de @code{assume} se @var{expr} @'{e} um inteiro.
1019 A fun@,{c}@~{a}o @code{askinteger} informa ao usu@'{a}rio se @var{expr} n@~{a}o puder ser dito em caso contr@'{a}rio,
1020 @c UMM, askinteger AND asksign DO NOT APPEAR TO HAVE ANY EFFECT ON THE assume
1021 @c DATABASE !!!
1022 e tenta instalar a informa@,{c}@~{a}o na base de dados de @code{assume} se isso for permitido.
1023 O comando @code{askinteger (@var{expr})} @'{e} equivalente ao comando
1024 @code{askinteger (@var{expr}, integer)}.
1026 Os comandos @code{askinteger (@var{expr}, even)} e @code{askinteger (@var{expr}, odd)}
1027 da mesma forma tentam determinar se @var{expr} @'{e} um inteiro par ou um inteiro @'{i}mpar,
1028 respectivamente.
1030 @opencatbox
1031 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1032 @closecatbox
1033 @end deffn
1035 @c THERE IS PROBABLY MORE TO THE STORY THAN WHAT IS INDICATED HERE ...
1037 @c -----------------------------------------------------------------------------
1038 @anchor{asksign}
1039 @deffn {Fun@,{c}@~{a}o} asksign (@var{expr})
1041 Primeiro tenta determinar se a express@~{a}o
1042 especificada @'{e} positiva, negativa, ou zero. Se n@~{a}o for poss@'{i}vel, pergunta ao
1043 usu@'{a}rio as quest@~{o}es necess@'{a}rias para completar sua dedu@,{c}@~{a}o. As respostas
1044 do usu@'{a}rio s@~{a}o gravadas na base de dados enquanto durar o
1045 c@'{a}lculo atual. O valor de retorna de @code{asksign} @'{e} um entre @code{pos},
1046 @code{neg}, ou @code{zero}.
1048 @opencatbox
1049 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1050 @closecatbox
1051 @end deffn
1053 @c -----------------------------------------------------------------------------
1054 @anchor{assume}
1055 @deffn {Fun@,{c}@~{a}o} assume (@var{pred_1}, @dots{}, @var{pred_n})
1057 Adiciona os predicados @var{pred_1}, @dots{}, @var{pred_n} ao contexto atual.
1058 Se um predicado for inconsistente ou redundante em rela@,{c}@~{a}o aos outros predicados no
1059 contexto atual, n@~{a}o ser@'{a} adicionado ao contexto. O contexto acumula predicados
1060 a cada chamada a @code{assume}.
1062 A fun@,{c}@~{a}o @code{assume} returna ou uma lista cujos elementos s@~{a}o os predicados adicionados ao
1063 contexto ou o @'{a}tomo @code{redundant} ou o @'{a}tomo @code{inconsistent} onde esse retorno for aplic@'{a}vel.
1065 Os predicados @var{pred_1}, @dots{}, @var{pred_n} podem somente ser express@~{o}es
1066 com os operadores relacionais @code{< <= equal notequal >=} e @code{>}.
1067 Predicados n@~{a}o podem ser express@~{o}es de igualdade literal @code{=} ou desigualdade
1068 literal @code{#}, nem podem ser fun@,{c}@~{o}es predicadas tais como @code{integerp}.
1070 Predicados compostos da forma @code{@var{pred_1} and ... and @var{pred_n}}
1071 s@~{a}o reconhecidos, mas n@~{a}o @code{@var{pred_1} or ... or @var{pred_n}}.
1072 A forma @code{not @var{pred_k}} @'{e} reconhecida se @var{pred_k} for um predicado relacional.
1073 Express@~{o}es da forma @code{not (@var{pred_1} and @var{pred_2})}
1074 e da forma @code{not (@var{pred_1} or @var{pred_2})} n@~{a}o s@~{a}o reconhecidos.
1076 O mecanismo de dedu@,{c}@~{a}o do m@'{a}xima n@~{a}o @'{e} muito forte;
1077 existem muitas consequ@^{e}ncias @'{o}bvias que n@~{a}o podem ser determindas por @mrefdot{is}
1078 @'{E} uma fraqueza conhecida.
1080 A fun@,{c}@~{a}o @code{assume} n@~{a}o manipula predicados com n@'{u}meros complexos. Se um predicado
1081 contiver um n@'{u}mero complexo @code{assume} retorna @code{inconsistent} ou
1082 @code{redunant}.
1084 A fun@,{c}@~{a}o @code{assume} avalia seus argumentos.
1086 Veja tamb@'{e}m @mrefcomma{is} @mrefcomma{facts} @mrefcomma{forget}@w{}
1087 @mrefcomma{context} e @mrefdot{declare}
1089 Exemplos:
1091 @c ===beg===
1092 @c assume (xx > 0, yy < -1, zz >= 0);
1093 @c assume (aa < bb and bb < cc);
1094 @c facts ();
1095 @c is (xx > yy);
1096 @c is (yy < -yy);
1097 @c is (sinh (bb - aa) > 0);
1098 @c forget (bb > aa);
1099 @c prederror : false;
1100 @c is (sinh (bb - aa) > 0);
1101 @c is (bb^2 < cc^2);
1102 @c ===end===
1103 @example
1104 (%i1) assume (xx > 0, yy < -1, zz >= 0);
1105 (%o1) [xx > 0, yy < - 1, zz >= 0]
1106 (%i2) assume (aa < bb and bb < cc);
1107 (%o2) [bb > aa, cc > bb]
1108 (%i3) facts ();
1109 (%o3) [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
1110 (%i4) is (xx > yy);
1111 (%o4) true
1112 (%i5) is (yy < -yy);
1113 (%o5) true
1114 (%i6) is (sinh (bb - aa) > 0);
1115 (%o6) true
1116 (%i7) forget (bb > aa);
1117 (%o7) [bb > aa]
1118 (%i8) prederror : false;
1119 (%o8) false
1120 (%i9) is (sinh (bb - aa) > 0);
1121 (%o9) unknown
1122 (%i10) is (bb^2 < cc^2);
1123 (%o10) unknown
1124 @end example
1126 @opencatbox
1127 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1128 @closecatbox
1129 @end deffn
1131 @c -----------------------------------------------------------------------------
1132 @anchor{assumescalar}
1133 @defvr {Vari@'{a}vel de op@,{c}@~{a}o} assumescalar
1134 Valor padr@~{a}o: @code{true}
1136 A vari@'{a}vel de op@,{c}@~{a}o @code{assumescalar} ajuda a decidir se express@~{o}es @code{expr}
1137 para as quais @code{nonscalarp (expr)} @'{e} @code{false}
1138 s@~{a}o assumindas comporta-se como escalares para certas transforma@,{c}@~{o}es.
1140 Fa@,{c}amos @code{expr} representar qualquer express@~{a}o que n@~{a}o seja uma lista ou uma matriz,
1141 e fa@,{c}amos @code{[1, 2, 3]} representar qualquer lista ou matriz.
1142 Ent@~{a}o @code{expr . [1, 2, 3]} retorna @code{[expr, 2 expr, 3 expr]}
1143 se @code{assumescalar} for @code{true}, ou @code{scalarp (expr)} for
1144 @code{true}, ou @code{constantp (expr)} for @code{true}.
1146 Se @code{assumescalar} for @code{true}, tais
1147 expres@~{o}es ir@~{a}o comportar-se como escalares somente para operadores
1148 comutativos, mas n@~{a}o se comportar@~{a}o como escalares em uma multiplica@,{c}@~{a}o n@~{a}o comutativa @code{.}.
1150 Quando @code{assumescalar} for @code{false}, tais
1151 express@~{o}es ir@~{a}o comportar-se como n@~{a}o escalares.
1153 Quando @code{assumescalar} for @code{all}, tais express@~{o}es ir@~{a}o comportar-se como
1154 escalares para todos os operadores listados acima.
1156 @opencatbox
1157 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1158 @closecatbox
1159 @end defvr
1161 @c -----------------------------------------------------------------------------
1162 @need 800
1163 @anchor{assume_pos}
1164 @defvr {Vari@'{a}vel de op@,{c}@~{a}o} assume_pos
1165 Valor padr@~{a}o: @code{false}
1167 Quando @code{assume_pos} for @code{true} e o sinal de um par@^{a}metro @var{x}
1168 n@~{a}o puder ser determinado a partir do contexto atual
1169 @c WHAT ARE THOSE OTHER CONSIDERATIONS ??
1170 ou outras considera@,{c}@~{o}es,
1171 @code{sign} e @code{asksign (@var{x})} retornam @code{true}.
1172 Isso pode passar informa@,{c}@~{o}es a alguma busca autom@'{a}tica gerada por @code{asksign},
1173 tias como as que podem surgir de @code{integrate} ou de outras computa@,{c}@~{o}es.
1175 Por padr@~{a}o, um par@^{a}metro @'{e} @var{x} tal que @code{symbolp (@var{x})} ou
1176 @code{subvarp (@var{x})} retorne @code{true}.
1177 A classe de express@~{o}es consideradas par@^{a}metros pode ser modificada para ser extendida
1178 por meio da vari@'{a}vel @code{assume_pos_pred}.
1180 As fun@,{c}@~{o}es @code{sign} e @code{asksign} tentam deduzir o sinal de express@~{o}es
1181 a partir do sinal dos operandos dentro da express@~{a}o.
1182 Por exemplo, se @code{a} e @code{b} forem ambos postivos,
1183 ent@~{a}o @code{a + b} @'{e} tambẽm positivo.
1185 Todavia, n@~{a}o existe forma de evitar todas as perguntas de @code{asksign}.
1186 Particularmente, quando o argumento a @code{asksign} for uma
1187 diferen@,{c}a @code{@var{x} - @var{y}} ou um logaritmo @code{log(@var{x})},
1188 @code{asksign} sempre requisita uma informa@,{c}@~{a}o ao usu@'{a}rio,
1189 mesmo quando @code{assume_pos} for @code{true} e @code{assume_pos_pred} for
1190 uma fun@,{c}@~{a}o que retorna @code{true} para todos os argumentos.
1192 @c NEED EXAMPLES HERE
1193 @opencatbox
1194 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1195 @closecatbox
1196 @end defvr
1198 @c -----------------------------------------------------------------------------
1199 @anchor{assume_pos_pred}
1200 @defvr {Vari@'{a}vel de op@,{c}@~{a}o} assume_pos_pred
1201 Valor padr@~{a}o: @code{false}
1203 Quando a @code{assume_pos_pred} for atribu@'{i}do o nome de uma fun@,{c}@~{a}o
1204 ou de uma express@~{a}o lambda de um argumento @var{x},
1205 a fun@,{c}@~{a}o ou express@~{a}o lambda @'{e} chamada para determinar
1206 se @var{x} @'{e} considerado um par@^{a}metro para o prop@'{o}sito de @code{assume_pos}.
1207 A vari@'{a}vel de op@,{c}@~{a}o @code{assume_pos_pred} @'{e} ignorada quando @code{assume_pos} for @code{false}.
1209 A fun@,{c}@~{a}o @code{assume_pos_pred} @'{e} chamada atrav@'{e}s de @code{sign} e de @code{asksign}
1210 com um argumento @var{x}
1211 que @'{e} ou um @'{a}tomo, ou uma vari@'{a}vel com subscrito, ou uma express@~{a}o que cont@'{e}m uma chamada de fun@,{c}@~{a}o.
1212 Se a fun@,{c}@~{a}o @code{assume_pos_pred} retornar @code{true},
1213 @var{x} @'{e} considerado um par@^{a}metro para o prop@'{o}sito de @code{assume_pos}.
1215 Por padr@~{a}o, um par@^{a}metro @var{x} @'{e} tal que @code{symbolp (@var{x})} ou
1216 @code{subvarp (@var{x})} retorna @code{true}.
1218 Veja tamb@'{e}m @mref{assume} e @mrefdot{assume_pos}
1220 Exemplos:
1222 @c ===beg===
1223 @c assume_pos: true$
1224 @c assume_pos_pred: symbolp$
1225 @c sign (a);
1226 @c sign (a[1]);
1227 @c assume_pos_pred: lambda ([x], display (x), true)$
1228 @c asksign (a);
1229 @c asksign (a[1]);
1230 @c asksign (foo (a));
1231 @c asksign (foo (a) + bar (b));
1232 @c asksign (log (a));
1233 @c asksign (a - b);
1234 @c ===end===
1235 @example
1236 (%i1) assume_pos: true$
1237 (%i2) assume_pos_pred: symbolp$
1238 (%i3) sign (a);
1239 (%o3) pos
1240 (%i4) sign (a[1]);
1241 (%o4) pnz
1242 (%i5) assume_pos_pred: lambda ([x], display (x), true)$
1243 (%i6) asksign (a);
1244 x = a
1246 (%o6) pos
1247 (%i7) asksign (a[1]);
1248 x = a
1249 1
1251 (%o7) pos
1252 (%i8) asksign (foo (a));
1253 x = foo(a)
1255 (%o8) pos
1256 (%i9) asksign (foo (a) + bar (b));
1257 x = foo(a)
1259 x = bar(b)
1261 (%o9) pos
1262 (%i10) asksign (log (a));
1263 x = a
1265 Is a - 1 positive, negative, or zero?
1267 p;
1268 (%o10) pos
1269 (%i11) asksign (a - b);
1270 x = a
1272 x = b
1274 x = a
1276 x = b
1278 Is b - a positive, negative, or zero?
1280 p;
1281 (%o11) neg
1282 @end example
1284 @opencatbox
1285 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1286 @closecatbox
1287 @end defvr
1289 @c -----------------------------------------------------------------------------
1290 @anchor{context}
1291 @defvr {Vari@'{a}vel de op@,{c}@~{a}o} context
1292 Valor padr@~{a}o: @code{initial}
1294 A vari@'{a}vel de op@,{c}@~{a}o @code{context} representa uma cole@,{c}@~{a}o de fatos mantida por @mref{assume} e por
1295 @mrefdot{forget} A fun@,{c}@~{a}o @code{assume} adiciona fatos @`{a} cole@,{c}@~{a}o nomeada por
1296 @code{context}, enquanto @code{forget} remove fatos.
1298 Associando @code{context} a um nome @var{qualquercoisa} modifica o contexto atual para
1299 @var{qualquercoisa}. Se o contexto especificado @var{qualquercoisa} n@~{a}o exite ainda,
1300 @'{e} criado automaticamente por uma chamada a @mrefdot{newcontext}
1301 @c ISN'T THIS NEXT BIT EQUIVALENT TO THE FIRST ??
1302 O contexto especificado @'{e} ativado automaticamente.
1304 Veja @mref{contexts} para uma descri@,{c}@~{a}o geral do mecanismo de contexto.
1306 @opencatbox
1307 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1308 @closecatbox
1309 @end defvr
1311 @c UMM, I'M HAVING TROUBLE GETTING THE CONTEXT-SWITCHING STUFF TO BEHAVE AS EXPECTED
1312 @c SOME EXAMPLES WILL HELP A LOT HERE
1314 @c -----------------------------------------------------------------------------
1315 @anchor{contexts}
1316 @defvr {Vari@'{a}vel de op@,{c}@~{a}o} contexts
1317 Valor padr@~{a}o: @code{[initial, global]}
1319 A vari@'{a}vel de op@,{c}@~{a}o @code{contexts} (no plural) @'{e} uma lista dos contextos que
1320 existem atualmente, incluindo o contexto ativo atualmente.
1322 O mecanismo de contexto torna poss@'{i}vel para um usu@'{a}rio associar
1323 um nome a uma cole@,{c}@~{a}o de fatos, chamado contexto.
1324 Uma vez que isso for feito, o usu@'{a}rio pode ter Maxima assumindo ou esquecendo grande n@'{u}mero
1325 de fatos meramente pela ativa@,{c}@~{a}o ou desativa@,{c}@~{a}o de seu contexto.
1327 Qualquer @'{a}tomo simb@'{o}lico pode ser um contexto, e os fatos contidos naquele
1328 contexti ser@'{a} retido em mem@'{o}ria at@'{e} ser destru@'{i}do um por um
1329 atrav@'{e}s de @mref{forget} ou destru@'{i}do por completo atrav@'{e}s de @mref{kill}@w{}
1330 para destruir o contexto de dentro do qual foi chamado.
1332 Contextos existem em uma hierarquia, com a ra@'{i}z sempre sendo
1333 o contexto global @code{global}, que cont@'{e}m informa@,{c}@~{o}es sobre o Maxima que algumas
1334 fun@,{c}ẽs precisam. Quando em um dado contexto, todos os fatos naquele
1335 contexto est@~{a}o "ativos" (significando que eles s@~{a}o usados em dedu@,{c}@~{o}es e
1336 recupera@,{c}@~{o}es) da mesma forma est@~{a}o tamb@'{e}m ativos em qualquer contexto que seja um subcontexto
1337 do contexto ativo.
1339 Quando um Maxima leve @'{e} iniciado, o usu@'{a}rio est@'{a} em um
1340 contexto chamado @code{initial}, que tem @code{global} como um subcontexto.
1342 Veja tamb@'{e}m @mrefcomma{facts} @mrefcomma{newcontext} @mrefcomma{supcontext}@w{}
1343 @mrefcomma{killcontext} @mrefcomma{activate} @mrefcomma{deactivate}@w{}
1344 @mrefcomma{assume} e @mrefdot{forget}
1346 @opencatbox
1347 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1348 @closecatbox
1349 @end defvr
1351 @c -----------------------------------------------------------------------------
1352 @anchor{deactivate}
1353 @deffn {Fun@,{c}@~{a}o} deactivate (@var{context_1}, @dots{}, @var{context_n})
1355 Desativa os contextos especificados @var{context_1}, @dots{}, @var{context_n}.
1357 @opencatbox
1358 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1359 @closecatbox
1360 @end deffn
1362 @c -----------------------------------------------------------------------------
1363 @anchor{facts}
1364 @deffn {Fun@,{c}@~{a}o} facts (@var{item})
1365 @deffnx {Fun@,{c}@~{a}o} facts ()
1367 Se @var{item} for o nome de um contexto, @code{facts (@var{item})} retorna uma
1368 lista de fatos no contexto especificado.
1370 Se @var{item} n@~{a}o @'{e} um nome de um contexto, @code{facts (@var{item})} retorna uma
1371 lista de fatos conhecidos sobre @var{item} no contexto atual. Fatos que
1372 est@~{a}o ativos, mas em um contexto diferente, n@~{a}o s@~{a}o listados.
1374 O comando @code{facts ()} (i.e., sem argumentos) lista o contexto atual.
1376 @opencatbox
1377 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1378 @closecatbox
1379 @end deffn
1381 @c -----------------------------------------------------------------------------
1382 @anchor{forget}
1383 @deffn {Fun@,{c}@~{a}o} forget (@var{pred_1}, @dots{}, @var{pred_n})
1384 @deffnx {Fun@,{c}@~{a}o} forget (@var{L})
1386 Remove predicados estabelecidos por @mrefdot{assume}
1387 Os predicados podem ser express@~{o}es equivalentes a (mas n@~{a}o necess@'{a}riamente identicas
1388 a) outros previamente assumidos.
1390 O comando @code{forget (@var{L})}, onde @var{L} @'{e} uma lista de predicados,
1391 esquece cada item na lista.
1393 @opencatbox
1394 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1395 @closecatbox
1396 @end deffn
1398 @c -----------------------------------------------------------------------------
1399 @anchor{is}
1400 @deffn {Fun@,{c}@~{a}o} is (@var{expr})
1402 Tenta determinar se o predicado @var{expr} @'{e} dedut@'{i}vel a partir dos
1403 fatos na base de dados do @code{assume}.
1405 Se o predicado for provavelmente @code{true} ou @code{false}, @code{is} retorna
1406 @code{true} ou @code{false}, respectivamente. De outra forma, o valor de retorno @'{e}
1407 determinado pelo sinalizador global @mrefdot{prederror} Quando @code{prederror} for
1408 @code{true}, @code{is} reclama com uma mensagem de erro. Nos outros casos, @code{is}
1409 retorna @code{unknown} @footnote{Nota do tradutor: desconhecido.}.
1411 O comando @code{ev(@var{expr}, pred)} (que pode ser escrito @code{@var{expr}, pred} na
1412 linha de comando do Maxima) @'{e} equivalente a @code{is(@var{expr})}.
1414 Veja tamb@'{e}m @mrefcomma{assume} @mrefcomma{facts} and @mrefdot{maybe}
1416 Exemplos:
1418 A fun@,{c}@~{a}o @code{is} avalia predicados.
1420 @c ===beg===
1421 @c %pi > %e;
1422 @c is (%pi > %e);
1423 @c ===end===
1424 @example
1425 (%i1) %pi > %e;
1426 (%o1) %pi > %e
1427 (%i2) is (%pi > %e);
1428 (%o2) true
1429 @end example
1431 A fun@,{c}@~{a}o @code{is} tenta tirar conclus@~{o}es a partir da base de dados de @code{assume}.
1433 @c ===beg===
1434 @c assume (a > b);
1435 @c assume (b > c);
1436 @c is (a < b);
1437 @c is (a > c);
1438 @c is (equal (a, c));
1439 @c ===end===
1440 @example
1441 (%i1) assume (a > b);
1442 (%o1) [a > b]
1443 (%i2) assume (b > c);
1444 (%o2) [b > c]
1445 (%i3) is (a < b);
1446 (%o3) false
1447 (%i4) is (a > c);
1448 (%o4) true
1449 (%i5) is (equal (a, c));
1450 (%o5) false
1451 @end example
1453 Se @code{is} n@~{a}o puder provar ou refutar um predicado a partir da base de dados do
1454 @code{assume}, o sinalizador global @code{prederror} escolhe o comportamento de @code{is}.
1456 @c ===beg===
1457 @c assume (a > b);
1458 @c prederror: true$
1459 @c is (a > 0);
1460 @c prederror: false$
1461 @c is (a > 0);
1462 @c ===end===
1463 @example
1464 (%i1) assume (a > b);
1465 (%o1) [a > b]
1466 (%i2) prederror: true$
1467 (%i3) is (a > 0);
1468 Maxima was unable to evaluate the predicate:
1469 a > 0
1470 -- an error. Quitting. To debug this try debugmode(true);
1471 (%i4) prederror: false$
1472 (%i5) is (a > 0);
1473 (%o5) unknown
1474 @end example
1476 @opencatbox
1477 @category{Fun@,{c}@~{o}es predicado} @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1478 @closecatbox
1479 @end deffn
1481 @c -----------------------------------------------------------------------------
1482 @anchor{killcontext}
1483 @deffn {Fun@,{c}@~{a}o} killcontext (@var{context_1}, @dots{}, @var{context_n})
1485 Apaga dos contextos @var{context_1}, @dots{}, @var{context_n}.
1487 Se um dos contextos for o contexto atual, o novo contexto ser@'{a}
1488 o primeiro subcontexto dispon@'{i}vel do contexto atual que n@~{a}o tiver sido
1489 apagado. Se o primeiro contexto n@~{a}o apagado for @code{global} ent@~{a}o
1490 @code{initial} @'{e} usado ao inv@'{e}s @code{global}. Se o contexto @code{initial} for apagado, um
1491 novo, vazido contexto @code{initial} @'{e} criado.
1493 A fun@,{c}@~{a}o @code{killcontext} recusa apagar um contexto que est@'{a}
1494 ativo atualmente, ou porque o contexto atual @'{e} um subcontexto do contexto
1495 atual, ou pelo uso da fun@,{c}@~{a}o @mrefdot{activate}
1497 A fun@,{c}@~{a}o @code{killcontext} avalia seus argumentos.
1498 A fun@,{c}@~{a}o @code{killcontext} retorna @code{done}.
1500 @opencatbox
1501 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1502 @closecatbox
1503 @end deffn
1505 @c -----------------------------------------------------------------------------
1506 @anchor{maybe}
1507 @deffn {Fun@,{c}@~{a}o} maybe (@var{expr})
1509 Tenta determinar se o predicado @var{expr} @'{e} demonstr@'{a}vel a partir dos
1510 fatos na base de dados do @code{assume}.
1512 Se o predicado for provavelmente @code{true} ou @code{false}, @code{maybe} retorna
1513 @code{true} ou @code{false}, respectivamente. De outra forma, @code{maybe} retorna
1514 @code{unknown}.
1516 A fun@,{c}@~{a}o @code{maybe} @'{e} funcionalmente equivalente a @code{is} com
1517 @code{prederror: false}, mas o resultado @'{e} calculado sem atualmente atribuir
1518 um valor a @code{prederror}.
1520 Veja tamb@'{e}m @mrefcomma{assume} @mrefcomma{facts} e @mrefdot{is}
1522 Exemplos:
1524 @c ===beg===
1525 @c maybe (x > 0);
1526 @c assume (x > 1);
1527 @c maybe (x > 0);
1528 @c ===end===
1529 @example
1530 (%i1) maybe (x > 0);
1531 (%o1) unknown
1532 (%i2) assume (x > 1);
1533 (%o2) [x > 1]
1534 (%i3) maybe (x > 0);
1535 (%o3) true
1536 @end example
1538 @opencatbox
1539 @category{Fun@,{c}@~{o}es predicado} @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1540 @closecatbox
1541 @end deffn
1543 @c -----------------------------------------------------------------------------
1544 @anchor{newcontext}
1545 @deffn {Fun@,{c}@~{a}o} newcontext (@var{nome})
1547 Cria um novo contexto, vazio, chamado @var{nome}, que
1548 tem @code{global} como seu @'{u}nico subcontexto. O contexto recentemente criado
1549 torna-se o contexto ativo atual.
1551 A fun@,{c}@~{a}o @code{newcontext} avalia seus argumentos.
1552 A fun@,{c}@~{a}o @code{newcontext} retorna @var{nome}.
1554 @opencatbox
1555 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1556 @closecatbox
1557 @end deffn
1559 @c -----------------------------------------------------------------------------
1560 @anchor{sign}
1561 @deffn {Fun@,{c}@~{a}o} sign (@var{expr})
1563 Tenta determinar o sinal de @var{expr} a partir dos fatos contidos na
1564 base de dados atual. Retorna uma das seguintes respostas: @code{pos}
1565 (positivo), @code{neg} (negativo), @code{zero}, @code{pz} (positivo ou zero),
1566 @code{nz} (negativo ou zero), @code{pn} (positivo ou negativo), ou @code{pnz}
1567 (positivo, negativo, ou zero, i.e. nada se pode afirmar).
1569 @opencatbox
1570 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1571 @closecatbox
1572 @end deffn
1574 @c -----------------------------------------------------------------------------
1575 @anchor{supcontext}
1576 @deffn {Fun@,{c}@~{a}o} supcontext (@var{nome}, @var{ctxto})
1577 @deffnx {Fun@,{c}@~{a}o} supcontext (@var{nome})
1579 Cria um novo contexto, chamado @var{nome}, que tem @var{ctxto} como um
1580 subcontexto. O @var{ctxto} deve existir.
1582 Se @var{ctxto} n@~{a}o for especificado, o contexto atual @'{e} usado.
1584 @opencatbox
1585 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1586 @closecatbox
1587 @end deffn
1589 @c -----------------------------------------------------------------------------
1590 @node Functions and Variables for Predicates, , Functions and Variables for Facts, Maximas Database
1591 @section Functions and Variables for Predicates
1592 @c -----------------------------------------------------------------------------
1594 @c -----------------------------------------------------------------------------
1595 @anchor{charfun}
1596 @deffn {Fun@,{c}@~{a}o} charfun (@var{p})
1598 Retorna 0 quando o predicado @var{p} avaliar para @code{false}; retorna 1 quando
1599 o predicado avaliar para @code{true}. Qaundo o predicado avaliar para
1600 alguma coisa que n@~{a}o seja @code{true} ou @code{false} (desconhecido), retorna uma forma substantiva.
1602 Exemplos:
1604 @c ===beg===
1605 @c charfun (x < 1);
1606 @c subst (x = -1, %);
1607 @c e : charfun ('"and" (-1 < x, x < 1))$
1608 @c [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1609 @c ===end===
1610 @example
1611 (%i1) charfun (x < 1);
1612 (%o1) charfun(x < 1)
1613 (%i2) subst (x = -1, %);
1614 (%o2) 1
1615 (%i3) e : charfun ('"and" (-1 < x, x < 1))$
1616 (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1617 (%o4) [0, 1, 0]
1618 @end example
1620 @opencatbox
1621 @category{Fun@,{c}@~{o}es matem@'{a}ticas}
1622 @closecatbox
1623 @end deffn
1625 @c -----------------------------------------------------------------------------
1626 @anchor{compare}
1627 @deffn {Fun@,{c}@~{a}o} compare (@var{x}, @var{y})
1629 Retorna um operador de compara@,{c}@~{a}o @var{op} (@code{<}, @code{<=}, @code{>}, @code{>=},
1630 @code{=}, ou @code{#}) tal que @code{is (@var{x} @var{op} @var{y})} avalie
1631 para @code{true}; quando ou @var{x} ou @var{y} estiver em fun@,{c}@~{a}o de @code{%i} e
1632 @code{@var{x} # @var{y}}, retorna @code{notcomparable}; quando n@~{a}o houver operador
1633 adequado ou o Maxima n@~{a}o estiver apto a determinar o operador, retorna @code{unknown}.
1635 Exemplos:
1637 @c ===beg===
1638 @c compare (1, 2);
1639 @c compare (1, x);
1640 @c compare (%i, %i);
1641 @c compare (%i, %i + 1);
1642 @c compare (1/x, 0);
1643 @c compare (x, abs(x));
1644 @c ===end===
1645 @example
1646 (%i1) compare (1, 2);
1647 (%o1) <
1648 (%i2) compare (1, x);
1649 (%o2) unknown
1650 (%i3) compare (%i, %i);
1651 (%o3) =
1652 (%i4) compare (%i, %i + 1);
1653 (%o4) notcomparable
1654 (%i5) compare (1/x, 0);
1655 (%o5) #
1656 (%i6) compare (x, abs(x));
1657 (%o6) <=
1658 @end example
1660 A fun@,{c}@~{a}o @code{compare} n@~{a}o tenta determinar se o dom@'{i}nio real de
1661 seus argumentos possuem um ou mais elementos; dessa forma
1663 @c ===beg===
1664 @c compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1665 @c ===end===
1666 @example
1667 (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1668 (%o1) <
1669 @end example
1671 @c IT IS NOT QUITE TRUE, WHAT ABOUT x=0 ?
1672 O dom@'{i}nio real de @code{acos (x^2 + 1)} @'{e} vazio.
1674 @opencatbox
1675 @category{Declara@,{c}@~{o}es e infer@^{e}ncias}
1676 @closecatbox
1677 @end deffn
1679 @c -----------------------------------------------------------------------------
1680 @anchor{equal}
1681 @deffn {Fun@,{c}@~{a}o} equal (@var{a}, @var{b})
1683 Representa equival@^{e}ncia, isto @'{e}, valor igual.
1685 Sozinha, @code{equal} n@~{a}o avalia ou simplifica.
1686 A fun@,{c}@~{a}o @mref{is} tenta avaliar @code{equal} para um valor Booleano.
1687 O comando @code{is(equal(@var{a}, @var{b}))} retorna @code{true} (ou @code{false}) se
1688 e somente se @var{a} e @var{b} forem iguais (ou diferentes) para todos os valores
1689 poss@'{i}veis de suas vari@'{a}veis, como determinado pela avalia@,{c}@~{a}o de
1690 @code{ratsimp(@var{a} - @var{b})}; se @mref{ratsimp} retornar 0, as duas
1691 express@~{o}es s@~{a}o consideradas equivalentes. Duas express@~{o}es podem ser equivalentes mesmo
1692 se n@~{a}o forem sintaticamente iguais (i.e., identicas).
1694 Quando a fun@,{c}@~{a}o @code{is} falha na tentativa de converter @code{equal} em @code{true} ou @code{false}, o
1695 resultado @'{e} governado pelo sinalizador global @mrefdot{prederror} Quando @code{prederror}
1696 for @code{true}, @code{is} reclama com uma mensagem de erro. De outra forma, @code{is}
1697 retorna @code{unknown}.
1699 Al@'{e} da fun@,{c}@~{a}o @code{is}, alguns outros operadores avaliam @code{equal} e
1700 @code{notequal} para @code{true} ou @code{false}, s@~{a}o eles @mrefcomma{if}@w{}
1701 @mrefcomma{and} @mrefcomma{or} e @mrefdot{not}
1703 @c FOLLOWING STATEMENT IS MORE OR LESS TRUE BUT I DON'T THINK THE DETAILS ARE CORRECT
1704 @c Declarations (integer, complex, etc)
1705 @c for variables appearing in @var{a} and @var{b} are ignored by @code{equal}.
1706 @c All variables are effectively assumed to be real-valued.
1708 A nega@,{c}@~{a}o de @code{equal} @'{e} @mrefdot{notequal}
1710 Exemplos:
1712 Sozinha, @code{equal} n@~{a}o avalia ou simplifica.
1714 @c ===beg===
1715 @c equal (x^2 - 1, (x + 1) * (x - 1));
1716 @c equal (x, x + 1);
1717 @c equal (x, y);
1718 @c ===end===
1719 @example
1720 (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
1721 2
1722 (%o1) equal(x - 1, (x - 1) (x + 1))
1723 (%i2) equal (x, x + 1);
1724 (%o2) equal(x, x + 1)
1725 (%i3) equal (x, y);
1726 (%o3) equal(x, y)
1727 @end example
1729 A fun@,{c}@~{a}o @code{is} tenta avaliar @code{equal} para um valor Booleano.
1730 O comando @code{is(equal(@var{a}, @var{b}))} retorna @code{true} quando
1731 @code{ratsimp(@var{a} - @var{b})} retorna 0. Duas express@~{o}es podem ser equivalentes
1732 mesmo se n@~{a}o forem sintaticamente iguais (i.e., id@^{e}nticas).
1734 @c ===beg===
1735 @c ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1736 @c is (equal (x^2 - 1, (x + 1) * (x - 1)));
1737 @c is (x^2 - 1 = (x + 1) * (x - 1));
1738 @c ratsimp (x - (x + 1));
1739 @c is (equal (x, x + 1));
1740 @c is (x = x + 1);
1741 @c ratsimp (x - y);
1742 @c is (equal (x, y));
1743 @c is (x = y);
1744 @c ===end===
1745 @example
1746 (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1747 (%o1) 0
1748 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
1749 (%o2) true
1750 (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
1751 (%o3) false
1752 (%i4) ratsimp (x - (x + 1));
1753 (%o4) - 1
1754 (%i5) is (equal (x, x + 1));
1755 (%o5) false
1756 (%i6) is (x = x + 1);
1757 (%o6) false
1758 (%i7) ratsimp (x - y);
1759 (%o7) x - y
1760 (%i8) is (equal (x, y));
1761 (%o8) unknown
1762 (%i9) is (x = y);
1763 (%o9) false
1764 @end example
1766 Quando @code{is} falha na tentativa de converter @code{equal} em @code{true} ou @code{false},
1767 o resultado @'{e} governado pelo sinalizador global @code{prederror}.
1769 @c ===beg===
1770 @c [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1771 @c ratsimp (aa - bb);
1772 @c prederror : true;
1773 @c is (equal (aa, bb));
1774 @c prederror : false;
1775 @c is (equal (aa, bb));
1776 @c ===end===
1777 @example
1778 (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1779 2 2
1780 (%o1) [x + 2 x + 1, x - 2 x - 1]
1781 (%i2) ratsimp (aa - bb);
1782 (%o2) 4 x + 2
1783 (%i3) prederror : true;
1784 (%o3) true
1785 (%i4) is (equal (aa, bb));
1786 Maxima was unable to evaluate the predicate:
1787 2 2
1788 equal(x + 2 x + 1, x - 2 x - 1)
1789 -- an error. Quitting. To debug this try debugmode(true);
1790 (%i5) prederror : false;
1791 (%o5) false
1792 (%i6) is (equal (aa, bb));
1793 (%o6) unknown
1794 @end example
1796 Alguns operadores avaliam @code{equal} e @code{notequal} para @code{true} ou
1797 @code{false}.
1799 @c ===beg===
1800 @c if equal (y, y - 1) then QUALQUERCOISA else OUTRACOISA;
1801 @c eq_1 : equal (x, x + 1);
1802 @c eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1803 @c [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1804 @c ===end===
1805 @example
1806 (%i1) if equal (y, y - 1) then QUALQUERCOISA else OUTRACOISA;
1807 (%o1) OUTRACOISA
1808 (%i2) eq_1 : equal (x, x + 1);
1809 (%o2) equal(x, x + 1)
1810 (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1811 2 2
1812 (%o3) equal(y + 2 y + 1, (y + 1) )
1813 (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1814 (%o4) [false, true, true]
1815 @end example
1817 Devido a @code{not @var{expr}} fazer com que ocorra avalia@,{c}@~{a}o de @var{expr},
1818 @code{not equal(@var{a}, @var{b})} @'{e} equivalente a
1819 @code{is(notequal(@var{a}, @var{b}))}.
1821 @c ===beg===
1822 @c [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1823 @c is (notequal (2*z, 2*z - 1));
1824 @c ===end===
1825 @example
1826 (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1827 (%o1) [notequal(2 z, 2 z - 1), true]
1828 (%i2) is (notequal (2*z, 2*z - 1));
1829 (%o2) true
1830 @end example
1832 @opencatbox
1833 @category{Operadores}
1834 @closecatbox
1835 @end deffn
1837 @c -----------------------------------------------------------------------------
1838 @anchor{notequal}
1839 @deffn {Fun@,{c}@~{a}o} notequal (@var{a}, @var{b})
1841 Representa a nega@,{c}@~{a}o de @code{equal(@var{a}, @var{b})}.
1843 Exemplos:
1845 @c ===beg===
1846 @c equal (a, b);
1847 @c maybe (equal (a, b));
1848 @c notequal (a, b);
1849 @c not equal (a, b);
1850 @c maybe (notequal (a, b));
1851 @c assume (a > b);
1852 @c equal (a, b);
1853 @c maybe (equal (a, b));
1854 @c notequal (a, b);
1855 @c maybe (notequal (a, b));
1856 @c ===end===
1857 @example
1858 (%i1) equal (a, b);
1859 (%o1) equal(a, b)
1860 (%i2) maybe (equal (a, b));
1861 (%o2) unknown
1862 (%i3) notequal (a, b);
1863 (%o3) notequal(a, b)
1864 (%i4) not equal (a, b);
1865 (%o4) notequal(a, b)
1866 (%i5) maybe (notequal (a, b));
1867 (%o5) unknown
1868 (%i6) assume (a > b);
1869 (%o6) [a > b]
1870 (%i7) equal (a, b);
1871 (%o7) equal(a, b)
1872 (%i8) maybe (equal (a, b));
1873 (%o8) false
1874 (%i9) notequal (a, b);
1875 (%o9) notequal(a, b)
1876 (%i10) maybe (notequal (a, b));
1877 (%o10) true
1878 @end example
1880 @opencatbox
1881 @category{Operadores}
1882 @closecatbox
1883 @end deffn
1885 @c -----------------------------------------------------------------------------
1886 @anchor{unknown}
1887 @deffn {Fun@,{c}@~{a}o} unknown (@var{expr})
1889 Retorna @code{true} se e somente se @var{expr} contiver um operador ou fun@,{c}@~{a}o
1890 n@~{a}o reconhecida pelo simplificador do Maxima.
1892 @opencatbox
1893 @category{Fun@,{c}@~{o}es predicado} @category{Simplification functions}
1894 @closecatbox
1895 @end deffn
1897 @c THIS FUNCTION APPEARS TO BE A HACK; SEE 4'TH ITEM BELOW
1898 @c DUNNO WHETHER WE CAN CLEAR THIS UP
1900 @c -----------------------------------------------------------------------------
1901 @anchor{zeroequiv}
1902 @deffn {Fun@,{c}@~{a}o} zeroequiv (@var{expr}, @var{v})
1904 Testa se a express@~{a}o @var{expr} na vari@'{a}vel @var{v} @'{e} equivalente
1905 a zero, retornando @code{true}, @code{false}, ou @code{dontknow} @footnote{Nota do tradutor: n@~{a}o sei.}.
1907 A fun@,{c}@~{a}o @code{zeroequiv} has these restrictions:
1909 @enumerate
1910 @item
1911 N@~{a}o use fun@,{c}@~{o}es que Maxima n@~{a}o sabe como
1912 diferenciar e avaliar.
1913 @item
1914 Se a express@~{a}o tem polin@^{o}mios na reta real, podem ocorrer erros
1915 no resultado (mas isso @'{e} improv@'{a}vel ocorrer).
1916 @item
1917 Se a express@~{a}o cont@'{e}m fun@,{c}@~{o}es que n@~{a}o s@~{a}o solu@,{c}@~{o}es de equa@,{c}@~{o}es diferenciais
1918 de primeira ordem (e.g. fun@,{c}@~{o}es de Bessel) pode ocorrer resultados incorretos.
1919 @item
1920 O algoritmo usa avalia@,{c}@~{a}o em pontos escolhidos aleat@'{o}riamente para subexpress@~{o}es cuidadosamente
1921 selecionadas. Essa postura @'{e} um tanto quanto perigosa, embora o
1922 algoritmo tente minimizar o potencial para erro.
1923 @end enumerate
1925 Por exemplo @code{zeroequiv (sin(2 * x) - 2 * sin(x) * cos(x), x)} retorna
1926 @code{true} e @code{zeroequiv (%e^x + x, x)} retorna @code{false}.
1927 Por outro lado @code{zeroequiv (log(a * b) - log(a) - log(b), a)} retorna
1928 @code{dontknow} devido @`{a} presen@,{c}a de um par@^{a}metro extra @code{b}.
1930 @opencatbox
1931 @category{Fun@,{c}@~{o}es predicado}
1932 @closecatbox
1933 @end deffn