| blob | 9050abbe506d3d687124feeea6dee7603dd33029 |
1 @c English version 2011-11-03
2 @menu
3 * Introducción a la base de datos de Maxima::
4 * Funciones y variables para las propiedades::
5 * Funciones y variables para los hechos::
6 * Funciones y variables para los predicados::
7 @end menu
12 @node Introducción a la base de datos de Maxima, Funciones y variables para las propiedades, Base de datos de Maxima, Base de datos de Maxima
13 @section Introducción a la base de datos de Maxima
15 @subheading Propiedades
17 A las variables y funciones se les puede asignar propiedades con la función
18 @code{declare}. Estas propiedades son almacenadas en un @i{banco de datos} o
19 registradas en una @i{lista de propiedades} que proporciona Lisp. Con la función
20 @code{featurep} se puede comprobar si un símbolo tiene una
21 determinada propiedad y con la función @code{properties} se pueden obtener
22 todas las propiedades asociadas a él. A su vez, la función @code{remove}
23 elimina una propiedad de la base de datos o de la lista de propiedades. En caso
24 de utilizar @code{kill} para borrar el valor asignado a una variable, también
25 serán borradas todas las propiedades asociadas a la misma.
27 El usuario tiene la facultad de añadirle propiedades a un símbolo
28 con las funciones @code{put} y @code{qput}. Con la función @code{get} podrá
29 leer sus propiedades y borrarlas con @code{rem}.
31 Las variables pueden tener las siguientes propiedades a almacenar en el banco de
32 datos:
34 @verbatim
35 constant
36 integer noninteger
37 even odd
38 rational irrational
39 real imaginary complex
40 @end verbatim
42 Las funciones pueden tener las siguientes propiedades a almacenar en el banco de
43 datos:
45 @verbatim
46 increasing decreasing
47 posfun integervalued
48 @end verbatim
50 Las siguientes propiedades se pueden aplicar a funciones y se utilizan para
51 su correcta simplificación. Estas propiedades se describen en el capítulo
52 dedicado a la simplificación:
54 @verbatim
55 linear additive multiplicative
56 outative commutative symmetric
57 antisymmetric nary lassociativ
58 rassociative evenfun oddfun
59 @end verbatim
61 Otras propiedades aplicables a variables y funciones, y que se almacenan
62 en la lista de propiedades de Lisp, son:
64 @verbatim
65 bindtest feature alphabetic
66 scalar nonscalar nonarray
67 @end verbatim
69 @subheading Contextos
71 Maxima administra contextos en los que se almacenan tanto las propiedades de las
72 variables y funciones como hechos o hipótesis sobre las mismas. Los hechos se
73 establecen con la función @code{assume} y se almacenan en el contexto actual.
74 Por ejemplo, con @code{assume(a>10)} guarda Maxima la información sobre el
75 hecho de que la variable @code{a} es mayor que @code{10}. Con la función
76 @code{forget} se borran los hechos de la base de datos. Cuando Maxima pregunta
77 al usuario sobre las propiedades de una variable, éstas son almacenadas en
78 un contexto.
80 Cada contexto se identifica por un nombre. Al iniciarse Maxima, el contexto
81 actual recibe el nombre de @code{initial} y se puede definir un número
82 arbitrario de contextos adicionales que pueden organizarse de forma jerárquica.
83 Así, el contexto @code{initial} está incluido en el contexto
84 @code{global}. Los hechos definidos en un contexto dado están siempre
85 activos en los contextos de nivel inferior. Por ejemplo, el contexto @code{global}
86 contiene hechos que se inicializan por el propio Maxima y estarán activos,
87 por tanto, en el contexto @code{initial}.
89 Los contextos pueden almacenar un número arbitrario de hechos y pueden desactivarse
90 con la función @code{deactivate}. Desactivar un contexto no implica la pérdida de
91 los hechos almacenados, pudiendo ser posteriormente reactivado con la función
92 @code{activate}, estando los hechos siempre a disposición del usuario.
101 @node Funciones y variables para las propiedades, Funciones y variables para los hechos, Introducción a la base de datos de Maxima, Base de datos de Maxima
102 @section Funciones y variables para las propiedades
104 @defvr {Propiedad} alphabetic
106 @code{alphabetic} es un tipo de propiedad reconocida por @code{declare}.
107 La expresión @code{declare(@var{s}, alphabetic)} le indica a Maxima que reconozca
108 como alfabéticos todos los caracteres que haya en @var{s}, que debe ser una cadena de texto.
110 Véase también @code{Identifiers}.
112 Ejemplo:
114 @c ===beg===
115 @c xx\~yy\`\@ : 1729;
116 @c declare ("~`@", alphabetic);
117 @c xx~yy`@ + @yy`xx + `xx@@yy~;
118 @c listofvars (%);
119 @c ===end===
120 @example
121 (%i1) xx\~yy\`\@@ : 1729;
122 (%o1) 1729
123 (%i2) declare ("~`@@", alphabetic);
124 (%o2) done
125 (%i3) xx~yy`@@ + @@yy`xx + `xx@@@@yy~;
126 (%o3) `xx@@@@yy~ + @@yy`xx + 1729
127 (%i4) listofvars (%);
128 (%o4) [@@yy`xx, `xx@@@@yy~]
129 @end example
130 @end defvr
132 @defvr {Propiedad} bindtest
133 La sentencia @code{declare(@var{x}, bindtest} le indica a Maxima que devuelva un mensaje
134 de error cuando el símbolo @var{x} no tenga asociado valor alguno.
136 Ejemplo:
138 @c ===beg===
139 @c aa + bb;
140 @c declare (aa, bindtest);
141 @c aa + bb;
142 @c aa : 1234;
143 @c aa + bb;
144 @c ===end===
145 @example
146 (%i1) aa + bb;
147 (%o1) bb + aa
148 (%i2) declare (aa, bindtest);
149 (%o2) done
150 (%i3) aa + bb;
151 aa unbound variable
152 -- an error. Quitting. To debug this try debugmode(true);
153 (%i4) aa : 1234;
154 (%o4) 1234
155 (%i5) aa + bb;
156 (%o5) bb + 1234
157 @end example
158 @end defvr
161 @deffn {Propiedad} constant
162 @code{declare(@var{a}, constant)} declara @var{a} como constante. La declaración
163 de un símbolo como constante no impide que se le asigne un valor no
164 constante al símbolo.
166 Véanse @code{constantp} y @code{declare}
168 Ejemplo:
170 @example
171 (%i1) declare(c, constant);
172 (%o1) done
173 (%i2) constantp(c);
174 (%o2) true
175 (%i3) c : x;
176 (%o3) x
177 (%i4) constantp(c);
178 (%o4) false
179 @end example
180 @end deffn
184 @deffn {Función} constantp (@var{expr})
185 Devuelve @code{true} si @var{expr} es una expresión constante y
186 @code{false} en caso contrario.
188 Una expresión se considera constante si sus argumentos son números
189 (incluidos los números racionales que se muestran con @code{/R/}),
190 constantes simbólicas como @code{%pi}, @code{%e} o @code{%i}, variables
191 con valor constante o declarada como constante por @code{declare},
192 o funciones cuyos argumentos son constantes.
194 La función @code{constantp} evalúa sus argumentos.
196 Ejemplos:
198 @c ===beg===
199 @c constantp (7 * sin(2));
200 @c constantp (rat (17/29));
201 @c constantp (%pi * sin(%e));
202 @c constantp (exp (x));
203 @c declare (x, constant);
204 @c constantp (exp (x));
205 @c constantp (foo (x) + bar (%e) + baz (2));
206 @c ===end===
208 @example
209 (%i1) constantp (7 * sin(2));
210 (%o1) true
211 (%i2) constantp (rat (17/29));
212 (%o2) true
213 (%i3) constantp (%pi * sin(%e));
214 (%o3) true
215 (%i4) constantp (exp (x));
216 (%o4) false
217 (%i5) declare (x, constant);
218 (%o5) done
219 (%i6) constantp (exp (x));
220 (%o6) true
221 (%i7) constantp (foo (x) + bar (%e) + baz (2));
222 (%o7) false
223 (%i8)
224 @end example
225 @end deffn
229 @deffn {Función} declare (@var{a_1}, @var{f_1}, @var{a_2}, @var{f_2}, ...)
230 Asigna al átomo o lista de átomos @var{a_i} la propiedad o lista de
231 propiedades@var{p_i}. Si @var{a_i} y/o @var{p_i} son listas, cada uno de
232 los átomos adquiere todas las propiedades.
234 La función @code{declare} no evalúa sus argumentos y siempre devuelve la
235 expresión @code{done}.
237 La llamada @code{featurep (@var{object}, @var{feature})} devuelve @code{true}
238 si @var{object} ha sido previamente declarado como poseedor de la propiedad
239 @var{feature}.
241 Véase también @code{features}.
243 La función @code{declare} reconoce las siguientes propiedades:
245 @table @code
246 @item additive
247 Hace que Maxima simplifique las expresiones @var{a_i}
248 haciendo uso de la sustitución
249 @code{@var{a_i}(x + y + z + ...)} @code{-->}
250 @code{@var{a_i}(x) + @var{a_i}(y) + @var{a_i}(z) + ...}.
251 Tal sustitución se aplica únicamente al primer argumento.
253 @item alphabetic
254 Indica a Maxima que reconozca todos los caracteres de la cadena alfanumérica
255 @var{a_i} como caracteres alfabéticos.
257 @item antisymmetric, commutative, symmetric
258 Hace que Maxima reconozca a @var{a_i} como una función simétrica o
259 antisimétrica. La propiedad @code{commutative} equivale a @code{symmetric}.
261 @item bindtest
262 Hace que Maxima envíe un error si @var{a_i} es evaluado sin habérsele
263 asignado un valor.
265 @item constant
266 Hace que Maxima considere a @var{a_i} como una constante
267 simbólica.
269 @item even, odd
270 Hace que Maxima reconozca a @var{a_i} como una variable entera par o impar.
272 @item evenfun, oddfun
273 Hace que Maxima reconozca a @var{a_i} como una función par o impar.
275 @item evflag
276 Hace que @var{a_i} sea reconocida por @code{ev}, de manera que a @var{a_i} se le
277 asigne el valor @code{true} durante la ejecución de @code{ev} cuando @var{a_i}
278 aparezca como argumento de control de @code{ev}. Véase también @code{evflag}.
280 @item evfun
281 Hace que @var{a_i} sea reconocida por @code{ev}, de manera que la función
282 nombrada por @var{a_i} se aplique cuando @var{a_i} aparezca como argumento
283 de control de @code{ev}. Véase también @code{evfun}.
285 @item feature
286 Hace que Maxima considere a @var{a_i} como el nombre de una propiedad.
287 Otros átomos podrán ser declarados entonces como poseedores de
288 la propiedad @var{a_i}.
290 @item increasing, decreasing
291 Hace que Maxima reconozca a @var{a_i} como una función creciente o decreciente.
293 @item integer, noninteger
294 Hace que Maxima reconozca a @var{a_i} como una variable entera o no entera.
296 @item integervalued
297 Hace que Maxima reconozca a @var{a_i} como una función de valor entero.
299 @item lassociative, rassociative
300 Hace que Maxima reconozca a @var{a_i} como una función asociativa por la derecha o
301 por la izquierda.
303 @item linear
304 Equivale a declarar @var{a_i} conjuntamente como @code{outative} y @code{additive}.
306 @item mainvar
307 Hace que Maxima considere a @var{a_i} como una "variable principal",
308 dándole prioridad frente a cualesquiera otras constantes o
309 variables en la ordenación canónica de expresiones de Maxima,
310 tal como determina @code{ordergreatp}.
312 @item multiplicative
313 Hace que Maxima simplifique las expresiones @var{a_i}
314 haciendo uso de la sustitución
315 @code{@var{a_i}(x * y * z * ...)} @code{-->} @code{@var{a_i}(x) * @var{a_i}(y) * @var{a_i}(z) * ...}.
316 Tal sustitución se aplica únicamente al primer argumento.
318 @item nary
319 Hace que Maxima reconozca a @var{a_i} como una función n-aria.
321 La declaración @code{nary} no es equivalente a la función @code{nary}.
322 El único efecto de @code{declare(foo, nary)} consiste en hacer que
323 el simplificador de Maxima reduzca expresiones anidadas; por ejemplo,
324 para transformar @code{foo(x, foo(y, z))} a @code{foo(x, y, z)}.
326 @item nonarray
327 Indica que Maxima no debe considerar @var{a_i} como un array. Esta declaración
328 evita la evaluación múltiple de variables subindicadas.
330 @item nonscalar
331 Hace que Maxima considere a @var{a_i} como una variable no escalar.
332 Se aplica comúnmente para declarar una variable como un vector simbólico
333 o una matriz simbólica.
335 @item noun
336 Hace que Maxima considere a @var{a_i} como un nombre. El efecto
337 que se obtiene es que se reemplazan todas las expresiones @var{a_i}
338 por @code{'@var{a_i}} o @code{nounify (@var{a_i})},
339 dependiendo del contexto.
341 @item outative
342 Hace que Maxima simplifique las expresiones @var{a_i}
343 extrayendo los factores constantes del primer argumento.
345 Cuando @var{a_i} tenga un único argumento, un factor se considerará constante
346 si es una constante literal o declarada.
348 Cuando @var{a_i} tenga dos o más argumentos, un factor se considerará constante
349 si el segundo argumento es un símbolo y el factor no contiene al
350 segundo argumento.
352 @item posfun
353 Hace que Maxima reconozca a @var{a_i} como una función positiva.
355 @item rational, irrational
356 Hace que Maxima reconozca a @var{a_i} como una variable real racional o irracional.
358 @item real, imaginary, complex
359 Hace que Maxima reconozca a @var{a_i} como una variable real, imaginaria o compleja.
361 @item scalar
362 Hace que Maxima considere a @var{a_i} como una variable escalar.
364 @end table
366 Ejemplos sobre el uso de estas propiedades están disponibles en la
367 documentación correspondiente a cada propiedad por separado.
368 @end deffn
372 @defvr {Propiedad} decreasing
373 @defvrx {Propiedad} increasing
375 Las instrucciones @code{declare(@var{f}, decreasing)} y
376 @code{declare(@var{f}, increasing} le indican a Maxima que reconozca la función
377 @var{f} como una función decreciente o creciente.
379 Véase también @code{declare} para más propiedades.
381 Ejemplo:
383 @example
384 (%i1) assume(a > b);
385 (%o1) [a > b]
386 (%i2) is(f(a) > f(b));
387 (%o2) unknown
388 (%i3) declare(f, increasing);
389 (%o3) done
390 (%i4) is(f(a) > f(b));
391 (%o4) true
392 @end example
393 @end defvr
396 @defvr {Propiedad} even
397 @defvrx {Propiedad} odd
399 @code{declare(@var{a}, even)} y @code{declare(@var{a}, odd)} le indican a Maxima
400 que reconozca el símbolo @var{a} como entero par o impar. Las
401 propiedades @code{even} y @code{odd} no son reconocidas por las funciones
402 @code{evenp}, @code{oddp} y @code{integerp}.
404 Véanse también @code{declare} y @code{askinteger}.
406 Ejemplo:
408 @example
409 (%i1) declare(n, even);
410 (%o1) done
411 (%i2) askinteger(n, even);
412 (%o2) yes
413 (%i3) askinteger(n);
414 (%o3) yes
415 (%i4) evenp(n);
416 (%o4) false
417 @end example
418 @end defvr
422 @defvr {Propiedad} feature
424 Maxima interpreta dos tipos diferentes de propiedades, del sistema y las que
425 se aplican a expresiones matemáticas. Véase @code{status} para obtener
426 información sobre propiedades del sistema, así como
427 @code{features} y @code{featurep} para propiedades de las expresiones matemáticas.
429 @code{feature} no es el nombre de ninguna función o variable.
430 @end defvr
433 @deffn {Función} featurep (@var{a}, @var{f})
435 Intenta determinar si el objeto @var{a} tiene la propiedad @var{f} en base a los
436 hechos almacenados en la base de datos. En caso afirmativo, devuelve @code{true},
437 o @code{false} en caso contrario.
439 Nótese que @code{featurep} devuelve @code{false} cuando no se puedan verificar ni
440 @var{f} ni su negación.
442 @code{featurep} evalúa su argumento.
444 Véanse también @code{declare} y @code{features}.
446 Ejemplos:
448 @example
449 (%i1) declare (j, even)$
450 (%i2) featurep (j, integer);
451 (%o2) true
452 @end example
453 @end deffn
457 @defvr {Declaración} features
458 Maxima reconoce ciertas propiedades matemáticas sobre funciones y variables.
460 La llamada @code{declare (@var{x}, @var{foo})} asocia la propiedad @var{foo} a la función o variable @var{x}.
462 La llamada @code{declare (@var{foo}, feature)} declara una nueva propiedad @var{foo}.
463 Por ejemplo, @code{declare ([rojo, verde, azul], feature)} declara tres nuevas propiedades,
464 @code{rojo}, @code{verde} y @code{azul}.
466 El predicado @code{featurep (@var{x}, @var{foo})}
467 devuelve @code{true} si @var{x} goza de la propiedad @var{foo}, y @code{false} en caso contrario.
469 La lista @code{features} contiene las propiedades que reconoce Maxima; a saber,
471 @verbatim
472 integer noninteger even
473 odd rational irrational
474 real imaginary complex
475 analytic increasing decreasing
476 oddfun evenfun posfun
477 commutative lassociative rassociative
478 symmetric antisymmetric
479 @end verbatim
481 junto con las definidas por el usuario.
483 La lista @code{features} sólo contiene propiedades matemáticas.
484 Hay otra lista con propiedades no matemáticas; Véase @code{status}.
486 Ejemplo:
488 @c ===beg===
489 @c declare (FOO, feature);
490 @c declare (x, FOO);
491 @c featurep (x, FOO);
492 @c ===end===
493 @example
494 (%i1) declare (FOO, feature);
495 (%o1) done
496 (%i2) declare (x, FOO);
497 (%o2) done
498 (%i3) featurep (x, FOO);
499 (%o3) true
500 @end example
501 @end defvr
505 @deffn {Función} get (@var{a}, @var{i})
507 Recupera la propiedad de usuario indicada por @var{i} asociada al átomo @var{a}
508 o devuelve @code{false} si @var{a} no tiene la propiedad @var{i}.
510 La función @code{get} evalúa sus argumentos.
512 Véanse también @code{put} y @code{qput}.
514 @c ===beg===
515 @c put (%e, 'transcendental, 'type);
516 @c put (%pi, 'transcendental, 'type)$
517 @c put (%i, 'algebraic, 'type)$
518 @c typeof (expr) := block ([q],
519 @c if numberp (expr)
520 @c then return ('algebraic),
521 @c if not atom (expr)
522 @c then return (maplist ('typeof, expr)),
523 @c q: get (expr, 'type),
524 @c if q=false
525 @c then errcatch (error(expr,"is not numeric.")) else q)$
526 @c typeof (2*%e + x*%pi);
527 @c typeof (2*%e + %pi);
528 @c ===end===
529 @example
530 (%i1) put (%e, 'transcendental, 'type);
531 (%o1) transcendental
532 (%i2) put (%pi, 'transcendental, 'type)$
533 (%i3) put (%i, 'algebraic, 'type)$
534 (%i4) typeof (expr) := block ([q],
535 if numberp (expr)
536 then return ('algebraic),
537 if not atom (expr)
538 then return (maplist ('typeof, expr)),
539 q: get (expr, 'type),
540 if q=false
541 then errcatch (error(expr,"is not numeric.")) else q)$
542 (%i5) typeof (2*%e + x*%pi);
543 x is not numeric.
544 (%o5) [[transcendental, []], [algebraic, transcendental]]
545 (%i6) typeof (2*%e + %pi);
546 (%o6) [transcendental, [algebraic, transcendental]]
547 @end example
548 @end deffn
551 @defvr {Propiedad} integer
552 @defvrx {Propiedad} noninteger
554 @code{declare(@var{a}, integer)} o @code{declare(@var{a}, noninteger)} indica a
555 Maxima que reconozca @var{a} como una variable entera o no entera.
557 Véase también @code{declare}.
559 Ejemplo:
561 @example
562 (%i1) declare(n, integer, x, noninteger);
563 (%o1) done
564 (%i2) askinteger(n);
565 (%o2) yes
566 (%i3) askinteger(x);
567 (%o3) no
568 @end example
569 @end defvr
573 @defvr {Propiedad} integervalued
575 @code{declare(@var{f}, integervalued)} indica a MAxima que reconozca @var{f} como
576 una función que toma valores enteros.
578 Véase también @code{declare}.
580 Ejemplo:
582 @example
583 (%i1) exp(%i)^f(x);
584 %i f(x)
585 (%o1) (%e )
586 (%i2) declare(f, integervalued);
587 (%o2) done
588 (%i3) exp(%i)^f(x);
589 %i f(x)
590 (%o3) %e
591 @end example
592 @end defvr
596 @deffn {Propiedad} nonarray
598 La instrucción @code{declare(a, nonarray)} le indica a Maxima que
599 no considere @var{a} como un array. Esta declaración evita la
600 evaluación múltiple de @var{a}, si ésta es una variable subindicada.
602 Véase también @code{declare}.
604 Ejemplo:
606 @c ===beg===
607 @c a:'b$ b:'c$ c:'d$
608 @c a[x];
609 @c declare(a, nonarray);
610 @c a[x];
611 @c ===end===
612 @example
613 (%i1) a:'b$ b:'c$ c:'d$
615 (%i4) a[x];
616 (%o4) d
617 x
618 (%i5) declare(a, nonarray);
619 (%o5) done
620 (%i6) a[x];
621 (%o6) a
622 x
623 @end example
624 @end deffn
627 @defvr {Propiedad} nonscalar
628 Hace que los átomos se comporten como hace una lista o matriz
629 con respecto del operador @code{.} del la multiplicación no conmutativa.
631 Véase también @code{declare}.
632 @end defvr
635 @deffn {Función} nonscalarp (@var{expr})
636 Devuelve @code{true} si @var{expr} no es escalar, es decir,
637 si contiene átomos declarados como no escalares, listas o matrices.
638 @end deffn
641 @defvr {Declaración} posfun
642 La instrucción @code{declare (f, posfun)} declara a @code{f} como
643 función positiva, de forma que
644 @code{is (f(x) > 0)} devolverá @code{true}.
646 Véase también @code{declare}.
647 @end defvr
650 @deffn {Función} printprops (@var{a}, @var{i})
651 @deffnx {Función} printprops ([@var{a_1}, ..., @var{a_n}], @var{i})
652 @deffnx {Función} printprops (all, @var{i})
653 Muestra la propiedad con el indicador @var{i} asociado
654 con el átomo @var{a}. @var{a} puede ser también una lista de
655 átomos o el átomo @code{all} en cuyo caso todos los átomos a los cuales se les haya dado esa propiedad serán usados.
656 Por ejemplo, @code{printprops ([f, g], atvalue)}. @code{printprops} es
657 para propiedades que no pueden ser mostradas de otra manera, i.e. para
658 @code{atvalue}, @code{atomgrad}, @code{gradef}, y @code{matchdeclare}.
660 @end deffn
663 @deffn {Función} properties (@var{a})
664 Devuelve una lista con los nombres de todas las propiedades asociadas
665 al @'tomo @var{a}.
666 @end deffn
669 @defvr {Variable del sistema} props
670 Valor por defecto: @code{[]}
672 @code{props} son @'tomos que tienen asociadas otras propiedades además de las
673 explícitamente mencionadas en @code{infolists}, tales como las
674 especificadas por @code{atvalue}, @code{matchdeclare} y la función
675 @code{declare}.
676 @end defvr
680 @deffn {Función} propvars (@var{prop})
682 Devuelve la lista con los átomos de la lista @code{props} que tienen
683 la propiedad indicada por @var{prop}. Así, @code{propvars (atvalue)}
684 devuelve la lista con los átomos a los que se les ha asociado valores con
685 @code{atvalue}.
686 @end deffn
689 @deffn {Función} put (@var{átomo}, @var{valor}, @var{indicador})
691 Asigna el @var{valor} a la propiedad (especificada por @var{indicador}) de @var{átomo};
692 @var{indicador} puede ser el nombre de cualquier propiedad y no solamente de aquellas definidas por el sistema.
694 @code{rem} deshace la asignación realizada por @code{put}.
696 La función @code{put} evalúa sus argumentos y devuelve @var{valor}.
698 Ejemplos:
700 @example
701 (%i1) put (foo, (a+b)^5, expr);
702 5
703 (%o1) (b + a)
704 (%i2) put (foo, "Hello", str);
705 (%o2) Hello
706 (%i3) properties (foo);
707 (%o3) [[user properties, str, expr]]
708 (%i4) get (foo, expr);
709 5
710 (%o4) (b + a)
711 (%i5) get (foo, str);
712 (%o5) Hello
713 @end example
715 @end deffn
719 @deffn {Función} qput (@var{átomo}, @var{valor}, @var{indicador})
721 Asigna @var{valor} a la propiedad de @var{átomo} que especifique @var{indicador}.
722 Actúa del mismo modeo que @code{put}, excepto que sus argumentos no son evaluados.
724 Véase también @code{get}.
726 Ejemplo:
728 @example
729 (%i1) foo: aa$
730 (%i2) bar: bb$
731 (%i3) baz: cc$
732 (%i4) put (foo, bar, baz);
733 (%o4) bb
734 (%i5) properties (aa);
735 (%o5) [[user properties, cc]]
736 (%i6) get (aa, cc);
737 (%o6) bb
738 (%i7) qput (foo, bar, baz);
739 (%o7) bar
740 (%i8) properties (foo);
741 (%o8) [value, [user properties, baz]]
742 (%i9) get ('foo, 'baz);
743 (%o9) bar
744 @end example
745 @end deffn
750 @defvr {Propiedad} rational
751 @defvrx {Propiedad} irrational
753 @code{declare(@var{a}, rational)} o @code{declare(@var{a}, irrational)} indica a
754 Maxima que reconozca @var{a} como una variable real racional o irracional.
756 Véase también @code{declare}.
757 @end defvr
761 @defvr {Propiedad} real
762 @defvrx {Propiedad} imaginary
763 @defvrx {Propiedad} complex
765 @code{declare(@var{a}, real)}, @code{declare(@var{a}, imaginary)} o
766 @code{declare(@var{a}, complex)} indican a Maxima que reconozca @var{a} como variable real,
767 imaginaria puro o compleja, respectivamente.
769 Véase también @code{declare}.
770 @end defvr
774 @deffn {Función} rem (@var{átomo}, @var{indicador})
776 Elimina del @var{átomo} la propiedad indicada por @var{indicador}.
777 @code{rem} deshace la asignación realizada por @code{put}.
779 @code{rem} devuelve @code{done} si @var{átomo} tenía la
780 propiedad @var{indicador} cuando @code{rem} fue invocado, devolviendo
781 @code{false} si carecía tal propiedad.
783 @end deffn
787 @deffn {Función} remove (@var{a_1}, @var{p_1}, ..., @var{a_n}, @var{p_n})
788 @deffnx {Función} remove ([@var{a_1}, ..., @var{a_m}], [@var{p_1}, ..., @var{p_n}], ...)
789 @deffnx {Función} remove ("@var{a}", operator)
790 @deffnx {Función} remove (@var{a}, transfun)
791 @deffnx {Función} remove (all, @var{p})
793 Elimina propiedades asociadas con átomos.
795 La llamada @code{remove (@var{a_1}, @var{p_1}, ..., @var{a_n}, @var{p_n})}
796 elimina la propiedad @code{p_k} del átomo @code{a_k}.
798 La llamada @code{remove ([@var{a_1}, ..., @var{a_m}], [@var{p_1}, ..., @var{p_n}], ...)}
799 elimina las propiedades @code{@var{p_1}, ..., @var{p_n}} de los átomos @var{a_1}, ..., @var{a_m}. Puede tener más de un par de listas.
801 La llamada @code{remove (all, @var{p})} elimina la propiedad @var{p} de todos los átomos que la tengan.
803 Las propiedades eliminadas pueden ser de las que define el sistema, como
804 @code{function}, @code{macro} o @code{mode_declare}; @code{remove} no elimina
805 las propiedades definidas por @code{put}.
807 La llamada @code{remove ("@var{a}", operator)} o su equivalente @code{remove ("@var{a}", op)} elimina de @var{a} las propiedades de operador declaradas por @code{prefix}, @code{infix}, @code{nary}, @code{postfix}, @code{matchfix} o @code{nofix}. Nótese que el nombre del operador debe escribirse como cadena precedida de apóstrofo.
809 La función @code{remove} devuelve siempre @code{done} independientemente que haya algún átomo con la propiedad especificada.
811 La función @code{remove} no evalúa sus argumentos.
812 @end deffn
815 @defvr {Propiedad} scalar
817 @code{declare(@var{a}, scalar)} indica a Maxima que considere a @var{a} como
818 una variable escalar.
820 Véase también @code{declare}.
821 @end defvr
825 @deffn {Función} scalarp (@var{expr})
827 Devuelve @code{true} si @var{expr} es un número, constante o variable
828 declarada como @code{scalar} con @code{declare}, o compuesta completamente de tales
829 números, constantes o variables, pero que no contengan matrices ni listas.
830 @end deffn
838 @node Funciones y variables para los hechos, Funciones y variables para los predicados, Funciones y variables para las propiedades, Base de datos de Maxima
839 @section Funciones y variables para los hechos
842 @deffn {Función} activate (@var{context_1}, ..., @var{context_n})
843 Activa los contextos @var{context_1}, ..., @var{context_n}.
844 Los hechos en estos contextos están disponibles para hacer deducciones y extraer información.
845 Los hechos en estos contextos no se listan al invocar @code{facts ()}.
847 La variable @code{activecontexts} es la lista de contextos que se han activado por medio de la función @code{activate}.
849 @end deffn
854 @defvr {Variable del sistema} activecontexts
855 Valor por defecto: @code{[]}
857 La variable @code{activecontexts} es la lista de contextos que se han activado por medio de la función @code{activate}, pero que no se han activado por ser subcontextos del contexto actual.
859 @end defvr
866 @deffn {Función} askinteger (@var{expr}, integer)
867 @deffnx {Función} askinteger (@var{expr})
868 @deffnx {Función} askinteger (@var{expr}, even)
869 @deffnx {Función} askinteger (@var{expr}, odd)
871 La llamada @code{askinteger (@var{expr}, integer)} intenta determinar a partir de la base de datos de @code{assume} si @var{expr} es un entero. La función @code{askinteger} pide más información al usuario si no encuentra la respuesta,
872 @c UMM, askinteger AND asksign DO NOT APPEAR TO HAVE ANY EFFECT ON THE assume DATABASE !!!
873 tratando de almacenar la nueva información en la base de datos si es posible. La llamada
874 @code{askinteger (@var{expr})} equivale a @code{askinteger (@var{expr}, integer)}.
876 La llamadas @code{askinteger (@var{expr}, even)} ay @code{askinteger (@var{expr}, odd)} intentan determinar si @var{expr} es un entero par o impar, respectivamente.
878 @end deffn
883 @deffn {Función} asksign (@var{expr})
884 Primero intenta determinar si la expresión especificada es positiva, negativa o cero. Si no lo consigue, planteará al usuario preguntas que le ayuden a conpletar la deducción. Las respuestas del usuario son almacenadas en la base de datos durante el tiempo que dure este cálculo. El valor que al final devuelva @code{asksign} será @code{pos}, @code{neg} o @code{zero}.
886 @end deffn
891 @deffn {Función} assume (@var{pred_1}, ..., @var{pred_n})
892 Añade los predicados @var{pred_1}, ..., @var{pred_n} al contexto actual.
893 Si un predicado es inconsistente o redundante con los otros predicados
894 del contexto actual, entonces no es añadido al contexto.
895 El contexto va acumulando predicados con cada llamada a @code{assume}.
897 La función @code{assume} devuelve una lista cuyos miembros son los
898 predicados que han sido añadidos al contexto, o los átomos
899 @code{redundant} o @code{inconsistent} si fuere necesario.
901 Los predicados @var{pred_1}, ..., @var{pred_n} tan solo pueden ser
902 expresiones formadas con los operadores relacionales @code{< <= equal notequal >=}
903 y @code{>}. Los predicados no pueden estar formados por expresiones que sean del
904 tipo igualdad @code{=} ni del tipo desigualdad @code{#}, ni tampoco pueden ser
905 funciones de predicado como @code{integerp}.
907 En cambio, sí se reconocen predicados compuestos de la forma
908 @code{@var{pred_1} and ... and @var{pred_n}}, pero no
909 @code{@var{pred_1} or ... or @var{pred_n}}.
910 También se reconoce @code{not @var{pred_k}} si @var{pred_k} es un
911 predicado relacional. Expresiones de la forma @code{not (@var{pred_1} and @var{pred_2})}
912 y @code{not (@var{pred_1} or @var{pred_2})} no son reconocidas.
914 El mecanismo deductivo de Maxima no es muy potente; existen muchas
915 consecuencias que, siendo obvias, no pueden ser obtenidas por @code{is}.
916 Se trata de una debilidad reconocida.
918 @code{assume} no gestiona predicados con números complejos. Si un
919 predicado contiene un número complejo, @code{assume} devuelve
920 @code{inconsistent} o @code{redunant}.
922 La función @code{assume} evalúa sus argumentos.
924 Véanse también @code{is}, @code{facts}, @code{forget}, @code{context} y @code{declare}.
926 Ejemplos:
928 @c ===beg===
929 @c assume (xx > 0, yy < -1, zz >= 0);
930 @c assume (aa < bb and bb < cc);
931 @c facts ();
932 @c is (xx > yy);
933 @c is (yy < -yy);
934 @c is (sinh (bb - aa) > 0);
935 @c forget (bb > aa);
936 @c prederror : false;
937 @c is (sinh (bb - aa) > 0);
938 @c is (bb^2 < cc^2);
939 @c ===end===
941 @example
942 (%i1) assume (xx > 0, yy < -1, zz >= 0);
943 (%o1) [xx > 0, yy < - 1, zz >= 0]
944 (%i2) assume (aa < bb and bb < cc);
945 (%o2) [bb > aa, cc > bb]
946 (%i3) facts ();
947 (%o3) [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
948 (%i4) is (xx > yy);
949 (%o4) true
950 (%i5) is (yy < -yy);
951 (%o5) true
952 (%i6) is (sinh (bb - aa) > 0);
953 (%o6) true
954 (%i7) forget (bb > aa);
955 (%o7) [bb > aa]
956 (%i8) prederror : false;
957 (%o8) false
958 (%i9) is (sinh (bb - aa) > 0);
959 (%o9) unknown
960 (%i10) is (bb^2 < cc^2);
961 (%o10) unknown
962 @end example
964 @end deffn
969 @defvr {Variable opcional} assumescalar
970 Valor por defecto: @code{true}
972 La variable @code{assumescalar} ayuda a controlar si una expresión @code{expr} para la cual @code{nonscalarp (expr)} es @code{false} va a tener un comportamiento similar a un escalar bajo ciertas transformaciones.
974 Sea @code{expr} cualquier expresión distinta de una lista o matriz, y sea también @code{[1, 2, 3]} una lista o una matriz. Entonces, @code{expr . [1, 2, 3]} dará como resultado @code{[expr, 2 expr, 3 expr]} si @code{assumescalar} es @code{true}, o si @code{scalarp (expr)} es @code{true}, o si @code{constantp (expr)} es @code{true}.
976 Si @code{assumescalar} vale @code{true}, la expresión se comportará como un escalar sólo en operaciones conmutativas, pero no en el caso de la multiplicación no conmutativa o producto matricial @code{.}.
978 Si @code{assumescalar} vale @code{false}, la expresión se comportará como un no escalar.
980 Si @code{assumescalar} vale @code{all}, la expresión se comportará como un escalar para todas las operaciones.
982 @end defvr
984 @defvr {Variable opcional} assume_pos
985 Valor por defecto: @code{false}
987 Si @code{assume_pos} vale @code{true} y el signo de un parámetro @var{x} no puede ser determinado a partir del contexto actual o de otras consideraciones, @code{sign} y @code{asksign (@var{x})} devolverán @code{true}. Con esto se pueden evitar algunas preguntas al usuario que se generan automáticamente, como las que hacen @code{integrate} y otras funciones.
989 By default, a parameter is @var{x} such that @code{symbolp (@var{x})}
990 or @code{subvarp (@var{x})}.
992 Por defecto, un parámetro @var{x} es aquel para el que @code{symbolp (@var{x})} o @code{subvarp (@var{x})} devuelven @code{true}.
993 La clase de expresiones que se consideran parámetros se puede extender mediante la utilización de la variable @code{assume_pos_pred}.
995 Las funciones @code{sign} y @code{asksign} intentan deducir el signo de una expresión a partir de los signos de los operandos que contiene. Por ejemplo, si @code{a} y @code{b} son ambos positivos, entonces @code{a + b} también es positivo.
997 Sin embargo, no es posible obviar todas las preguntas que hace @code{asksign}. En particular, cuando el argumento de @code{asksign} es una diferencia @code{@var{x} - @var{y}} o un logaritmo @code{log(@var{x})}, @code{asksign} siempre solicita una respuesta por parte del usuario, incluso cuando @code{assume_pos} vale @code{true} y @code{assume_pos_pred} es una función que devuelve @code{true} para todos los argumentos.
999 @c NEED EXAMPLES HERE
1000 @end defvr
1004 @defvr {Variable opcional} assume_pos_pred
1005 Valor por defecto: @code{false}
1007 Cuando a @code{assume_pos_pred} se le asigna el nombre de una función o una expresión lambda de un único argumento @var{x}, ésta será invocada para determinar si @var{x} se considera un parámetro por @code{assume_pos}. La variable
1008 @code{assume_pos_pred} se ignora cuando @code{assume_pos} vale @code{false}.
1010 La función @code{assume_pos_pred} es invocada por @code{sign} y por @code{asksign} con un argumento @var{x}, el cual puede ser un átomo, una variable subindicada o una expresión de llamada a una función. Si la función @code{assume_pos_pred} devuelve @code{true}, @var{x} será considerada como un parámetro por @code{assume_pos}.
1012 Por defecto, un parámetro @var{x} es aquel para el que @code{symbolp (@var{x})} o @code{subvarp (@var{x})} devuelven @code{true}.
1014 Véanse también @code{assume} y @code{assume_pos}.
1016 Ejemplos:
1017 @c EXAMPLE OUTPUT GENERATED FROM:
1018 @c assume_pos: true$
1019 @c assume_pos_pred: symbolp$
1020 @c sign (a);
1021 @c sign (a[1]);
1022 @c assume_pos_pred: lambda ([x], display (x), true)$
1023 @c asksign (a);
1024 @c asksign (a[1]);
1025 @c asksign (foo (a));
1026 @c asksign (foo (a) + bar (b));
1027 @c asksign (log (a));
1028 @c asksign (a - b);
1030 @example
1031 (%i1) assume_pos: true$
1032 (%i2) assume_pos_pred: symbolp$
1033 (%i3) sign (a);
1034 (%o3) pos
1035 (%i4) sign (a[1]);
1036 (%o4) pnz
1037 (%i5) assume_pos_pred: lambda ([x], display (x), true)$
1038 (%i6) asksign (a);
1039 x = a
1041 (%o6) pos
1042 (%i7) asksign (a[1]);
1043 x = a
1044 1
1046 (%o7) pos
1047 (%i8) asksign (foo (a));
1048 x = foo(a)
1050 (%o8) pos
1051 (%i9) asksign (foo (a) + bar (b));
1052 x = foo(a)
1054 x = bar(b)
1056 (%o9) pos
1057 (%i10) asksign (log (a));
1058 x = a
1060 Is a - 1 positive, negative, or zero?
1062 p;
1063 (%o10) pos
1064 (%i11) asksign (a - b);
1065 x = a
1067 x = b
1069 x = a
1071 x = b
1073 Is b - a positive, negative, or zero?
1075 p;
1076 (%o11) neg
1077 @end example
1079 @end defvr
1083 @defvr {Variable opcional} context
1084 Valor por defecto: @code{initial}
1086 La variable @code{context} da nombre al conjunto de hechos establecidos desde @code{assume} y @code{forget}. La función @code{assume} añade nuevos hechos al conjunto nombrado por @code{context}, mientras que @code{forget} los va eliminando.
1087 Asignando a @code{context} un nuevo nombre @var{foo} cambia el contexto actual a @var{foo}. Si el contexto @var{foo} no existe todavía, se crea automáticamente mediante una llamada a @code{newcontext}.
1089 Véase @code{contexts} para una descripción general del mecanismo que siguen los contextos.
1091 @end defvr
1093 @defvr {Variable opcional} contexts
1094 Valor por defecto: @code{[initial, global]}
1096 La variable @code{contexts} es una lista que contiene los contextos existentes, incluyendo el actualmente activo.
1098 El mecanismo que siguen los contextos permiten al usuario agrupar y nombrar un conjunto de hechos, que recibe el nombre de contexto. Una vez hecho esto, el usuario puede hacer que Maxima tenga en cuenta o que olvide cualquier número de hechos sin más que activar o desactivar su contexto.
1100 Cualquier átomo simbólico puede ser el nombre de un contexto, y los hechos contenidos en tal contexto pueden ser almacenados hasta que se destruyan uno a uno mediante llamadas a la función @code{forget}, o que se destruyan conjuntamente invocando a @code{kill} para eliminar el contexto al que pertenecen.
1102 Los contextos tienen estructura jerárquica, siendo su raíz el contexto @code{global}, el cual contiene información sobre Maxima que necesitan algunas funciones. Cuando en un contexto todos los hechos están activos (lo que significa que están siendo utilizados en deducciones) lo estarán también en cualquier subcontexto del contexto actual.
1104 Cuando se comienza una sesión de Maxima, el usuario estará trabajando en un contexto llamado @code{initial}, el cual tiene un subcontexto de nombre @code{global}.
1106 Véanse también @code{facts}, @code{newcontext}, @code{supcontext}, @code{killcontext}, @code{activate}, @code{deactivate}, @code{assume} y @code{forget}.
1108 @end defvr
1112 @deffn {Función} deactivate (@var{contexto_1}, ..., @var{contexto_n})
1113 Desactiva los contextos especificados @var{contexto_1}, ..., @var{contexto_n}.
1115 @end deffn
1117 @deffn {Función} facts (@var{item})
1118 @deffnx {Función} facts ()
1119 Si @var{item} es el nombre de un contexto,
1120 @code{facts (@var{item})} devuelve una lista
1121 con los hechos asociados al contexto especificado.
1123 Si @var{item} no es el nombre de un contexto,
1124 @code{facts (@var{item})} devuelve una lista con los hechos conocidos acerca de @var{item} en el contexto actual. Los hechos que estén activos en contextos diferentes no aparecen en la lista.
1126 La llamada @code{facts ()}, sin argumentos, muestra el contexto actual.
1128 @end deffn
1133 @deffn {Función} forget (@var{pred_1}, ..., @var{pred_n})
1134 @deffnx {Función} forget (@var{L})
1135 Borra los predicados establecidos por @code{assume}. Los predicados pueden ser expresiones equivalentes, pero no necesariamente idénticas, a las establecidas por @code{assume}.
1137 La llamada @code{forget (@var{L})}, siendo @var{L} una lista de predicados, borra todos los predicados contenidos en ella.
1139 @end deffn
1143 @deffn {Función} is (@var{expr})
1144 Intenta determinar si el predicado @var{expr} se puede deducir de los hechos almacenados en la base de datos gestionada por @code{assume}.
1146 Si el predicado se reduce a @code{true} o @code{false},
1147 @code{is} devuelve @code{true} o @code{false}, respectivamente.
1148 En otro caso, el valor devuelto está controlado por la variable global @code{prederror}.
1149 Si @code{prederror} vale @code{true}, @code{is} emite un mensaje de error;
1150 en caso contrario, @code{is} devuelve @code{unknown}.
1152 La instrucción @code{ev(@var{expr}, pred)}
1153 (que puede escribirse como @code{@var{expr}, pred} en el
1154 modo interactivo) equivale a @code{is(@var{expr})}.
1156 Véanse también @code{assume}, @code{facts} y @code{maybe}.
1158 Ejemplos:
1160 @code{is} evalúa los predicados,
1162 @c ===beg===
1163 @c %pi > %e;
1164 @c is (%pi > %e);
1165 @c ===end===
1166 @example
1167 (%i1) %pi > %e;
1168 (%o1) %pi > %e
1169 (%i2) is (%pi > %e);
1170 (%o2) true
1171 @end example
1173 @code{is} intenta evaluar predicados a partir
1174 del conocimiento almacenado en la base de datos de @code{assume}.
1176 @c ===beg===
1177 @c assume (a > b);
1178 @c assume (b > c);
1179 @c is (a < b);
1180 @c is (a > c);
1181 @c is (equal (a, c));
1182 @c ===end===
1183 @example
1184 (%i1) assume (a > b);
1185 (%o1) [a > b]
1186 (%i2) assume (b > c);
1187 (%o2) [b > c]
1188 (%i3) is (a < b);
1189 (%o3) false
1190 (%i4) is (a > c);
1191 (%o4) true
1192 (%i5) is (equal (a, c));
1193 (%o5) false
1194 @end example
1196 Si @code{is} no puede evaluar el valor lógico del predicado
1197 a partir de la base de datos gestionada por @code{assume},
1198 la variable global @code{prederror} controla el comportamiento de @code{is}.
1200 @c ===beg===
1201 @c assume (a > b);
1202 @c prederror: true$
1203 @c is (a > 0);
1204 @c prederror: false$
1205 @c is (a > 0);
1206 @c ===end===
1207 @example
1208 (%i1) assume (a > b);
1209 (%o1) [a > b]
1210 (%i2) prederror: true$
1211 (%i3) is (a > 0);
1212 Maxima was unable to evaluate the predicate:
1213 a > 0
1214 -- an error. Quitting. To debug this try debugmode(true);
1215 (%i4) prederror: false$
1216 (%i5) is (a > 0);
1217 (%o5) unknown
1218 @end example
1220 @end deffn
1223 @deffn {Función} killcontext (@var{contexto_1}, ..., @var{contexto_n})
1224 Elimina los contextos @var{contexto_1}, ..., @var{contexto_n}.
1226 Si alguno de estos contextos es el actual, el nuevo contexto activo será el primer subcontexto disponible del actual que no haya sido eliminado. Si el primer contexto no eliminado disponible es @code{global} entonces @code{initial} será usado en su lugar. Si el contexto @code{initial} es eliminado, se creará un nuevo contexto @code{initial} completamente vacío.
1228 La función @code{killcontext} no elimina un contexto actualmente activo si es un subcontexto del contexto actual, o si se hace uso de la función @code{activate}.
1230 La función @code{killcontext} evalúa sus argumentos y devuelve @code{done}.
1232 @end deffn
1237 @deffn {Función} maybe (@var{expr})
1238 Intenta determinar si el predicado @var{expr} se puede deducir de los hechos almacenados en la base de datos gestionada por @code{assume}.
1240 Si el predicado se reduce a @code{true} o @code{false},
1241 @code{maybe} devuelve @code{true} o @code{false}, respectivamente.
1242 En otro caso, @code{maybe} devuelve @code{unknown}.
1244 La función @code{maybe} es funcionalmente equivalente a @code{is} con @code{prederror: false},
1245 pero el resultado se calcula sin asignar valor alguno a @code{prederror}.
1247 Véanse también @code{assume}, @code{facts} y @code{is}.
1249 Ejemplos:
1251 @c ===beg===
1252 @c maybe (x > 0);
1253 @c assume (x > 1);
1254 @c maybe (x > 0);
1255 @c ===end===
1256 @example
1257 (%i1) maybe (x > 0);
1258 (%o1) unknown
1259 (%i2) assume (x > 1);
1260 (%o2) [x > 1]
1261 (%i3) maybe (x > 0);
1262 (%o3) true
1263 @end example
1265 @end deffn
1269 @deffn {Función} newcontext (@var{nombre})
1270 Crea un nuevo contexto vacío @var{nombre}, el cual tiene a @code{global} como su único subcontexto. El recién creado contexto pasa a ser el contexto actualmente activo.
1272 La función @code{newcontext} evalúa sus argumentos y devuelve @var{nombre}.
1274 @end deffn
1278 @deffn {Función} sign (@var{expr})
1279 Intenta determinar el signo de @var{expr} en base a los hechos almacenados en la base de datos. Devuelve una de las siguientes respuestas: @code{pos} (positivo), @code{neg} (negativo), @code{zero} (cero), @code{pz}
1280 (positivo o cero), @code{nz} (negativo o cero), @code{pn} (positivo o negativo),
1281 o @code{pnz} (positivo, negativo o cero, lo que significa que el signo es desconocido).
1283 @end deffn
1287 @deffn {Función} supcontext (@var{nombre}, @var{contexto})
1288 @deffnx {Función} supcontext (@var{nombre})
1289 Crea un nuevo contexto @var{nombre}, que tiene a @var{contexto} como subcontexto. El argumento
1290 @var{contexto} debe existir ya.
1292 Si no se especifica @var{context}, se tomará como tal el actual.
1294 @end deffn
1304 @node Funciones y variables para los predicados, , Funciones y variables para los hechos, Base de datos de Maxima
1305 @section Funciones y variables para los predicados
1308 @deffn {Función} charfun (@var{p})
1310 Devuelve 0 cuando el predicado @var{p} toma el valor @code{false}, y devuelve
1311 1 cuando vale @code{true}. Si el predicado toma un valor diferente de @code{true} y @code{false} (desconocido),
1312 entonces devuelve una forma nominal.
1314 Ejemplos:
1316 @c ===beg===
1317 @c charfun (x < 1);
1318 @c subst (x = -1, %);
1319 @c e : charfun ('"and" (-1 < x, x < 1))$
1320 @c [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1321 @c ===end===
1322 @example
1323 (%i1) charfun(x<1);
1324 (%o1) charfun(x<1)
1325 (%i2) subst(x=-1,%);
1326 (%o2) 1
1327 (%i3) e : charfun('"and"(-1 < x, x < 1))$
1328 (%i4) [subst(x=-1,e), subst(x=0,e), subst(x=1,e)];
1329 (%o4) [0,1,0]
1330 @end example
1332 @end deffn
1337 @deffn {Función} compare (@var{x}, @var{y})
1339 Devuelve un operador de comparación @var{op}
1340 (@code{<}, @code{<=}, @code{>}, @code{>=}, @code{=} o @code{#}) de manera que
1341 @code{is (@var{x} @var{op} @var{y})} tome el valor @code{true};
1342 cuando tanto @var{x} como @var{y} dependan de @code{%i} y
1343 @code{@var{x} # @var{y}}, devuelve @code{notcomparable};
1344 cuando no exista tal operador o Maxima sea incapaz de determinarlo, devolverá @code{unknown}.
1346 Ejemplos:
1348 @c ===beg===
1349 @c compare (1, 2);
1350 @c compare (1, x);
1351 @c compare (%i, %i);
1352 @c compare (%i, %i + 1);
1353 @c compare (1/x, 0);
1354 @c compare (x, abs(x));
1355 @c ===end===
1356 @example
1357 (%i1) compare(1,2);
1358 (%o1) <
1359 (%i2) compare(1,x);
1360 (%o2) unknown
1361 (%i3) compare(%i,%i);
1362 (%o3) =
1363 (%i4) compare(%i,%i+1);
1364 (%o4) notcomparable
1365 (%i5) compare(1/x,0);
1366 (%o5) #
1367 (%i6) compare(x,abs(x));
1368 (%o6) <=
1369 @end example
1371 La función @code{compare} no intenta determinar si los dominios reales de sus argumentos son conjuntos no vacíos; así,
1373 @c ===beg===
1374 @c compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1375 @c ===end===
1376 @example
1377 (%i1) compare(acos(x^2+1), acos(x^2+1) + 1);
1378 (%o1) <
1379 @end example
1381 Aquí, el dominio real de @code{acos (x^2 + 1)} es el conjunto vacío.
1383 @end deffn
1387 @deffn {Función} equal (@var{a}, @var{b})
1388 Representa la equivalencia, esto es, la igualdad de los valores.
1390 Por sí misma, @code{equal} no evalúa ni simplifica.
1391 La función @code{is} intenta evaluar @code{equal} a un resultado
1392 booleano. La instrucción @code{is(equal(@var{a}, @var{b}))}
1393 devuelve @code{true} (o @code{false}) si y sólo si
1394 @var{a} y @var{b} son iguales (o no iguales) para todos los posibles
1395 valores de sus variables, tal como lo determina @code{ratsimp(@var{a} - @var{b})};
1396 si @code{ratsimp} devuelve 0, las dos expresiones se consideran
1397 equivalentes. Dos expresiones pueden ser equivalentes sin
1398 ser sintácticamente iguales (es decir, idénticas).
1400 Si @code{is} no consigue reducir @code{equal} a @code{true} o @code{false},
1401 el resultado está controlado por la variable global @code{prederror}.
1402 Si @code{prederror} vale @code{true}, @code{is} emite un mensaje
1403 de error; en caso contrario, @code{is} devuelve @code{unknown}.
1405 Además de @code{is}, otros operadores evalúan @code{equal} y @code{notequal}
1406 a @code{true} o @code{false}; a saber, @code{if}, @code{and}, @code{or} y @code{not}.
1408 La negación de @code{equal} es @code{notequal}.
1410 Ejemplos:
1412 Por sí misma, @code{equal} no evalúa ni simplifica.
1414 @c ===beg===
1415 @c equal (x^2 - 1, (x + 1) * (x - 1));
1416 @c equal (x, x + 1);
1417 @c equal (x, y);
1418 @c ===end===
1419 @example
1420 (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
1421 2
1422 (%o1) equal(x - 1, (x - 1) (x + 1))
1423 (%i2) equal (x, x + 1);
1424 (%o2) equal(x, x + 1)
1425 (%i3) equal (x, y);
1426 (%o3) equal(x, y)
1427 @end example
1429 La función @code{is} intenta evaluar @code{equal} a un resultado
1430 booleano. La instrucción @code{is(equal(@var{a}, @var{b}))}
1431 devuelve @code{true} si @code{ratsimp(@var{a} - @var{b})}
1432 devuelve 0. Dos expresiones pueden ser equivalentes sin
1433 ser sintácticamente iguales (es decir, idénticas).
1435 @c ===beg===
1436 @c ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1437 @c is (equal (x^2 - 1, (x + 1) * (x - 1)));
1438 @c is (x^2 - 1 = (x + 1) * (x - 1));
1439 @c ratsimp (x - (x + 1));
1440 @c is (equal (x, x + 1));
1441 @c is (x = x + 1);
1442 @c ratsimp (x - y);
1443 @c is (equal (x, y));
1444 @c is (x = y);
1445 @c ===end===
1446 @example
1447 (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1448 (%o1) 0
1449 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
1450 (%o2) true
1451 (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
1452 (%o3) false
1453 (%i4) ratsimp (x - (x + 1));
1454 (%o4) - 1
1455 (%i5) is (equal (x, x + 1));
1456 (%o5) false
1457 (%i6) is (x = x + 1);
1458 (%o6) false
1459 (%i7) ratsimp (x - y);
1460 (%o7) x - y
1461 (%i8) is (equal (x, y));
1462 (%o8) unknown
1463 (%i9) is (x = y);
1464 (%o9) false
1465 @end example
1467 Si @code{is} no consigue reducir @code{equal} a @code{true} o @code{false},
1468 el resultado está controlado por la variable global @code{prederror}.
1470 @c ===beg===
1471 @c [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1472 @c ratsimp (aa - bb);
1473 @c prederror : true;
1474 @c is (equal (aa, bb));
1475 @c prederror : false;
1476 @c is (equal (aa, bb));
1477 @c ===end===
1478 @example
1479 (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1480 2 2
1481 (%o1) [x + 2 x + 1, x - 2 x - 1]
1482 (%i2) ratsimp (aa - bb);
1483 (%o2) 4 x + 2
1484 (%i3) prederror : true;
1485 (%o3) true
1486 (%i4) is (equal (aa, bb));
1487 Maxima was unable to evaluate the predicate:
1488 2 2
1489 equal(x + 2 x + 1, x - 2 x - 1)
1490 -- an error. Quitting. To debug this try debugmode(true);
1491 (%i5) prederror : false;
1492 (%o5) false
1493 (%i6) is (equal (aa, bb));
1494 (%o6) unknown
1495 @end example
1497 Otros operadores evalúan @code{equal} y @code{notequal}
1498 a @code{true} o @code{false}.
1500 @c ===beg===
1501 @c if equal (y, y - 1) then FOO else BAR;
1502 @c eq_1 : equal (x, x + 1);
1503 @c eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1504 @c [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1505 @c ===end===
1506 @example
1507 (%i1) if equal (y, y - 1) then FOO else BAR;
1508 (%o1) BAR
1509 (%i2) eq_1 : equal (x, x + 1);
1510 (%o2) equal(x, x + 1)
1511 (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1512 2 2
1513 (%o3) equal(y + 2 y + 1, (y + 1) )
1514 (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1515 (%o4) [false, true, true]
1516 @end example
1518 Debido a que @code{not @var{expr}}
1519 obliga a la evaluación previa de @var{expr},
1520 @code{not equal(@var{a}, @var{b})} equivale a @code{is(notequal(@var{a}, @var{b}))}.
1522 @c ===beg===
1523 @c [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1524 @c is (notequal (2*z, 2*z - 1));
1525 @c ===end===
1526 @example
1527 (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1528 (%o1) [notequal(2 z, 2 z - 1), true]
1529 (%i2) is (notequal (2*z, 2*z - 1));
1530 (%o2) true
1531 @end example
1532 @end deffn
1537 @deffn {Función} notequal (@var{a}, @var{b})
1538 Representa la negación de @code{equal (@var{a}, @var{b})}.
1540 Ejemplos:
1542 @c ===beg===
1543 @c equal (a, b);
1544 @c maybe (equal (a, b));
1545 @c notequal (a, b);
1546 @c not equal (a, b);
1547 @c maybe (notequal (a, b));
1548 @c assume (a > b);
1549 @c equal (a, b);
1550 @c maybe (equal (a, b));
1551 @c notequal (a, b);
1552 @c maybe (notequal (a, b));
1553 @c ===end===
1554 @example
1555 (%i1) equal (a, b);
1556 (%o1) equal(a, b)
1557 (%i2) maybe (equal (a, b));
1558 (%o2) unknown
1559 (%i3) notequal (a, b);
1560 (%o3) notequal(a, b)
1561 (%i4) not equal (a, b);
1562 (%o4) notequal(a, b)
1563 (%i5) maybe (notequal (a, b));
1564 (%o5) unknown
1565 (%i6) assume (a > b);
1566 (%o6) [a > b]
1567 (%i7) equal (a, b);
1568 (%o7) equal(a, b)
1569 (%i8) maybe (equal (a, b));
1570 (%o8) false
1571 (%i9) notequal (a, b);
1572 (%o9) notequal(a, b)
1573 (%i10) maybe (notequal (a, b));
1574 (%o10) true
1575 @end example
1577 @end deffn
1581 @deffn {Función} unknown (@var{expr})
1582 Devuelve @code{true} si y sólo si @var{expr} contiene un operador o función no reconocido por el simplificador de Maxima.
1584 @end deffn
1588 @deffn {Función} zeroequiv (@var{expr}, @var{v})
1589 Analiza si la expresión @var{expr} de variable @var{v} equivale a cero, devolviendo @code{true}, @code{false} o
1590 @code{dontknow}.
1592 La función @code{zeroequiv} tiene estas restricciones:
1593 @enumerate
1594 @item
1595 No utilizar funciones que Maxima no sepa derivar y evaluar.
1596 @item
1597 Si la expresión tiene polos en la recta real, pueden aparecer errores en el resultado, aunque es poco probable.
1598 @item
1599 Si la expresión contiene funciones que no son soluciones de ecuaciones diferenciales ordinarias de primer orden (como las funciones de Bessel) pueden presentarse resultados incorrectos.
1600 @item
1601 El algoritmo utiliza evaluaciones en puntos aleatoriamente seleccionados. Esto conlleva un riesgo,aunque el algoritmo intenta minimizar el error.
1602 @end enumerate
1604 Por ejemplo, @code{zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)} devuelve
1605 @code{true} y @code{zeroequiv (%e^x + x, x)} devuelve @code{false}.
1606 Por otro lado @code{zeroequiv (log(a*b) - log(a) - log(b), a)} devuelve @code{dontknow} debido a la presencia del parámetro @code{b}.
1608 @end deffn