| blob | 7d91fd23b4b1094b490f7b34e22547a9c9a95be9 |
1 @c English version 2011-09-03
2 @menu
3 * Introducción a los operadores::
4 * Operadores aritméticos::
5 * Operadores relacionales::
6 * Operadores lógicos::
7 * Operadores para ecuaciones::
8 * Operadores de asignación::
9 * Operadores definidos por el usuario::
10 @end menu
12 @node Introducción a los operadores, Operadores aritméticos, Operadores, Operadores
13 @section Introducción a los operadores
15 Maxima reconoce los operadores aritméticos, relacionales y lógicos
16 usuales de la matemática. Además, Maxima dispone de operadores para
17 la asignación de valores a variables y la definición de funciones.
18 La siguiente tabla muestra los operadores que se describen en este
19 capítulo, en la que se incluye el nombre del operador,
20 el rango de enlace por la izquierda @code{lbp}, el rango de enlace
21 por la derecha @code{rbp}, el tipo de operador y un ejemplo, para
22 finalizar, en cada caso, con su formato interno tal como
23 es leída por el analizador sintáctico.
25 @verbatim
27 Operador lbp rbp Tipo Ejemplo Formato interno
29 + 100 134 nary a+b ((mplus) $A $B)
30 - 100 134 prefix -a ((mminus) $A)
31 * 120 nary a*b ((mtimes) $A $B)
32 / 120 120 infix a/b ((mquotient) $A $B)
33 ^ 140 139 infix a^b ((mexpt) $A $B)
34 ** 140 139 infix a**b ((mexpt) $A $B)
35 ^^ 140 139 infix a^^b ((mncexpt) $A $B)
36 . 130 129 infix a.b ((mnctimes) $A $B)
38 < 80 80 infix a<b ((mlessp) $A $B)
39 <= 80 80 infix a<=b ((mleqp) $A $B)
40 > 80 80 infix a>b ((mqreaterp) $A $B)
41 >= 80 80 infix a>=b ((mgeqp) $A $B)
43 not 70 prefix not a ((mnot) $A)
44 and 65 nary a and b ((mand) $A $B)
45 or 60 nary a or b ((mor) $A $B)
47 # 80 80 infix a#b ((mnotequal) $A $B)
48 = 80 80 infix a=b ((mequal) $A $B)
50 : 180 20 infix a:b ((msetq) $A $B)
51 :: 180 20 infix a::b ((mset) $A $B)
52 := 180 20 infix a:=b ((mdefine) $A $B)
53 ::= 180 20 infix a::=b ((mdefmacro) $A $B)
55 @end verbatim
57 Con los rangos de enlace de los operadores se definen las reglas de prioridad de
58 cálculo de los mismos. Así, por ejemplo, el analizador
59 sintáctico interpreta la expresión @code{ a + b * c } como
60 @code{ a + (b * c) }, pues el rango de enlace por la izquierda de la
61 multiplicación es mayor que rango de enlace por la izquierda de la
62 suma.
64 Maxima clasifica los operadores de la siguiente manera:
66 @table @emph
67 @item Prefijo (prefix)
68 Los operadores prefijos son unarios con un único operando que
69 se escribe a continuación del operando. Ejemplos son @code{-} y @code{not}.
70 @item Sufijo (postfix)
71 Los operadores sufijos son unarios con un único operando que
72 se escribe precediendo al operando. Un ejemplo es el factorial @code{!}.
73 @item Infijo (infix)
74 Los operadores infijos son operadores binarios que necesitan dos operandos,
75 los cuales se colocan uno a cada lado del operador. Ejemplos son el operador
76 para la exponenciación, @code{^}, y el operador de asignación, @code{:}.
77 @item N-ario (n-ary)
78 Los operadores n-arios admiten un número arbitrario de operandos. Son
79 ejemplos la multiplicación, @code{*}, y la suma, @code{+}.
80 @item Acotador (matchfix)
81 Los acotadores son operadores que se utilizan para establecer el comienzo
82 y final de una lista de operandos. Los operadores @code{[} y @code{]} son
83 ejemplos de acotadores, que se utilizan para definir una lista tal como
84 @code{[a, b, ...]}.
85 @item No-fijo (nofix)
86 Un operador no-fijo carece de operandos. Maxima no tiene operadores internos
87 no-fijos, pero se pueden crear como cuando se escribe @code{nofix(quit)},
88 lo que permite obviar el uso de paréntesis, y utilizar simplemente @code{quit}
89 en lugar de @code{quit()}, para cerrar una sesión de Maxima.
90 @end table
92 En la sección dedicada a los operadores definidos por el usuario
93 se describe cómo redefinir los operadores internos de Maxima y cómo
94 crear otros nuevos.
96 El mecanismo para definir un nuevo operador es sencillo.
97 Tan solo es necesario declarar una función como operador;
98 la función operador puede estar definida o no.
100 Un ejemplo de operador definido por el usuario es el siguiente.
101 Nótese que la llamada a función @code{"dd" (a)} equivale a @code{dd a},
102 de igual manera que @code{"<-" (a, b)} también equivale a @code{a <- b}.
103 Nótese también que las funciones @code{"dd"} y @code{"<-"} no están definidas en este ejemplo.
105 @c ===beg===
106 @c prefix ("dd");
107 @c dd a;
108 @c "dd" (a);
109 @c infix ("<-");
110 @c a <- dd b;
111 @c "<-" (a, "dd" (b));
112 @c ===end===
113 @example
114 (%i1) prefix ("dd");
115 (%o1) dd
116 (%i2) dd a;
117 (%o2) dd a
118 (%i3) "dd" (a);
119 (%o3) dd a
120 (%i4) infix ("<-");
121 (%o4) <-
122 (%i5) a <- dd b;
123 (%o5) a <- dd b
124 (%i6) "<-" (a, "dd" (b));
125 (%o6) a <- dd b
126 @end example
128 La tabla anterior no incluye todos los operadores definidos en Maxima,
129 ya que también lo son @code{!} para el factorial, @code{for}, @code{do} y
130 @code{while} para programar bucles, o @code{if}, @code{then} y @code{else}
131 para definir condicionales.
133 Las funciones @code{remove} y @code{kill} eliminan propiedades de operadores de un átomo.
134 La llamada @code{remove ("@var{a}", op)} sólo elimina las propiedades de operador de @var{a}.
135 La llamada @code{kill ("@var{a}")} elimina todas las propiedades de @var{a}, incluidas las propiedades de operador.
136 Nótese que el nombre del operador debe ir entre comillas.
138 @c MAYBE COPY THIS EXAMPLE TO remove AND/OR kill
139 @c ===beg===
140 @c infix ("##");
141 @c "##" (a, b) := a^b;
142 @c 5 ## 3;
143 @c remove ("##", op);
144 @c 5 ## 3;
145 @c "##" (5, 3);
146 @c infix ("##");
147 @c 5 ## 3;
148 @c kill ("##");
149 @c 5 ## 3;
150 @c "##" (5, 3);
151 @c ===end===
152 @example
153 (%i1) infix ("##");
154 (%o1) ##
155 (%i2) "##" (a, b) := a^b;
156 b
157 (%o2) a ## b := a
158 (%i3) 5 ## 3;
159 (%o3) 125
160 (%i4) remove ("##", op);
161 (%o4) done
162 (%i5) 5 ## 3;
163 Incorrect syntax: # is not a prefix operator
164 5 ##
165 ^
166 (%i5) "##" (5, 3);
167 (%o5) 125
168 (%i6) infix ("##");
169 (%o6) ##
170 (%i7) 5 ## 3;
171 (%o7) 125
172 (%i8) kill ("##");
173 (%o8) done
174 (%i9) 5 ## 3;
175 Incorrect syntax: # is not a prefix operator
176 5 ##
177 ^
178 (%i9) "##" (5, 3);
179 (%o9) ##(5, 3)
180 @end example
191 @node Operadores aritméticos, Operadores relacionales, Introducción a los operadores, Operadores
192 @section Operadores aritméticos
195 @deffn {Operador} +
196 @ifinfo
197 @fnindex Suma
198 @end ifinfo
199 @deffnx {Operador} -
200 @ifinfo
201 @fnindex Resta
202 @end ifinfo
203 @deffnx {Operador} *
204 @ifinfo
205 @fnindex Multiplicación
206 @end ifinfo
207 @deffnx {Operador} /
208 @ifinfo
209 @fnindex División
210 @end ifinfo
211 @deffnx {Operador} ^
212 @ifinfo
213 @fnindex Exponenciación
214 @end ifinfo
216 Los símbolos @code{+} @code{*} @code{/} y @code{^} representan
217 la suma, resta, multiplicación, división y exponenciación, respectivamente.
218 Los nombres de estos operadores son @code{"+"} @code{"*"} @code{"/"} y @code{"^"},
219 que pueden aparecer allá donde se requiera el nombre de una función u operador.
221 Los símbolos @code{+} y @code{-} representan el positivo y negativo unario,
222 siendo los nombres de estos operadores @code{"+"} y @code{"-"}, respectivamente.
224 En Maxima, la resta @code{a - b} se representa como la suma @code{a + (- b)}.
225 Expresiones tales como @code{a + (- b)} se muestran como restas. Maxima
226 reconoce @code{"-"} tan solo como el operador de negación unaria, no como
227 el nombre del operador de resta binaria.
229 La división @code{a / b} se representa en maxima como la multiplicación
230 @code{a * b^(- 1)}. Expresiones tales como @code{a * b^(- 1)} se muestran
231 como divisiones. Maxima reconoce @code{"/"} como el nombre del operador
232 de división.
234 La suma y la multiplicación son operadores conmutativos n-arios. La
235 división y la exponenciación son operadores no conmutativos binarios.
237 Maxima ordena los operandos de los operadores conmutativos para
238 formar lo que se conoce como representación canónica. A efectos de
239 almacenamiento interno, la ordenación viene determinada por @code{orderlessp}.
240 A efectos de presentación de las expresiones, la ordenación de la suma
241 la determina @code{ordergreatp}, y en el caso de la multiplicación, la
242 ordenación coincide con la del almacenamiento interno.
244 Los cálculos aritméticos se realizan con números literales
245 (enteros, racionales, decimales ordinarios y decimales grandes).
246 Excepto en el caso de la exponenciación, todas las operaciones
247 aritméticas con números dan lugar a resultados en forma de
248 números. La exponenciación da como resultado un número
249 si alguno de los operandos es decimal ordinario o grande (@i{bigfloat}),
250 o si el resultado es un entero o racional; en caso contrario,
251 la exponenciación puede expresarse como una raíz
252 cuadrada (@code{sqrt}), como otra potencia, o simplemente no
253 sufre cambios.
255 Se produce contagio de los decimales en coma flotante en los
256 cálculos aritméticos: si algún operando es un número decimal
257 grande (@i{bigfloat}), el resultado será también un número
258 decimal grande; no habiendo decimales grandes, pero sí
259 ordinarios, el resultado srá también un decimal ordinario; de no
260 haber operandos decimales, el resultado será un número racional o
261 entero.
263 Los cálculos aritméticos son simplificaciones, no evaluaciones, por lo
264 que se realizan en expresiones comentadas.
266 Las operaciones aritméticas se aplican elemento a elemento en el
267 caso de las listas cuando la variable global @code{listarith} vale @code{true};
268 pero en el caso de las matrices, siempre se aplican elemento a elemento.
269 Cuando un operando es una lista o matriz y otro operando lo es de otro tipo
270 cualquiera, éste se combina con cada uno de los elementos de la lista o
271 matriz.
273 Ejemplos:
275 La suma y la multiplicación son operadores conmutativos n-arios.
276 Maxima ordena los operandos para formar lo que se conoce como
277 representación canónica. Los nombres de estos operadores son
278 @code{"+"} y @code{"-"}.
279 @c ===beg===
280 @c c + g + d + a + b + e + f;
281 @c [op (%), args (%)];
282 @c c * g * d * a * b * e * f;
283 @c [op (%), args (%)];
284 @c apply ("+", [a, 8, x, 2, 9, x, x, a]);
285 @c apply ("*", [a, 8, x, 2, 9, x, x, a]);
286 @c ===end===
288 @example
289 (%i1) c + g + d + a + b + e + f;
290 (%o1) g + f + e + d + c + b + a
291 (%i2) [op (%), args (%)];
292 (%o2) [+, [g, f, e, d, c, b, a]]
293 (%i3) c * g * d * a * b * e * f;
294 (%o3) a b c d e f g
295 (%i4) [op (%), args (%)];
296 (%o4) [*, [a, b, c, d, e, f, g]]
297 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
298 (%o5) 3 x + 2 a + 19
299 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
300 2 3
301 (%o6) 144 a x
302 @end example
304 La división y la exponenciación son operadores no conmutativos binarios.
305 Los nombres de estos operadores son @code{"/"} y @code{"^"}.
306 @c ===beg===
307 @c [a / b, a ^ b];
308 @c [map (op, %), map (args, %)];
309 @c [apply ("/", [a, b]), apply ("^", [a, b])];
310 @c ===end===
312 @example
313 (%i1) [a / b, a ^ b];
314 a b
315 (%o1) [-, a ]
316 b
317 (%i2) [map (op, %), map (args, %)];
318 (%o2) [[/, ^], [[a, b], [a, b]]]
319 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
320 a b
321 (%o3) [-, a ]
322 b
323 @end example
325 La resta y la división se representan internamente en
326 términos de la suma y multiplicación, respectivamente.
327 @c ===beg===
328 @c [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
329 @c [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
330 @c ===end===
332 @example
333 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
334 (%o1) [+, a, - b]
335 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
336 1
337 (%o2) [*, a, -]
338 b
339 @end example
341 Los cálculos se realizan con números literales.
342 Se produce el contagio de los números decimales.
343 @c ===beg===
344 @c 17 + b - (1/2)*29 + 11^(2/4);
345 @c [17 + 29, 17 + 29.0, 17 + 29b0];
346 @c ===end===
348 @example
349 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
350 5
351 (%o1) b + sqrt(11) + -
352 2
353 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
354 (%o2) [46, 46.0, 4.6b1]
355 @end example
357 Los cálculos aritméticos son una simplificación, no una
358 evaluación.
359 @c ===beg===
360 @c simp : false;
361 @c '(17 + 29*11/7 - 5^3);
362 @c simp : true;
363 @c '(17 + 29*11/7 - 5^3);
364 @c ===end===
366 @example
367 (%i1) simp : false;
368 (%o1) false
369 (%i2) '(17 + 29*11/7 - 5^3);
370 29 11 3
371 (%o2) 17 + ----- - 5
372 7
373 (%i3) simp : true;
374 (%o3) true
375 (%i4) '(17 + 29*11/7 - 5^3);
376 437
377 (%o4) - ---
378 7
379 @end example
381 Los cálculos aritméticos se realizan elemento a elemento
382 en las listas (según sea el valor de @code{listarith}) y
383 matrices.
384 @c ===beg===
385 @c matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
386 @c 5 * matrix ([a, x], [h, u]);
387 @c listarith : false;
388 @c [a, c, m, t] / [1, 7, 2, 9];
389 @c [a, c, m, t] ^ x;
390 @c listarith : true;
391 @c [a, c, m, t] / [1, 7, 2, 9];
392 @c [a, c, m, t] ^ x;
393 @c ===end===
395 @example
396 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
397 [ a - 1 x - 2 ]
398 (%o1) [ ]
399 [ h - 3 u - 4 ]
400 (%i2) 5 * matrix ([a, x], [h, u]);
401 [ 5 a 5 x ]
402 (%o2) [ ]
403 [ 5 h 5 u ]
404 (%i3) listarith : false;
405 (%o3) false
406 (%i4) [a, c, m, t] / [1, 7, 2, 9];
407 [a, c, m, t]
408 (%o4) ------------
409 [1, 7, 2, 9]
410 (%i5) [a, c, m, t] ^ x;
411 x
412 (%o5) [a, c, m, t]
413 (%i6) listarith : true;
414 (%o6) true
415 (%i7) [a, c, m, t] / [1, 7, 2, 9];
416 c m t
417 (%o7) [a, -, -, -]
418 7 2 9
419 (%i8) [a, c, m, t] ^ x;
420 x x x x
421 (%o8) [a , c , m , t ]
422 @end example
424 @end deffn
429 @deffn {Operador} **
431 Operador de exponenciación.
432 Maxima identifica @code{**} con el operador @code{^} en la entrada
433 de expresiones, pero se representa como @code{^} en las salidas
434 no formateadas (@code{display2d=false}), o colocando un
435 superíndice en la salida formateada (@code{display2d=true}).
437 La función @code{fortran} representa el operador de exponenciación
438 con @code{**}, tanto si se ha introducido como @code{**} o como @code{^}.
440 Ejemplos:
442 @c ===beg===
443 @c is (a**b = a^b);
444 @c x**y + x^z;
445 @c string (x**y + x^z);
446 @c fortran (x**y + x^z);
447 @c ===end===
448 @example
449 (%i1) is (a**b = a^b);
450 (%o1) true
451 (%i2) x**y + x^z;
452 z y
453 (%o2) x + x
454 (%i3) string (x**y + x^z);
455 (%o3) x^z+x^y
456 (%i4) fortran (x**y + x^z);
457 x**z+x**y
458 (%o4) done
459 @end example
461 @end deffn
466 @deffn {Operator} ^^
467 @ifinfo
468 @fnindex Exponenciación no conmutativa
469 @end ifinfo
471 Operador de exponenciación no conmutativa.
472 Se trata del operador de exponenciación correspondiente a la
473 multiplicación no conmutativa @code{.}, del mismo modo que el
474 operador de exponenciación ordinario @code{^} se corresponde
475 con la multiplicación conmutativa @code{*}.
477 La exponenciación no conmutativa se representa como @code{^^}
478 en las salidas no formateadas (@code{display2d=false}), o colocando un
479 superíndice entre ángulos (@code{< >}) en la salida
480 formateada (@code{display2d=true}).
482 Ejemplos:
484 @c ===beg===
485 @c a . a . b . b . b + a * a * a * b * b;
486 @c string (a . a . b . b . b + a * a * a * b * b);
487 @c ===end===
488 @example
489 (%i1) a . a . b . b . b + a * a * a * b * b;
490 3 2 <2> <3>
491 (%o1) a b + a . b
492 (%i2) string (a . a . b . b . b + a * a * a * b * b);
493 (%o2) a^3*b^2+a^^2 . b^^3
494 @end example
496 @end deffn
500 @deffn {Operador} .
501 @ifinfo
502 @fnindex Multiplicación no conmutativa
503 @end ifinfo
504 El operador punto, para multiplicación de matrices (no-conmutativo).
505 Cuando @code{"."} se usa de esta forma, se dejarán espacios a
506 ambos lados de éste, como en @code{A . B}. Así se evita que se confunda con el punto decimal de los números.
508 Véanse:
509 @code{dot},
510 @code{dot0nscsimp},
511 @code{dot0simp},
512 @code{dot1simp},
513 @code{dotassoc},
514 @code{dotconstrules},
515 @code{dotdistrib},
516 @code{dotexptsimp},
517 @code{dotident}
518 y
519 @code{dotscrules}.
521 @end deffn
529 @node Operadores relacionales, Operadores lógicos, Operadores aritméticos, Operadores
530 @section Operadores relacionales
534 @deffn {Operator} <
535 @ifinfo
536 @fnindex Menor que
537 @end ifinfo
538 @deffnx {Operator} <=
539 @ifinfo
540 @fnindex Menor o igual que
541 @end ifinfo
542 @deffnx {Operator} >=
543 @ifinfo
544 @fnindex Mayor o igual que
545 @end ifinfo
546 @deffnx {Operator} >
547 @ifinfo
548 @fnindex Mayor que
549 @end ifinfo
551 Los símbolos @code{<}, @code{<=}, @code{>=} y @code{>}
552 representan menor que, menor o igual que, mayor o igual que y mayor que, respectivamente.
553 Los nombres de estos operadores son @code{"<"} @code{"<="} @code{">="} y @code{">"},
554 que pueden aparecer allá donde se requiera el nombre de una función u operador.
556 Estos operadores relacionales son todos operadores binarios. Maxima
557 no reconoce expresiones del estilo @code{a < b < c}.
559 Las expresiones relacionales devuelven valores booleanos haciendo uso
560 de las funciones @code{is} o @code{maybe}, así como de las
561 sentencias condicionales @code{if}, @code{while} y @code{unless}.
562 Las expresiones relacionales no se evalúan de otra manera, aunque sus
563 argumentos sí sean evaluados.
565 Cuando una expresión relacional no pueda ser evaluada a @code{true} o @code{false},
566 el comportamiento de @code{is} y de @code{if} estará controlado por la variable
567 global @code{prederror}. Si @code{prederror} toma el valor @code{true}, @code{is} y
568 @code{if} emiten un mensaje de error. Si @code{prederror} toma el valor @code{false},
569 @code{is} devuelve @code{unknown} y @code{if} devuelve una expresión condicional
570 parcialmente evaluada.
572 @code{maybe} se comporta siempre como si @code{prederror} fuese @code{false},
573 al tiempo que @code{while} y @code{unless} se comportan siempre como si
574 @code{prederror} fuese @code{true}.
576 Los operadores relacionales no se distribuyen sobre listas ni sobre cualesquiera
577 otros tipos de estructuras de datos.
579 Véanse también @code{=}, @code{#}, @code{equal} y @code{notequal}.
581 Ejemplos:
583 Las expresiones relacionales se reducen a valores booleanos a través de ciertas
584 funciones y sentencias condicionales.
586 @c ===beg===
587 @c [x, y, z] : [123, 456, 789];
588 @c is (x < y);
589 @c maybe (y > z);
590 @c if x >= z then 1 else 0;
591 @c block ([S], S : 0,
592 @c for i:1 while i <= 100 do S : S + i, return (S));
593 @c ===end===
594 @example
595 (%i1) [x, y, z] : [123, 456, 789];
596 (%o1) [123, 456, 789]
597 (%i2) is (x < y);
598 (%o2) true
599 (%i3) maybe (y > z);
600 (%o3) false
601 (%i4) if x >= z then 1 else 0;
602 (%o4) 0
603 (%i5) block ([S], S : 0,
604 for i:1 while i <= 100 do S : S + i, return (S));
605 (%o5) 5050
606 @end example
608 Las expresiones relacionales no se evalúan de otra manera, aunque sus
609 argumentos sí sean evaluados.
611 @c ===beg===
612 @c [x, y, z] : [123, 456, 789];
613 @c [x < y, y <= z, z >= y, y > z];
614 @c map (is, %);
615 @c ===end===
616 @example
617 (%o1) [123, 456, 789]
618 (%i2) [x < y, y <= z, z >= y, y > z];
619 (%o2) [123 < 456, 456 <= 789, 789 >= 456, 456 > 789]
620 (%i3) map (is, %);
621 (%o3) [true, true, true, false]
622 @end example
624 @end deffn
632 @node Operadores lógicos, Operadores para ecuaciones, Operadores relacionales, Operadores
633 @section Operadores lógicos
638 @deffn {Operador} and
639 @ifinfo
640 @fnindex Conjunción lógica
641 @end ifinfo
642 Operador de conjunción lógica.
643 El operador @code{and} es un operador infijo @code{n}-ario;
644 sus operandos son expresiones booleanas y su resultado es un valor lógico.
646 El operador @code{and} impone la evaluación (igual que @code{is}) de uno o más operandos,
647 y puede forzar la evaluación de todos los operandos.
649 Los operandos se evalúan en el orden en el que aparecen;
650 sólo evalúa tantos operandos como sean necesarios para determinar el resultado.
651 Si algún operando vale @code{false},
652 el resultado es @code{false} y ya no se evalúan más operandos.
654 La variable global @code{prederror} controla el comportamiento de @code{and}
655 cuando la evaluación de un operando no da como resultado @code{true} o @code{false};
656 @code{and} imprime un mensaje de error cuando @code{prederror} vale @code{true}.
657 Cuando los operandos devuelven un valor diferente a @code{true} o @code{false}
658 al ser evaluados, el resultado es una expresión booleana.
660 El operador @code{and} no es conmutativo:
661 @code{a and b} puede no ser igual a @code{b and a} debido al tratamiento de operandos indeterminados.
663 @end deffn
667 @deffn {Operador} not
668 @ifinfo
669 @fnindex Negación lógica
670 @end ifinfo
671 Operador de negación lógica. El operador @code{not} es un operador prefijo;
672 su operando es una expresión booleana y su resultado es un valor lógico.
674 El operador @code{not} impone la evaluación (igual que @code{is}) de su operando.
676 La variable global @code{prederror} controla el comportamiento de
677 @code{not} cuando la evaluación de su operando no da como
678 resultado @code{true} o @code{false}; @code{not} imprime un mensaje
679 de error cuando @code{prederror} vale @code{true}.
680 Cuando los operandos devuelven un valor diferente a @code{true} o @code{false}
681 al ser evaluados, el resultado es una expresión booleana.
683 @end deffn
688 @deffn {Operador} or
689 @ifinfo
690 @fnindex Disyunción lógica
691 @end ifinfo
692 Operador de disyunción lógica. El operador @code{or} es un operador infijo @code{n}-ario;
693 sus operandos son expresiones booleanas y su resultado es un valor lógico.
695 El operador @code{or} impone la evaluación (igual que @code{is}) de uno o más operandos,
696 y puede forzar la evaluación de todos los operandos.
698 Los operandos se evalúan en el orden en el que aparecen; @code{or} sólo evalúa tantos operandos como sean necesarios para determinar el resultado. Si un operando vale @code{true}, el resultado es @code{true} y ya no se evalúan más operandos.
700 La variable global @code{prederror} controla el comportamiento
701 de @code{or} cuando la evaluación de un operando no da como
702 resultado @code{true} o @code{false}; @code{or} imprime un
703 mensaje de error cuando @code{prederror} vale @code{true}.
704 Cuando los operandos devuelven un valor diferente a @code{true} o @code{false}
705 al ser evaluados, el resultado es una expresión booleana.
707 El operador @code{or} no es conmutativo: @code{a or b} puede no ser igual a @code{b or a} debido al tratamiento de operandos indeterminados.
709 @end deffn
717 @node Operadores para ecuaciones, Operadores de asignación, Operadores lógicos, Operadores
718 @section Operadores para ecuaciones
722 @deffn {Operador} #
723 @ifinfo
724 @fnindex Negación de la igualdad sintáctica
725 @end ifinfo
726 Representa la negación de la igualdad sintáctica @code{=}.
728 Nótese que debido a las reglas de evaluación de expresiones
729 de tipo predicado (en concreto debido a que @code{not @var{expr}}
730 obliga a la evaluación previa de @var{expr}),
731 @code{not @var{a} = @var{b}} equivale a @code{is(@var{a} # @var{b})},
732 pero no a @code{@var{a} # @var{b}}.
734 Ejemplos:
736 @c ===beg===
737 @c a = b;
738 @c is (a = b);
739 @c a # b;
740 @c not a = b;
741 @c is (a # b);
742 @c is (not a = b);
743 @c ===end===
744 @example
745 (%i1) a = b;
746 (%o1) a = b
747 (%i2) is (a = b);
748 (%o2) false
749 (%i3) a # b;
750 (%o3) a # b
751 (%i4) not a = b;
752 (%o4) true
753 (%i5) is (a # b);
754 (%o5) true
755 (%i6) is (not a = b);
756 (%o6) true
757 @end example
759 @end deffn
764 @deffn {Operador} =
765 @ifinfo
766 @fnindex Operador de ecuación
767 @fnindex Igualdad sintáctica
768 @end ifinfo
769 Operador de ecuación.
771 La expresión @code{@var{a} = @var{b}} representa una ecuación
772 sin evaluar, la cual puede verificarse o no. Las ecuaciones sin evaluar
773 pueden aparecer como argumentos de @code{solve}, @code{algsys}
774 y de algunas otras funciones.
776 La función @code{is} evalúa el operador @code{=} a un
777 resultado booleano; @code{is(@var{a} = @var{b})} asigna un valor
778 de verdad a @code{@var{a} = @var{b}}, siendo @code{true} si
779 @var{a} y @var{b} son idénticos, lo cual acontece si
780 ambos @var{a} y @var{b} son átomos idénticos, o si no
781 siendo átomos, sus operadores y argumentos respectivos
782 son idénticos; en caso contrario, @code{is(@var{a} = @var{b})}
783 devuelve el valor @code{false}. Nunca se devuelve el valor @code{unknown}.
784 Cuando @code{is(@var{a} = @var{b})} toma el valor @code{true},
785 se dice que @var{a} y @var{b} son sintácticamente iguales,
786 no expresiones equivalentes, para las cuales
787 @code{is(equal(@var{a}, @var{b}))} devuelve @code{true}.
788 Las expresiones pueden ser equivalentes, pero no
789 sintácticamente iguales.
791 La negación de @code{=} se representa por @code{#}.
792 Como en el caso de @code{=}, la expresión
793 @code{@var{a} # @var{b}} no está evaluada; sin embargo,
794 @code{is(@var{a} # @var{b})} evalúa @code{@var{a} # @var{b}}
795 a @code{true} o @code{false}.
797 Además de @code{is}, hay otros operadores que evalúan
798 @code{=} y @code{#} a @code{true} o @code{false};
799 a saber, @code{if}, @code{and}, @code{or} y @code{not}.
801 Nótese que debido a las reglas de evaluación de expresiones
802 de tipo predicado (en concreto debido a que @code{not @var{expr}}
803 obliga a la evaluación previa de @var{expr}),
804 @code{not @var{a} = @var{b}} equivale a @code{is(@var{a} # @var{b})},
805 pero no a @code{@var{a} # @var{b}}.
807 Las funciones @code{rhs} y @code{lhs} devuelven los miembros
808 derecho e izquierdo, respectivamente, de una ecuación o inecuación.
810 Véanse también @code{equal} y @code{notequal}.
812 Ejemplos:
814 La expresión @code{@var{a} = @var{b}} representa una ecuación
815 sin evaluar, la cual puede verificarse o no.
817 @c ===beg===
818 @c eq_1 : a * x - 5 * y = 17;
819 @c eq_2 : b * x + 3 * y = 29;
820 @c solve ([eq_1, eq_2], [x, y]);
821 @c subst (%, [eq_1, eq_2]);
822 @c ratsimp (%);
823 @c ===end===
824 @example
825 (%i1) eq_1 : a * x - 5 * y = 17;
826 (%o1) a x - 5 y = 17
827 (%i2) eq_2 : b * x + 3 * y = 29;
828 (%o2) 3 y + b x = 29
829 (%i3) solve ([eq_1, eq_2], [x, y]);
830 196 29 a - 17 b
831 (%o3) [[x = ---------, y = -----------]]
832 5 b + 3 a 5 b + 3 a
833 (%i4) subst (%, [eq_1, eq_2]);
834 196 a 5 (29 a - 17 b)
835 (%o4) [--------- - --------------- = 17,
836 5 b + 3 a 5 b + 3 a
837 196 b 3 (29 a - 17 b)
838 --------- + --------------- = 29]
839 5 b + 3 a 5 b + 3 a
840 (%i5) ratsimp (%);
841 (%o5) [17 = 17, 29 = 29]
842 @end example
844 @code{is(@var{a} = @var{b})} evalúa @code{@var{a} = @var{b}}
845 a @code{true} si @var{a} y @var{b}
846 son sintácticamente iguales (es decir, idénticas).
847 Las expresiones pueden ser equivalentes, pero no
848 sintácticamente iguales.
850 @c ===beg===
851 @c a : (x + 1) * (x - 1);
852 @c b : x^2 - 1;
853 @c [is (a = b), is (a # b)];
854 @c [is (equal (a, b)), is (notequal (a, b))];
855 @c ===end===
856 @example
857 (%i1) a : (x + 1) * (x - 1);
858 (%o1) (x - 1) (x + 1)
859 (%i2) b : x^2 - 1;
860 2
861 (%o2) x - 1
862 (%i3) [is (a = b), is (a # b)];
863 (%o3) [false, true]
864 (%i4) [is (equal (a, b)), is (notequal (a, b))];
865 (%o4) [true, false]
866 @end example
868 Algunos operadores evalúan @code{=} y @code{#} a @code{true} o @code{false}.
870 @c ===beg===
871 @c if expand ((x + y)^2) = x^2 + 2 * x * y + y^2
872 @c then FOO else BAR;
873 @c eq_3 : 2 * x = 3 * x;
874 @c eq_4 : exp (2) = %e^2;
875 @c [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
876 @c ===end===
877 @example
878 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2
879 then FOO else BAR;
880 (%o1) FOO
881 (%i2) eq_3 : 2 * x = 3 * x;
882 (%o2) 2 x = 3 x
883 (%i3) eq_4 : exp (2) = %e^2;
884 2 2
885 (%o3) %e = %e
886 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
887 (%o4) [false, true, true]
888 @end example
890 Debido a que @code{not @var{expr}}
891 obliga a la evaluación previa de @var{expr},
892 @code{not @var{a} = @var{b}} equivale a @code{is(@var{a} # @var{b})}.
894 @c ===beg===
895 @c [2 * x # 3 * x, not (2 * x = 3 * x)];
896 @c is (2 * x # 3 * x);
897 @c ===end===
898 @example
899 (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
900 (%o1) [2 x # 3 x, true]
901 (%i2) is (2 * x # 3 * x);
902 (%o2) true
903 @end example
905 @end deffn
913 @node Operadores de asignación, Operadores definidos por el usuario, Operadores para ecuaciones, Operadores
914 @section Operadores de asignación
918 @deffn {Operador} :
919 @ifinfo
920 @fnindex Operador de asignación
921 @end ifinfo
922 Operador de asignación.
924 Cuando el miembro de la izquierda es una variable simple (no subindicada),
925 @code{:} evalúa la expresión de la derecha y asigna ese
926 valor a la variable del lado izquierdo.
928 Cuando en el lado izquierdo hay un elemento subindicado correspondiente a
929 una lista, matriz, array declarado de Maxima o array de Lisp, la expresión de
930 la derecha se asigna a ese elemento. El subíndice debe hacer
931 referencia a un elemento ya existente, ya que los objetos anteriores no
932 pueden ampliarse nombrando elementos no existentes.
934 Cuando en el lado izquierdo hay un elemento subindicado correspondiente a
935 un array no declarado de Maxima, la expresión de la derecha se asigna a ese elemento
936 en caso de que ya exista, o a un nuevo elemento, si éste todavía
937 no existe.
939 Cuando el miembro de la izquierda es una lista de átomos y/o variables subindicadas,
940 el miembro derecho debe evaluar también a una lista, cuyos elementos serán
941 asignados en paralelo a las variables de la lista de la izquierda.
943 Véanse también @code{kill} y @code{remvalue}, que deshacen las asociaciones
944 hechas por el operador @code{:}.
946 Ejemplos:
948 Asignación a una variable simple.
950 @c ===beg===
951 @c a;
952 @c a : 123;
953 @c a;
954 @c ===end===
955 @example
956 (%i1) a;
957 (%o1) a
958 (%i2) a : 123;
959 (%o2) 123
960 (%i3) a;
961 (%o3) 123
962 @end example
964 Asignación a un elemento de una lista.
966 @c ===beg===
967 @c b : [1, 2, 3];
968 @c b[3] : 456;
969 @c b;
970 @c ===end===
971 @example
972 (%i1) b : [1, 2, 3];
973 (%o1) [1, 2, 3]
974 (%i2) b[3] : 456;
975 (%o2) 456
976 (%i3) b;
977 (%o3) [1, 2, 456]
978 @end example
980 La asignación crea un array no declarado.
982 @c ===beg===
983 @c c[99] : 789;
984 @c c[99];
985 @c c;
986 @c arrayinfo (c);
987 @c listarray (c);
988 @c ===end===
989 @example
990 (%i1) c[99] : 789;
991 (%o1) 789
992 (%i2) c[99];
993 (%o2) 789
994 (%i3) c;
995 (%o3) c
996 (%i4) arrayinfo (c);
997 (%o4) [hashed, 1, [99]]
998 (%i5) listarray (c);
999 (%o5) [789]
1000 @end example
1002 Asignación múltiple.
1004 @c ===beg===
1005 @c [a, b, c] : [45, 67, 89];
1006 @c a;
1007 @c b;
1008 @c c;
1009 @c ===end===
1010 @example
1011 (%i1) [a, b, c] : [45, 67, 89];
1012 (%o1) [45, 67, 89]
1013 (%i2) a;
1014 (%o2) 45
1015 (%i3) b;
1016 (%o3) 67
1017 (%i4) c;
1018 (%o4) 89
1019 @end example
1021 La asignación múltiple se hace en paralelo. Los valores
1022 de @code{a} y @code{b} se intercambian en este ejemplo.
1024 @c ===beg===
1025 @c [a, b] : [33, 55];
1026 @c [a, b] : [b, a];
1027 @c a;
1028 @c b;
1029 @c ===end===
1030 @example
1031 (%i1) [a, b] : [33, 55];
1032 (%o1) [33, 55]
1033 (%i2) [a, b] : [b, a];
1034 (%o2) [55, 33]
1035 (%i3) a;
1036 (%o3) 55
1037 (%i4) b;
1038 (%o4) 33
1039 @end example
1040 @end deffn
1045 @deffn {Operador} ::
1046 @ifinfo
1047 @fnindex Operador de asignación (evalúa el miembro izquierdo)
1048 @end ifinfo
1049 Operador de asignación.
1051 El operador @code{::} es similar a @code{:}, excepto que @code{::}
1052 evalúa ambos miembros, tanto el derecho como el izquierdo.
1054 Ejemplos:
1056 @c ===beg===
1057 @c x : 'foo;
1058 @c x :: 123;
1059 @c foo;
1060 @c x : '[a, b, c];
1061 @c x :: [11, 22, 33];
1062 @c a;
1063 @c b;
1064 @c c;
1065 @c ===end===
1066 @example
1067 (%i1) x : 'foo;
1068 (%o1) foo
1069 (%i2) x :: 123;
1070 (%o2) 123
1071 (%i3) foo;
1072 (%o3) 123
1073 (%i4) x : '[a, b, c];
1074 (%o4) [a, b, c]
1075 (%i5) x :: [11, 22, 33];
1076 (%o5) [11, 22, 33]
1077 (%i6) a;
1078 (%o6) 11
1079 (%i7) b;
1080 (%o7) 22
1081 (%i8) c;
1082 (%o8) 33
1083 @end example
1084 @end deffn
1089 @deffn {Operador} ::=
1090 @ifinfo
1091 @fnindex Operador de definición de funciones macro
1092 @end ifinfo
1093 El operador de definición de macros @code{::=} define una función (llamada macro por razones históricas) que no evalúa sus argumentos, siendo la expresión que retorna (llamada "macroexpansión") evaluada dentro del contexto desde el cual se ha invocado la macro. En cualquier otro sentido, una función macro es igual que una función ordinaria.
1095 @code{macroexpand} devuelve la expresión que a su vez fue devuelta por una macro (sin evaluar la expresión);
1096 @code{macroexpand (foo (x))} seguida de @code{''%} es equivalente a @code{foo (x)} si @code{foo} es una función macro.
1098 @code{::=} coloca el nombre de la nueva función macro en la lista global @code{macros}. Por otro lado, las funciones
1099 @code{kill}, @code{remove} y @code{remfunction} borran las definiciones de las funciones macro y eliminan sus nombres de la lista @code{macros}.
1101 Las funciones @code{fundef} y @code{dispfun} devuelven la definición de una función macro y le asignan una etiqueta, respectivamente.
1103 Las funciones macro normalmente contienen expresiones @code{buildq} y @code{splice} para construir una expresión, que luego será evaluada.
1105 Ejemplos:
1107 Una función macro no evalúa sus argumentos, por lo que el mensaje (1) muestra @code{y - z}, no el valor de @code{y - z}.
1108 La macroexpansión (es decir, la expresión no evaluada @code{'(print ("(2) x is equal to", x))}) se evalúa en el contexto desde el cual se produjo la llamada a la macro, imprimiendo el mensaje (2).
1110 @c ===beg===
1111 @c x: %pi$
1112 @c y: 1234$
1113 @c z: 1729 * w$
1114 @c printq1 (x) ::= block (print ("(1) x is equal to", x),
1115 @c '(print ("(2) x is equal to", x)))$
1116 @c printq1 (y - z);
1117 @c ===end===
1118 @example
1119 (%i1) x: %pi$
1121 (%i2) y: 1234$
1123 (%i3) z: 1729 * w$
1125 (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
1126 '(print ("(2) x is equal to", x)))$
1128 (%i5) printq1 (y - z);
1129 (1) x is equal to y - z
1130 (2) x is equal to %pi
1131 (%o5) %pi
1132 @end example
1135 Una función ordinaria evalúa sus argumentos, por lo que el mensaje (1) muestra el valor de @code{y - z}.
1136 El valor de retorno no se evalúa, por lo que el mensaje (2) no se imprime hasta la evaluación explícita @code{''%}.
1138 @c ===beg===
1139 @c x: %pi$
1140 @c y: 1234$
1141 @c z: 1729 * w$
1142 @c printe1 (x) := block (print ("(1) x is equal to", x),
1143 @c '(print ("(2) x is equal to", x)))$
1144 @c printe1 (y - z);
1145 @c ''%;
1146 @c ===end===
1147 @example
1148 (%i1) x: %pi$
1150 (%i2) y: 1234$
1152 (%i3) z: 1729 * w$
1154 (%i4) printe1 (x) := block (print ("(1) x is equal to", x),
1155 '(print ("(2) x is equal to", x)))$
1157 (%i5) printe1 (y - z);
1158 (1) x is equal to 1234 - 1729 w
1159 (%o5) print((2) x is equal to, x)
1160 (%i6) ''%;
1161 (2) x is equal to %pi
1162 (%o6) %pi
1163 @end example
1165 @code{macroexpand} devuelve la macroexpansión;
1166 @code{macroexpand (foo (x))} seguida de @code{''%} es equivalente a @code{foo (x)} si @code{foo} es una función macro.
1168 @c ===beg===
1169 @c x: %pi$
1170 @c y: 1234$
1171 @c z: 1729 * w$
1172 @c g (x) ::= buildq ([x], print ("x is equal to", x))$
1173 @c macroexpand (g (y - z));
1174 @c ''%;
1175 @c g (y - z);
1176 @c ===end===
1177 @example
1178 (%i1) x: %pi$
1180 (%i2) y: 1234$
1182 (%i3) z: 1729 * w$
1184 (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$
1186 (%i5) macroexpand (g (y - z));
1187 (%o5) print(x is equal to, y - z)
1188 (%i6) ''%;
1189 x is equal to 1234 - 1729 w
1190 (%o6) 1234 - 1729 w
1191 (%i7) g (y - z);
1192 x is equal to 1234 - 1729 w
1193 (%o7) 1234 - 1729 w
1194 @end example
1196 @end deffn
1201 @deffn {Operador} :=
1202 @ifinfo
1203 @fnindex Operador de definición de funciones
1204 @end ifinfo
1206 El operador de definición de funciones.
1207 La expresión @code{@var{f}(@var{x_1}, ..., @var{x_n}) := @var{expr}}
1208 define una función de nombre @var{f} con argumentos
1209 @var{x_1}, ..., @var{x_n} y cuerpo @var{expr}.
1210 El operador @code{:=} no evalúa el cuerpo de la función (a menos que
1211 se indique lo contrario mediante el operador comilla-comilla @code{'@w{}'}).
1212 La función así definida puede ser una función ordinaria
1213 de Maxima (con argumentos encerrados entre paréntesis) o una función
1214 array (con argumentos encerrados entre corchetes).
1216 Cuando el último o único argumento @var{x_n} es una lista de un solo
1217 elemento, la función definida por @code{:=} acepta un número variable
1218 de argumentos. Los valores de los argumentos se asignan uno a uno a los
1219 argumentos formales @var{x_1}, ..., @var{x_(n - 1)}, y cualesquiera otros
1220 valores de argumentos, si existen, se asignan a @var{x_n} en forma de lista.
1222 Todas las definiciones de funciones aparecen en el mismo espacio de
1223 nombres; definiendo una función @code{f} dentro de otra función @code{g}
1224 no limita automáticamente el alcance de @code{f} a @code{g}.
1225 No obstante, @code{local(f)} hace que la función @code{f}
1226 sea efectiva solamente dentro del bloque o empaquetado de expresiones en la
1227 que aparece @code{local}.
1229 Si un argumento formal @var{x_k} es un símbolo afectado por el
1230 operador comilla (expresión nominal), la función definida por @code{:=} no evalúa el
1231 correspondiente valor de argumento.
1232 En cualquier otro caso, los argumentos que se pasan son evaluados.
1234 Véanse también @code{define} y @code{::=}.
1236 Ejemplos:
1238 @code{:=} no evalúa el cuerpo de la función (a menos que
1239 se indique lo contrario mediante el operador comilla-comilla @code{'@w{}'}).
1241 @c ===beg===
1242 @c expr : cos(y) - sin(x);
1243 @c F1 (x, y) := expr;
1244 @c F1 (a, b);
1245 @c F2 (x, y) := ''expr;
1246 @c F2 (a, b);
1247 @c ===end===
1248 @example
1249 (%i1) expr : cos(y) - sin(x);
1250 (%o1) cos(y) - sin(x)
1251 (%i2) F1 (x, y) := expr;
1252 (%o2) F1(x, y) := expr
1253 (%i3) F1 (a, b);
1254 (%o3) cos(y) - sin(x)
1255 (%i4) F2 (x, y) := ''expr;
1256 (%o4) F2(x, y) := cos(y) - sin(x)
1257 (%i5) F2 (a, b);
1258 (%o5) cos(b) - sin(a)
1259 @end example
1261 La función así definida puede ser una función ordinaria
1262 de Maxima o una función array.
1264 @c ===beg===
1265 @c G1 (x, y) := x.y - y.x;
1266 @c G2 [x, y] := x.y - y.x;
1267 @c ===end===
1268 @example
1269 (%i1) G1 (x, y) := x.y - y.x;
1270 (%o1) G1(x, y) := x . y - y . x
1271 (%i2) G2 [x, y] := x.y - y.x;
1272 (%o2) G2 := x . y - y . x
1273 x, y
1274 @end example
1276 Cuando el último o único argumento @var{x_n} es una lista de un solo
1277 elemento, la función definida por @code{:=} acepta un número variable
1278 de argumentos.
1280 @c ===beg===
1281 @c H ([L]) := apply ("+", L);
1282 @c H (a, b, c);
1283 @c ===end===
1284 @example
1285 (%i1) H ([L]) := apply ("+", L);
1286 (%o1) H([L]) := apply("+", L)
1287 (%i2) H (a, b, c);
1288 (%o2) c + b + a
1289 @end example
1291 @code{local} define una función como local.
1293 @c ===beg===
1294 @c foo (x) := 1 - x;
1295 @c foo (100);
1296 @c block (local (foo), foo (x) := 2 * x, foo (100));
1297 @c foo (100);
1298 @c ===end===
1299 @example
1300 (%i1) foo (x) := 1 - x;
1301 (%o1) foo(x) := 1 - x
1302 (%i2) foo (100);
1303 (%o2) - 99
1304 (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
1305 (%o3) 200
1306 (%i4) foo (100);
1307 (%o4) - 99
1308 @end example
1309 @end deffn
1318 @node Operadores definidos por el usuario, , Operadores de asignación, Operadores
1319 @section Operadores definidos por el usuario
1324 @deffn {Función} infix (@var{op})
1325 @deffnx {Función} infix (@var{op}, @var{lbp}, @var{rbp})
1326 @deffnx {Función} infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})
1327 Declara @var{op} como operador infijo.
1328 Un operador infijo es una función de dos argumentos,
1329 con el nombre de la función escrito entre sus argumentos.
1330 Por ejemplo, el operador de sustracción @code{-} es un operador infijo.
1332 @code{infix (@var{op})} declara @var{op} como operador infijo
1333 con fuerzas de ligadura por la izquierda y por la derecha iguales a 180, que es el valor por defecto,
1334 y partes izquierda y derecha iguales a @code{any}.
1335 @c HOW IS pos DIFFERENT FROM lpos AND rpos ??
1337 @code{infix (@var{op}, @var{lbp}, @var{rbp})} declara @var{op} como operador infijo
1338 con fuerzas de ligadura por la izquierda y por la derecha declaradas en los argumentos, siendo las partes izquierda y derecha iguales a @code{any}.
1340 @code{infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})}
1341 declara @var{op} como operador infijo con fuerzas de ligadura por la
1342 izquierda y por la derecha, junto con los tipos de expresiones correspondientes
1343 a @var{lpos}, @var{rpos} y @var{pos}, que son el operando de la izquierda,
1344 el de la derecha y el operador del resultado; los tipos reconocidos son:
1345 @code{expr}, @code{clause} y @code{any}, que indican expresión algebraica,
1346 expresión booleana o cualquier otra, respectivamente. Maxima puede detectar
1347 algunos errores sintácticos comparando los tipos declarados con los de la expresión
1348 actual.
1350 La precedencia de @var{op} con respecto a otros operadores deriva de las fuerzas de ligadura de los operadores en cuestión.
1351 Si las fuerzas de ligadura a izquierda y derecha de @var{op} son ambas mayores que las fuerzas de ligadura a izquierda y derecha de otro operador, entonces @var{op} tiene preferencia sobre el otro operador. Si las fuerzas de ligadura no son ambas mayores o menores, se aplican otras relaciones más complejas.
1353 La asociatividad de @var{op} depende de las fuerzas de ligadura.
1354 Una mayor fuerza de ligadura a la izquierda (@var{lbp}) implica que @var{op} sea evaluado antes que otros operadores a su izquierda en la expresión, mientras que mayor fuerza de ligadura a la derecha (@var{rbp}) implica que @var{op} sea evaluado antes que otros operadores a su derecha en la expresión.
1355 Así, si @var{lbp} es mayor, @var{op} es asociativo por la derecha, mientras que si @var{rbp} es mayor, @var{op} es asociativo por la izquierda.
1357 Véase también @code{Syntax}.
1359 Ejemplos:
1361 Si las fuerzas de ligadura a izquierda y derecha de @var{op} son ambas mayores que las fuerzas de ligadura a izquierda y derecha de otro operador, entonces @var{op} tiene preferencia sobre el otro operador.
1363 @c ===beg===
1364 @c :lisp (get '$+ 'lbp)
1365 @c :lisp (get '$+ 'rbp)
1366 @c infix ("##", 101, 101);
1367 @c "##"(a, b) := sconcat("(", a, ",", b, ")");
1368 @c 1 + a ## b + 2;
1369 @c infix ("##", 99, 99);
1370 @c 1 + a ## b + 2;
1371 @c ===end===
1372 @example
1373 (%i1) :lisp (get '$+ 'lbp)
1374 100
1375 (%i1) :lisp (get '$+ 'rbp)
1376 100
1377 (%i1) infix ("##", 101, 101);
1378 (%o1) ##
1379 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
1380 (%o2) (a ## b) := sconcat("(", a, ",", b, ")")
1381 (%i3) 1 + a ## b + 2;
1382 (%o3) (a,b) + 3
1383 (%i4) infix ("##", 99, 99);
1384 (%o4) ##
1385 (%i5) 1 + a ## b + 2;
1386 (%o5) (a+1,b+2)
1387 @end example
1389 Mayor @var{lbp} hace a @var{op} asociativo por la derecha,
1390 mientras que mayor @var{rbp} hace a @var{op} asociativo por la izquierda.
1392 @c ===beg===
1393 @c infix ("##", 100, 99);
1394 @c "##"(a, b) := sconcat("(", a, ",", b, ")")$
1395 @c foo ## bar ## baz;
1396 @c infix ("##", 100, 101);
1397 @c foo ## bar ## baz;
1398 @c ===end===
1399 @example
1400 (%i1) infix ("##", 100, 99);
1401 (%o1) ##
1402 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
1403 (%i3) foo ## bar ## baz;
1404 (%o3) (foo,(bar,baz))
1405 (%i4) infix ("##", 100, 101);
1406 (%o4) ##
1407 (%i5) foo ## bar ## baz;
1408 (%o5) ((foo,bar),baz)
1409 @end example
1411 Maxima puede detectar algunos errores sintácticos comparando
1412 los tipos declarados con los de la expresión actual.
1414 @c ===beg===
1415 @c infix ("##", 100, 99, expr, expr, expr);
1416 @c if x ## y then 1 else 0;
1417 @c infix ("##", 100, 99, expr, expr, clause);
1418 @c if x ## y then 1 else 0;
1419 @c ===end===
1420 @example
1421 (%i1) infix ("##", 100, 99, expr, expr, expr);
1422 (%o1) ##
1423 (%i2) if x ## y then 1 else 0;
1424 Incorrect syntax: Found algebraic expression where logical expression expected
1425 if x ## y then
1426 ^
1427 (%i2) infix ("##", 100, 99, expr, expr, clause);
1428 (%o2) ##
1429 (%i3) if x ## y then 1 else 0;
1430 (%o3) if x ## y then 1 else 0
1431 @end example
1432 @end deffn
1437 @deffn {Función} matchfix (@var{ldelimiter}, @var{rdelimiter})
1438 @deffnx {Función} matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})
1440 Declara un operador "matchfix" con delimitadores a la izquierda y derecha, @var{ldelimiter} y @var{rdelimiter}, respectivamente. Los delimitadores son cadenas alfanuméricas.
1442 Un operador "matchfix" es una función con un número arbitrario de argumentos, de manera que los argumentos se presentan entre los delimitadores de la izquierda y derecha. Los delimitadores pueden ser cualquier tipo de cadena, en tanto que el analizador sintáctico pueda distinguirlos de los operandos y de expresiones con operadores. En la práctica esto excluye delimitadores como @code{%}, @code{,}, @code{$} y @code{;}, necesitando aislar los delimitadores con espacios en blanco. El delimitador de la derecha puede ser igual o diferente del de la izquierda.
1444 Un delimitador de la izquierda sólo puede asociarse con un único delimitador de la derecha; dos operadores "matchfix" diferentes no pueden tener el mismo delimitador por la izquierda.
1446 Un operador ya existente puede declararse como operador "matchfix" sin necesidad de que cambie el resto de propiedades. En particular, los operadores de Maxima tales como la suma @code{+} pueden ser declarados como "matchfix".
1448 La llamada @code{matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})}
1449 declara el argumento @var{arg_pos} y el resultado @var{pos}, así
1450 como los delimitadores @var{ldelimiter} y @var{rdelimiter}.
1452 Los argumentos @var{arg_pos} y @var{pos} son tipos de funciones,
1453 reconociéndose como tales: @code{expr}, @code{clause} y @code{any},
1454 los cuales hacen referencia a una expresión algebraica, booleana o
1455 de cualquier otro tipo, respectivamente.
1456 Maxima puede detectar ciertos errores sintácticos comparando el
1457 tipo de expresión declarado con el de la expresión actual.
1459 La función que ejecutará una operación "matchfix" será una típica función definida por el usuario. La función de operador se define por el método habitual con @code{:=} o @code{define}. Los argumentos pueden escribirse entre los delimitadores, o con el delimitador izquierdo como una cadena precedida de apóstrofo y seguidamente los argumentos entre paréntesis. La llamada @code{dispfun (@var{ldelimiter})} muestra la definición de la función.
1461 El único operador "matchfix" de Maxima es el constructor de listas @code{[ ]}. Los paréntesis @code{( )} y las comillas dobles @code{" "} actúan como operadores "matchfix", pero son tratados como operadores "matchfix" por el analizador sintáctico de Maxima.
1463 Ejemplos:
1465 @itemize @bullet
1466 @item
1467 Los delimitadores pueden ser practicamente cualquier cadena.
1468 @end itemize
1469 @c ===beg===
1470 @c matchfix ("@@", "~");
1471 @c @@ a, b, c ~;
1472 @c matchfix (">>", "<<");
1473 @c >> a, b, c <<;
1474 @c matchfix ("foo", "oof");
1475 @c foo a, b, c oof;
1476 @c >> w + foo x, y oof + z << / @@ p, q ~;
1477 @c ===end===
1478 @example
1479 (%i1) matchfix ("@@@@", "~");
1480 (%o1) @@@@
1481 (%i2) @@@@ a, b, c ~;
1482 (%o2) @@@@a, b, c~
1483 (%i3) matchfix (">>", "<<");
1484 (%o3) >>
1485 (%i4) >> a, b, c <<;
1486 (%o4) >>a, b, c<<
1487 (%i5) matchfix ("foo", "oof");
1488 (%o5) foo
1489 (%i6) foo a, b, c oof;
1490 (%o6) fooa, b, coof
1491 (%i7) >> w + foo x, y oof + z << / @@@@ p, q ~;
1492 >>z + foox, yoof + w<<
1493 (%o7) ----------------------
1494 @@@@p, q~
1495 @end example
1497 @itemize @bullet
1498 @item
1499 Los operadores "matchfix" son funciones definidas por el usuario.
1500 @end itemize
1501 @example
1502 (%i1) matchfix ("!-", "-!");
1503 (%o1) "!-"
1504 (%i2) !- x, y -! := x/y - y/x;
1505 x y
1506 (%o2) !-x, y-! := - - -
1507 y x
1508 (%i3) define (!-x, y-!, x/y - y/x);
1509 x y
1510 (%o3) !-x, y-! := - - -
1511 y x
1512 (%i4) define ("!-" (x, y), x/y - y/x);
1513 x y
1514 (%o4) !-x, y-! := - - -
1515 y x
1516 (%i5) dispfun ("!-");
1517 x y
1518 (%t5) !-x, y-! := - - -
1519 y x
1521 (%o5) done
1522 (%i6) !-3, 5-!;
1523 16
1524 (%o6) - --
1525 15
1526 (%i7) "!-" (3, 5);
1527 16
1528 (%o7) - --
1529 15
1530 @end example
1532 @end deffn
1536 @deffn {Función} nary (@var{op})
1537 @deffnx {Función} nary (@var{op}, @var{bp}, @var{arg_pos}, @var{pos})
1539 Un operador n-ario denota una función con un número arbitrario de
1540 argumentos entre los que se intercal el símbolo del operador,
1541 como en @code{A+B+C}. La instrucción @code{nary("x")} declara @code{x}
1542 como operador n-ario. Las funciones se pueden declarar como n-arias;
1543 de modo que si se ejecuta @code{declare(j,nary)}, el simplificador
1544 transforma @code{j(j(a,b),j(c,d))} en @code{j(a, b, c, d)}.
1546 @end deffn
1550 @deffn {Función} nofix (@var{op})
1551 @deffnx {Función} nofix (@var{op}, @var{pos})
1553 Los operadores no-fijos se utilizan para definir funciones sin argumentos.
1554 La mera presencia de tal operador en una instrucción hará que se
1555 evalúe la función correspondiente. Por ejemplo, cuando se teclea @code{exit;}
1556 para salir de una interrupción de Maxima, @code{exit} se comporta como una
1557 función no-fija. La instrucción @code{nofix("x")} declara @code{x}
1558 como operador no-fijo.
1560 @end deffn
1564 @deffn {Función} postfix (@var{op})
1565 @deffnx {Función} postfix (@var{op}, @var{lbp}, @var{lpos}, @var{pos})
1567 Los operadores sufijos son funciones de un único argumento en las que éste
1568 precede al operador, como en @code{3!}. La instrucción @code{postfix("x")}
1569 declara @code{x} como operador sufijo.
1571 @end deffn
1575 @deffn {Función} prefix (@var{op})
1576 @deffnx {Función} prefix (@var{op}, @var{rbp}, @var{rpos}, @var{pos})
1578 Los operadores prefijos son funciones de un único argumento en las que éste
1579 se coloca a continuación del operador. La instrucción
1580 @code{prefix("x")} declara @code{x} como operador prefijo.
1581 @end deffn