| blob | ea21ac3d8a57f24e59dbc890d595b90eeeea9e52 |
1 @c
2 @c versao pt_BR baseada no md5sum abaixo:
3 @c 735c640397e886d271d4de87d783df89 Operators.texi
4 @c
5 @menu
6 * Introduction to operators::
7 * Arithmetic operators::
8 * Relational operators::
9 * Logical operators::
10 * Operators for Equations::
11 * Assignment operators::
12 * User defined operators::
13 @end menu
15 @c -----------------------------------------------------------------------------
16 @node Introduction to operators, Arithmetic operators, Operators, Operators
17 @section Introduction to operators
18 @c -----------------------------------------------------------------------------
20 @'{E} poss@'{i}vel definir novos operadores com determinada preced@^{e}ncia, para remover a defini@,{c}@~{a}o de
21 operadores j@'{a} existentes, ou para redefinir a precedencia de operadores existentes. Um
22 operador pode ser un@'{a}rio pr@'{e}fixado ou un@'{a}rio p@'{o}sfixado, bin@'{a}rio infixo, en@'{a}rio infixo,
23 matchfix, ou nofix. "Matchfix" significa um par de s@'{i}mbolos que abra@,{c}a seu argumento
24 ou seus argumentos, e "nofix" significa um operador sem argumentos.
25 Como exemplo de diferentes tipos de operadores, existe o seguinte.
27 @table @asis
28 @item un@'{a}rio prefixado
29 nega@,{c}@~{a}o @code{- a}
30 @item un@'{a}rio p@'{o}sfixado
31 fatorial @code{a!}
32 @item bin@'{a}rio infixo
33 exponencia@,{c}@~{a}o @code{a^b}
34 @item en@'{a}rio infixo
35 adi@,{c}@~{a}o @code{a + b}
36 @item matchfix
37 os colch@^{e}tes envolvendo uma lista @code{[a, b]}
38 @end table
40 (N@~{a}o existe operadores internos "nofix"; para um exemplo de tal operador,
41 veja @code{nofix}.)
43 O mecanismo para definir um novo operador @'{e} direto. @'{E} somente necess@'{a}rio
44 declarar uma fun@,{c}@~{a}o como um operador; a fun@,{c}@~{a}o operador pode ou n@~{a}o
45 ser definida.
47 Um exemplo de operadores definidos pelo usu@'{a}rio @'{e} o seguinte. Note que que a chamada expl@'{i}cita de
48 da fun@,{c}@~{a}o @code{"dd" (a)} @'{e} equivalente a @code{dd a}, da mesma forma
49 @code{"<-" (a, b)} @'{e} equivalente a @code{a <- b}. Note tamb@'{e}m que as fun@,{c}@~{o}es
50 @code{"dd"} e @code{"<-"} n@~{a}o est@~{a}o definidas no exemplo.
52 @c ===beg===
53 @c prefix ("dd");
54 @c dd a;
55 @c "dd" (a);
56 @c infix ("<-");
57 @c a <- dd b;
58 @c "<-" (a, "dd" (b));
59 @c ===end===
60 @example
61 (%i1) prefix ("dd");
62 (%o1) dd
63 (%i2) dd a;
64 (%o2) dd a
65 (%i3) "dd" (a);
66 (%o3) dd a
67 (%i4) infix ("<-");
68 (%o4) <-
69 (%i5) a <- dd b;
70 (%o5) a <- dd b
71 (%i6) "<-" (a, "dd" (b));
72 (%o6) a <- dd b
73 @end example
75 As fun@,{c}@~{o}es do Maxima que definem novos operadores s@~{a}o sumarizadas na tabela adiante,
76 equilibrando (padr@~{a}o) poder associado @`{a} esquerda e poder associada @`{a} direita (left binding power, right binding power, lbp e rbp, respectivamente).
77 @c REWORK FOLLOWING COMMENT.
78 @c IT'S NOT CLEAR ENOUGH, GIVEN THAT IT'S FAIRLY IMPORTANT
79 (For@,{c}a associada determina a preced@^{e}ncia do operador. Todavia, uma vez que o poder associado @`{a} esquerda e o poder
80 associado @`{a} direita podem ser diferentes, associar poder @'{e} um pouco mais complicado que
81 preced@^{e}ncia.) Alguma das fun@,{c}@~{o}es de defini@,{c}@~{a}o de opera@,{c}@~{a}o recebem argumentos
82 adicionais; veja as descri@,{c}@~{o}es de fun@,{c}@~{a}o para detalhes.
84 @c MAKE ANCHORS FOR ALL 6 FUNCTIONS AND CHANGE @code TO @ref ACCORDINGLY
85 @table @code
86 @item prefix
87 rbp=180
88 @item postfix
89 lbp=180
90 @item infix
91 lbp=180, rbp=180
92 @item nary
93 lbp=180, rbp=180
94 @item matchfix
95 (poder associado n@~{a}o aplic@'{a}vel)
96 @item nofix
97 (poder associado n@~{a}o aplic@'{a}vel)
98 @end table
100 Para compara@,{c}@~{a}o, aqui est@'{a} alguns operadores internos e seus poderes associados
101 esquerdo e direito.
103 @example
104 Operator lbp rbp
106 : 180 20
107 :: 180 20
108 := 180 20
109 ::= 180 20
110 ! 160
111 !! 160
112 ^ 140 139
113 . 130 129
114 * 120
115 / 120 120
116 + 100 100
117 - 100 134
118 = 80 80
119 # 80 80
120 > 80 80
121 >= 80 80
122 < 80 80
123 <= 80 80
124 not 70
125 and 65
126 or 60
127 , 10
128 $ -1
129 ; -1
130 @end example
132 As fun@,{c}@~{o}es @mref{remove}
133 e @mref{kill}
134 removem propriedades de operador de um @'{a}tomo.
135 O comando @code{remove ("@var{a}", op)} remove as propriedades de operador de @var{a}.
136 O comando @code{kill ("@var{a}")} remove todas as propriedades de @var{a}, incluindo as
137 propriedades de operador. Note que o nome do operador deve estar entre
138 aspas aspas duplas.
140 @c MAYBE COPY THIS EXAMPLE TO remove AND/OR kill
141 @c ===beg===
142 @c infix ("##");
143 @c "##" (a, b) := a^b;
144 @c 5 ## 3;
145 @c remove ("##", op);
146 @c 5 ## 3;
147 @c "##" (5, 3);
148 @c infix ("##");
149 @c 5 ## 3;
150 @c kill ("##");
151 @c 5 ## 3;
152 @c "##" (5, 3);
153 @c ===end===
154 @example
155 (%i1) infix ("##");
156 (%o1) ##
157 (%i2) "##" (a, b) := a^b;
158 b
159 (%o2) a ## b := a
160 (%i3) 5 ## 3;
161 (%o3) 125
162 (%i4) remove ("##", op);
163 (%o4) done
164 (%i5) 5 ## 3;
165 Incorrect syntax: # is not a prefix operator
166 5 ##
167 ^
168 (%i5) "##" (5, 3);
169 (%o5) 125
170 (%i6) infix ("##");
171 (%o6) ##
172 (%i7) 5 ## 3;
173 (%o7) 125
174 (%i8) kill ("##");
175 (%o8) done
176 (%i9) 5 ## 3;
177 Incorrect syntax: # is not a prefix operator
178 5 ##
179 ^
180 (%i9) "##" (5, 3);
181 (%o9) ##(5, 3)
182 @end example
184 @opencatbox
185 @category{Operadores} @category{Sintaxe}
186 @closecatbox
188 @c -----------------------------------------------------------------------------
189 @node Arithmetic operators, Relational operators, Introduction to operators, Operators
190 @section Arithmetic operators
191 @c -----------------------------------------------------------------------------
193 @c -----------------------------------------------------------------------------
194 @anchor{+}
195 @anchor{-}
196 @anchor{*}
197 @anchor{/}
198 @anchor{^}
199 @fnindex Adi@,{c}@~{a}o
200 @fnindex Subtra@,{c}@~{a}o
201 @fnindex Multiplica@,{c}@~{a}o
202 @fnindex Divis@~{a}o
203 @fnindex Exponencia@,{c}@~{a}o
205 @deffn {Operador} +
206 @deffnx {Operador} -
207 @deffnx {Operador} *
208 @deffnx {Operador} /
209 @deffnx {Operador} ^
211 Os s@'{i}mbolos @code{+} @code{*} @code{/} e @code{^} representam adi@,{c}@~{a}o,
212 multiplica@,{c}@~{a}o, divis@~{a}o, e exponencia@,{c}@~{a}o, respectivamente. Os nomes desses
213 operadores s@~{a}o @code{"+"} @code{"*"} @code{"/"} e @code{"^"}, que podem aparecer
214 onde o nome de uma fun@,{c}@~{a}o ou operador for necess@'{a}rio.
216 Os simbolos @code{+} e @code{-} representam adi@,{c}@~{a}o un@'{a}ria e nega@,{c}@~{a}o,
217 respectivamente, e os nomes desses operadores s@~{a}o @code{"+"} e @code{"-"},
218 respectivamente.
220 Subtra@,{c}@~{a}o @code{a - b} @'{e} representado internamente no Maxima como adi@,{c}@~{a}o,
221 @code{a + (- b)}. Express@~{o}es tais como @code{a + (- b)} s@~{a}o mostradas como
222 subtra@,{c}@~{a}o. Maxima reconhece @code{"-"} somente como o nome do operador
223 un@'{a}rio de nega@,{c}@~{a}o, e n@~{a}o como o nome do operador bin@'{a}rio de subtra@,{c}@~{a}o.
225 Divis@~{a}o @code{a / b} @'{e} representado internamente no Maxima como multiplica@,{c}@~{a}o,
226 @code{a * b^(- 1)}. Express@~{o}es tais como @code{a * b^(- 1)} s@~{a}o mostradas como
227 divis@~{a}o. Maxima reconhece @code{"/"} como o nome do operador de divis@~{a}o.
229 Adi@,{c}@~{a}o e multiplica@,{c}@~{a}o s@~{a}o operadores en@'{a}rios comutativos.
230 Divis@~{a}o e exponencia@,{c}@~{a}o s@~{a}o operadores bin@'{a}rios n@~{a}o comutativos.
232 Maxima ordena os operandos de operadores comutativos para construir uma
233 representa@,{c}@~{a}o can@^{o}nica. Para armazenamento interno, a ordena@,{c}@~{a}o @'{e} determinada por
234 @mrefdot{orderlessp}
235 Para exibi@,{c}@~{a}o, a ordena@,{c}@~{a}o da adi@,{c}@~{a}o @'{e} determinada por
236 @mrefcomma{ordergreatp}
237 e para a multiplica@,{c}@~{a}o, @'{e} a mesma que a ordena@,{c}@~{a}o interna.
239 Computa@,{c}@~{o}es aritm@'{e}ticas s@~{a}o realizadas sobre n@'{u}meros literais (inteiros, racionais,
240 em ponto flutuantes comuns, e grandes n@'{u}meros em ponto flutuante). Exceto para exponencia@,{c}@~{a}o, todas as opera@,{c}@~{o}es
241 aritm@'{e}ticas sobre n@'{u}meros s@~{a}o simplificadas para n@'{u}meros. Exponencia@,{c}@~{a}o @'{e} simplificada
242 para um n@'{u}mero se ou o operando for um n@'{u}mero em ponto flutuante comum ou um grande n@'{u}mero em ponto flutuante ou se o resultado
243 for um inteiro exato ou um racional; de outra forma uma exponencia@,{c}@~{a}o pode ser simplificada
244 para @mref{sqrt}
245 ou outra exponencia@,{c}@~{a}o ou esquerda sem modifica@,{c}@~{a}o.
247 Propaga@,{c}@~{a}o de ponto flutuante se aplica a c@'{a}lculos aritm@'{e}ticos: se qualquer operando for
248 um grande n@'{u}mero em ponto flutuante, o resultado @'{e} um grande n@'{u}mero em ponto flutuante; de outra forma, se um operando for um n@'{u}mero em ponto
249 flutuante comum, o resultado @'{e} um n@'{u}mero em ponto flutuante comum; de outra forma, os operandos s@~{a}o racionais
250 ou inteiros e o resultado @'{e} um racional ou um inteiro.
252 Computa@,{c}@~{o}es aritm@'{e}ticas s@~{a}o uma simplifica@,{c}@~{a}o, n@~{a}o uma avalia@,{c}@~{a}o.
253 Dessa forma a aritm@'{e}tica @'{e} realizada em express@~{o}es entre aspas duplas (mas simplificadas).
255 Opera@,{c}@~{o}es aritm@'{e}ticas s@~{a}o aplicadas elemento-a-elemento para listas quando o sinalizador
256 global @mref{listarith}
257 for @code{true}, e sempre aplicada elemento-a-elemento para
258 matrizes. Quando um operando for uma lista ou matriz e o outro for um operando de
259 algum outro tipo, o outro operando @'{e} combinado com cada um dos elementos da
260 lista ou matriz.
262 Exemplos:
264 Adi@,{c}@~{a}o e multiplica@,{c}@~{a}o s@~{a}o operadores en@'{a}rios comutativos.
265 Maxima ordena os operando para construir uma representa@,{c}@~{a}o can@^{o}nica.
266 Os nomes desses operadores s@~{a}o @code{"+"} e @code{"*"}.
268 @c ===beg===
269 @c c + g + d + a + b + e + f;
270 @c [op (%), args (%)];
271 @c c * g * d * a * b * e * f;
272 @c [op (%), args (%)];
273 @c apply ("+", [a, 8, x, 2, 9, x, x, a]);
274 @c apply ("*", [a, 8, x, 2, 9, x, x, a]);
275 @c ===end===
276 @example
277 (%i1) c + g + d + a + b + e + f;
278 (%o1) g + f + e + d + c + b + a
279 (%i2) [op (%), args (%)];
280 (%o2) [+, [g, f, e, d, c, b, a]]
281 (%i3) c * g * d * a * b * e * f;
282 (%o3) a b c d e f g
283 (%i4) [op (%), args (%)];
284 (%o4) [*, [a, b, c, d, e, f, g]]
285 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
286 (%o5) 3 x + 2 a + 19
287 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
288 2 3
289 (%o6) 144 a x
290 @end example
292 Divis@~{a}o e exponencia@,{c}@~{a}o s@~{a}o operadores bin@'{a}rios n@~{a}o comutativos.
293 Os nomes desses operadores s@~{a}o @code{"/"} e @code{"^"}.
295 @c ===beg===
296 @c [a / b, a ^ b];
297 @c [map (op, %), map (args, %)];
298 @c [apply ("/", [a, b]), apply ("^", [a, b])];
299 @c ===end===
300 @example
301 (%i1) [a / b, a ^ b];
302 a b
303 (%o1) [-, a ]
304 b
305 (%i2) [map (op, %), map (args, %)];
306 (%o2) [[/, ^], [[a, b], [a, b]]]
307 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
308 a b
309 (%o3) [-, a ]
310 b
311 @end example
313 Subtra@,{c}@~{a}o e divis@~{a}o s@~{a}o representadas internamente
314 em termos de adi@,{c}@~{a}o e multiplica@,{c}@~{a}o, respectivamente.
316 @c ===beg===
317 @c [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
318 @c [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
319 @c ===end===
320 @example
321 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
322 (%o1) [+, a, - b]
323 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
324 1
325 (%o2) [*, a, -]
326 b
327 @end example
329 Computa@,{c}@~{o}es s@~{a}o realizadas sobre n@'{u}meros literais.
330 Aplica-se propaga@,{c}@~{a}o de n@'{u}meros em ponto flutuante.
332 @c ===beg===
333 @c 17 + b - (1/2)*29 + 11^(2/4);
334 @c [17 + 29, 17 + 29.0, 17 + 29b0];
335 @c ===end===
336 @example
337 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
338 5
339 (%o1) b + sqrt(11) + -
340 2
341 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
342 (%o2) [46, 46.0, 4.6b1]
343 @end example
345 Computa@,{c}@~{a}o aritm@'{e}ticas s@~{a}o uma simplifica@,{c}@~{a}o, n@~{a}o uma avalia@,{c}@~{a}o.
347 @c ===beg===
348 @c simp : false;
349 @c '(17 + 29*11/7 - 5^3);
350 @c simp : true;
351 @c '(17 + 29*11/7 - 5^3);
352 @c ===end===
353 @example
354 (%i1) simp : false;
355 (%o1) false
356 (%i2) '(17 + 29*11/7 - 5^3);
357 29 11 3
358 (%o2) 17 + ----- - 5
359 7
360 (%i3) simp : true;
361 (%o3) true
362 (%i4) '(17 + 29*11/7 - 5^3);
363 437
364 (%o4) - ---
365 7
366 @end example
368 Aritm@'{e}tica @'{e} realizada elemento-a-elemento em listas (dependendo de
369 @code{listarith}) e matrizes.
371 @c ===beg===
372 @c matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
373 @c 5 * matrix ([a, x], [h, u]);
374 @c listarith : false;
375 @c [a, c, m, t] / [1, 7, 2, 9];
376 @c [a, c, m, t] ^ x;
377 @c listarith : true;
378 @c [a, c, m, t] / [1, 7, 2, 9];
379 @c [a, c, m, t] ^ x;
380 @c ===end===
381 @example
382 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
383 @group
384 [ a - 1 x - 2 ]
385 (%o1) [ ]
386 [ h - 3 u - 4 ]
387 @end group
388 (%i2) 5 * matrix ([a, x], [h, u]);
389 [ 5 a 5 x ]
390 (%o2) [ ]
391 [ 5 h 5 u ]
392 (%i3) listarith : false;
393 (%o3) false
394 (%i4) [a, c, m, t] / [1, 7, 2, 9];
395 [a, c, m, t]
396 (%o4) ------------
397 [1, 7, 2, 9]
398 (%i5) [a, c, m, t] ^ x;
399 x
400 (%o5) [a, c, m, t]
401 (%i6) listarith : true;
402 (%o6) true
403 (%i7) [a, c, m, t] / [1, 7, 2, 9];
404 c m t
405 (%o7) [a, -, -, -]
406 7 2 9
407 (%i8) [a, c, m, t] ^ x;
408 x x x x
409 (%o8) [a , c , m , t ]
410 @end example
412 @opencatbox
413 @category{Operadores}
414 @closecatbox
415 @end deffn
417 @c -----------------------------------------------------------------------------
418 @anchor{**}
419 @deffn {Operador} **
421 Operador de exponencia@,{c}@~{a}o.
422 Maxima reconhece @code{**} como o mesmo operador que @mref{^}
423 na entrada,
424 e @code{**} @'{e} mostrado como @code{^} na sa@'{i}da unidimensional,
425 ou colocando o expoente como um super-escrito na sa@'{i}da bidimensional.
427 A fun@,{c}@~{a}o @mref{fortran}
428 mostra o operador de exponencia@,{c}@~{a}o como @code{**},
429 independente de esse operador de exponencia@,{c}@~{a}o vir de uma entrada @code{**} ou de uma entrada @code{^}.
431 Exemplos:
433 @c ===beg===
434 @c is (a**b = a^b);
435 @c x**y + x^z;
436 @c string (x**y + x^z);
437 @c fortran (x**y + x^z);
438 @c ===end===
439 @example
440 (%i1) is (a**b = a^b);
441 (%o1) true
442 (%i2) x**y + x^z;
443 z y
444 (%o2) x + x
445 (%i3) string (x**y + x^z);
446 (%o3) x^z+x^y
447 (%i4) fortran (x**y + x^z);
448 x**z+x**y
449 (%o4) done
450 @end example
452 @opencatbox
453 @category{Operadores}
454 @closecatbox
455 @end deffn
457 @c -----------------------------------------------------------------------------
458 @anchor{^^}
459 @deffn {Operador} ^^
460 @ifinfo
461 @fnindex Exponencia@,{c}@~{a}o n@~{a}o comutativa
462 @end ifinfo
464 Operador de exponencia@,{c}@~{a}o n@~{a}o comutativa.
465 O operador @code{^^} @'{e} o operador de exponencia@,{c}@~{a}o n@~{a}o comutativa que corresponde @`{a} multiplica@,{c}@~{a}o
466 n@~{a}o comutativa @code{.}, da mesma forma que o operador de exponencia@,{c}@~{a}o comum @code{^}
467 corresponde ao operador de multiplica@,{c}@~{a}o comutativa @code{*}.
469 A exponencia@,{c}@~{a}o n@~{a}o comutativa @'{e} mostrada como @code{^^} na sa@'{i}da unidimensional,
470 e pela comoca@,{c}@~{a}o do expoente como um super-escrito entre os sinais de "menor que" e "maior que" @code{< >}
471 na sa@'{i}da bidimensional.
473 Exemplos:
475 @c ===beg===
476 @c a . a . b . b . b + a * a * a * b * b;
477 @c string (a . a . b . b . b + a * a * a * b * b);
478 @c ===end===
479 @example
480 (%i1) a . a . b . b . b + a * a * a * b * b;
481 3 2 <2> <3>
482 (%o1) a b + a . b
483 (%i2) string (a . a . b . b . b + a * a * a * b * b);
484 (%o2) a^3*b^2+a^^2 . b^^3
485 @end example
487 @opencatbox
488 @category{Operadores}
489 @closecatbox
490 @end deffn
492 @c -----------------------------------------------------------------------------
493 @anchor{.}
494 @deffn {Operador} .
495 @ifinfo
496 @fnindex Multiplica@,{c}@~{a}o n@~{a}o comutativa
497 @end ifinfo
499 O operador ponto, para multiplica@,{c}@~{a}o (n@~{a}o comutativa) de matrizes.
500 Quando @code{"."} for usado nessa situa@,{c}@~{a}o, deve ter um espa@,{c}o em branco antes e outro depois
501 do ponto, e.g. @code{A . B}. Esse procedimento distingue o ponto da multiplica@,{c}@~{a}o n@~{a}o comutativa do ponto
502 decimal de um n@'{u}mero em ponto flutuante de forma clara.
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 @opencatbox
518 @category{Operadores}
519 @closecatbox
520 @end deffn
522 @c -----------------------------------------------------------------------------
523 @node Relational operators, Logical operators, Arithmetic operators, Operators
524 @section Relational operators
525 @c -----------------------------------------------------------------------------
527 @c -----------------------------------------------------------------------------
528 @anchor{<}
529 @anchor{<=}
530 @anchor{>=}
531 @anchor{>}
532 @fnindex Menor que
533 @fnindex Menor que ou equal
534 @fnindex Maior que ou equal
535 @fnindex Maior que
537 @deffn {Operator} <
538 @deffnx {Operator} <=
539 @deffnx {Operator} >=
540 @deffnx {Operator} >
542 Os s@'{i}mbolos @code{<} @code{<=} @code{>=} e @code{>} representam menor que, menor
543 que ou igual a, maior que ou igual a, e maior que, respectivamente. Os nomes
544 desses operadores s@~{a}o @code{"<"} @code{"<="} @code{">="} e @code{">"}, os quais
545 podem aparecer onde o nome de uma fun@,{c}@~{a}o ou operador seja necess@'{a}rio.
547 Esses operadores relacionais s@~{a}o todos operadores bin@'{a}rios; constru@,{c}@~{o}es tais como
548 @code{a < b < c} n@~{a}o s@~{a}o reconhecidas pelo Maxima.
550 Express@~{o}es relacionais s@~{a}o avaliadas para valores Booleanos @footnote{Nota do tradutor: George Boole - 1815/1864 - Lincoln, Inglaterra.} atrav@'{e}s das fun@,{c}@~{o}es
551 @mref{is}
552 e @mrefcomma{maybe}
553 e atrav@'{e}s das constru@,{c}@~{o}es de programa@,{c}@~{a}o
554 @mrefcomma{if} @mrefcomma{while}
555 e @mrefdot{unless}
556 Express@~{o}es relacionais
557 n@~{a}o s@~{a}o avaliadas de outra forma ou simplificadas para valores Booleanos, embora os
558 argumentos de express@~{o}es relacionais sejam avaliados (quando avalia@,{c}@~{a}o n@~{a}o for
559 de outra forma evitada atrav@'{e}s do uso do ap@'{o}strofo).
561 Quando uma express@~{a}o relacional n@~{a}o puder ser avaliada para @code{true} ou @code{false},
562 o comportamento de @code{is} e @code{if} @'{e} governado pelo sinalizador global
563 @mrefdot{prederror}
564 Quando @code{prederror} for @code{true}, @code{is} e
565 @code{if} dispara um erro. Quando @code{prederror} for @code{false}, @code{is}
566 retorna @code{unknown}, e @code{if} retorna uma express@~{a}o condicional
567 parcialmente avaliada.
569 A fun@,{c}@~{a}o @code{maybe} sempre comporta-se como @code{prederror} onde @code{false}, e
570 @code{while} e @code{unless} sempre comporta-se como @code{prederror} onde
571 @code{true}.
573 Operadores relacionais n@~{a}o s@~{a}o distributivos sobre listas ou outras agrega@,{c}@~{o}es.
575 Veja tamb@'{e}m @mrefcomma{=} @mrefcomma{#} @mrefcomma{equal}
576 e @mrefdot{notequal}
578 Exemplos:
580 Express@~{o}es relacionais s@~{a}o avaliadas para valores Booleanos atrav@'{e}s de algumas fun@,{c}@~{o}es e
581 constru@,{c}@~{o}es de programa@,{c}@~{a}o.
583 @c ===beg===
584 @c [x, y, z] : [123, 456, 789];
585 @c is (x < y);
586 @c maybe (y > z);
587 @c if x >= z then 1 else 0;
588 @c block ([S], S : 0, for i:1 while i <= 100 do S : S + i,
589 @c return (S));
590 @c ===end===
591 @example
592 (%i1) [x, y, z] : [123, 456, 789];
593 (%o1) [123, 456, 789]
594 (%i2) is (x < y);
595 (%o2) true
596 (%i3) maybe (y > z);
597 (%o3) false
598 (%i4) if x >= z then 1 else 0;
599 (%o4) 0
600 (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i,
601 return (S));
602 (%o5) 5050
603 @end example
605 Espress@~{o}es relacionais n@~{a}o s@~{a}o avaliadas ou simplificadas de outra forma para vlores
606 Booleanos, embora os argumentos de express@~{o}es relacionais sejam avaliados.
608 @c ===beg===
609 @c [x, y, z] : [123, 456, 789];
610 @c [x < y, y <= z, z >= y, y > z];
611 @c map (is, %);
612 @c ===end===
613 @example
614 (%o1) [123, 456, 789]
615 (%i2) [x < y, y <= z, z >= y, y > z];
616 (%o2) [123 < 456, 456 <= 789, 789 >= 456, 456 > 789]
617 (%i3) map (is, %);
618 (%o3) [true, true, true, false]
619 @end example
621 @opencatbox
622 @category{Operadores}
623 @closecatbox
624 @end deffn
626 @c -----------------------------------------------------------------------------
627 @node Logical operators, Operators for Equations, Relational operators, Operators
628 @section Logical operators
629 @c -----------------------------------------------------------------------------
631 @c NEEDS EXAMPLES
633 @c -----------------------------------------------------------------------------
634 @anchor{and}
635 @deffn {Operador} and
636 @ifinfo
637 @fnindex Conjun@,{c}@~{a}o l@'{o}gica
638 @end ifinfo
640 O operador l@'{o}gico de conjun@,{c}@~{a}o. O operador @code{and} @'{e} um operador en@'{a}rio infixo;
641 seus operandos s@~{a}o express@~{o}es Booleanas, e seu resultado @'{e} um valor Booleano.
643 O operador @code{and} for@,{c}a avalia@,{c}@~{a}o de um ou mais de seus operandos (da mesma forma que @mref{is}
644 ), e pode for@,{c}ar a avalia@,{c}@~{a}o de todos os operandos.
646 Operandos s@~{a}o avaliados na ordem em que aparecerem. O operador @code{and} avalia
647 somente a quantidade de operandos necess@'{a}rias para determinar o resultado. Se qualquer
648 operando for @code{false}, o resultado @'{e} @code{false} e nenhum operando da@'{i} em diante @'{e}
649 avaliado.
651 O sinalizador global @mref{prederror}
652 governa o comportamento de @code{and} quando um
653 operando avaliado n@~{a}o puder ser determinado @code{true} ou @code{false}.
654 O operador @code{and} mostra uma mensagem de erro quando @code{prederror} for @code{true}.
655 De outra forma, operandos que n@~{a}o avaliam para @code{true} ou @code{false} s@~{a}o
656 aceitos, e o resultado @'{e} uma express@~{a}o Booleana.
658 O operador @code{and} n@~{a}o @'{e} comutativo: @code{a and b} pode n@~{a}o ser igual a
659 @code{b and a} devido ao tratamento de operandos indeterminados.
661 @opencatbox
662 @category{Operadores}
663 @closecatbox
664 @end deffn
666 @c NEEDS EXAMPLES
668 @c -----------------------------------------------------------------------------
669 @anchor{not}
670 @deffn {Operador} not
671 @ifinfo
672 @fnindex Nega@,{c}@~{a}o l@'{o}gica
673 @end ifinfo
675 O operador de nega@,{c}@~{a}o l@'{o}gica. O operador @code{not} @'{e} um operador prefixado;
676 seu operando @'{e} uma express@~{a}o Booleana, e seu resultado @'{e} um valor Booleano.
678 O operador @code{not} for@,{c}a avalia@,{c}@~{a}o de seus operandos (da mesma forma que @code{is}).
680 O sinalizador global @mref{prederror}
681 governa o comportamento de @code{not} quando seu
682 operando n@~{a}o puder ser determinado @code{true} ou @code{false}. O operador @code{not}
683 mostra uma mensagem de erro quando @code{prederror} for @code{true}. De outra forma,
684 operandos que n@~{a}o avaliam para @code{true} ou @code{false} s@~{a}o aceitos,
685 e o resultado @'{e} uma express@~{a}o Booleana.
687 @opencatbox
688 @category{Operadores}
689 @closecatbox
690 @end deffn
692 @c NEEDS EXAMPLES
694 @c -----------------------------------------------------------------------------
695 @anchor{or}
696 @deffn {Operador} or
697 @ifinfo
698 @fnindex Disjun@,{c}@~{a}o l@'{o}gica
699 @end ifinfo
701 O operador de disjun@,{c}@~{a}o l@'{o}gica. O operador @code{or} @'{e} um operador en@'{a}rio infixo;
702 seus operandos s@~{a}o express@~{o}es Booleana, e seu resultado @'{e} um valor Booleano.
704 O operador @code{or} for@,{c}a avalia@,{c}@~{a}o de um ou mais de seus operandos (da mesma forma que @mref{is}
705 ), e pode for@,{c}ar a avalia@,{c}@~{a}o de todos os operandos.
707 Operandos s@~{a}o avaliados na ordem em que eles aparecem. O operador @code{or} avalia
708 somente a quantidade de operandos necess@'{a}ria para determinar o resultado. Se qualquer
709 operando for @code{true}, o resultado @'{e} @code{true} e nenhum operando adicional @'{e}
710 avaliado.
712 O sinalizador global @mref{prederror}
713 governa o comportamento de @code{or} quando um
714 operando avaliado n@~{a}o pode ser determinado @code{true} ou @code{false}.
715 O operando @code{or} mostra uma mensagem de erro quando @code{prederror} for @code{true}.
716 De outra forma, operandos que n@~{a}o avaliam para @code{true} ou @code{false} s@~{a}o
717 aceitos, e o resultado @'{e} uma express@~{a}o Booleana.
719 O operando @code{or} n@~{a}o @'{e} comutativo: @code{a or b} pode n@~{a}o ser igual a @code{b or a}
720 devido ao tratamento de operandos indeterminados.
722 @opencatbox
723 @category{Operadores}
724 @closecatbox
725 @end deffn
727 @c -----------------------------------------------------------------------------
728 @node Operators for Equations, Assignment operators, Logical operators, Operators
729 @section Operators for Equations
730 @c -----------------------------------------------------------------------------
732 @c -----------------------------------------------------------------------------
733 @anchor{#}
734 @deffn {Operador} #
735 @ifinfo
736 @fnindex Diferente (desigualdade sint@'{a}tica)
737 @end ifinfo
739 Representa a nega@,{c}@~{a}o da igualdade sint@'{a}tica @mrefdot{=}
741 Note que devido @`{a}s regras para avalia@,{c}@~{a}o de express@~{o}es predicadas
742 (em particular devido a @code{not @var{expr}} ocasionar a avalia@,{c}@~{a}o de @var{expr}),
743 @code{not @var{a} = @var{b}} @'{e} equivalente a @code{is(@var{a} # @var{b})},
744 ao inv@'{e}s de ser equivalente a @code{@var{a} # @var{b}}.
746 Exemplos:
748 @c ===beg===
749 @c a = b;
750 @c is (a = b);
751 @c a # b;
752 @c not a = b;
753 @c is (a # b);
754 @c is (not a = b);
755 @c ===end===
756 @example
757 (%i1) a = b;
758 (%o1) a = b
759 (%i2) is (a = b);
760 (%o2) false
761 (%i3) a # b;
762 (%o3) a # b
763 (%i4) not a = b;
764 (%o4) true
765 (%i5) is (a # b);
766 (%o5) true
767 (%i6) is (not a = b);
768 (%o6) true
769 @end example
771 @opencatbox
772 @category{Operadores}
773 @closecatbox
774 @end deffn
776 @c -----------------------------------------------------------------------------
777 @anchor{=}
778 @deffn {Operador} =
779 @ifinfo
780 @fnindex Operador de equa@,{c}@~{a}o
781 @fnindex Igual (igualdade sint@'{a}tica)
782 @end ifinfo
784 O operador de equa@,{c}@~{a}o.
786 Uma express@~{a}o @code{@var{a} = @var{b}}, por si mesma, representa uma equa@,{c}@~{a}o
787 n@~{a}o avaliada, que pode ou n@~{a}o manter-se. Equa@,{c}@~{o}es n@~{a}o avaliadas podem aparecer como
788 argumentos a @mref{solve}
789 e a @mref{algsys}
790 ou a alguma outra fun@,{c}@~{a}o.
792 A fun@,{c}@~{a}o @mref{is}
793 avalia @code{=} para um valor Booleano.
794 O comando @code{is(@var{a} = @var{b})} avalia @code{@var{a} = @var{b}} para @code{true}
795 quando @var{a} e @var{b} forem identicos. Isto @'{e}, @var{a} e @var{b} s@~{a}o @'{a}tomos
796 que s@~{a}o identicos, ou eles n@~{a}o s@~{a}o @'{a}tomos e seus operadores s@~{a}o identicos e
797 seus argumentos s@~{a}o identicos. De outra forma, @code{is(@var{a} = @var{b})}
798 avalia para @code{false}; @code{is(@var{a} = @var{b})} nunca avalia para @code{unknown}. Quando
799 @code{is(@var{a} = @var{b})} for @code{true}, @var{a} e @var{b} s@~{a}o ditos serem
800 sintaticamente iguais, em oposi@,{c}@~{a}o a express@~{o}es equivalentes, para o que
801 @code{is(equal(@var{a}, @var{b}))} @'{e} @code{true}. Express@~{o}es podem ser
802 equivalentes e n@~{a}o sintaticamente iguais.
804 A nega@,{c}@~{a}o de @code{=} @'{e} representada por @mrefdot{#}
805 Da mesma forma que o @code{=}, uma express@~{a}o @code{@var{a} # @var{b}}, por si mesma, n@~{a}o @'{e}
806 avaliada. O comando @code{is(@var{a} # @var{b})} avalia @code{@var{a} # @var{b}} para
807 @code{true} ou @code{false}.
809 Al@'{e}m de @code{is}, alguns outros oeradores avaliam @code{=} e @code{#}
810 para @code{true} ou @code{false}, s@~{a}o eles @mrefcomma{if} @mrefcomma{and}
811 @w{}@mrefcomma{or}
812 e @mrefdot{not}
814 Note que pelo fato de as regras para avalia@,{c}@~{a}o de express@~{o}es predicadas
815 (em particular pelo fato de @code{not @var{expr}} causar a avalia@,{c}@~{a}o de @var{expr}),
816 @code{not @var{a} = @var{b}} @'{e} equivalente a @code{is(@var{a} # @var{b})},
817 ao inv@'{e}s de ser equivalente a @code{@var{a} # @var{b}}.
819 As fun@,{c}@~{o}es @mref{rhs}
820 e @mref{lhs}
821 retornam o primeiro membro e o segundo membro da equa@,{c}@~{a}o,
822 respectivamente, de uma equa@,{c}@~{a}o ou inequa@,{c}@~{a}o.
824 Veja tamb@'{e}m @mref{equal}
825 e @mrefdot{notequal}
827 Exemplos:
829 Uma express@~{a}o @code{@var{a} = @var{b}}, por si mesma, representa
830 uma equa@,{c}@~{a}o n@~{a}o avaliada, que pode ou n@~{a}o se manter.
832 @c ===beg===
833 @c eq_1 : a * x - 5 * y = 17;
834 @c eq_2 : b * x + 3 * y = 29;
835 @c solve ([eq_1, eq_2], [x, y]);
836 @c subst (%, [eq_1, eq_2]);
837 @c ratsimp (%);
838 @c ===end===
839 @example
840 (%i1) eq_1 : a * x - 5 * y = 17;
841 (%o1) a x - 5 y = 17
842 (%i2) eq_2 : b * x + 3 * y = 29;
843 (%o2) 3 y + b x = 29
844 (%i3) solve ([eq_1, eq_2], [x, y]);
845 196 29 a - 17 b
846 (%o3) [[x = ---------, y = -----------]]
847 5 b + 3 a 5 b + 3 a
848 (%i4) subst (%, [eq_1, eq_2]);
849 @group
850 196 a 5 (29 a - 17 b)
851 (%o4) [--------- - --------------- = 17,
852 5 b + 3 a 5 b + 3 a
853 196 b 3 (29 a - 17 b)
854 --------- + --------------- = 29]
855 5 b + 3 a 5 b + 3 a
856 @end group
857 (%i5) ratsimp (%);
858 (%o5) [17 = 17, 29 = 29]
859 @end example
861 O comando @code{is(@var{a} = @var{b})} avalia @code{@var{a} = @var{b}} para @code{true}
862 quando @var{a} e @var{b} forem sintaticamente iguais (isto @'{e}, identicos).
863 Express@~{o}es podem ser equivalentes e n@~{a}o sintaticamente iguais.
865 @c ===beg===
866 @c a : (x + 1) * (x - 1);
867 @c b : x^2 - 1;
868 @c [is (a = b), is (a # b)];
869 @c [is (equal (a, b)), is (notequal (a, b))];
870 @c ===end===
871 @example
872 (%i1) a : (x + 1) * (x - 1);
873 (%o1) (x - 1) (x + 1)
874 (%i2) b : x^2 - 1;
875 2
876 (%o2) x - 1
877 (%i3) [is (a = b), is (a # b)];
878 (%o3) [false, true]
879 (%i4) [is (equal (a, b)), is (notequal (a, b))];
880 (%o4) [true, false]
881 @end example
883 Alguns operadores avaliam @code{=} e @code{#} para @code{true} ou @code{false}.
885 @c ===beg===
886 @c if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
887 @c BAR;
888 @c eq_3 : 2 * x = 3 * x;
889 @c eq_4 : exp (2) = %e^2;
890 @c [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
891 @c ===end===
892 @example
893 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
894 BAR;
895 (%o1) FOO
896 (%i2) eq_3 : 2 * x = 3 * x;
897 (%o2) 2 x = 3 x
898 (%i3) eq_4 : exp (2) = %e^2;
899 2 2
900 (%o3) %e = %e
901 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
902 (%o4) [false, true, true]
903 @end example
905 Devido a @code{not @var{expr}} causar a avalia@,{c}@~{a}o de @var{expr},
906 @code{not @var{a} = @var{b}} @'{e} equivalente a @code{is(@var{a} # @var{b})}.
908 @c ===beg===
909 @c [2 * x # 3 * x, not (2 * x = 3 * x)];
910 @c is (2 * x # 3 * x);
911 @c ===end===
912 @example
913 (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
914 (%o1) [2 x # 3 x, true]
915 (%i2) is (2 * x # 3 * x);
916 (%o2) true
917 @end example
919 @opencatbox
920 @category{Operadores}
921 @closecatbox
922 @end deffn
924 @c -----------------------------------------------------------------------------
925 @node Assignment operators, User defined operators, Operators for Equations, Operators
926 @section Assignment operators
927 @c -----------------------------------------------------------------------------
929 @c -----------------------------------------------------------------------------
930 @anchor{:}
931 @deffn {Operador} :
932 @ifinfo
933 @fnindex Operador de atribui@,{c}@~{a}o
934 @end ifinfo
936 Operador de atribui@,{c}@~{a}o.
938 Quando o primeiro membro @'{e} uma vari@'{a}vel simples (n@~{a}o uma vari@'{a}vel de subscrito), @code{:}
939 avalia seu segundo membro e associa aquele valor ao primeiro membro da equa@,{c}@~{a}o.
941 Quando o primeiro membro for um elemento subscrito de uma lista, matriz, Vetor est@'{a}tico do
942 Maxima explicitamente declarado, ou um vetor est@'{a}tico do Lisp, o segundo membro @'{e} atribu@'{i}do @`{a}quele elemento.
943 O subscrito deve dar nome a um elemento existente; tais objetos n@~{a}o podem ser extendidos
944 dando nome a elementos n@~{a}o existentes.
946 Quando o primeiro membro da igualdade for um elemento com subscrito de um vetor est@'{a}tico do Maxima n@~{a}o declarado,
947 o segundo emebro @'{e} atribu@'{i}do a aquele elemento, se esse elemento j@'{a} existia anteriormente,
948 ou um novo elemento @'{e} alocado, se ele n@~{a}o existir anteriormente.
950 Quando o primeiro membro for uma lista de vari@'{a}veis simples e/ou de vari@'{a}veis de subscritos, o
951 segundo membro deve avaliar para uma lista, e os elementos do segundo membro
952 s@~{a}o atribu@'{i}dos a elementos do primeiro membro, paralelamente.
954 Veja tamb@'{e}m @mref{kill}
955 e @mrefcomma{remvalue} que removem associa@,{c}@~{o}es entre
956 o primeiro membro e seu valor.
958 Exemplos:
960 Atribui@,{c}@~{a}o a uma vari@'{a}vel simples.
962 @c ===beg===
963 @c a;
964 @c a : 123;
965 @c a;
966 @c ===end===
967 @example
968 (%i1) a;
969 (%o1) a
970 (%i2) a : 123;
971 (%o2) 123
972 (%i3) a;
973 (%o3) 123
974 @end example
976 Atribui@,{c}@~{a}o a um elemento de uma lista.
978 @c ===beg===
979 @c b : [1, 2, 3];
980 @c b[3] : 456;
981 @c b;
982 @c ===end===
983 @example
984 (%i1) b : [1, 2, 3];
985 (%o1) [1, 2, 3]
986 (%i2) b[3] : 456;
987 (%o2) 456
988 (%i3) b;
989 (%o3) [1, 2, 456]
990 @end example
992 Atribui@,{c}@~{a}o cria um vetor est@'{a}tico n@~{a}o declarado.
994 @c ===beg===
995 @c c[99] : 789;
996 @c c[99];
997 @c c;
998 @c arrayinfo (c);
999 @c listarray (c);
1000 @c ===end===
1001 @example
1002 (%i1) c[99] : 789;
1003 (%o1) 789
1004 (%i2) c[99];
1005 (%o2) 789
1006 (%i3) c;
1007 (%o3) c
1008 (%i4) arrayinfo (c);
1009 (%o4) [hashed, 1, [99]]
1010 (%i5) listarray (c);
1011 (%o5) [789]
1012 @end example
1014 Atribui@,{c}@~{a}o multipla.
1016 @c ===beg===
1017 @c [a, b, c] : [45, 67, 89];
1018 @c a;
1019 @c b;
1020 @c c;
1021 @c ===end===
1022 @example
1023 (%i1) [a, b, c] : [45, 67, 89];
1024 (%o1) [45, 67, 89]
1025 (%i2) a;
1026 (%o2) 45
1027 (%i3) b;
1028 (%o3) 67
1029 (%i4) c;
1030 (%o4) 89
1031 @end example
1033 Atribui@,{c}@~{a}o m@'{u}ltipla @'{e} realizada paralelamente.
1034 Os valores de @code{a} e @code{b} s@~{a}o comutados nesse exemplo.
1036 @c ===beg===
1037 @c [a, b] : [33, 55];
1038 @c [a, b] : [b, a];
1039 @c a;
1040 @c b;
1041 @c ===end===
1042 @example
1043 (%i1) [a, b] : [33, 55];
1044 (%o1) [33, 55]
1045 (%i2) [a, b] : [b, a];
1046 (%o2) [55, 33]
1047 (%i3) a;
1048 (%o3) 55
1049 (%i4) b;
1050 (%o4) 33
1051 @end example
1053 @opencatbox
1054 @category{Avalia@,{c}@~{a}o} @category{Operadores}
1055 @closecatbox
1056 @end deffn
1058 @c -----------------------------------------------------------------------------
1059 @need 900
1060 @anchor{::}
1061 @deffn {Operador} ::
1062 @ifinfo
1063 @fnindex Operador de atribui@,{c}@~{a}o (avalia o primeiro membro da igualdade)
1064 @end ifinfo
1066 Operador de atribui@,{c}@~{a}o.
1068 O operador @code{::} funciona da mesma forma que @mref{:}
1069 (o que se pode concluir pela leitura do t@'{o}pico correspondente a @mref{:}
1070 ) exceto que @code{::} avalia
1071 o primeiro e o segundo membros da atribui@,{c}@~{a}o.
1073 Exemplos:
1075 @c ===beg===
1076 @c x : 'foo;
1077 @c x :: 123;
1078 @c foo;
1079 @c x : '[a, b, c];
1080 @c x :: [11, 22, 33];
1081 @c a;
1082 @c b;
1083 @c c;
1084 @c ===end===
1085 @example
1086 (%i1) x : 'foo;
1087 (%o1) foo
1088 (%i2) x :: 123;
1089 (%o2) 123
1090 (%i3) foo;
1091 (%o3) 123
1092 (%i4) x : '[a, b, c];
1093 (%o4) [a, b, c]
1094 (%i5) x :: [11, 22, 33];
1095 (%o5) [11, 22, 33]
1096 (%i6) a;
1097 (%o6) 11
1098 (%i7) b;
1099 (%o7) 22
1100 (%i8) c;
1101 (%o8) 33
1102 @end example
1104 @opencatbox
1105 @category{Avalia@,{c}@~{a}o} @category{Operadores}
1106 @closecatbox
1107 @end deffn
1109 @c -----------------------------------------------------------------------------
1110 @anchor{::=}
1111 @deffn {Operador} ::=
1112 @ifinfo
1113 @fnindex Operador de defini@,{c}@~{a}o de fun@,{c}@~{a}o macro
1114 @end ifinfo
1116 Operador de defini@,{c}@~{a}o de fun@,{c}@~{a}o de Macro.
1117 O operador @code{::=} define uma fun@,{c}@~{a}o (chamada uma "macro" por raz@~{o}es hist@'{o}ricas) a qual
1118 n@~{a}o avalia seus argumentos, e a express@~{a}o que o @code{::=} retorna (chamada "expans@~{a}o de
1119 macro") @'{e} avaliada no contexto a partor do qual a macro foi chamada.
1120 Uma fun@,{c}@~{a}o de macro @'{e}, em outras ocasi@~{o}es, a mesma coisa que uma defini@,{c}@~{a}o de fun@,{c}@~{a}o comum.
1122 A fun@,{c}@~{a}o @mref{macroexpand}
1123 retorna uma expans@~{a}o de macro (sem que essa expans@~{a}o seja avaliada).
1124 A fun@,{c}@~{a}o @code{macroexpand (qualquercoisa (x))} seguida por @code{''%} @'{e} equivalente a
1125 @code{qualquercoisa (x)} quando @code{qualquercoisa} for uma fun@,{c}@~{a}o de macro.
1127 O operador @code{::=} coloca o nome de fun@,{c}@~{a}o de nova macro dentro da lista global
1128 @mrefdot{macros} @mrefcomma{kill} @mrefcomma{remove}
1129 e @mref{remfunction}
1130 @w{} desassociam defini@,{c}@~{o}es de fun@,{c}@~{a}o de macro e remove nomes da lista global @code{macros}.
1132 A fun@,{c}@~{a}o @mref{fundef}
1133 retorna uma defini@,{c}@~{a}o de fun@,{c}@~{a}o de macro. A fun@,{c}@~{a}o @mref{dispfun}
1134 alem de retornar a defini@,{c}@~{a}o atribui a essa defini@,{c}@~{a}o um r@'{o}tulo.
1136 Fun@,{c}@~{o}es de macro comumente possuem express@~{o}es @mref{buildq}
1137 e @mref{splice}
1138 para contruir uma express@~{a}o, que @'{e} ent@~{a}o avaliada.
1140 Exemplos:
1142 A fun@,{c}@~{a}o de macro n@~{a}o avalia seus argumentos, ent@~{a}o a messagem (1) mostra @code{y - z}, n@~{a}o
1143 o valor de @code{y - z}. A expans@~{a}o de macro (a express@~{a}o com ap@'{o}strofo
1144 @code{'(print ("(2) x @'{e} igual a", x))}) @'{e} avaliada no contexto a partir do qual
1145 a macro foi chamada, mostrando a mensagem (2).
1147 @c ===beg===
1148 @c x: %pi$
1149 @c y: 1234$
1150 @c z: 1729 * w$
1151 @c printq1 (x) ::= block (print ("(1) x @'{e} igual a", x),
1152 @c '(print ("(2) x @'{e} igual a", x)))$
1153 @c printq1 (y - z);
1154 @c ===end===
1155 @example
1156 (%i1) x: %pi$
1157 (%i2) y: 1234$
1158 (%i3) z: 1729 * w$
1159 (%i4) printq1 (x) ::= block (print ("(1) x @'{e} igual a", x),
1160 '(print ("(2) x @'{e} igual a", x)))$
1161 (%i5) printq1 (y - z);
1162 (1) x @'{e} igual a y - z
1163 (2) x @'{e} igual a %pi
1164 (%o5) %pi
1165 @end example
1167 Uma fun@,{c}@~{a}o comum avalia seus argumentos, ent@~{a}o mensagem (1) mostra o valor de
1168 @code{y - z}. O valor de retorno n@~{a}o @'{e} avaliado, ent@~{a}o mensagem (2) n@~{a}o @'{e} mostrada
1169 at@'{e} a avalia@,{c}@~{a}o expl@'{i}cita @code{''%}.
1171 @c ===beg===
1172 @c x: %pi$
1173 @c y: 1234$
1174 @c z: 1729 * w$
1175 @c printe1 (x) := block (print ("(1) x @'{e} igual a", x),
1176 @c '(print ("(2) x @'{e} igual a", x)))$
1177 @c printe1 (y - z);
1178 @c ''%;
1179 @c ===end===
1180 @example
1181 (%i1) x: %pi$
1182 (%i2) y: 1234$
1183 (%i3) z: 1729 * w$
1184 (%i4) printe1 (x) := block (print ("(1) x @'{e} igual a", x),
1185 '(print ("(2) x @'{e} igual a", x)))$
1186 (%i5) printe1 (y - z);
1187 (1) x is equal to 1234 - 1729 w
1188 (%o5) print((2) x @'{e} igual a, x)
1189 (%i6) ''%;
1190 (2) x @'{e} igual a %pi
1191 (%o6) %pi
1192 @end example
1194 A fun@,{c}@~{a}o @code{macroexpand} retorna uma expans@~{a}o de macro.
1195 O comando @code{macroexpand (qualquercoisa (x))} seguido por @code{''%} @'{e} equivalente a
1196 @code{qualquercoisa (x)} quando @code{qualquercoisa} for uma fun@,{c}@~{a}o de macro.
1198 @c ===beg===
1199 @c x: %pi$
1200 @c y: 1234$
1201 @c z: 1729 * w$
1202 @c g (x) ::= buildq ([x], print ("x @'{e} igual a", x))$
1203 @c macroexpand (g (y - z));
1204 @c ''%;
1205 @c g (y - z);
1206 @c ===end===
1207 @example
1208 (%i1) x: %pi$
1209 (%i2) y: 1234$
1210 (%i3) z: 1729 * w$
1211 (%i4) g (x) ::= buildq ([x], print ("x @'{e} igual a", x))$
1212 (%i5) macroexpand (g (y - z));
1213 (%o5) print(x @'{e} igual a, y - z)
1214 (%i6) ''%;
1215 x is equal to 1234 - 1729 w
1216 (%o6) 1234 - 1729 w
1217 (%i7) g (y - z);
1218 x is equal to 1234 - 1729 w
1219 (%o7) 1234 - 1729 w
1220 @end example
1222 @opencatbox
1223 @category{Defini@,{c}@~{a}o de fun@,{c}@~{a}o} @category{Operadores}
1224 @closecatbox
1225 @end deffn
1227 @c -----------------------------------------------------------------------------
1228 @anchor{:=}
1229 @deffn {Operador} :=
1230 @ifinfo
1231 @fnindex Operador de defini@,{c}@~{a}o de fun@,{c}@~{a}o
1232 @end ifinfo
1234 O operador de defini@,{c}@~{a}o de fun@,{c}@~{a}o.
1236 O comando @code{@var{f}(@var{x_1}, ..., @var{x_n}) := @var{expr}} define uma fun@,{c}@~{a}o chamada
1237 @var{f} com argumentos @var{x_1}, @dots{}, @var{x_n} e lei de forma@,{c}@~{a}o
1238 @var{expr}. O operador @code{:=} nunca avalia a lei de forma@,{c}@~{a}o (a menos que explicitamente
1239 avaliado por ap@'{o}strofo-ap@'{o}strofo @code{'@w{}'}).
1240 O corpo da função é avaliado sempre que a função for chamada.
1242 O comando @code{@var{f}[@var{x_1}, ..., @var{x_n}] := @var{expr}} define uma então chamada função de vetor estático @footnote{Nota do tradutor: array.}.
1243 Seu corpo de função é avaliado apenas uma vez para cada valor distinto de seus argumentos,
1244 e aquele valor é retornado, sem fazer avaliação do corpo da função,
1245 sempre que os argumentos tiverem aqueles valores novamente.
1246 (Uma funçao desse tipo é comumente conhecida com uma ``função de memoizing''@footnote{Nota do tradutor: memoizing vem do latin -memorandum- e não do latin -memoria- é uma técnica de otimização de memória computacional.}.)
1248 O comando @code{@var{f}[@var{x_1}, ..., @var{x_n}](@var{y_1}, ..., @var{y_m}) := @var{expr}}
1249 é um caso especial de uma função de vetor estático.
1250 O comando @code{@var{f}[@var{x_1}, ..., @var{x_n}]} é uma função de vetor estático que retorna uma expressão @mref{lambda}
1251 com argumentos @code{@var{y_1}, ..., @var{y_m}}.
1252 O corpo da função é avaliado uma única vez para cada valor distinto de @code{@var{x_1}, ..., @var{x_n}},
1253 e o corpo da expressão lambda é aquele valor.
1255 Quando o @'{u}ltimo ou @'{u}nico argumento de fun@,{c}@~{a}o @var{x_n} for uma lista de um elemento, a
1256 fun@,{c}@~{a}o definida por @code{:=} aceita um n@'{u}mero de argumentos vari@'{a}vel. Os argumentos
1257 atuais s@~{a}o atribu@'{i}dos um-a-um a argumentos formais @var{x_1}, @dots{},
1258 @var{x_(n - 1)}, e quaisquer argumentos adicionais, se presentes, s@~{a}o atribu@'{i}dos a
1259 @var{x_n} como uma lista.
1261 Todas as defini@,{c}@~{o}es de fun@,{c}@~{a}o aparecem no mesmo espa@,{c}o de trabalho; definindo uma fun@,{c}@~{a}o
1262 @code{f} dentro de outra fun@,{c}@~{a}o @code{g} n@~{a}o limita automaticamente o escopo
1263 de @code{f} ao escopo de @code{g}. Todavia, @code{local(f)} torna a defini@,{c}@~{a}o da
1264 fun@,{c}@~{a}o @code{f} efetiva somente dentro do bloco ou somente dentro de outra express@~{a}o composta
1265 na qual @mref{local}
1266 apare@,{c}a.
1268 Se algum argumento formal @var{x_k} for um s@'{i}mbolo com ap@'{o}strofo no in@'{i}cio, a fun@,{c}@~{a}o definida atrav@'{e}s de
1269 @code{:=} n@~{a}o avalia o argumento atual correspondente. De outra forma todos os
1270 argumentos atuais s@~{a}o avaliados.
1272 Veja tamb@'{e}m @mref{define}
1273 e @mrefdot{::=}
1275 Exemplos:
1277 O operador @code{:=} nunca avalia o corpo da fun@,{c}@~{a}o (a menos que explicitamente avaliado por
1278 ap@'{o}strofo-ap@'{o}strofo).
1280 @c ===beg===
1281 @c expr : cos(y) - sin(x);
1282 @c F1 (x, y) := expr;
1283 @c F1 (a, b);
1284 @c F2 (x, y) := ''expr;
1285 @c F2 (a, b);
1286 @c ===end===
1287 @example
1288 (%i1) expr : cos(y) - sin(x);
1289 (%o1) cos(y) - sin(x)
1290 (%i2) F1 (x, y) := expr;
1291 (%o2) F1(x, y) := expr
1292 (%i3) F1 (a, b);
1293 (%o3) cos(y) - sin(x)
1294 (%i4) F2 (x, y) := ''expr;
1295 (%o4) F2(x, y) := cos(y) - sin(x)
1296 (%i5) F2 (a, b);
1297 (%o5) cos(b) - sin(a)
1298 @end example
1300 O comando @code{f(@var{x_1}, ..., @var{x_n}) := ...} define uma fun@,{c}@~{a}o comum.
1302 @c ===beg===
1303 @c G1(x, y) := (print ("Evaluating G1 for x=", x, "and y=", y), x.y - y.x);
1304 @c G1([1, a], [2, b]);
1305 @c G1([1, a], [2, b]);
1306 @c ===end===
1307 @example
1308 (%i1) G1(x, y) := (print ("Evaluating G1 for x=", x, "and y=", y), x.y - y.x);
1309 (%o1) G1(x, y) := (print("Evaluating G1 for x=", x, "and y=",
1310 y), x . y - y . x)
1311 (%i2) G1([1, a], [2, b]);
1312 Evaluating G1 for x= [1, a] and y= [2, b]
1313 (%o2) 0
1314 (%i3) G1([1, a], [2, b]);
1315 Evaluating G1 for x= [1, a] and y= [2, b]
1316 (%o3) 0
1317 @end example
1319 O comando @code{f[@var{x_1}, ..., @var{x_n}] := ...} define uma fun@,{c}@~{a}o array (vetor est@'{a}tico).
1321 @c ===beg===
1322 @c G2[a] := (print ("Evaluating G2 for a=", a), a^2);
1323 @c G2[1234];
1324 @c G2[1234];
1325 @c G2[2345];
1326 @c arrayinfo (G2);
1327 @c listarray (G2);
1328 @c ===end===
1329 @example
1330 (%i1) G2[a] := (print ("Evaluating G2 for a=", a), a^2);
1331 2
1332 (%o1) G2 := (print("Evaluating G2 for a=", a), a )
1333 a
1334 (%i2) G2[1234];
1335 Evaluating G2 for a= 1234
1336 (%o2) 1522756
1337 (%i3) G2[1234];
1338 (%o3) 1522756
1339 (%i4) G2[2345];
1340 Evaluating G2 for a= 2345
1341 (%o4) 5499025
1342 (%i5) arrayinfo (G2);
1343 (%o5) [hashed, 1, [1234], [2345]]
1344 (%i6) listarray (G2);
1345 (%o6) [1522756, 5499025]
1346 @end example
1348 O comando @code{@var{f}[@var{x_1}, ..., @var{x_n}](@var{y_1}, ..., @var{y_m}) := @var{expr}}
1349 @'{e} um caso especial de uma fun@,{c}@~{a}o array (vetor est@'{a}tico).
1351 @c ===beg===
1352 @c G3[n](x) := (print ("Evaluating G3 for n=", n), diff (sin(x)^2, x, n));
1353 @c G3[2];
1354 @c G3[2];
1355 @c G3[2](1);
1356 @c arrayinfo (G3);
1357 @c listarray (G3);
1358 @c ===end===
1359 @example
1360 (%i1) G3[n](x) := (print ("Evaluating G3 for n=", n), diff (sin(x)^2, x, n));
1361 (%o1) G3 (x) := (print("Evaluating G3 for n=", n),
1362 n
1363 2
1364 diff(sin (x), x, n))
1365 (%i2) G3[2];
1366 Evaluating G3 for n= 2
1367 2 2
1368 (%o2) lambda([x], 2 cos (x) - 2 sin (x))
1369 (%i3) G3[2];
1370 2 2
1371 (%o3) lambda([x], 2 cos (x) - 2 sin (x))
1372 (%i4) G3[2](1);
1373 2 2
1374 (%o4) 2 cos (1) - 2 sin (1)
1375 (%i5) arrayinfo (G3);
1376 (%o5) [hashed, 1, [2]]
1377 (%i6) listarray (G3);
1378 2 2
1379 (%o6) [lambda([x], 2 cos (x) - 2 sin (x))]
1380 @end example
1382 Quando o @'{u}ltimo ou @'{u}nico argumento da fun@,{c}@~{a}o @var{x_n} for uma lista de um elemento,
1383 a fun@,{c}@~{a}o definida atrav@'{e}s de @code{:=} aceita um n@'{u}mero vari@'{a}vel de argumentos.
1385 @c ===beg===
1386 @c H ([L]) := apply ("+", L);
1387 @c H (a, b, c);
1388 @c ===end===
1389 @example
1390 (%i1) H ([L]) := apply ("+", L);
1391 (%o1) H([L]) := apply("+", L)
1392 (%i2) H (a, b, c);
1393 (%o2) c + b + a
1394 @end example
1396 A declara@,{c}@~{a}o @code{local} torna uma defini@,{c}@~{a}o de fun@,{c}@~{a}o v@'{a}lida apenas localmente.
1398 @c ===beg===
1399 @c foo (x) := 1 - x;
1400 @c foo (100);
1401 @c block (local (foo), foo (x) := 2 * x, foo (100));
1402 @c foo (100);
1403 @c ===end===
1404 @example
1405 (%i1) foo (x) := 1 - x;
1406 (%o1) foo(x) := 1 - x
1407 (%i2) foo (100);
1408 (%o2) - 99
1409 (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
1410 (%o3) 200
1411 (%i4) foo (100);
1412 (%o4) - 99
1413 @end example
1415 @opencatbox
1416 @category{Defini@,{c}@~{a}o de fun@,{c}@~{a}o} @category{Operadores}
1417 @closecatbox
1418 @end deffn
1420 @c -----------------------------------------------------------------------------
1421 @node User defined operators, , Assignment operators, Operators
1422 @section User defined operators
1423 @c -----------------------------------------------------------------------------
1425 @c -----------------------------------------------------------------------------
1426 @anchor{infix}
1427 @deffn {Fun@,{c}@~{a}o} infix @
1428 @fname{infix} (@var{op}) @
1429 @fname{infix} (@var{op}, @var{lbp}, @var{rbp}) @
1430 @fname{infix} (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})
1432 Declara que o operador @var{op} @'{e} um operador infixo. Um operador infixo @'{e} uma fun@,{c}@~{a}o de
1433 dois argumentos, com o nome da fun@,{c}@~{a}o escrito entre os argumentos.
1434 Por exemplo, o operador de substra@,{c}@~{a}o @code{-} @'{e} um operador infixo.
1436 O comando @code{infix (@var{op})} declara que o operador @var{op} @'{e} um operador infixo com poder
1437 associado padr@~{a}o de (esquerda e direita ambas iguais a 180) e classe gramatical (esquerda e
1438 direita ambas iguais a @code{any}).
1439 @c HOW IS pos DIFFERENT FROM lpos AND rpos ??
1441 O comando @code{infix (@var{op}, @var{lbp}, @var{rbp})} declara que @var{op} @'{e} um operador
1442 infixo com poder associado direito e poder associado esquerdo ambos estabelecidos e classe gramatical padr@~{a}o
1443 (esquedo e direito ambos iguais a @code{any}).
1445 O comando @code{infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})}
1446 declara que o operador @var{op} @'{e} um operador infixo com poder associado direito e poder associado
1447 esquerdo ambos estabelecidos e classes gramaticais @var{lpos}, @var{rpos}, e @var{pos} para o operando
1448 esquerdo, o operando direito, e o resultado do operador, respectivamente.
1450 "Classe gramatical", referindo-se a declara@,{c}@~{o}es de operador, significa tipo de express@~{a}o.
1451 Tr@^{e}s tipos de express@~{a}o s@~{a}o reconhecidos: @code{expr}, @code{clause}, e @code{any},
1452 indicando uma express@~{a}o alg@'{e}brica, uma express@~{a}o Booleana, ou qualquer tipo de
1453 express@~{a}o, respectivamente. Maxima pode detectar alguns erros de sintaxe comparando a
1454 classe gramatical declarada com uma express@~{a}o atual.
1456 A preced@^{e}ncia do operador @var{op} em rela@,{c}@~{a}o a outro operador vem dos poderes
1457 associados esquerdo e direito dos operadores em quest@~{a}o. Se os poderes associados
1458 esquerdo e direito of @var{op} forem ambos maiores que os oderes associados esquerdo e direito de
1459 algum outro operador, ent@~{a}o o operador @var{op} tem preced@^{e}ncia sobre o outro operador.
1460 Se os poderes associados de um deles n@~{a}o forem ambos n@~{a}o forem ambos maiores ou menores, alguma rela@,{c}@~{a}o mais
1461 complicada acontece.
1463 A associatividade de @var{op} depende de seus poderes associados. Maior poder
1464 associado esquerdo (@var{lbp}) implica que uma inst@^{a}ncia de @var{op} @'{e} avaliada antes de
1465 outros operadores para sua esquerda em uma express@~{a}o, enquanto maior poder associado esquerdo
1466 (@var{rbp}) imprica que uma inst@^{a}ncia de @var{op} @'{e} avaliado antes de outros operadores
1467 para sua direita em uma express@~{a}o. Deesa forma maior poder associado esquerdo (@var{lbp}) torna @var{op}
1468 associativo @`{a} direita, enquanto maior poder associado direito (@var{rbp}) torna @var{op} associativo @`{a} esquerda.
1469 Se @var{lbp} for igual a @var{rbp}, o operador @var{op} @'{e} associativo @`{a} esquerda.
1471 Veja tamb@'{e}m @ref{Introduction to operators}.
1473 Exemplos:
1475 Se os poderes associados esqeurdo e direito de @var{op} forem ambos maiores
1476 que os poderes associados esquerdo e direito de algum outro operador,
1477 ent@~{a}o @var{op} tem preced@^{e}ncia sobre o outro operador.
1479 @c ===beg===
1480 @c :lisp (get '$+ 'lbp)
1481 @c :lisp (get '$+ 'rbp)
1482 @c infix ("##", 101, 101);
1483 @c "##"(a, b) := sconcat("(", a, ",", b, ")");
1484 @c 1 + a ## b + 2;
1485 @c infix ("##", 99, 99);
1486 @c 1 + a ## b + 2;
1487 @c ===end===
1488 @example
1489 (%i1) :lisp (get '$+ 'lbp)
1490 100
1491 (%i1) :lisp (get '$+ 'rbp)
1492 100
1493 (%i1) infix ("##", 101, 101);
1494 (%o1) ##
1495 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
1496 (%o2) (a ## b) := sconcat("(", a, ",", b, ")")
1497 (%i3) 1 + a ## b + 2;
1498 (%o3) (a,b) + 3
1499 (%i4) infix ("##", 99, 99);
1500 (%o4) ##
1501 (%i5) 1 + a ## b + 2;
1502 (%o5) (a+1,b+2)
1503 @end example
1505 Maior @var{lbp} torna @var{op} associativo @`{a} direita,
1506 enquanto maior @var{rbp} torna @var{op} associativo @`{a} esquerda.
1508 @c ===beg===
1509 @c infix ("##", 100, 99);
1510 @c "##"(a, b) := sconcat("(", a, ",", b, ")")$
1511 @c foo ## bar ## baz;
1512 @c infix ("##", 100, 101);
1513 @c foo ## bar ## baz;
1514 @c ===end===
1515 @example
1516 (%i1) infix ("##", 100, 99);
1517 (%o1) ##
1518 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
1519 (%i3) foo ## bar ## baz;
1520 (%o3) (foo,(bar,baz))
1521 (%i4) infix ("##", 100, 101);
1522 (%o4) ##
1523 (%i5) foo ## bar ## baz;
1524 (%o5) ((foo,bar),baz)
1525 @end example
1527 Maxima pode detectar alguns erros de sintaxe comparando a
1528 classe gramatical declarada com uma express@~{a}o atual.
1530 @c ===beg===
1531 @c infix ("##", 100, 99, expr, expr, expr);
1532 @c if x ## y then 1 else 0;
1533 @c infix ("##", 100, 99, expr, expr, clause);
1534 @c if x ## y then 1 else 0;
1535 @c ===end===
1536 @example
1537 (%i1) infix ("##", 100, 99, expr, expr, expr);
1538 (%o1) ##
1539 (%i2) if x ## y then 1 else 0;
1540 Incorrect syntax: Found algebraic expression where logical
1541 expression expected
1542 if x ## y then
1543 ^
1544 (%i2) infix ("##", 100, 99, expr, expr, clause);
1545 (%o2) ##
1546 (%i3) if x ## y then 1 else 0;
1547 (%o3) if x ## y then 1 else 0
1548 @end example
1550 @opencatbox
1551 @category{Operadores} @category{Declara@,{c}@~{o}es e infer@^{e}ncias} @category{Sintaxe}
1552 @closecatbox
1553 @end deffn
1555 @c -----------------------------------------------------------------------------
1556 @anchor{matchfix}
1557 @deffn {Fun@,{c}@~{a}o} matchfix @
1558 @fname{matchfix} (@var{ldelimiter}, @var{rdelimiter}) @
1559 @fname{matchfix} (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})
1561 Declara um operador matchfix com delimitadores esquerdo e direito @var{de}
1562 e @var{dd}. Os delimitadores s@~{a}o especificados como sequ@^{e}ncias de caractere.
1564 Um operador "matchfix" @'{e} uma fun@,{c}@~{a}o com qualquer n@'{u}mero de argumentos,
1565 tal que os argumentos ocorrem entre os delimitadores esquerdo e direito.
1566 Os delimitadores podem ser sequencias de caractere, t@~{a}o longas quanto o analizador possa
1567 os delimitadores dos operandos
1568 e de outras express@~{o}es e operadores.
1569 Na pr@'{a}tica isso inviabiliza delimitadores n@~{a}o analis@'{a}veis tais como
1570 @code{%}, @code{,}, @code{$} e @code{;},
1571 e pode exigir isolamento de delimitadores com espa@,{c}o em branco.
1572 O delimitador da direita pode ser igual ou diferente do delimitador da esquerda.
1574 Umdelimitador esquerdo pode ser associado a somente um delimitador direito;
1575 dois diferentes operadores matchfix n@~{a}o podem ter o mesmo delimitador esquerdo.
1577 Um operador existente pode ser declarado novamente como sendo um operador matchfix
1578 sem modificar suas outras propriedades.
1579 Em particular, operadores embutidos como adi@,{c}@~{a}o @code{+} podem
1580 ser declarados matchfix,
1581 mas fun@,{c}@~{o}es de operador n@~{a}o podem ser definidas para operadores embutidos.
1583 O comando @code{matchfix (@var{de}, @var{dd}, @var{clgr_arg},
1584 @var{clgr})} declara que o argumento tem a classe gramatical @var{clgr_arg} e resultado
1585 tem a classe gramatical @var{clgr}, e os delimitadores @var{de} e
1586 @var{dd}.
1588 "Classe gramatical", referindo-se a declara@,{c}@~{o}es de operador, significa tipo de express@~{a}o.
1589 Tr@^{e}s tipos s@~{a}o reconhecidos: @code{expr}, @code{clause}, e @code{any},
1590 indicando uma express@~{a}o alg@'{e}brica, uma express@~{a}o Booleana, ou qualquer tipo de
1591 express@~{a}o, respectivamente.
1592 Maxima pode detectar alguns erros de sintaxe comparando a
1593 classe gramatical declarada com uma express@~{a}o atual.
1595 @c DUNNO IF WE REALLY NEED TO MENTION BINDING POWER HERE -- AS NOTED IT'S IRRELEVANT
1596 @c An operator declared by @code{matchfix} is assigned a low binding power.
1597 @c Since a matchfix operator must be evaluated before any expression
1598 @c which contains it,
1599 @c binding power is effectively irrelevant
1600 @c to the declaration of a matchfix operator.
1602 A fun@,{c}@~{a}o para realizar uma opera@,{c}@~{a}o matchfix @'{e} uma fun@,{c}@~{a}o
1603 comum definida pelo usu@'{a}rio.
1604 A fun@,{c}@~{a}o de operador @'{e} definida
1605 da forma usual
1606 com o operador de defini@,{c}@~{a}o de fun@,{c}@~{a}o @code{:=} ou com @code{define}.
1607 Os argumentos podem ser escritos entre os delimitadores,
1608 ou com o delimitador esquerdo como uma sequ@^{e}ncia de caracteres entre aspas duplas e os argumentos
1609 em seguida entre par@^{e}ntesis.
1610 O comando @code{dispfun (@var{de})} mostra a defini@,{c}@~{a}o da fun@,{c}@~{a}o.
1612 O @'{u}nico operador matchfix embutido @'{e} o construtor de listas @code{[ ]}.
1613 Os par@^{e}ntesis @code{( )} e as aspas duplas @code{" "}
1614 atuam como operadores matchfix,
1615 mas n@~{a}o s@~{a}o tratados como tais pelo analisador do Maxima.
1617 O comando @code{matchfix} avalia seus argumentos.
1618 O comando @code{matchfix} retorna seu primeiro argumento, @var{de}.
1619 @c HOW TO TAKE AWAY THE MATCHFIX PROPERTY ??
1621 Exemplos:
1623 Delimitadores podem ser quase qualquer sequ@^{e}ncia de caracteres.
1625 @c ===beg===
1626 @c matchfix ("@@", "~");
1627 @c @@ a, b, c ~;
1628 @c matchfix (">>", "<<");
1629 @c >> a, b, c <<;
1630 @c matchfix ("foo", "oof");
1631 @c foo a, b, c oof;
1632 @c >> w + foo x, y oof + z << / @@ p, q ~;
1633 @c ===end===
1634 @example
1635 (%i1) matchfix ("@@@@", "~");
1636 (%o1) @@@@
1637 (%i2) @@@@ a, b, c ~;
1638 (%o2) @@@@a, b, c~
1639 (%i3) matchfix (">>", "<<");
1640 (%o3) >>
1641 (%i4) >> a, b, c <<;
1642 (%o4) >>a, b, c<<
1643 (%i5) matchfix ("foo", "oof");
1644 (%o5) foo
1645 (%i6) foo a, b, c oof;
1646 (%o6) fooa, b, coof
1647 (%i7) >> w + foo x, y oof + z << / @@@@ p, q ~;
1648 >>z + foox, yoof + w<<
1649 (%o7) ----------------------
1650 @@@@p, q~
1651 @end example
1653 Operadores matchfix s@~{a}o fun@,{c}@~{o}es comuns definidas pelo usu@'{a}rio.
1655 @example
1656 (%i1) matchfix ("!-", "-!");
1657 (%o1) "!-"
1658 (%i2) !- x, y -! := x/y - y/x;
1659 x y
1660 (%o2) !-x, y-! := - - -
1661 y x
1662 (%i3) define (!-x, y-!, x/y - y/x);
1663 x y
1664 (%o3) !-x, y-! := - - -
1665 y x
1666 (%i4) define ("!-" (x, y), x/y - y/x);
1667 x y
1668 (%o4) !-x, y-! := - - -
1669 y x
1670 (%i5) dispfun ("!-");
1671 x y
1672 (%t5) !-x, y-! := - - -
1673 y x
1675 (%o5) done
1676 (%i6) !-3, 5-!;
1677 16
1678 (%o6) - --
1679 15
1680 (%i7) "!-" (3, 5);
1681 16
1682 (%o7) - --
1683 15
1684 @end example
1686 @opencatbox
1687 @category{Sintaxe} @category{Operadores}
1688 @closecatbox
1689 @end deffn
1691 @c -----------------------------------------------------------------------------
1692 @anchor{function_nary}
1693 @deffn {Fun@,{c}@~{a}o} nary @
1694 @fname{nary} (@var{op}) @
1695 @fname{nary} (@var{op}, @var{bp}, @var{arg_pos}, @var{pos})
1697 Um operador @code{nary} é usado para denotar uma função de qualquer número de argumentos,
1698 cada um dos quais separados por uma ocorrência do operador, e.g. A+B or A+B+C.
1699 A função @code{nary("x")} é uma extensão da sintaxe de função para declarar @code{x}
1700 como sendo um operador do tipo @code{nary}. Funções podem ser declaradas para serem @code{nary}. Se
1701 @code{declare(j,nary);} for concluído, diz ao simplificador para simplificar, e.g.
1702 @code{j(j(a,b),j(c,d))} em @code{j(a, b, c, d)}.
1704 Veja tamb@'{e}m @ref{Introduction to operators}.
1706 @opencatbox
1707 @category{Operadores} @category{Sintaxe}
1708 @closecatbox
1709 @end deffn
1711 @c -----------------------------------------------------------------------------
1712 @anchor{nofix}
1713 @deffn {Fun@,{c}@~{a}o} nofix @
1714 @fname{nofix} (@var{op}) @
1715 @fname{nofix} (@var{op}, @var{pos})
1717 Os operadors @code{nofix} são usados para denotar funções que não possuem argumentos.
1718 A mera presença de tal operador em um comando fará com que a
1719 função correspondente seja avaliada. Por exemplo, quando se digita
1720 "exit;" para sair de uma parada do Maxima, "exit" se comporta de forma semelhante a um
1721 operador @code{nofix}. A função @code{nofix("x")} é uma extensão da sintaxe
1722 de função que declara @code{x} como sendo um operador @code{nofix}.
1724 Veja tamb@'{e}m @ref{Introduction to operators}.
1726 @opencatbox
1727 @category{Operadores} @category{Sintaxe}
1728 @closecatbox
1729 @end deffn
1731 @c -----------------------------------------------------------------------------
1732 @anchor{postfix}
1733 @deffn {Fun@,{c}@~{a}o} postfix @
1734 @fname{postfix} (@var{op}) @
1735 @fname{postfix} (@var{op}, @var{lbp}, @var{lpos}, @var{pos})
1737 Operadores @code{postfix} como a variedade @code{prefix} denota fun@,{c}@~{o}es de um
1738 @'{u}nico argumento, mas nesse caso o argumento precede uma
1739 ocorr@^{e}ncia do operador na sequ@^{e}ncia de caracteres de entrada, e.g. 3!. A
1740 fun@,{c}@~{a}o @code{postfix("x")} @'{e} uma fun@,{c}@~{a}o de extens@~{a}o de sintaxe para declarar que @code{x}
1741 @'{e} um operador @code{postfix}.
1743 Veja tamb@'{e}m @ref{Introduction to operators}.
1745 @opencatbox
1746 @category{Operadores} @category{Sintaxe}
1747 @closecatbox
1748 @end deffn
1750 @c -----------------------------------------------------------------------------
1751 @anchor{prefix}
1752 @deffn {Fun@,{c}@~{a}o} prefix @
1753 @fname{prefix} (@var{op}) @
1754 @fname{prefix} (@var{op}, @var{rbp}, @var{rpos}, @var{pos})
1756 Um operador @code{prefix} significa uma fun@,{c}@~{a}o de um argumento,
1757 o qual segue imediatamente uma ocorr@^{e}ncia do operador.
1758 O comando @code{prefix("x")} @'{e} uma fun@,{c}@~{a}o de extens@~{a}o de sintaxe para declarar que @code{x} @'{e} um
1759 operador @code{prefix}.
1761 Veja tamb@'{e}m @ref{Introduction to operators}.
1763 @opencatbox
1764 @category{Operadores} @category{Sintaxe}
1765 @closecatbox
1766 @end deffn