| blob | c40f76d464feaf7018bb9eba11d52e239f9052c0 |
1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
2 @c /Operators.texi/1.39/Fri Jun 8 05:36:44 2007/-ko/
3 @iftex
4 @hyphenation{con-se-cu-ti-vos}
5 @hyphenation{u-san-do}
6 @end iftex
7 @menu
8 * N-Argumentos::
9 * Operador n@~{a}o fixado::
10 * Operador P@'{o}sfixado::
11 * Operador Pr@'{e}fixado::
12 * Operadores Aritm@'{e}ticos::
13 * Operadores Relacionais::
14 * Operadores Geral::
15 @end menu
18 @node N-Argumentos, Operador n@~{a}o fixado, Operadores, Operadores
19 @section N-Argumentos
20 Um operador @code{nary} @'{e} usado para denotar uma funç@~{a}o com qualquer n@'{u}mero de
21 argumentos, cada um dos quais @'{e} separado por uma ocorr@^{e}ncia do
22 operador, e.g. A+B ou A+B+C. A funç@~{a}o @code{nary("x")} @'{e} uma funç@~{a}o
23 de extens@~{a}o sint@'{a}tica para declarar x como sendo um operador @code{nary}.
24 Funç@~{o}es podem ser declaradas para serem
25 @code{nary}. Se @code{declare(j,nary);} @'{e} conclu@'{i}da, diz ao simplicador para
26 simplificar, e.g. @code{j(j(a,b),j(c,d))} para @code{j(a, b, c, d)}.
28 Veja tamb@'{e}m @code{syntax}.
30 @node Operador n@~{a}o fixado, Operador P@'{o}sfixado, N-Argumentos, Operadores
31 @section Operador n@~{a}o fixado
32 Operadores @code{nofix} s@~{a}o usados para denotar funç@~{o}es sem argumentos.
33 A mera presença de tal operador em um comando far@'{a} com que a
34 funç@~{a}o correspondente seja avaliada. Por exemplo, quando se digita
35 "exit;" para sair de uma parada do Maxima, "exit" tem comportamento similar a um
36 operador @code{nofix}. A funç@~{a}o @code{nofix("x")} @'{e} uma funç@~{a}o de extens@~{a}o
37 sint@'{a}tica que declara x como sendo um operador @code{nofix}.
39 Veja tamb@'{e}m @code{syntax}.
41 @node Operador P@'{o}sfixado, Operador Pr@'{e}fixado, Operador n@~{a}o fixado, Operadores
42 @section Operador P@'{o}sfixado
43 Operadores @code{postfix} como a variedade @code{prefix} denotam funç@~{o}es
44 de um argumento simples, mas nesse caso o argumento sucede
45 imediatamente uma ocorr@^{e}ncia do operador na seq@"{u}@^{e}ncia de caracteres de entrada, e.g. 3! .
46 Uma funç@~{a}o @code{postfix("x")} @'{e} uma funç@~{a}o de extens@~{a}o
47 sint@'{a}tica que declara x como sendo um operador @code{postfix}.
49 Veja tamb@'{e}m @code{syntax}.
51 @node Operador Pr@'{e}fixado, Operadores Aritm@'{e}ticos, Operador P@'{o}sfixado, Operadores
52 @section Operador Pr@'{e}fixado
53 Um operador @code{prefix} @'{e} um que significa uma funç@~{a}o de um
54 argumento, o qual imediatamente segue uma ocorr@^{e}ncia do
55 operador. @code{prefix("x")} @'{e} uma funç@~{a}o de extens@~{a}o
56 sint@'{a}tica que declara x como sendo um operador @code{prefix}.
58 Veja tamb@'{e}m @code{syntax}.
60 @node Operadores Aritm@'{e}ticos, Operadores Relacionais, Operador Pr@'{e}fixado, Operadores
61 @section Operadores Aritm@'{e}ticos
63 @deffn {Operador} +
64 @ifinfo
65 @fnindex Adiç@~{a}o
66 @end ifinfo
67 @deffnx {Operador} -
68 @ifinfo
69 @fnindex Subtraç@~{a}o
70 @end ifinfo
71 @deffnx {Operador} *
72 @ifinfo
73 @fnindex Multiplicaç@~{a}o
74 @end ifinfo
75 @deffnx {Operador} /
76 @ifinfo
77 @fnindex Divis@~{a}o
78 @end ifinfo
79 @deffnx {Operador} ^
80 @ifinfo
81 @fnindex Exponenciaç@~{a}o
82 @end ifinfo
84 Os s@'{i}mbolos @code{+} @code{*} @code{/} e @code{^} representam
85 adiç@~{a}o, multiplicaç@~{a}o, divis@~{a}o, e exponenciaç@~{a}o, respectivamente.
86 O nome desses operadores s@~{a}o @code{"+"} @code{"*"} @code{"/"} e @code{"^"},
87 os quais podem aparecer em lugares onde o nome da funç@~{a}o ou operador @'{e} requerido.
89 Os s@'{i}mbolos @code{+} e @code{-} representam a adiç@~{a}o un@'{a}ria e a negaç@~{a}o un@'{a}ria, respectivamente,
90 e os nomes desses operadores s@~{a}o @code{"+"} e @code{"-"}, respectivamente.
92 A subtraç@~{a}o @code{a - b} @'{e} representada dentro do Maxima como a adiç@~{a}o, @code{a + (- b)}.
93 Express@~{o}es tais como @code{a + (- b)} s@~{a}o mostradas como subtraç@~{a}o.
94 Maxima reconhece @code{"-"} somente como o nome do operador un@'{a}rio de negaç@~{a}o,
95 e n@~{a}o como o nome do operador bin@'{a}rio de subraç@~{a}o.
97 A divis@~{a}o @code{a / b} @'{e} representada dentro do Maxima como multiplicaç@~{a}o, @code{a * b^(- 1)}.
98 Express@~{o}es tais como @code{a * b^(- 1)} s@~{a}o mostradas como divis@~{a}o.
99 Maxima reconhece @code{"/"} como o nome do operador de divis@~{a}o.
101 A adiç@~{a}o e a multiplicaç@~{a}o s@~{a}o operadores en@'{a}rios e comutativos.
102 a divis@~{a}o e a exponenciaç@~{a}o s@~{a}o operadores bin@'{a}rios e n@~{a}o comutativos.
104 Maxima ordena os operandos de operadores n@~{a}o comutativos para construir uma representaç@~{a}o can@^{o}nica.
105 Para armazenamento interno, a ordem @'{e} determinada por @code{orderlessp}.
106 Para mostrar na tela, a ordem para adiç@~{a}o @'{e} determinada por @code{ordergreatp},
107 e para a multiplicaç@~{a}o, a ordem @'{e} a mesma da ordenaç@~{a}o para armazenamento interno.
109 Computaç@~{o}es aritim@'{e}ticas s@~{a}o realizadas sobre n@'{u}meros literais
110 (inteiro, racionais, n@'{u}meros comuns em ponto flutuante, e grandes n@'{u}meros em ponto flutuante de dupla precis@~{a}o).
111 Execto a exponenciaç@~{a}o, todas as operaç@~{o}es aritm@'{e}ticas sobre n@'{u}meros s@~{a}o simplificadas para n@'{u}meros.
112 A exponenciaç@~{a}o @'{e} simplificada para um n@'{u}mero se ou o operando @'{e} um n@'{u}mero comum em ponto flutuante ou um grande n@'{u}mero em ponto flutuante de dupla precis@~{a}o
113 ou se o resultado for um inteiro exato ou um racional exato;
114 de outra forma uma exponenciaç@~{a}o pode ser simplificada para @code{sqrt} ou outra exponenciaç@~{a}o ou permanecer inalterada.
116 A propagaç@~{a}o de n@'{u}meros em ponto flutuante aplica-se a computaç@~{o}es aritim@'{e}ticas:
117 Se qualquer operando for um grande n@'{u}mero em ponto flutuante, o resultado @'{e} um grande n@'{u}mero em ponto flutuante;
118 de outra forma, se qualquer operando for um n@'{u}mero em ponto flutuante comum, o resultado @'{e} um n@'{u}mero comum em ponto flutuante;
119 de outra forma, se os operandos forem racioanis ou inteiros e o resultado ser@'{a} um racional ou inteiro.
121 Computaç@~{a}oes aritim@'{e}ticas s@~{a}o uma simplificaç@~{a}o, n@~{a}o uma avaliaç@~{a}o.
122 Dessa forma a aritm@'{e}tica @'{e} realizada em express@~{o}es com ap@'{o}strofo (mas simplificadas).
124 Operaç@~{o}es aritm@'{e}ticas s@~{a}o aplicadas elemento-por-elemento
125 para listas quando a vari@'{a}vel global @code{listarith} for @code{true},
126 e sempre aplicada elemento-por-elemento para matrizes.
127 Quando um operando for uma lista ou uma matriz e outro for um operando de algum outro tipo,
128 o outro operando @'{e} combinado com cada um dos elementos da lista ou matriz.
130 Exemplos:
132 Adiç@~{a}o e multiplicaç@~{a}o s@~{a}o opeadores en@'{a}rios comutativos.
133 Maxima ordena os operandos para construir uma representaç@~{a}o can@^{o}nica.
134 Os nomes desses operadores s@~{a}o @code{"+"} e @code{"*"}.
135 @c ===beg===
136 @c c + g + d + a + b + e + f;
137 @c [op (%), args (%)];
138 @c c * g * d * a * b * e * f;
139 @c [op (%), args (%)];
140 @c apply ("+", [a, 8, x, 2, 9, x, x, a]);
141 @c apply ("*", [a, 8, x, 2, 9, x, x, a]);
142 @c ===end===
144 @example
145 (%i1) c + g + d + a + b + e + f;
146 (%o1) g + f + e + d + c + b + a
147 (%i2) [op (%), args (%)];
148 (%o2) [+, [g, f, e, d, c, b, a]]
149 (%i3) c * g * d * a * b * e * f;
150 (%o3) a b c d e f g
151 (%i4) [op (%), args (%)];
152 (%o4) [*, [a, b, c, d, e, f, g]]
153 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
154 (%o5) 3 x + 2 a + 19
155 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
156 2 3
157 (%o6) 144 a x
158 @end example
160 Divis@~{a}o e exponenciaç@~{a}o s@~{a}o operadores bin@'{a}rios e n@~{a}o comutativos.
161 Os nomes desses operadores s@~{a}o @code{"/"} e @code{"^"}.
162 @c ===beg===
163 @c [a / b, a ^ b];
164 @c [map (op, %), map (args, %)];
165 @c [apply ("/", [a, b]), apply ("^", [a, b])];
166 @c ===end===
168 @example
169 (%i1) [a / b, a ^ b];
170 a b
171 (%o1) [-, a ]
172 b
173 (%i2) [map (op, %), map (args, %)];
174 (%o2) [[/, ^], [[a, b], [a, b]]]
175 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
176 a b
177 (%o3) [-, a ]
178 b
179 @end example
181 Subtraç@~{a}o e divis@~{a}o s@~{a}o representados internamente
182 em termos de adiç@~{a}o e multiplicaç@~{a}o, respectivamente.
183 @c ===beg===
184 @c [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
185 @c [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
186 @c ===end===
188 @example
189 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
190 (%o1) [+, a, - b]
191 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
192 1
193 (%o2) [*, a, -]
194 b
195 @end example
197 C@'{a}lculos s@~{a}o realizados sobre n@'{u}meros lterais.
198 A propagaç@~{a}o de n@'{u}meros em poto flutuante aplica-se.
199 @c ===beg===
200 @c 17 + b - (1/2)*29 + 11^(2/4);
201 @c [17 + 29, 17 + 29.0, 17 + 29b0];
202 @c ===end===
204 @example
205 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
206 5
207 (%o1) b + sqrt(11) + -
208 2
209 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
210 (%o2) [46, 46.0, 4.6b1]
211 @end example
213 Computaç@~oes aritm@'{e}ticas s@~{a}o uma simplificaç@~{a}o, n@~{a}o uma avaliaç@~{a}o.
214 @c ===beg===
215 @c simp : false;
216 @c '(17 + 29*11/7 - 5^3);
217 @c simp : true;
218 @c '(17 + 29*11/7 - 5^3);
219 @c ===end===
221 @example
222 (%i1) simp : false;
223 (%o1) false
224 (%i2) '(17 + 29*11/7 - 5^3);
225 29 11 3
226 (%o2) 17 + ----- - 5
227 7
228 (%i3) simp : true;
229 (%o3) true
230 (%i4) '(17 + 29*11/7 - 5^3);
231 437
232 (%o4) - ---
233 7
234 @end example
236 A aritm@'{e}tica @'{e} realizada elemento-por-elemento para listas lists (dependendo de @code{listarith}) e dependendo de matrizes.
237 @c ===beg===
238 @c matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
239 @c 5 * matrix ([a, x], [h, u]);
240 @c listarith : false;
241 @c [a, c, m, t] / [1, 7, 2, 9];
242 @c [a, c, m, t] ^ x;
243 @c listarith : true;
244 @c [a, c, m, t] / [1, 7, 2, 9];
245 @c [a, c, m, t] ^ x;
246 @c ===end===
248 @example
249 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
250 [ a - 1 x - 2 ]
251 (%o1) [ ]
252 [ h - 3 u - 4 ]
253 (%i2) 5 * matrix ([a, x], [h, u]);
254 [ 5 a 5 x ]
255 (%o2) [ ]
256 [ 5 h 5 u ]
257 (%i3) listarith : false;
258 (%o3) false
259 (%i4) [a, c, m, t] / [1, 7, 2, 9];
260 [a, c, m, t]
261 (%o4) ------------
262 [1, 7, 2, 9]
263 (%i5) [a, c, m, t] ^ x;
264 x
265 (%o5) [a, c, m, t]
266 (%i6) listarith : true;
267 (%o6) true
268 (%i7) [a, c, m, t] / [1, 7, 2, 9];
269 c m t
270 (%o7) [a, -, -, -]
271 7 2 9
272 (%i8) [a, c, m, t] ^ x;
273 x x x x
274 (%o8) [a , c , m , t ]
275 @end example
277 @end deffn
279 @deffn {Operador} **
281 Operador de exponenciaç@~{a}o.
282 Maxima reconhece @code{**} como o mesmo operador que @code{^} em entrada,
283 e @code{**} @'{e} mostrado como @code{^} em sa@'{i}da unidimensional,
284 ou colocando o expoente como sobrescrito em sa@'{i}da bidimensional.
286 A funç@~{a}o @code{fortran} mostra o operador de exponenciaç@~{a}o com como @code{**},
287 independente de a entrada ter sido na forma @code{**} ou a forma @code{^}.
289 Exemplos:
291 @c ===beg===
292 @c is (a**b = a^b);
293 @c x**y + x^z;
294 @c string (x**y + x^z);
295 @c fortran (x**y + x^z);
296 @c ===end===
297 @example
298 (%i1) is (a**b = a^b);
299 (%o1) true
300 (%i2) x**y + x^z;
301 z y
302 (%o2) x + x
303 (%i3) string (x**y + x^z);
304 (%o3) x^z+x^y
305 (%i4) fortran (x**y + x^z);
306 x**z+x**y
307 (%o4) done
308 @end example
310 @end deffn
312 @node Operadores Relacionais, Operadores Geral, Operadores Aritm@'{e}ticos, Operadores
313 @section Operadores Relacionais
315 @deffn {Operador} <
316 @ifinfo
317 @fnindex Menor que
318 @end ifinfo
319 @deffnx {Operador} <=
320 @ifinfo
321 @fnindex Menor que ou igual a
322 @end ifinfo
323 @deffnx {Operador} >=
324 @ifinfo
325 @fnindex Maior que ou igual a
326 @end ifinfo
327 @deffnx {Operador} >
328 @ifinfo
329 @fnindex Maior que
330 @end ifinfo
332 @end deffn
334 @node Operadores Geral, , Operadores Relacionais, Operadores
335 @section Operadores Geral
337 @deffn {Operador} ^^
338 @ifinfo
339 @fnindex exponenciaç@~{a}o n@~{a}o comutativa
340 @end ifinfo
342 @end deffn
344 @deffn {Operador} !
345 @ifinfo
346 @fnindex Fatorial
347 @end ifinfo
348 O operador fatorial.
349 Para qualquer n@'{u}mero complexo @code{x} (inclu@'{i}ndo n@'{u}meros inteiros, racionais, e reais) exceto para
350 inteiros negativos, @code{x!} @'{e} definido como @code{gamma(x+1)}.
352 Para um inteiro @code{x}, @code{x!} simplifica para o produto de inteiros de 1 a @code{x} inclusive.
353 @code{0!} simplifica para 1.
354 Para um n@'{u}mero em ponto flutuante @code{x}, @code{x!} simplifica para o valor de @code{gamma (x+1)}.
355 Para @code{x} igual a @code{n/2} onde @code{n} @'{e} um inteiro @'{i}mpar,
356 @code{x!} simplifica para um fator racional vezes @code{sqrt (%pi)}
357 (uma vez que @code{gamma (1/2)} @'{e} igual a @code{sqrt (%pi)}).
358 Se @code{x} for qualquer outra coisa,
359 @code{x!} n@~{a}o @'{e} simplificado.
361 As vari@'{a}veis
362 @code{factlim}, @code{minfactorial}, e @code{factcomb} controlam a simplificaç@~{a}o
363 de express@~{o}es contendo fatoriais.
365 As funç@~{o}es @code{gamma}, @code{bffac}, e @code{cbffac}
366 s@~{a}o variedades da funç@~{a}o @code{gamma}.
367 @code{makegamma} substitui @code{gamma} para funç@~{o}es relacionadas a fatoriais.
369 Veja tamb@'{e}m @code{binomial}.
371 O fatorial de um inteiro, inteiro dividido por dois, ou argumento em ponto flutuante @'{e} simplificado
372 a menos que o operando seja maior que @code{factlim}.
374 @c ===beg===
375 @c factlim : 10;
376 @c [0!, (7/2)!, 4.77!, 8!, 20!];
377 @c ===end===
378 @example
379 (%i1) factlim : 10;
380 (%o1) 10
381 (%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
382 + 105 sqrt(%pi)
383 +(%o2) [1, -------------, 81.44668037931199, 40320, 20!]
384 + 16
385 @end example
387 O fatorial de um n@'{u}mero complexo, constante conhecida, ou express@~{a}o geral n@~{a}o @'{e} simplificado.
388 Ainda assim pode ser poss@'{i}vel simplificar o fatorial ap@'{o}s avaliar o operando.
390 @c ===beg===
391 @c [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
392 @c ev (%, numer, %enumer);
393 @c ===end===
394 @example
395 (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
396 (%o1) [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
397 (%i2) ev (%, numer, %enumer);
398 (%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357,
399 1.227580202486819]
400 @end example
402 O fatorial de um s@'{i}mbolo n@~{a}o associado n@~{a}o @'{e} simplificado.
404 @c ===beg===
405 @c kill (foo);
406 @c foo!;
407 @c ===end===
408 @example
409 (%i1) kill (foo);
410 (%o1) done
411 (%i2) foo!;
412 (%o2) foo!
413 @end example
415 Fatoriais s@~{a}o simplificados, n@~{a}o avaliados.
416 Dessa forma @code{x!} pode ser substitu@'{i}do mesmo em uma express@~{a}o com ap@'{o}strofo.
418 @c ===beg===
419 @c '([0!, (7/2)!, 4.77!, 8!, 20!]);
420 @c ===end===
421 @example
422 (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
423 105 sqrt(%pi)
424 (%o1) [1, -------------, 81.44668037931199, 40320,
425 16
426 2432902008176640000]
427 @end example
429 @end deffn
431 @deffn {Operador} !!
432 @ifinfo
433 @fnindex Duplo fatorial
434 @end ifinfo
435 O operador de duplo fatorial.
437 Para um n@'{u}mero inteiro, n@'{u}mero em ponto flutuante, ou n@'{u}mero racional @code{n},
438 @code{n!!} avalia para o produto @code{n (n-2) (n-4) (n-6) ... (n - 2 (k-1))}
439 onde @code{k} @'{e} igual a @code{entier (n/2)},
440 que @'{e}, o maior inteiro menor que ou igual a @code{n/2}.
441 Note que essa definiç@~{a}o n@~{a}o coincide com outras definiç@~{o}es publicadas
442 para argumentos que n@~{a}o s@~{a}o inteiros.
443 @c REPORTED TO BUG TRACKER AS BUG # 1093138 !!!
445 Para um inteiro par (ou @'{i}mpar) @code{n}, @code{n!!} avalia para o produto de
446 todos os inteiros consecutivos pares (ou @'{i}mpares) de 2 (ou 1) at@'{e} @code{n} inclusive.
448 Para um argumento @code{n} que n@~{a}o @'{e} um n@'{u}mero inteiro, um n@'{u}mero em ponto flutuante, ou um n@'{u}mero racional,
449 @code{n!!} retorna uma forma substantiva @code{genfact (n, n/2, 2)}.
450 @c n!! IS NEITHER SIMPLIFIED NOR EVALUATED IN THIS CASE -- MENTION THAT? OR TOO MUCH DETAIL ???
452 @end deffn
454 @deffn {Operador} #
455 @ifinfo
456 @fnindex N@~{a}o igual (desigualdade sint@'{a}tica)
457 @end ifinfo
458 Representa a negaç@~{a}o da igualdade sint@'{a}tica @code{=}.
460 Note que pelo fato de as regras de avaliaç@~{a}o de express@~{o}es predicadas
461 (em particular pelo fato de @code{not @var{expr}} fazer com que ocorra a avaliaç@~{a}o de @var{expr}),
462 a forma @code{not @var{a} = @var{b}} n@~{a}o @'{e} equivalente @`a forma @code{@var{a} # @var{b}} em alguns casos.
464 Note que devido @`as regras para avaliaç@~{a}o de express@~{o}es predicadas
465 (em particular devido a @code{not @var{expr}} fazer com que a avaliaç@~{a}o de @var{expr} ocorra),
466 @code{not @var{a} = @var{b}} @'{e} equivalente a @code{is(@var{a} # @var{b})},
467 em lugar de ser equivalente a @code{@var{a} # @var{b}}.
469 Exemplos:
470 @c ===beg===
471 @c a = b;
472 @c @'{e} (a = b);
473 @c a # b;
474 @c not a = b;
475 @c @'{e} (a # b);
476 @c @'{e} (not a = b);
477 @c ===end===
478 @example
479 (%i1) a = b;
480 (%o1) a = b
481 (%i2) @'{e} (a = b);
482 (%o2) false
483 (%i3) a # b;
484 (%o3) a # b
485 (%i4) not a = b;
486 (%o4) true
487 (%i5) @'{e} (a # b);
488 (%o5) true
489 (%i6) @'{e} (not a = b);
490 (%o6) true
491 @end example
493 @end deffn
495 @deffn {Operador} .
496 @ifinfo
497 @fnindex Multiplicaç@~{a}o n@~{a}o comutativa matricial
498 @end ifinfo
499 O operador ponto, para multiplicaç@~{a}o (n@~{a}o comutativa) de matrizes.
500 Quando "." @'{e} usado com essa finalidade, espaços devem ser colocados em ambos os lados desse
501 operador, e.g. A . B. Isso disting@"{u}e o operador ponto plenamente de um ponto decimal em
502 um n@'{u}mero em ponto flutuante.
504 Veja tamb@'{e}m
505 @code{dot},
506 @code{dot0nscsimp},
507 @code{dot0simp},
508 @code{dot1simp},
509 @code{dotassoc},
510 @code{dotconstrules},
511 @code{dotdistrib},
512 @code{dotexptsimp},
513 @code{dotident},
514 e
515 @code{dotscrules}.
517 @end deffn
519 @deffn {Operador} :
520 @ifinfo
521 @fnindex Operador de atribuiç@~{a}o
522 @end ifinfo
523 O operador de atribuiç@~{a}o. E.g. A:3 escolhe a vari@'{a}vel A para 3.
525 @end deffn
527 @deffn {Operador} ::
528 @ifinfo
529 @fnindex Operador de atribuiç@~{a}o (avalia o lado esquerdo da igualdade)
530 @end ifinfo
531 Operador de atribuiç@~{a}o. :: atribui o valor da express@~{a}o
532 em seu lado direito para o valor da quantidade na sua esquerda, que pode
533 avaliar para uma vari@'{a}vel at@^{o}mica ou vari@'{a}vel subscrita.
535 @end deffn
537 @deffn {Operador} ::=
538 @ifinfo
539 @fnindex Operador de definiç@~{a}o de funç@~{a}o de macro
540 @end ifinfo
541 Operador de definiç@~{a}o de funç@~{a}o de macro.
542 @code{::=} define uma funç@~{a}o (chamada uma "macro" por raz@~{o}es hist@'{o}ricas)
543 que coloca um ap@'{o}strofo em seus argumentos (evitando avaliaç@~{a}o),
544 e a express@~{a}o que @'{e} retornada (chamada a "expans@~{a}o de macro")
545 @'{e} avaliada no contexto a partir do qual a macro foi chamada.
546 Uma funç@~{a}o de macro @'{e} de outra forma o mesmo que uma funç@~{a}o comum.
548 @code{macroexpand} retorna uma expans@~{a}o de macro (sem avaliar a expans@~{a}o).
549 @code{macroexpand (foo (x))} seguida por @code{''%} @'{e} equivalente a @code{foo (x)}
550 quando @code{foo} for uma funç@~{a}o de macro.
552 @code{::=} coloca o nome da nova funç@~{a}o de macro dentro da lista global @code{macros}.
553 @code{kill}, @code{remove}, e @code{remfunction} desassocia definiç@~{o}es de funç@~{a}o de macro
554 e remove nomes de @code{macros}.
556 @code{fundef} e @code{dispfun} retornam respectivamente uma definiç@~{a}o de funç@~{a}o de macro
557 e uma atribuiç@~{a}o dessa definiç@~{a}o a um r@'{o}tulo, respectivamente.
559 Funç@~{o}es de macro comumente possuem express@~{o}es @code{buildq} e
560 @code{splice} para construir uma express@~{a}o,
561 que @'{e} ent@~{a}o avaliada.
563 Exemplos
565 Uma funç@~{a}o de macro coloca um ap@'{o}strofo em seus argumentos evitando ent@~{a}o a avaliaç@~{a}o,
566 ent@~{a}o mensagem (1) mostra @code{y - z}, n@~{a}o o valor de @code{y - z}.
567 A expans@~{a}o de macro (a express@~{a}o com ap@'{o}strofo @code{'(print ("(2) x is equal to", x))}
568 @'{e} avaliada no contexto a partir do qual a macro for chamada,
569 mostrando a mensagem (2).
571 @c ===beg===
572 @c x: %pi;
573 @c y: 1234;
574 @c z: 1729 * w;
575 @c printq1 (x) ::= block (print ("(1) x is equal to", x), '(print ("(2) x is equal to", x)));
576 @c printq1 (y - z);
577 @c ===end===
578 @example
579 (%i1) x: %pi;
580 (%o1) %pi
581 (%i2) y: 1234;
582 (%o2) 1234
583 (%i3) z: 1729 * w;
584 (%o3) 1729 w
585 (%i4) printq1 (x) ::= block (print ("(1) x @'{e} igual a", x), '(print ("(2) x @'{e} igual a", x)));
586 (%o4) printq1(x) ::= block(print("(1) x @'{e} igual a", x),
587 '(print("(2) x @'{e} igual a", x)))
588 (%i5) printq1 (y - z);
589 (1) x @'{e} igual a y - z
590 (2) x @'{e} igual a %pi
591 (%o5) %pi
592 @end example
594 Uma funç@~{a}o comum avalia seus argumentos, ent@~{a}o message (1) mostra o valor de @code{y - z}.
595 O valor de retorno n@~{a}o @'{e} avaliado, ent@~{a}o mensagem (2) n@~{a}o @'{e} mostrada
596 at@'{e} a avaliaç@~{a}o expl@'{i}cita @code{''%}.
598 @c ===beg===
599 @c x: %pi;
600 @c y: 1234;
601 @c z: 1729 * w;
602 @c printe1 (x) := block (print ("(1) x @'{e} igual a", x), '(print ("(2) x @'{e} igual a", x)));
603 @c printe1 (y - z);
604 @c ''%;
605 @c ===end===
606 @example
607 (%i1) x: %pi;
608 (%o1) %pi
609 (%i2) y: 1234;
610 (%o2) 1234
611 (%i3) z: 1729 * w;
612 (%o3) 1729 w
613 (%i4) printe1 (x) := block (print ("(1) x @'{e} igual a", x), '(print ("(2) x @'{e} igual a", x)));
614 (%o4) printe1(x) := block(print("(1) x @'{e} igual a", x),
615 '(print("(2) x @'{e} igual a", x)))
616 (%i5) printe1 (y - z);
617 (1) x @'{e} igual a 1234 - 1729 w
618 (%o5) print((2) x @'{e} igual a, x)
619 (%i6) ''%;
620 (2) x @'{e} igual a %pi
621 (%o6) %pi
622 @end example
624 @code{macroexpand} retorna uma expans@~{a}o de macro.
625 @code{macroexpand (foo (x))} seguido por @code{''%} @'{e} equivalente a @code{foo (x)}
626 quando @code{foo} for uma funç@~{a}o de macro.
628 @c ===beg===
629 @c x: %pi;
630 @c y: 1234;
631 @c z: 1729 * w;
632 @c g (x) ::= buildq ([x], print ("x @'{e} igual a", x));
633 @c macroexpand (g (y - z));
634 @c ''%;
635 @c g (y - z);
636 @c ===end===
637 @example
638 (%i1) x: %pi;
639 (%o1) %pi
640 (%i2) y: 1234;
641 (%o2) 1234
642 (%i3) z: 1729 * w;
643 (%o3) 1729 w
644 (%i4) g (x) ::= buildq ([x], print ("x @'{e} igual a", x));
645 (%o4) g(x) ::= buildq([x], print("x @'{e} igual a", x))
646 (%i5) macroexpand (g (y - z));
647 (%o5) print(x @'{e} igual a, y - z)
648 (%i6) ''%;
649 x @'{e} igual a 1234 - 1729 w
650 (%o6) 1234 - 1729 w
651 (%i7) g (y - z);
652 x @'{e} igual a 1234 - 1729 w
653 (%o7) 1234 - 1729 w
654 @end example
656 @end deffn
658 @deffn {Operador} :=
659 @ifinfo
660 @fnindex Operador de definiç@~{a}o de funç@~{a}o
661 @end ifinfo
662 O operador de definiç@~{a}o de funç@~{a}o. E.g. @code{f(x):=sin(x)} define
663 uma funç@~{a}o @code{f}.
665 @end deffn
667 @deffn {Operador} =
668 @ifinfo
669 @fnindex Operador de equaç@~{a}o
670 @fnindex Igual (igualdade sint@'{a}tica)
671 @end ifinfo
672 O operador de equaç@~{a}o.
674 Uma express@~{a}o @code{@var{a} = @var{b}}, por si mesma, representa
675 uma equaç@~{a}o n@~{a}o avaliada, a qual pode ou n@~{a}o se manter.
676 Equaç@~{o}es n@~{a}o avaliadas podem aparecer como argumentos para @code{solve} e @code{algsys}
677 ou algumas outras funç@~{o}es.
679 A funç@~{a}o @code{is} avalia @code{=} para um valor Booleano.
680 @code{is(@var{a} = @var{b})} avalia @code{@var{a} = @var{b}} para @code{true} quando @var{a} e @var{b}
681 forem id@^{e}nticos. Isto @'{e}, @var{a} e @var{b} forem @'{a}tomos que s@~{a}o id@^{e}nticos,
682 ou se eles n@~{a}o forem @'{a}tomos e seus operadores forem id@^{e}nticos e seus argumentos forem id@^{e}nticos.
683 De outra forma, @code{is(@var{a} = @var{b})} avalia para @code{false};
684 @code{is(@var{a} = @var{b})} nunca avalia para @code{unknown}.
685 Quando @code{is(@var{a} = @var{b})} for @code{true}, @var{a} e @var{b} s@~{a}o ditos para serem sintaticamente iguais,
686 em contraste para serem express@~{o}es equivalentes, para as quais @code{is(equal(@var{a}, @var{b}))} @'{e} @code{true}.
687 Express@~{o}es podem ser equivalentes e n@~{a}o sint@'{a}ticamente iguais.
689 A negaç@~{a}o de @code{=} @'{e} representada por @code{#}.
690 Da mesma forma que com @code{=}, uma express@~{a}o @code{@var{a} # @var{b}}, por si mesma, n@~{a}o @'{e} avaliada.
691 @code{is(@var{a} # @var{b})} avalia @code{@var{a} # @var{b}} para
692 @code{true} ou @code{false}.
694 Complementando a funç@~{a}o @code{is},
695 alguns outros operadores avaliam @code{=} e @code{#} para @code{true} ou @code{false},
696 a saber @code{if}, @code{and}, @code{or}, e @code{not}.
698 Note que pelo fato de as regras de avaliaç@~{a}o de express@~{o}es predicadas
699 (em particular pelo fato de @code{not @var{expr}} fazer com que ocorra a avaliaç@~{a}o de @var{expr}),
700 a forma @code{not @var{a} = @var{b}} @'{e} equivalente a @code{is(@var{a} # @var{b})},
701 em lugar de ser equivalente a @code{@var{a} # @var{b}}.
703 @code{rhs} e @code{lhs} retornam o primeiro membro e o segundo membro de uma equaç@~{a}o,
704 respectivamente, de uma equaç@~{a}o ou inequaç@~{a}o.
706 Veja tamb@'{e}m @code{equal} e @code{notequal}.
708 Exemplos:
710 Uma express@~{a}o @code{@var{a} = @var{b}}, por si mesma, representa
711 uma equaç@~{a}o n@~{a}o avaliada, a qual pode ou n@~{a}o se manter.
713 @c ===beg===
714 @c eq_1 : a * x - 5 * y = 17;
715 @c eq_2 : b * x + 3 * y = 29;
716 @c solve ([eq_1, eq_2], [x, y]);
717 @c subst (%, [eq_1, eq_2]);
718 @c ratsimp (%);
719 @c ===end===
720 @example
721 (%i1) eq_1 : a * x - 5 * y = 17;
722 (%o1) a x - 5 y = 17
723 (%i2) eq_2 : b * x + 3 * y = 29;
724 (%o2) 3 y + b x = 29
725 (%i3) solve ([eq_1, eq_2], [x, y]);
726 196 29 a - 17 b
727 (%o3) [[x = ---------, y = -----------]]
728 5 b + 3 a 5 b + 3 a
729 (%i4) subst (%, [eq_1, eq_2]);
730 196 a 5 (29 a - 17 b)
731 (%o4) [--------- - --------------- = 17,
732 5 b + 3 a 5 b + 3 a
733 196 b 3 (29 a - 17 b)
734 --------- + --------------- = 29]
735 5 b + 3 a 5 b + 3 a
736 (%i5) ratsimp (%);
737 (%o5) [17 = 17, 29 = 29]
738 @end example
740 @code{is(@var{a} = @var{b})} avalia @code{@var{a} = @var{b}} para @code{true} quando @var{a} e @var{b}
741 s@~{a}o sintaticamente iguais (isto @'{e}, identicos).
742 Express@~{o}es podem ser equivalentes e n@~{a}o sintaticamente iguais.
744 @c ===beg===
745 @c a : (x + 1) * (x - 1);
746 @c b : x^2 - 1;
747 @c [is (a = b), is (a # b)];
748 @c [is (equal (a, b)), is (notequal (a, b))];
749 @c ===end===
750 @example
751 (%i1) a : (x + 1) * (x - 1);
752 (%o1) (x - 1) (x + 1)
753 (%i2) b : x^2 - 1;
754 2
755 (%o2) x - 1
756 (%i3) [is (a = b), is (a # b)];
757 (%o3) [false, true]
758 (%i4) [is (equal (a, b)), is (notequal (a, b))];
759 (%o4) [true, false]
760 @end example
762 Alguns operadores avaliam @code{=} e @code{#} para @code{true} ou @code{false}.
764 @c ===beg===
765 @c if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR;
766 @c eq_3 : 2 * x = 3 * x;
767 @c eq_4 : exp (2) = %e^2;
768 @c [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
769 @c ===end===
770 @example
771 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR;
772 (%o1) FOO
773 (%i2) eq_3 : 2 * x = 3 * x;
774 (%o2) 2 x = 3 x
775 (%i3) eq_4 : exp (2) = %e^2;
776 2 2
777 (%o3) %e = %e
778 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
779 (%o4) [false, true, true]
780 @end example
782 Devido a @code{not @var{expr}} fazer com que a avaliaç@~{a}o de @var{expr} ocorra,
783 @code{not @var{a} = @var{b}} @'{e} equivalente a @code{is(@var{a} # @var{b})}.
785 @c ===beg===
786 @c [2 * x # 3 * x, not (2 * x = 3 * x)];
787 @c is (2 * x # 3 * x);
788 @c ===end===
789 @example
790 (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
791 (%o1) [2 x # 3 x, true]
792 (%i2) is (2 * x # 3 * x);
793 (%o2) true
794 @end example
796 @end deffn
798 @c NEEDS EXAMPLES
799 @deffn {Operador} and
800 @ifinfo
801 @fnindex Conjunç@~{a}o l@'{o}gica
802 @end ifinfo
803 O operador l@'{o}gico de conjunç@~{a}o.
804 @code{and} @'{e} um operador n-@'{a}rio infixo;
805 seus operandos s@~{a}o express@~{o}es Booleanas, e seu resultado @'{e} um valor Booleano.
807 @code{and} força avaliaç@~{a}o (como @code{is}) de um ou mais operandos,
808 e pode forçar a avaliaç@~{a}o de todos os operandos.
810 Operandos s@~{a}o avaliados na ordem em que aparecerem.
811 @code{and} avalia somente quantos de seus operandos forem necess@'{a}rios para determinar o resultado.
812 Se qualquer operando for @code{false},
813 o resultado @'{e} @code{false} e os operandos restantes n@~{a}o s@~{a}o avaliados.
815 O sinalizador global @code{prederror} governa o comportamento de @code{and}
816 quando um operando avaliado n@~{a}o pode ser determinado como sendo @code{true} ou @code{false}.
817 @code{and} imprime uma mensagem de erro quando @code{prederror} for @code{true}.
818 De outra forma, operandos que n@~{a}o avaliam para @code{true} ou para @code{false} s@~{a}o aceitos,
819 and o resultado @'{e} uma express@~{a}o Booleana.
821 @code{and} n@~{a}o @'{e} comutativo:
822 @code{a and b} pode n@~{a}o ser igual a @code{b and a} devido ao tratamento de operandos indeterminados.
824 @end deffn
826 @c NEEDS EXAMPLES
827 @deffn {Operador} or
828 @ifinfo
829 @fnindex Disjunç@~{a}o l@'{o}gica
830 @end ifinfo
831 O operador l@'{o}gico de disjunç@~{a}o.
832 @code{or} @'{e} um operador n-@'{a}rio infixo;
833 seus operandos s@~{a}o express@~{o}es Booleanas, e seu resultado @'{e} um valor Booleano.
835 @code{or} força avaliaç@~{a}o (como @code{is}) de um ou mais operandos,
836 e pode forçar a avaliaç@~{a}o de todos os operandos.
838 Operandos s@~{a}o avaliados na ordem em que aparecem.
839 @code{or} avalia somente quantos de seus operandos forem necess@'{a}rios para determinar o resultado.
840 Se qualquer operando for @code{true},
841 o resultado @'{e} @code{true} e os operandos restantes n@~{a}o s@~{a}o avaliados.
843 O sinalizador global @code{prederror} governa o comportamento de @code{or}
844 quando um operando avaliado n@~{a}o puder ser determinado como sendo @code{true} ou @code{false}.
845 @code{or} imprime uma mensagem de erro quando @code{prederror} for @code{true}.
846 De outra forma, operandos que n@~{a}o avaliam para @code{true} ou para @code{false} s@~{a}o aceitos,
847 E o resultado @'{e} uma express@~{a}o Booleana.
849 @code{or} n@~{a}o @'{e} comutativo:
850 @code{a or b} pode n@~{a}o ser igual a @code{b or a} devido ao tratamento de operando indeterminados.
852 @end deffn
854 @c NEEDS EXAMPLES
855 @deffn {Operador} not
856 @ifinfo
857 @fnindex Negaç@~{a}o l@'{o}gica
858 @end ifinfo
859 O operador l@'{o}gico de negaç@~{a}o.
860 @code{not} @'{e} operador prefixado;
861 Seu operando @'{e} uma express@~{a}o Booleana, e seu resultado @'{e} um valor Booleano.
863 @code{not} força a avaliaç@~{a}o (como @code{is}) de seu operando.
865 O sinalizador global @code{prederror} governa o comportamento de @code{not}
866 quando seu operando n@~{a}o pode ser determinado em termos de @code{true} ou @code{false}.
867 @code{not} imprime uma mensagem de erro quando @code{prederror} for @code{true}.
868 De outra forma, operandos que n@~{a}o avaliam para @code{true} ou para @code{false} s@~{a}o aceitos,
869 e o resultado @'{e} uma express@~{a}o Booleana.
871 @end deffn
873 @deffn {Funç@~{a}o} abs (@var{expr})
874 Retorna o valor absoluto de @var{expr}. Se @var{expr} for um n@'{u}mero complexo, retorna o m@'{o}dulo
875 complexo de @var{expr}.
877 @end deffn
879 @defvr {Palavra chave} additive
880 Se @code{declare(f,additive)} tiver sido executado, ent@~{a}o:
882 (1) Se @code{f} for uma funç@~{a}o de uma @'{u}nica vari@'{a}vel, sempre que o simplificador encontrar @code{f} aplicada
883 a uma adiç@~{a}o, @code{f} ser@'{a} distribu@'{i}do sobre aquela adiç@~{a}o. I.e. @code{f(y+x)} ir@'{a}
884 simplificar para @code{f(y)+f(x)}.
886 (2) Se @code{f} for uma funç@~{a}o de 2 ou mais argumentos, a adiç@~{a}o @'{e} definida como
887 adiç@~{a}o no primeiro argumento para @code{f}, como no caso de @code{sum} ou
888 @code{integrate}, i.e. @code{f(h(x)+g(x),x)} ir@'{a} simplificar para @code{f(h(x),x)+f(g(x),x)}.
889 Essa simplificaç@~{a}o n@~{a}o ocorre quando @code{f} @'{e} aplicada para express@~{o}es da
890 forma @code{sum(x[i],i,lower-limit,upper-limit)}.
892 @end defvr
894 @c NEEDS TO BE REWORKED. NOT CONVINCED THIS SYMBOL NEEDS ITS OWN ITEM
895 @c (SHOULD BE DESCRIBED IN CONTEXT OF EACH FUNCTION WHICH RECOGNIZES IT)
896 @defvr {Palavra chave} allbut
897 trabalha com os comandos @code{part} (i.e. @code{part}, @code{inpart}, @code{substpart},
898 @code{substinpart}, @code{dpart}, e @code{lpart}). Por exemplo,
900 @c ===beg===
901 @c expr : e + d + c + b + a;
902 @c part (expr, [2, 5]);
903 @c ===end===
904 @example
905 (%i1) expr : e + d + c + b + a;
906 (%o1) e + d + c + b + a
907 (%i2) part (expr, [2, 5]);
908 (%o2) d + a
909 @end example
911 enquanto
913 @c ===beg===
914 @c expr : e + d + c + b + a;
915 @c part (expr, allbut (2, 5));
916 @c ===end===
917 @example
918 (%i1) expr : e + d + c + b + a;
919 (%o1) e + d + c + b + a
920 (%i2) part (expr, allbut (2, 5));
921 (%o2) e + c + b
922 @end example
924 @code{allbut} @'{e} tamb@'{e}m reconhecido por @code{kill}.
926 @c ===beg===
927 @c [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
928 @c kill (allbut (cc, dd));
929 @c [aa, bb, cc, dd];
930 @c ===end===
931 @example
932 (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
933 (%o1) [11, 22, 33, 44, 55]
934 (%i2) kill (allbut (cc, dd));
935 (%o0) done
936 (%i1) [aa, bb, cc, dd];
937 (%o1) [aa, bb, 33, 44]
938 @end example
940 @code{kill(allbut(@var{a_1}, @var{a_2}, ...))} tem o mesmo efeito que @code{kill(all)}
941 exceto que n@~{a}o elimina os s@'{i}mbolos @var{a_1}, @var{a_2}, ... .
943 @end defvr
945 @defvr {Declaraç@~{a}o} antisymmetric
946 Se @code{declare(h,antisymmetric)} @'{e} conclu@'{i}da, diz ao
947 simplicador que @code{h} @'{e} uma funç@~{a}o antisim@'{e}trica. E.g. @code{h(x,z,y)} simplificar@'{a} para
948 @code{- h(x, y, z)}. Isto @'{e}, dar@'{a} (-1)^n vezes o resultado dado por
949 @code{symmetric} ou @code{commutative}, quando n for o n@'{u}mero de interescolhas de dois
950 argumentos necess@'{a}rios para converter isso naquela forma.
952 @end defvr
954 @deffn {Funç@~{a}o} cabs (@var{expr})
955 Retorna o valor absoluto complexo (o m@'{o}dulo complexo) de
956 @var{expr}.
958 @end deffn
960 @deffn {Funç@~{a}o} ceiling (@var{x})
962 Quando @var{x} for um n@'{u}mero real, retorna o @'{u}ltimo inteiro que
963 @'{e} maior que ou igual a @var{x}.
965 Se @var{x} for uma express@~{a}o constante (@code{10 * %pi}, por exemplo),
966 @code{ceiling} avalia @var{x} usando grandes n@'{u}meros em ponto flutuante, e
967 aplica @code{ceiling} para o grande n@'{u}mero em ponto flutuante resultante. Porque @code{ceiling} usa
968 avaliaç@~{a}o de ponto flutuante, @'{e} poss@'{i}vel, embora improv@'{a}vel,
969 que @code{ceiling} possa retornar uma valor err@^{o}neo para entradas
970 constantes. Para prevenir erros, a avaliaç@~{a}o de ponto flutuante
971 @'{e} conclu@'{i}da usando tr@^{e}s valores para @code{fpprec}.
973 Para entradas n@~{a}o constantes, @code{ceiling} tenta retornar um valor
974 simplificado. Aqui est@'{a} um exemplo de simplificaç@~{o}es que @code{ceiling}
975 conhece:
977 @c ===beg===
978 @c ceiling (ceiling (x));
979 @c ceiling (floor (x));
980 @c declare (n, integer)$
981 @c [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
982 @c assume (x > 0, x < 1)$
983 @c ceiling (x);
984 @c tex (ceiling (a));
985 @c ===end===
986 @example
987 (%i1) ceiling (ceiling (x));
988 (%o1) ceiling(x)
989 (%i2) ceiling (floor (x));
990 (%o2) floor(x)
991 (%i3) declare (n, integer)$
992 (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
993 (%o4) [n, abs(n), max(n, 6)]
994 (%i5) assume (x > 0, x < 1)$
995 (%i6) ceiling (x);
996 (%o6) 1
997 (%i7) tex (ceiling (a));
998 $$\left \lceil a \right \rceil$$
999 (%o7) false
1000 @end example
1002 A funç@~{a}o @code{ceiling} n@~{a}o mapeia automaticamente sobre listas ou matrizes.
1003 Finalmente, para todas as entradas que forem manifestamente complexas, @code{ceiling} retorna
1004 uma forma substantiva.
1006 Se o intervalo de uma funç@~{a}o @'{e} um subconjunto dos inteiros, o intervalo pode ser
1007 declarado @code{integervalued}. Ambas as funç@~{o}es @code{ceiling} e @code{floor}
1008 podem usar essa informaç@~{a}o; por exemplo:
1010 @c ===beg===
1011 @c declare (f, integervalued)$
1012 @c floor (f(x));
1013 @c ceiling (f(x) - 1);
1014 @c ===end===
1015 @example
1016 (%i1) declare (f, integervalued)$
1017 (%i2) floor (f(x));
1018 (%o2) f(x)
1019 (%i3) ceiling (f(x) - 1);
1020 (%o3) f(x) - 1
1021 @end example
1023 @end deffn
1025 @deffn {Funç@~{a}o} charfun (@var{p})
1027 Retorna 0 quando o predicado @var{p} avaliar para @code{false}; retorna
1028 1 quando o predicado avaliar para @code{true}. Quando o predicado
1029 avaliar para alguma coisa que n@~{a}o @code{true} ou @code{false} (@code{unknown}),
1030 retorna uma forma substantiva.
1032 Exemplos:
1034 @c ===beg===
1035 @c charfun (x < 1);
1036 @c subst (x = -1, %);
1037 @c e : charfun ('"and" (-1 < x, x < 1))$
1038 @c [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1039 @c ===end===
1040 @example
1041 (%i1) charfun (x < 1);
1042 (%o1) charfun(x < 1)
1043 (%i2) subst (x = -1, %);
1044 (%o2) 1
1045 (%i3) e : charfun ('"and" (-1 < x, x < 1))$
1046 (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1047 (%o4) [0, 1, 0]
1048 @end example
1050 @end deffn
1052 @defvr {Declaraç@~{a}o} commutative
1053 Se @code{declare(h,commutative)} @'{e} conclu@'{i}da, diz ao
1054 simplicador que @code{h} @'{e} uma funç@~{a}o comutativa. E.g. @code{h(x,z,y)} ir@'{a}
1055 simplificar para @code{h(x, y, z)}. Isto @'{e} o mesmo que @code{symmetric}.
1057 @end defvr
1059 @deffn {Funç@~{a}o} compare (@var{x}, @var{y})
1061 Retorna um operador de comparaç@~{a}o @var{op}
1062 (@code{<}, @code{<=}, @code{>}, @code{>=}, @code{=}, ou @code{#}) tal que
1063 @code{is (@var{x} @var{op} @var{y})} avalia para @code{true};
1064 quando ou @var{x} ou @var{y} dependendo de @code{%i} e
1065 @code{@var{x} # @var{y}}, retorna @code{notcomparable};
1066 Quando n@~{a}o existir tal operador ou
1067 Maxima n@~{a}o estiver apto a determinar o operador, retorna @code{unknown}.
1069 Exemplos:
1071 @c ===beg===
1072 @c compare (1, 2);
1073 @c compare (1, x);
1074 @c compare (%i, %i);
1075 @c compare (%i, %i + 1);
1076 @c compare (1/x, 0);
1077 @c compare (x, abs(x));
1078 @c ===end===
1079 @example
1080 (%i1) compare (1, 2);
1081 (%o1) <
1082 (%i2) compare (1, x);
1083 (%o2) unknown
1084 (%i3) compare (%i, %i);
1085 (%o3) =
1086 (%i4) compare (%i, %i + 1);
1087 (%o4) notcomparable
1088 (%i5) compare (1/x, 0);
1089 (%o5) #
1090 (%i6) compare (x, abs(x));
1091 (%o6) <=
1092 @end example
1094 A funç@~{a}o @code{compare} n@~{a}o tenta de terminar se o dom@'{i}nio real de
1095 seus argumentos @'{e} n@~{a}o vazio; dessa forma
1097 @c ===beg===
1098 @c compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1099 @c ===end===
1100 @example
1101 (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1102 (%o1) <
1103 @end example
1105 O dom@'{i}nio real de @code{acos (x^2 + 1)} @'{e} vazio.
1107 @end deffn
1109 @deffn {Funç@~{a}o} entier (@var{x})
1110 Retorna o @'{u}ltimo inteiro menor que ou igual a @var{x} onde @var{x} @'{e} num@'{e}rico. @code{fix} (como em
1111 @code{fixnum}) @'{e} um sin@^{o}nimo disso, ent@~{a}o @code{fix(@var{x})} @'{e} precisamente o mesmo.
1113 @end deffn
1115 @c NEEDS CLARIFICATION
1116 @deffn {Funç@~{a}o} equal (@var{a}, @var{b})
1118 Representa a equival@^{e}ncia, isto @'{e}, valor igual.
1120 Por si mesma, @code{equal} n@~{a}o avalia ou simplifica.
1121 A funç@~{a}o @code{is} tenta avaliar @code{equal} para um valor Booleano.
1122 @code{is(equal(@var{a}, @var{b}))}
1123 retorna @code{true} (ou @code{false}) se
1124 e somente se @var{a} e @var{b} forem iguais (ou n@~{a}o iguais) para todos os poss@'{i}veis
1125 valores de suas vari@'{a}veis, como determinado atrav@'{e}s da avaliaç@~{a}o de @code{ratsimp(@var{a} - @var{b})};
1126 se @code{ratsimp} retornar 0, as duas express@~{o}es s@~{a}o consideradas equivalentes.
1127 Duas express@~{o}es podem ser equivalentes mesmo se mesmo se elas n@~{a}o forem sintaticamente iguais (i.e., identicas).
1129 Quando @code{is} falhar em reduzir @code{equal} a @code{true} ou @code{false},
1130 o resultado @'{e} governado atrav@'{e}s do sinalizador global @code{prederror}.
1131 Quando @code{prederror} for @code{true},
1132 @code{is} reclama com uma mensagem de erro.
1133 De outra forma, @code{is} retorna @code{unknown}.
1135 Complementando @code{is},
1136 alguns outros operadores avaliam @code{equal} e @code{notequal} para @code{true} ou @code{false},
1137 a saber @code{if}, @code{and}, @code{or}, e @code{not}.
1139 @c FOLLOWING STATEMENT IS MORE OR LESS TRUE BUT I DON'T THINK THE DETAILS ARE CORRECT
1140 @c Declarations (integer, complex, etc)
1141 @c for variables appearing in @var{a} and @var{b} are ignored by @code{equal}.
1142 @c All variables are effectively assumed to be real-valued.
1144 A negaç@~{a}o de @code{equal} @'{e} @code{notequal}.
1146 Exemplos:
1148 Por si mesmo, @code{equal} n@~{a}o avalia ou simplifica.
1150 @c ===beg===
1151 @c equal (x^2 - 1, (x + 1) * (x - 1));
1152 @c equal (x, x + 1);
1153 @c equal (x, y);
1154 @c ===end===
1155 @example
1156 (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
1157 2
1158 (%o1) equal(x - 1, (x - 1) (x + 1))
1159 (%i2) equal (x, x + 1);
1160 (%o2) equal(x, x + 1)
1161 (%i3) equal (x, y);
1162 (%o3) equal(x, y)
1163 @end example
1165 A funç@~{a}o @code{is} tenta avaliar @code{equal} para um valor Booleano.
1166 @code{is(equal(@var{a}, @var{b}))} retorna @code{true} quando @code{ratsimp(@var{a} - @var{b})} retornar 0.
1167 Duas express@~{o}es podem ser equivalentes mesmo se n@~{a}o forem sintaticamente iguais (i.e., identicas).
1169 @c ===beg===
1170 @c ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1171 @c is (equal (x^2 - 1, (x + 1) * (x - 1)));
1172 @c is (x^2 - 1 = (x + 1) * (x - 1));
1173 @c ratsimp (x - (x + 1));
1174 @c is (equal (x, x + 1));
1175 @c is (x = x + 1);
1176 @c ratsimp (x - y);
1177 @c is (equal (x, y));
1178 @c is (x = y);
1179 @c ===end===
1180 @example
1181 (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1182 (%o1) 0
1183 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
1184 (%o2) true
1185 (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
1186 (%o3) false
1187 (%i4) ratsimp (x - (x + 1));
1188 (%o4) - 1
1189 (%i5) is (equal (x, x + 1));
1190 (%o5) false
1191 (%i6) is (x = x + 1);
1192 (%o6) false
1193 (%i7) ratsimp (x - y);
1194 (%o7) x - y
1195 (%i8) is (equal (x, y));
1196 (%o8) unknown
1197 (%i9) is (x = y);
1198 (%o9) false
1199 @end example
1201 Quando @code{is} falha em reduzir @code{equal} a @code{true} ou @code{false},
1202 o resultado @'{e} governado atrav@'{e}s do sinalizador global @code{prederror}.
1204 @c ===beg===
1205 @c [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1206 @c ratsimp (aa - bb);
1207 @c prederror : true;
1208 @c is (equal (aa, bb));
1209 @c prederror : false;
1210 @c is (equal (aa, bb));
1211 @c ===end===
1212 @example
1213 (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1214 2 2
1215 (%o1) [x + 2 x + 1, x - 2 x - 1]
1216 (%i2) ratsimp (aa - bb);
1217 (%o2) 4 x + 2
1218 (%i3) prederror : true;
1219 (%o3) true
1220 (%i4) is (equal (aa, bb));
1221 Maxima was unable to evaluate the predicate:
1222 2 2
1223 equal(x + 2 x + 1, x - 2 x - 1)
1224 -- an error. Quitting. To debug this try debugmode(true);
1225 (%i5) prederror : false;
1226 (%o5) false
1227 (%i6) is (equal (aa, bb));
1228 (%o6) unknown
1229 @end example
1231 Alguns operadores avaliam @code{equal} e @code{notequal} para @code{true} ou @code{false}.
1233 @c ===beg===
1234 @c if equal (y, y - 1) then FOO else BAR;
1235 @c eq_1 : equal (x, x + 1);
1236 @c eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1237 @c [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1238 @c ===end===
1239 @example
1240 (%i1) if equal (y, y - 1) then FOO else BAR;
1241 (%o1) BAR
1242 (%i2) eq_1 : equal (x, x + 1);
1243 (%o2) equal(x, x + 1)
1244 (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1245 2 2
1246 (%o3) equal(y + 2 y + 1, (y + 1) )
1247 (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1248 (%o4) [false, true, true]
1249 @end example
1251 Devido a @code{not @var{expr}} fazer com que ocorra a avaliaç@~{a}o de @var{expr},
1252 @code{not equal(@var{a}, @var{b})} @'{e} equivalente a @code{is(notequal(@var{a}, @var{b}))}.
1254 @c ===beg===
1255 @c [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1256 @c is (notequal (2*z, 2*z - 1));
1257 @c ===end===
1258 @example
1259 (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1260 (%o1) [notequal(2 z, 2 z - 1), true]
1261 (%i2) is (notequal (2*z, 2*z - 1));
1262 (%o2) true
1263 @end example
1265 @end deffn
1267 @deffn {Funç@~{a}o} floor (@var{x})
1269 Quando @var{x} for um n@'{u}mero real, retorna o maior inteiro que
1270 @'{e} menor que ou igual a @var{x}.
1272 Se @var{x} for uma express@~{a}o constante (@code{10 * %pi}, for exemplo),
1273 @code{floor} avalia @var{x} usando grandes n@'{u}meros em ponto flutuante, e
1274 aplica @code{floor} ao grande n@'{u}mero em ponto flutuante resultante. Porque @code{floor} usa
1275 avaliaç@~{a}o em ponto flutuante, @'{e} poss@'{i}vel, embora improv@'{a}vel,
1276 que @code{floor} n@~{a}o possa retornar um valor err@^{o}neo para entradas
1277 constantes. Para prevenir erros, a avaliaç@~{a}o de ponto flutuante
1278 @'{e} conclu@'{i}da usando tr@^{e}s valores para @code{fpprec}.
1280 Para entradas n@~{a}o constantes, @code{floor} tenta retornar um valor
1281 simplificado. Aqui est@'{a} exemplos de simplificaç@~{o}es que @code{floor}
1282 conhece:
1284 @c ===beg===
1285 @c floor (ceiling (x));
1286 @c floor (floor (x));
1287 @c declare (n, integer)$
1288 @c [floor (n), floor (abs (n)), floor (min (n, 6))];
1289 @c assume (x > 0, x < 1)$
1290 @c floor (x);
1291 @c tex (floor (a));
1292 @c ===end===
1293 @example
1294 (%i1) floor (ceiling (x));
1295 (%o1) ceiling(x)
1296 (%i2) floor (floor (x));
1297 (%o2) floor(x)
1298 (%i3) declare (n, integer)$
1299 (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
1300 (%o4) [n, abs(n), min(n, 6)]
1301 (%i5) assume (x > 0, x < 1)$
1302 (%i6) floor (x);
1303 (%o6) 0
1304 (%i7) tex (floor (a));
1305 $$\left \lfloor a \right \rfloor$$
1306 (%o7) false
1307 @end example
1309 A funç@~{a}o @code{floor} n@~{a}o mapeia automaticamente sobre listas ou matrizes.
1310 Finalmente, para todas as entradas que forem manifestamente complexas, @code{floor} retorna
1311 uma forma substantiva.
1313 Se o intervalo de uma funç@~{a}o for um subconjunto dos inteiros, o intervalo pode ser
1314 declarado @code{integervalued}. Ambas as funç@~{o}es @code{ceiling} e @code{floor}
1315 podem usar essa informaç@~{a}o; por exemplo:
1317 @c ===beg===
1318 @c declare (f, integervalued)$
1319 @c floor (f(x));
1320 @c ceiling (f(x) - 1);
1321 @c ===end===
1322 @example
1323 (%i1) declare (f, integervalued)$
1324 (%i2) floor (f(x));
1325 (%o2) f(x)
1326 (%i3) ceiling (f(x) - 1);
1327 (%o3) f(x) - 1
1328 @end example
1330 @end deffn
1332 @deffn {Funç@~{a}o} notequal (@var{a}, @var{b})
1333 Represents the negation of @code{equal(@var{a}, @var{b})}.
1335 Exemplos:
1337 @c ===beg===
1338 @c equal (a, b);
1339 @c maybe (equal (a, b));
1340 @c notequal (a, b);
1341 @c not equal (a, b);
1342 @c maybe (notequal (a, b));
1343 @c assume (a > b);
1344 @c equal (a, b);
1345 @c maybe (equal (a, b));
1346 @c notequal (a, b);
1347 @c maybe (notequal (a, b));
1348 @c ===end===
1349 @example
1350 (%i1) equal (a, b);
1351 (%o1) equal(a, b)
1352 (%i2) maybe (equal (a, b));
1353 (%o2) unknown
1354 (%i3) notequal (a, b);
1355 (%o3) notequal(a, b)
1356 (%i4) not equal (a, b);
1357 (%o4) notequal(a, b)
1358 (%i5) maybe (notequal (a, b));
1359 (%o5) unknown
1360 (%i6) assume (a > b);
1361 (%o6) [a > b]
1362 (%i7) equal (a, b);
1363 (%o7) equal(a, b)
1364 (%i8) maybe (equal (a, b));
1365 (%o8) false
1366 (%i9) notequal (a, b);
1367 (%o9) notequal(a, b)
1368 (%i10) maybe (notequal (a, b));
1369 (%o10) true
1370 @end example
1372 @end deffn
1374 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
1375 @c NOTE THAT eval IS RECOGNIZED ONLY AS AN ARGUMENT TO ev,
1376 @c BUT FOR SOME REASON eval DOES NOT HAVE THE evflag PROPERTY
1377 @deffn {Operador} eval
1378 Como um argumento em uma chamada a @code{ev (@var{expr})},
1379 @code{eval} causa uma avaliaç@~{a}o extra de @var{expr}.
1380 Veja @code{ev}.
1382 @end deffn
1384 @deffn {Funç@~{a}o} evenp (@var{expr})
1385 Retorna @code{true} se @var{expr} for um inteiro sempre.
1386 @c THIS IS STRANGE -- SHOULD RETURN NOUN FORM IF INDETERMINATE
1387 @code{false} @'{e} retornado em todos os outros casos.
1389 @end deffn
1391 @deffn {Funç@~{a}o} fix (@var{x})
1392 Um sin@^{o}nimo para @code{entier (@var{x})}.
1394 @end deffn
1396 @deffn {Funç@~{a}o} fullmap (@var{f}, @var{expr_1}, ...)
1397 Similar a @code{map}, mas @code{fullmap} mant@'{e}m mapeadas para
1398 baixo todas as subexpress@~{o}es at@'{e} que os operadores principais n@~{a}o mais sejam os
1399 mesmos.
1401 @code{fullmap} @'{e} usada pelo simplificador do
1402 Maxima para certas manipulaç@~{o}es de matrizes; dessa forma, Maxima algumas vezes gera
1403 uma mensagem de erro concernente a @code{fullmap} mesmo apesar de @code{fullmap} n@~{a}o ter sido
1404 explicitamente chamada pelo usu@'{a}rio.
1406 Exemplos:
1408 @c ===beg===
1409 @c a + b * c;
1410 @c fullmap (g, %);
1411 @c map (g, %th(2));
1412 @c ===end===
1413 @example
1414 (%i1) a + b * c;
1415 (%o1) b c + a
1416 (%i2) fullmap (g, %);
1417 (%o2) g(b) g(c) + g(a)
1418 (%i3) map (g, %th(2));
1419 (%o3) g(b c) + g(a)
1420 @end example
1422 @end deffn
1424 @deffn {Funç@~{a}o} fullmapl (@var{f}, @var{list_1}, ...)
1425 Similar a @code{fullmap}, mas @code{fullmapl} somente mapeia sobre
1426 listas e matrizes.
1428 Exemplo:
1430 @c ===beg===
1431 @c fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1432 @c ===end===
1433 @example
1434 (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1435 (%o1) [[a + 3, 4], [4, 3.5]]
1436 @end example
1438 @end deffn
1440 @deffn {Funç@~{a}o} is (@var{expr})
1441 Tenta determinar se a @var{expr} predicada (express@~{o}es que avaliam para @code{true}
1442 ou @code{false}) @'{e} dedut@'{i}vel de fatos localizados na base de dados de @code{assume}.
1444 Se a dedutibilidade do predicado for @code{true} ou @code{false},
1445 @code{is} retorna @code{true} ou @code{false}, respectivamente.
1446 De outra forma, o valor de retorno @'{e} governado atrav@'{e}s do sinalizador global @code{prederror}.
1447 Quando @code{prederror} for @code{true},
1448 @code{is} reclama com uma mensagem de erro.
1449 De outra forma, @code{is} retorna @code{unknown}.
1451 @code{ev(@var{expr}, pred)}
1452 (que pode ser escrita da forma @code{@var{expr}, pred} na linha de comando interativa)
1453 @'{e} equivalente a @code{is(@var{expr})}.
1455 Veja tamb@'{e}m @code{assume}, @code{facts}, e @code{maybe}.
1457 Exemplos:
1459 @code{is} causa avaliaç@~{a}o de predicados.
1460 @c GENERATED FROM:
1461 @c %pi > %e;
1462 @c @'{e} (%pi > %e);
1464 @example
1465 (%i1) %pi > %e;
1466 (%o1) %pi > %e
1467 (%i2) @'{e} (%pi > %e);
1468 (%o2) true
1469 @end example
1471 @code{is} tenta derivar predicados da base de dados do @code{assume}.
1473 @c ===beg===
1474 @c assume (a > b);
1475 @c assume (b > c);
1476 @c @'{e} (a < b);
1477 @c @'{e} (a > c);
1478 @c @'{e} (equal (a, c));
1479 @c ===end===
1480 @example
1481 (%i1) assume (a > b);
1482 (%o1) [a > b]
1483 (%i2) assume (b > c);
1484 (%o2) [b > c]
1485 (%i3) @'{e} (a < b);
1486 (%o3) false
1487 (%i4) @'{e} (a > c);
1488 (%o4) true
1489 (%i5) @'{e} (equal (a, c));
1490 (%o5) false
1491 @end example
1493 Se @code{is} n@~{a}o puder nem comprovar nem refutar uma forma predicada a partir da base de dados de @code{assume},
1494 o sinalizador global @code{prederror} governa o comportamento de @code{is}.
1496 @c ===beg===
1497 @c assume (a > b);
1498 @c prederror: true$
1499 @c @'{e} (a > 0);
1500 @c prederror: false$
1501 @c @'{e} (a > 0);
1502 @c ===end===
1503 @example
1504 (%i1) assume (a > b);
1505 (%o1) [a > b]
1506 (%i2) prederror: true$
1507 (%i3) @'{e} (a > 0);
1508 Maxima was unable to evaluate the predicate:
1509 a > 0
1510 -- an error. Quitting. To debug this try debugmode(true);
1511 (%i4) prederror: false$
1512 (%i5) @'{e} (a > 0);
1513 (%o5) unknown
1514 @end example
1516 @end deffn
1518 @deffn {Funç@~{a}o} maybe (@var{expr})
1519 Tenta determinar se a @var{expr} predicada
1520 @'{e} dedut@'{i}vel dos fatos na base de dados de @code{assume}.
1522 Se a dedutibilidade do predicado for @code{true} ou @code{false},
1523 @code{maybe} retorna @code{true} ou @code{false}, respectivamente.
1524 De outra forma, @code{maybe} retorna @code{unknown}.
1526 @code{maybe} @'{e} funcinalmente equivalente a @code{is} com @code{prederror: false},
1527 mas o resultado @'{e} computado sem atualmente atribuir um valor a @code{prederror}.
1529 Veja tamb@'{e}m @code{assume}, @code{facts}, e @code{is}.
1531 Exemplos:
1533 @c ===beg===
1534 @c maybe (x > 0);
1535 @c assume (x > 1);
1536 @c maybe (x > 0);
1537 @c ===end===
1538 @example
1539 (%i1) maybe (x > 0);
1540 (%o1) unknown
1541 (%i2) assume (x > 1);
1542 (%o2) [x > 1]
1543 (%i3) maybe (x > 0);
1544 (%o3) true
1545 @end example
1547 @end deffn
1549 @deffn {Funç@~{a}o} isqrt (@var{x})
1550 Retorna o "inteiro ra@'{i}z quadrada"
1551 do valor absoluto de @var{x},
1552 que @'{e} um inteiro.
1554 @end deffn
1556 @deffn {Funç@~{a}o} lmax (@var{L})
1558 Quando @var{L} for uma lista ou um conjunto, retorna @code{apply ('max, args (@var{L}))}. Quando @var{L} n@~{a}o for uma
1559 lista ou tamb@'{e}m n@~{a}o for um conjunto, sinaliza um erro.
1561 @end deffn
1563 @deffn {Funç@~{a}o} lmin (@var{L})
1565 Quando @var{L} for uma lista ou um conjunto, retorna @code{apply ('min, args (@var{L}))}. Quando @var{L} n@~{a}o for uma
1566 lista ou ou tamb@'{e}m n@~{a}o for um conjunto, sinaliza um erro.
1568 @end deffn
1570 @deffn {Funç@~{a}o} max (@var{x_1}, ..., @var{x_n})
1572 Retorna um valor simplificado para o m@'{a}ximo entre as express@~{o}es @var{x_1} a @var{x_n}.
1573 Quando @code{get (trylevel, maxmin)}, for dois ou mais, @code{max} usa a simplificaç@~{a}o
1574 @code{max (e, -e) --> |e|}. Quando @code{get (trylevel, maxmin)} for 3 ou mais, @var{max} tenta
1575 eliminar express@~{o}es que estiverem entre dois outros argumentos; por exemplo,
1576 @code{max (x, 2*x, 3*x) --> max (x, 3*x)}. Para escolher o valor de @code{trylevel} para 2, use
1577 @code{put (trylevel, 2, maxmin)}.
1579 @end deffn
1581 @deffn {Funç@~{a}o} min (@var{x_1}, ..., @var{x_n})
1583 Retorna um valor simplificado para o m@'{i}nimo entre as express@~{o}es @code{x_1} at@'{e} @code{x_n}.
1584 Quando @code{get (trylevel, maxmin)}, for 2 ou mais, @code{min} usa a simplificaç@~{a}o
1585 @code{min (e, -e) --> -|e|}. Quando @code{get (trylevel, maxmin)} for 3 ou mais, @code{min} tenta
1586 eliminar express@~{o}es que estiverem entre dois outros argumentos; por exemplo,
1587 @code{min (x, 2*x, 3*x) --> min (x, 3*x)}. Para escolher o valor de @code{trylevel} para 2, use
1588 @code{put (trylevel, 2, maxmin)}.
1590 @end deffn
1592 @deffn {Funç@~{a}o} polymod (@var{p})
1593 @deffnx {Funç@~{a}o} polymod (@var{p}, @var{m})
1594 Converte o polin@^{o}mio @var{p} para uma representaç@~{a}o modular
1595 com relaç@~{a}o ao m@'{o}dulo corrente que @'{e} o valor da vari@'{a}vel
1596 @code{modulus}.
1598 @code{polymod (@var{p}, @var{m})} especifica um m@'{o}dulo @var{m} para ser usado
1599 em lugar do valor corrente de @code{modulus}.
1601 Veja @code{modulus}.
1603 @end deffn
1605 @deffn {Funç@~{a}o} mod (@var{x}, @var{y})
1607 Se @var{x} e @var{y} forem n@'{u}meros reais e @var{y} for n@~{a}o nulo,
1608 retorna @code{@var{x} - @var{y} * floor(@var{x} / @var{y})}.
1609 Adicionalmente para todo real @var{x}, n@'{o}s temos @code{mod (@var{x}, 0) = @var{x}}. Para uma discurs@~{a}o da
1610 definiç@~{a}o @code{mod (@var{x}, 0) = @var{x}}, veja a Seç@~{a}o 3.4, de "Concrete Mathematics,"
1611 por Graham, Knuth, e Patashnik. A funç@~{a}o @code{mod (@var{x}, 1)}
1612 @'{e} uma funç@~{a}o dente de serra com per@'{i}odo 1 e com @code{mod (1, 1) = 0} e
1613 @code{mod (0, 1) = 0}.
1615 Para encontrar o argumento (um n@'{u}mero no intervalo @code{(-%pi, %pi]}) de um
1616 n@'{u}mero complexo, use a funç@~{a}o @code{@var{x} |-> %pi - mod (%pi - @var{x}, 2*%pi)}, onde
1617 @var{x} @'{e} um argumento.
1619 Quando @var{x} e @var{y} forem express@~{o}es constantes (@code{10 * %pi}, por exemplo), @code{mod}
1620 usa o mesmo esquema de avaliaç@~{a}o em ponto flutuante que @code{floor} e @code{ceiling} usam.
1621 Novamente, @'{e} poss@'{i}vel, embora improv@'{a}vel, que @code{mod} possa retornar um
1622 valor err@^{o}neo nesses casos.
1624 Para argumentos n@~{a}o num@'{e}ricos @var{x} ou @var{y}, @code{mod }conhece muitas regras de
1625 simplificaç@~{a}o:
1627 @c ===beg===
1628 @c mod (x, 0);
1629 @c mod (a*x, a*y);
1630 @c mod (0, x);
1631 @c ===end===
1632 @example
1633 (%i1) mod (x, 0);
1634 (%o1) x
1635 (%i2) mod (a*x, a*y);
1636 (%o2) a mod(x, y)
1637 (%i3) mod (0, x);
1638 (%o3) 0
1639 @end example
1641 @end deffn
1643 @deffn {Funç@~{a}o} oddp (@var{expr})
1644 @'{e} @code{true} se @var{expr} for um inteiro @'{i}mpar.
1645 @c THIS IS STRANGE -- SHOULD RETURN NOUN FORM IF INDETERMINATE
1646 @code{false} @'{e} retornado em todos os outros casos.
1648 @end deffn
1650 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
1651 @c NOTE THAT pred IS RECOGNIZED ONLY AS AN ARGUMENT TO ev,
1652 @c BUT FOR SOME REASON pred DOES NOT HAVE THE evflag PROPERTY
1653 @deffn {Operador} pred
1654 Como um argumento em uma chamada a @code{ev (@var{expr})},
1655 @code{pred} faz com que predicados (express@~{o}es que avaliam para @code{true}
1656 ou @code{false}) sejam avaliados.
1657 Veja @code{ev}.
1659 @end deffn
1661 @deffn {Funç@~{a}o} make_random_state (@var{n})
1662 @deffnx {Funç@~{a}o} make_random_state (@var{s})
1663 @deffnx {Funç@~{a}o} make_random_state (true)
1664 @deffnx {Funç@~{a}o} make_random_state (false)
1665 @c OMIT THIS FOR NOW. SEE COMMENT BELOW.
1666 @c @defunx make_random_state (@var{a})
1667 Um objeto de estado rand@^{o}mico representa o estado do gerador de n@'{u}meros rand@^{o}micos (aleat@'{o}rios).
1668 O estado compreende 627 palavras de 32 bits.
1670 @code{make_random_state (@var{n})} retorna um novo objeto de estado rand@^{o}mico
1671 criado de um valor inteiro semente igual a @var{n} modulo 2^32.
1672 @var{n} pode ser negativo.
1674 @c OMIT THIS FOR NOW. NOT SURE HOW THIS IS SUPPOSED TO WORK.
1675 @c @code{make_random_state (@var{a})} returns a new random state object
1676 @c created from an array @var{a}, which must be a Lisp array of 32 unsigned bytes.
1678 @code{make_random_state (@var{s})} retorna uma copia do estado rand@^{o}mico @var{s}.
1680 @code{make_random_state (true)} retorna um novo objeto de estado rand@^{o}mico,
1681 usando a hora corrente do rel@'{o}gio do computador como semente.
1683 @code{make_random_state (false)} retorna uma c@'{o}pia do estado corrente
1684 do gerador de n@'{u}meros rand@^{o}micos.
1686 @end deffn
1688 @deffn {Funç@~{a}o} set_random_state (@var{s})
1689 Copia @var{s} para o estado do gerador de n@'{u}meros rand@^{o}micos.
1691 @code{set_random_state} sempre retorna @code{done}.
1693 @end deffn
1695 @deffn {Funç@~{a}o} random (@var{x})
1696 Retorna um n@'{u}mero pseudorand@^{o}mico. Se @var{x} @'{e} um inteiro, @code{random (@var{x})} retorna um
1697 inteiro de 0 a @code{@var{x} - 1} inclusive. Se @var{x} for um n@'{u}mero em ponto flutuante,
1698 @code{random (@var{x})} retorna um n@'{u}mero n@~{a}o negativo em ponto flutuante menor que @var{x}.
1699 @code{random} reclama com um erro se @var{x} n@~{a}o for nem um inteiro nem um n@'{u}mero em ponto flutuante,
1700 ou se @var{x} n@~{a}o for positivo.
1702 As funç@~{o}es @code{make_random_state} e @code{set_random_state}
1703 mant@'{e}m o estado do gerador de n@'{u}meros rand@^{o}micos.
1705 O gerador de n@'{u}meros rand@^{o}micos do Maxima @'{e} uma implementaç@~{a}o do algor@'{i}tmo de Mersenne twister MT 19937.
1707 Exemplos:
1709 @c ===beg===
1710 @c s1: make_random_state (654321)$
1711 @c set_random_state (s1);
1712 @c random (1000);
1713 @c random (9573684);
1714 @c random (2^75);
1715 @c s2: make_random_state (false)$
1716 @c random (1.0);
1717 @c random (10.0);
1718 @c random (100.0);
1719 @c set_random_state (s2);
1720 @c random (1.0);
1721 @c random (10.0);
1722 @c random (100.0);
1723 @c ===end===
1724 @example
1725 (%i1) s1: make_random_state (654321)$
1726 (%i2) set_random_state (s1);
1727 (%o2) done
1728 (%i3) random (1000);
1729 (%o3) 768
1730 (%i4) random (9573684);
1731 (%o4) 7657880
1732 (%i5) random (2^75);
1733 (%o5) 11804491615036831636390
1734 (%i6) s2: make_random_state (false)$
1735 (%i7) random (1.0);
1736 (%o7) .2310127244107132
1737 (%i8) random (10.0);
1738 (%o8) 4.394553645870825
1739 (%i9) random (100.0);
1740 (%o9) 32.28666704056853
1741 (%i10) set_random_state (s2);
1742 (%o10) done
1743 (%i11) random (1.0);
1744 (%o11) .2310127244107132
1745 (%i12) random (10.0);
1746 (%o12) 4.394553645870825
1747 (%i13) random (100.0);
1748 (%o13) 32.28666704056853
1749 @end example
1751 @end deffn
1753 @deffn {Funç@~{a}o} rationalize (@var{expr})
1755 Converte todos os n@'{u}meros em ponto flutuante de precis@~{a}o dupla e grandes n@'{u}meros em ponto flutuante na express@~{a}o do Maxima
1756 @var{expr} para seus exatos equivalentes racionais. Se voc@^{e} n@~{a}o estiver faminilarizado com
1757 a representaç@~{a}o bin@'{a}ria de n@'{u}meros em ponto flutuante, voc@^{e} pode se
1758 surpreender que @code{rationalize (0.1)} n@~{a}o seja igual a 1/10. Esse comportamento
1759 n@~{a}o @'{e} especial para o Maxima -- o n@'{u}mero 1/10 tem uma representaç@~{a}o bin@'{a}ria
1760 repetitiva e n@~{a}o terminada.
1762 @c ===beg===
1763 @c rationalize (0.5);
1764 @c rationalize (0.1);
1765 @c fpprec : 5$
1766 @c rationalize (0.1b0);
1767 @c fpprec : 20$
1768 @c rationalize (0.1b0);
1769 @c rationalize (sin (0.1*x + 5.6));
1770 @c ===end===
1771 @example
1772 (%i1) rationalize (0.5);
1773 1
1774 (%o1) -
1775 2
1776 (%i2) rationalize (0.1);
1777 1
1778 (%o2) --
1779 10
1780 (%i3) fpprec : 5$
1781 (%i4) rationalize (0.1b0);
1782 209715
1783 (%o4) -------
1784 2097152
1785 (%i5) fpprec : 20$
1786 (%i6) rationalize (0.1b0);
1787 236118324143482260685
1788 (%o6) ----------------------
1789 2361183241434822606848
1790 (%i7) rationalize (sin (0.1*x + 5.6));
1791 x 28
1792 (%o7) sin(-- + --)
1793 10 5
1794 @end example
1796 Exemplo de utilizaç@~{a}o:
1798 @c ===beg===
1799 @c unitfrac(r) := block([uf : [], q],
1800 @c if not(ratnump(r)) then error("A entrada para 'unitfrac' deve ser um n@'{u}mero racional"),
1801 @c while r # 0 do (
1802 @c uf : cons(q : 1/ceiling(1/r), uf),
1803 @c r : r - q),
1804 @c reverse(uf));
1805 @c unitfrac (9/10);
1806 @c apply ("+", %);
1807 @c unitfrac (-9/10);
1808 @c apply ("+", %);
1809 @c unitfrac (36/37);
1810 @c apply ("+", %);
1811 @c ===end===
1812 @example
1813 (%i1) unitfrac(r) := block([uf : [], q],
1814 if not(ratnump(r)) then error("The input to 'unitfrac' must be a rational number"),
1815 while r # 0 do (
1816 uf : cons(q : 1/ceiling(1/r), uf),
1817 r : r - q),
1818 reverse(uf));
1819 (%o1) unitfrac(r) := block([uf : [], q],
1820 if not ratnump(r) then error("The input to 'unitfrac' must be a rational number"
1821 1
1822 ), while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
1823 1
1824 ceiling(-)
1825 r
1826 reverse(uf))
1827 (%i2) unitfrac (9/10);
1828 1 1 1
1829 (%o2) [-, -, --]
1830 2 3 15
1831 (%i3) apply ("+", %);
1832 9
1833 (%o3) --
1834 10
1835 (%i4) unitfrac (-9/10);
1836 1
1837 (%o4) [- 1, --]
1838 10
1839 (%i5) apply ("+", %);
1840 9
1841 (%o5) - --
1842 10
1843 (%i6) unitfrac (36/37);
1844 1 1 1 1 1
1845 (%o6) [-, -, -, --, ----]
1846 2 3 8 69 6808
1847 (%i7) apply ("+", %);
1848 36
1849 (%o7) --
1850 37
1851 @end example
1853 @end deffn
1855 @deffn {Funç@~{a}o} sign (@var{expr})
1856 Tenta determinar o sinal de @var{expr}
1857 a partir dos fatos na base de dados corrente. Retorna uma das
1858 seguintes respostar: @code{pos} (positivo), @code{neg} (negativo), @code{zero}, @code{pz}
1859 (positivo ou zero), @code{nz} (negativo ou zero), @code{pn} (positivo ou negativo),
1860 ou @code{pnz} (positivo, negativo, ou zero, i.e. nada se sabe sobre o sinal da epress@~{a}o).
1862 @end deffn
1864 @deffn {Funç@~{a}o} signum (@var{x})
1865 Para um @var{x} num@'{e}rico retorna 0 se @var{x} for 0, de outra forma retorna -1 ou +1
1866 @`a medida que @var{x} seja menor ou maior que 0, respectivamente.
1868 Se @var{x} n@~{a}o for num@'{e}rico ent@~{a}o uma forma simplificada mas equivalente @'{e} retornada.
1869 Por exemplo, @code{signum(-x)} fornece @code{-signum(x)}.
1870 @c UMM, THIS ISN'T THE WHOLE STORY, AS IT APPEARS signum CONSULTS THE assume DATABASE FOR SYMBOLIC ARGUMENT
1872 @end deffn
1874 @deffn {Funç@~{a}o} sort (@var{L}, @var{P})
1875 @deffnx {Funç@~{a}o} sort (@var{L})
1876 Organiza uma lista @var{L} coforme o predicado @code{P} de dois argumentos,
1877 de forma que @code{@var{P} (@var{L}[k], @var{L}[k + 1])} seja @code{true}
1878 para qualquer dois elementos sucessivos.
1879 O predicado pode ser especificado como o nome de uma funç@~{a}o ou operador bin@'{a}rio infixo,
1880 ou como uma express@~{a}o @code{lambda}.
1881 Se especificado como o nome de um operador,
1882 o nome deve ser contido entre "aspas duplas".
1884 A lista ordenada @'{e} retornada como novo objeto;
1885 o argumento @var{L} n@~{a}o @'{e} modificado.
1886 Para construir o valor de retorno,
1887 @code{sort} faz uma c@'{o}pia superficial dos elementos de @var{L}.
1888 @c DUNNO IF WE NEED TO GO INTO THE IMPLICATIONS OF SHALLOW COPY HERE ...
1889 @c MIGHT CONSIDER A REF FOR TOTAL ORDER HERE
1890 Se o predicado @var{P} n@~{a}o for uma ordem total sobre os elementos de @var{L},
1891 ent@~{a}o @code{sort} possivelvente pode executar para concluir sem error,
1892 mas os resultados s@~{a}o indefinidos.
1893 @code{sort} reclama se o predicado avaliar para alguma outra coisa
1894 que n@~{a}o seja @code{true} ou @code{false}.
1896 @code{sort (@var{L})} @'{e} equivalente a @code{sort (@var{L}, orderlessp)}.
1897 Isto @'{e}, a ordem padr@~{a}o de organizaç@~{a}o @'{e} ascendente,
1898 como determinado por @code{orderlessp}.
1899 Todos os @'{a}tomos do Maxima e express@~{o}es s@~{a}o compar@'{a}veis sob @code{orderlessp},
1900 embora exista exemplos isolados de express@~{o}es para as quais @code{orderlessp} n@~{a}o @'{e} transitiva;
1901 isso @'{e} uma falha.
1903 Exemplos:
1905 @c ===beg===
1906 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
1907 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x], ordergreatp);
1908 @c sort ([%pi, 3, 4, %e, %gamma]);
1909 @c sort ([%pi, 3, 4, %e, %gamma], "<");
1910 @c my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
1911 @c sort (my_list);
1912 @c sort (my_list, lambda ([a, b], orderlessp (reverse (a), reverse (b))));
1913 @c ===end===
1914 @example
1915 (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
1916 5
1917 (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
1918 2
1919 (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x], ordergreatp);
1920 5
1921 (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
1922 2
1923 (%i3) sort ([%pi, 3, 4, %e, %gamma]);
1924 (%o3) [3, 4, %e, %gamma, %pi]
1925 (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
1926 (%o4) [%gamma, %e, 3, %pi, 4]
1927 (%i5) my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
1928 (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
1929 (%i6) sort (my_list);
1930 (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
1931 (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a), reverse (b))));
1932 (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
1933 @end example
1935 @end deffn
1937 @deffn {Funç@~{a}o} sqrt (@var{x})
1938 A ra@'{i}z quadrada de @var{x}. @'{E} representada internamente por
1939 @code{@var{x}^(1/2)}. Veja tamb@'{e}m @code{rootscontract}.
1941 @code{radexpand} se @code{true} far@'{a} com que n-@'{e}simas ra@'{i}zes de fatores de um produto
1942 que forem pot@^{e}ncias de n sejam colocados fora do radical, e.g.
1943 @code{sqrt(16*x^2)} retonar@'{a} @code{4*x} somente se @code{radexpand} for @code{true}.
1945 @end deffn
1947 @defvr {Vari@'{a}vel de opç@~{a}o} sqrtdispflag
1948 Valor padr@~{a}o: @code{true}
1950 Quando @code{sqrtdispflag} for @code{false},
1951 faz com que @code{sqrt} seja mostrado como expoente 1/2.
1952 @c AND OTHERWISE ... ??
1954 @end defvr
1956 @c NEEDS EXPANSION, CLARIFICATION, MORE EXAMPLES
1957 @c sublis CAN ONLY SUBSTITUTE FOR ATOMS, RIGHT ?? IF SO, SAY SO
1958 @deffn {Funç@~{a}o} sublis (@var{lista}, @var{expr})
1959 Faz multiplas substituiç@~{o}es paralelas dentro de uma express@~{a}o.
1961 A vari@'{a}vel @code{sublis_apply_lambda} controla a simplificaç@~{a}o ap@'{o}s
1962 @code{sublis}.
1964 Exemplo:
1966 @example
1967 @c ===beg===
1968 @c sublis ([a=b, b=a], sin(a) + cos(b));
1969 @c ===end===
1970 @end example
1972 @end deffn
1974 @deffn {Funç@~{a}o} sublist (@var{lista}, @var{p})
1975 Retorna a lista de elementos da @var{lista} da qual o
1976 predicado @code{p} retornar @code{true}.
1978 Exemplo:
1980 @c ===beg===
1981 @c L: [1, 2, 3, 4, 5, 6];
1982 @c sublist (L, evenp);
1983 @c ===end===
1984 @example
1985 (%i1) L: [1, 2, 3, 4, 5, 6];
1986 (%o1) [1, 2, 3, 4, 5, 6]
1987 (%i2) sublist (L, evenp);
1988 (%o2) [2, 4, 6]
1989 @end example
1991 @end deffn
1993 @defvr {Vari@'{a}vel de opç@~{a}o} sublis_apply_lambda
1994 Valor padr@~{a}o: @code{true} - controla se os substitutos de
1995 @code{lambda} s@~{a}o aplicados na simplificaç@~{a}o ap@'{o}s as @code{sublis} serem usadas ou
1996 se voc@^{e} tem que fazer um @code{ev} para pegar coisas para aplicar. @code{true} significa faça a
1997 aplicaç@~{a}o.
1999 @end defvr
2001 @c NEEDS CLARIFICATION, MORE EXAMPLES
2002 @deffn {Funç@~{a}o} subst (@var{a}, @var{b}, @var{c})
2003 Substitue @var{a} por @var{b} em @var{c}. @var{b} deve ser um @'{a}tomo ou uma
2004 subexpress@~{a}o completa de @var{c}. Por exemplo, @code{x+y+z} @'{e} uma subexpress@~{a}o
2005 completa de @code{2*(x+y+z)/w} enquanto @code{x+y} n@~{a}o @'{e}. Quando @var{b} n@~{a}o tem
2006 essas caracter@'{i}sticas, pode-se algumas vezes usar @code{substpart} ou @code{ratsubst}
2007 (veja abaixo). Alternativamente, se @var{b} for da forma de @code{e/f} ent@~{a}o se poder@'{a}
2008 usar @code{subst (a*f, e, c)} enquanto se @var{b} for da forma @code{e^(1/f)} ent@~{a}o se poder@'{a}
2009 usar @code{subst (a^f, e, c)}. O comando @code{subst} tamb@'{e}m discerne o @code{x^y} de @code{x^-y}
2010 de modo que @code{subst (a, sqrt(x), 1/sqrt(x))} retorna @code{1/a}. @var{a} e @var{b} podem tamb@'{e}m ser
2011 operadores de uma express@~{a}o contida entre aspas duplas @code{"} ou eles podem ser nomes de
2012 funç@~{a}o. Se se desejar substituir por uma vari@'{a}vel independente em
2013 formas derivadas ent@~{a}o a funç@~{a}o @code{at} (veja abaixo) poder@'{a} ser usada.
2015 @c UMM, REVERSE THIS AND MOVE IT TO substitute ??
2016 @code{subst} @'{e} um @'{a}lias para @code{substitute}.
2018 @code{subst (@var{eq_1}, @var{expr})} ou @code{subst ([@var{eq_1}, ..., @var{eq_k}], @var{expr})}
2019 s@~{a}o outras formas
2020 permitidas. As @var{eq_i} s@~{a}o equaç@~{o}es indicando substituiç@~{o}es a serem feitas.
2021 Para cada equaç@~{a}o, o lado direito ser@'{a} substitu@'{i}do pelo lado esquerdo na
2022 express@~{a}o @var{expr}.
2024 @code{exptsubst} se @code{true} permite que substituiç@~{o}es
2025 como @code{y} por @code{%e^x} em @code{%e^(a*x)} ocorram.
2027 @c WHAT IS THIS ABOUT ??
2028 Quando @code{opsubst} for @code{false},
2029 @code{subst} tentar@'{a} substituir dentro do operador de uma express@~{a}o.
2030 E.g. @code{(opsubst: false, subst (x^2, r, r+r[0]))} trabalhar@'{a}.
2032 Exemplos:
2034 @example
2035 (%i1) subst (a, x+y, x + (x+y)^2 + y);
2036 2
2037 (%o1) y + x + a
2038 (%i2) subst (-%i, %i, a + b*%i);
2039 (%o2) a - %i b
2040 @end example
2042 @noindent
2043 Para exemplos adicionais, faça @code{example (subst)}.
2045 @end deffn
2047 @c NEEDS CLARIFICATION
2048 @deffn {Funç@~{a}o} substinpart (@var{x}, @var{expr}, @var{n_1}, ..., @var{n_k})
2049 Similar a @code{substpart}, mas @code{substinpart} trabalha sobre a
2050 representaç@~{a}o interna de @var{expr}.
2052 Exemplos:
2054 @c ===beg===
2055 @c x . 'diff (f(x), x, 2);
2056 @c substinpart (d^2, %, 2);
2057 @c substinpart (f1, f[1](x + 1), 0);
2058 @c ===end===
2059 @example
2060 (%i1) x . 'diff (f(x), x, 2);
2061 2
2062 d
2063 (%o1) x . (--- (f(x)))
2064 2
2065 dx
2066 (%i2) substinpart (d^2, %, 2);
2067 2
2068 (%o2) x . d
2069 (%i3) substinpart (f1, f[1](x + 1), 0);
2070 (%o3) f1(x + 1)
2071 @end example
2073 Se o @'{u}ltimo argumento para a funç@~{a}o @code{part} for uma lista de @'{i}ndices ent@~{a}o
2074 muitas subexpress@~{o}es s@~{a}o escolhidas, cada uma correspondendo a um
2075 @'{i}ndice da lista. Dessa forma
2077 @c ===beg===
2078 @c part (x + y + z, [1, 3]);
2079 @c ===end===
2080 @example
2081 (%i1) part (x + y + z, [1, 3]);
2082 (%o1) z + x
2083 @end example
2085 @code{piece} recebe o valor da @'{u}ltima express@~{a}o selecionada quando usando as
2086 funç@~{o}es @code{part}. @code{piece} @'{e} escolhida durante a execuç@~{a}o da funç@~{a}o e
2087 dessa forma pode ser referenciada para a pr@'{o}pria funç@~{a}o como mostrado abaixo.
2088 Se @code{partswitch} for escolhida para @code{true} ent@~{a}o @code{end} @'{e} retornado quando uma
2089 parte selecionada de uma express@~{a}o n@~{a}o existir, de outra forma uma mensagem
2090 de erro @'{e} fornecida.
2092 @c ===beg===
2093 @c expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
2094 @c part (expr, 2, [1, 3]);
2095 @c sqrt (piece/54);
2096 @c substpart (factor (piece), expr, [1, 2, 3, 5]);
2097 @c expr: 1/x + y/x - 1/z;
2098 @c substpart (xthru (piece), expr, [2, 3]);
2099 @c ===end===
2100 @example
2101 (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
2102 3 2 2 3
2103 (%o1) 27 y + 54 x y + 36 x y + y + 8 x + x + 1
2104 (%i2) part (expr, 2, [1, 3]);
2105 2
2106 (%o2) 54 y
2107 (%i3) sqrt (piece/54);
2108 (%o3) abs(y)
2109 (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
2110 3
2111 (%o4) (3 y + 2 x) + y + x + 1
2112 (%i5) expr: 1/x + y/x - 1/z;
2113 1 y 1
2114 (%o5) - - + - + -
2115 z x x
2116 (%i6) substpart (xthru (piece), expr, [2, 3]);
2117 y + 1 1
2118 (%o6) ----- - -
2119 x z
2120 @end example
2122 Tamb@'{e}m, escolhendo a opç@~{a}o @code{inflag} para @code{true} e chamando @code{part} ou @code{substpart} @'{e}
2123 o mesmo que chamando @code{inpart} ou @code{substinpart}.
2125 @end deffn
2127 @c NEEDS CLARIFICATION
2128 @deffn {Funç@~{a}o} substpart (@var{x}, @var{expr}, @var{n_1}, ..., @var{n_k})
2129 Substitue @var{x} para a subexpress@~{a}o
2130 selecionada pelo resto dos argumentos como em @code{part}. Isso retorna o
2131 novo valor de @var{expr}. @var{x} pode ser algum operador a ser substitu@'{i}do por um
2132 operador de @var{expr}. Em alguns casos @var{x} precisa ser contido em aspas duplas @code{"}
2133 (e.g. @code{substpart ("+", a*b, 0)} retorna @code{b + a}).
2135 @c ===beg===
2136 @c 1/(x^2 + 2);
2137 @c substpart (3/2, %, 2, 1, 2);
2138 @c a*x + f(b, y);
2139 @c substpart ("+", %, 1, 0);
2140 @c ===end===
2141 @example
2142 (%i1) 1/(x^2 + 2);
2143 1
2144 (%o1) ------
2145 2
2146 x + 2
2147 (%i2) substpart (3/2, %, 2, 1, 2);
2148 1
2149 (%o2) --------
2150 3/2
2151 x + 2
2152 (%i3) a*x + f (b, y);
2153 (%o3) a x + f(b, y)
2154 (%i4) substpart ("+", %, 1, 0);
2155 (%o4) x + f(b, y) + a
2156 @end example
2158 Tamb@'{e}m, escolhendo a opç@~{a}o @code{inflag} para @code{true} e chamando @code{part} ou @code{substpart} @'{e}
2159 o mesmo que chamando @code{inpart} ou @code{substinpart}.
2161 @end deffn
2163 @c NEEDS EXPANSION AND EXAMPLES
2164 @deffn {Funç@~{a}o} subvarp (@var{expr})
2165 Retorna @code{true} se @var{expr} for uma vari@'{a}vel subscrita (i.e. que possui @'{i}ndice ou subscrito em sua grafia), por exemplo
2166 @code{a[i]}.
2168 @end deffn
2170 @deffn {Funç@~{a}o} symbolp (@var{expr})
2171 Retorna @code{true} se @var{expr} for um s@'{i}mbolo, de outra forma retorna @code{false}.
2172 com efeito, @code{symbolp(x)} @'{e} equivalente ao predicado @code{atom(x) and not numberp(x)}.
2174 @c FOLLOWING REALLY WANTS TO BE @xref{Identiifers} BUT THAT
2175 @c LEAVES THE UNPLEASANT RESIDUE *Note ...:: IN THE OUTPUT OF describe
2176 Veja tamb@'{e}m @ref{Identificadores}
2178 @end deffn
2180 @deffn {Funç@~{a}o} unorder ()
2181 Disabilita a aç@~{a}o de alias criada pelo @'{u}ltimo uso dos comandos
2182 de ordenaç@~{a}o @code{ordergreat} e @code{orderless}. @code{ordergreat} e @code{orderless} n@~{a}o podem
2183 ser usados mais que uma vez cada sem chamar @code{unorder}.
2184 Veja tamb@'{e}m @code{ordergreat} e @code{orderless}.
2186 Exemplos:
2188 @c HMM, IN THIS EXAMPLE, WHY ISN'T %o5 EQUAL TO ZERO ???
2189 @c ===beg===
2190 @c unorder();
2191 @c b*x + a^2;
2192 @c ordergreat (a);
2193 @c b*x + a^2;
2194 @c %th(1) - %th(3);
2195 @c unorder();
2196 @c ===end===
2197 @example
2198 (%i1) unorder();
2199 (%o1) []
2200 (%i2) b*x + a^2;
2201 2
2202 (%o2) b x + a
2203 (%i3) ordergreat (a);
2204 (%o3) done
2205 (%i4) b*x + a^2;
2206 %th(1) - %th(3);
2207 2
2208 (%o4) a + b x
2209 (%i5) unorder();
2210 2 2
2211 (%o5) a - a
2212 @end example
2214 @end deffn
2216 @c THIS ITEM SEEMS OUT OF PLACE -- IS IT FROM A SHARE PACKAGE ??
2217 @c NEEDS EXAMPLES
2218 @deffn {Funç@~{a}o} vectorpotential (@var{givencurl})
2219 Retorna o potencial do vetor de um dado
2220 vetor de torç@~{a}o, no sistema de coordenadas corrente.
2221 @code{potentialzeroloc} tem um papel similar ao de @code{potential}, mas a ordem dos
2222 lados esquerdos das equaç@~{o}es deve ser uma permutaç@~{a}o c@'{i}clica das
2223 vari@'{a}veis de coordenadas.
2225 @end deffn
2227 @deffn {Funç@~{a}o} xthru (@var{expr})
2228 Combina todos os termos de @var{expr} (o qual pode ser uma adiç@~{a}o) sobre um
2229 denominador comum sem produtos e somas exponenciadas
2230 como @code{ratsimp} faz. @code{xthru} cancela fatores comuns no numerador e
2231 denominador de express@~{o}es racionais mas somente se os fatores s@~{a}o
2232 expl@'{i}citos.
2234 @c REPHRASE IN NEUTRAL TONE (GET RID OF "IT IS BETTER")
2235 Algumas vezes @'{e} melhor usar @code{xthru} antes de @code{ratsimp} em uma
2236 express@~{a}o com o objetivo de fazer com que fatores explicitos do m@'{a}ximo divisor comum entre o
2237 numerador e o denominador seja cancelado simplificando dessa forma a
2238 express@~{a}o a ser aplicado o @code{ratsimp}.
2240 @c ===beg===
2241 @c ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
2242 @c xthru (%);
2243 @c ===end===
2244 @example
2245 (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
2246 20
2247 1 (x + 2) - 2 y x
2248 (%o1) --------- + --------------- - ---------
2249 19 20 20
2250 (y + x) (y + x) (y + x)
2251 (%i2) xthru (%);
2252 20
2253 (x + 2) - y
2254 (%o2) -------------
2255 20
2256 (y + x)
2257 @end example
2259 @end deffn
2261 @c THIS FUNCTION APPEARS TO BE A HACK; SEE 4'TH ITEM BELOW
2262 @c DUNNO WHETHER WE CAN CLEAR THIS UP
2263 @deffn {Funç@~{a}o} zeroequiv (@var{expr}, @var{v})
2264 Testa se a express@~{a}o @var{expr} na vari@'{a}vel
2265 @var{v} @'{e} equivalente a zero, retornando @code{true}, @code{false}, ou
2266 @code{dontknow} (n@~{a}o sei).
2268 @code{zeroequiv} Tem essas restriç@~{o}es:
2269 @enumerate
2270 @item
2271 N@~{a}o use funç@~{o}es que o Maxima n@~{a}o sabe como
2272 diferenciar e avaliar.
2273 @item
2274 Se a express@~{a}o tem postes sobre o eixo real, podem existir erros
2275 no resultado (mas isso @'{e} improv@'{a}vel ocorrer).
2276 @item
2277 Se a express@~{a}o contem funç@~{o}es que n@~{a}o s@~{a}o soluç@~{o}es para
2278 equaç@~{o}es diferenciais de primeira ordem (e.g. funç@~{o}es de Bessel) pode ocorrer
2279 resultados incorretos.
2280 @item
2281 O algor@'{i}tmo usa avaliaç@~{a}o em pontos aleat@'{o}riamente escolhidos para
2282 subexpress@~{o}es selecionadas cuidadosamente. Isso @'{e} sempre neg@'{o}cio um tanto
2283 quanto perigoso, embora o algor@'{i}tmo tente minimizar o
2284 potencial de erro.
2285 @end enumerate
2287 Por exemplo
2288 @code{zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)} retorna
2289 @code{true} e @code{zeroequiv (%e^x + x, x)} retorna @code{false}.
2290 Por outro lado @code{zeroequiv (log(a*b) - log(a) - log(b), a)} retorna @code{dontknow} devido @`a
2291 presença de um par@^{a}metro extra @code{b}.
2293 @end deffn