doc/info/es/Database.es.texi

   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
   8
   9
  10
  11
  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
  14
  15 @subheading Propiedades
  16
  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.
  26
  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}.
  30
  31 Las variables pueden tener las siguientes propiedades a almacenar en el banco de
  32 datos:
  33
  34 @verbatim
  35    constant
  36    integer        noninteger
  37    even           odd
  38    rational       irrational
  39    real           imaginary      complex
  40 @end verbatim
  41
  42 Las funciones pueden tener las siguientes propiedades a almacenar en el banco de
  43 datos:
  44
  45 @verbatim
  46    increasing     decreasing
  47    posfun         integervalued
  48 @end verbatim
  49
  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:
  53
  54 @verbatim
  55    linear         additive       multiplicative
  56    outative       commutative    symmetric
  57    antisymmetric  nary           lassociativ
  58    rassociative   evenfun        oddfun
  59 @end verbatim
  60
  61 Otras propiedades aplicables a variables y funciones, y que se almacenan
  62 en la lista de propiedades de Lisp, son:
  63
  64 @verbatim
  65    bindtest       feature        alphabetic
  66    scalar         nonscalar      nonarray
  67 @end verbatim
  68
  69 @subheading Contextos
  70
  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.
  79
  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}.
  88
  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.
  93
  94
  95
  96
  97
  98
  99
 100
 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
 103
 104 @defvr {Propiedad} alphabetic
 105
 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.
 109
 110 Véase también @code{Identifiers}.
 111
 112 Ejemplo:
 113
 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
 131
 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.
 135
 136 Ejemplo:
 137
 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
 159
 160
 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.
 165
 166 Véanse @code{constantp} y @code{declare}
 167
 168 Ejemplo:
 169
 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
 181
 182
 183
 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.
 187
 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.
 193
 194 La función @code{constantp} evalúa sus argumentos.
 195
 196 Ejemplos:
 197
 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===
 207
 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
 226
 227
 228
 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.
 233
 234 La función @code{declare} no evalúa sus argumentos y siempre devuelve la
 235 expresión @code{done}.
 236
 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}.
 240
 241 Véase también @code{features}.
 242
 243 La función @code{declare} reconoce las siguientes propiedades:
 244
 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.
 252
 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.
 256
 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}.
 260
 261 @item bindtest
 262       Hace que Maxima envíe un error si @var{a_i} es evaluado sin habérsele
 263       asignado un valor.
 264
 265 @item constant
 266       Hace que Maxima considere a @var{a_i} como una constante
 267       simbólica.
 268
 269 @item even, odd
 270       Hace que Maxima reconozca a @var{a_i} como una variable entera par o impar.
 271
 272 @item evenfun, oddfun
 273       Hace que Maxima reconozca a @var{a_i} como una función par o impar.
 274
 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}.
 279
 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}.
 284
 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}.
 289
 290 @item increasing, decreasing
 291       Hace que Maxima reconozca a @var{a_i} como una función creciente o decreciente.
 292
 293 @item integer, noninteger
 294       Hace que Maxima reconozca a @var{a_i} como una variable entera o no entera.
 295
 296 @item integervalued
 297       Hace que Maxima reconozca a @var{a_i} como una función de valor entero.
 298
 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.
 302
 303 @item linear
 304       Equivale a declarar @var{a_i} conjuntamente como @code{outative} y @code{additive}.
 305
 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}.
 311
 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.
 317
 318 @item nary
 319       Hace que Maxima reconozca a @var{a_i} como una función n-aria.
 320
 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)}.
 325
 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.
 329
 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.
 334
 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.
 340
 341 @item outative
 342       Hace que Maxima simplifique las expresiones @var{a_i}
 343       extrayendo los factores constantes del primer argumento.
 344
 345       Cuando @var{a_i} tenga un único argumento, un factor se considerará constante
 346       si es una constante literal o declarada.
 347
 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.
 351
 352 @item posfun
 353       Hace que Maxima reconozca a @var{a_i} como una función positiva.
 354
 355 @item rational, irrational
 356       Hace que Maxima reconozca a @var{a_i} como una variable real racional o irracional.
 357
 358 @item real, imaginary, complex
 359       Hace que Maxima reconozca a @var{a_i} como una variable real, imaginaria o compleja.
 360
 361 @item scalar
 362       Hace que Maxima considere a @var{a_i} como una variable escalar.
 363
 364 @end table
 365
 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
 369
 370
 371
 372 @defvr  {Propiedad} decreasing
 373 @defvrx {Propiedad} increasing
 374
 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.
 378
 379 Véase también @code{declare} para más propiedades.
 380
 381 Ejemplo:
 382
 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
 394
 395
 396 @defvr  {Propiedad} even
 397 @defvrx {Propiedad} odd
 398
 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}.
 403
 404 Véanse también @code{declare} y @code{askinteger}.
 405
 406 Ejemplo:
 407
 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
 419
 420
 421
 422 @defvr {Propiedad} feature
 423
 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.
 428
 429 @code{feature} no es el nombre de ninguna función o variable.
 430 @end defvr
 431
 432
 433 @deffn {Función} featurep (@var{a}, @var{f})
 434
 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.
 438
 439 Nótese que @code{featurep} devuelve @code{false} cuando no se puedan verificar ni
 440 @var{f} ni su negación.
 441
 442 @code{featurep} evalúa su argumento.
 443
 444 Véanse también @code{declare} y @code{features}.
 445
 446 Ejemplos:
 447
 448 @example
 449 (%i1) declare (j, even)$
 450 (%i2) featurep (j, integer);
 451 (%o2)                           true
 452 @end example
 453 @end deffn
 454
 455
 456
 457 @defvr {Declaración} features
 458 Maxima reconoce ciertas propiedades matemáticas sobre funciones y variables.
 459
 460 La llamada @code{declare (@var{x}, @var{foo})} asocia la propiedad @var{foo} a la función o variable @var{x}.
 461
 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}.
 465
 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.
 468
 469 La lista @code{features} contiene las propiedades que reconoce Maxima; a saber,
 470
 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
 480
 481 junto con las definidas por el usuario.
 482
 483 La lista @code{features} sólo contiene propiedades matemáticas.
 484 Hay otra lista con propiedades no matemáticas; Véase @code{status}.
 485
 486 Ejemplo:
 487
 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
 502
 503
 504
 505 @deffn {Función} get (@var{a}, @var{i})
 506
 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}.
 509
 510 La función @code{get} evalúa sus argumentos.
 511
 512 Véanse también @code{put} y @code{qput}.
 513
 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
 549
 550
 551 @defvr  {Propiedad} integer
 552 @defvrx {Propiedad} noninteger
 553
 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.
 556
 557 Véase también @code{declare}.
 558
 559 Ejemplo:
 560
 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
 570
 571
 572
 573 @defvr {Propiedad} integervalued
 574
 575 @code{declare(@var{f}, integervalued)} indica a MAxima que reconozca @var{f} como
 576 una función que toma valores enteros.
 577
 578 Véase también @code{declare}.
 579
 580 Ejemplo:
 581
 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
 593
 594
 595
 596 @deffn {Propiedad} nonarray
 597
 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.
 601
 602 Véase también @code{declare}.
 603
 604 Ejemplo:
 605
 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$
 614
 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
 625
 626
 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.
 630
 631 Véase también @code{declare}.
 632 @end defvr
 633
 634
 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
 639
 640
 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}.
 645
 646 Véase también @code{declare}.
 647 @end defvr
 648
 649
 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}.
 659
 660 @end deffn
 661
 662
 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
 667
 668
 669 @defvr {Variable del sistema} props
 670 Valor por defecto: @code{[]}
 671
 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
 677
 678
 679
 680 @deffn {Función} propvars (@var{prop})
 681
 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
 687
 688
 689 @deffn {Función} put (@var{átomo}, @var{valor}, @var{indicador})
 690
 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.
 693
 694 @code{rem} deshace la asignación realizada por @code{put}.
 695
 696 La función @code{put} evalúa sus argumentos y devuelve @var{valor}.
 697
 698 Ejemplos:
 699
 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
 714
 715 @end deffn
 716
 717
 718
 719 @deffn {Función} qput (@var{átomo}, @var{valor}, @var{indicador})
 720
 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.
 723
 724 Véase también @code{get}.
 725
 726 Ejemplo:
 727
 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
 746
 747
 748
 749
 750 @defvr  {Propiedad} rational
 751 @defvrx {Propiedad} irrational
 752
 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.
 755
 756 Véase también @code{declare}.
 757 @end defvr
 758
 759
 760
 761 @defvr  {Propiedad} real
 762 @defvrx {Propiedad} imaginary
 763 @defvrx {Propiedad} complex
 764
 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.
 768
 769 Véase también @code{declare}.
 770 @end defvr
 771
 772
 773
 774 @deffn {Función} rem (@var{átomo}, @var{indicador})
 775
 776 Elimina del @var{átomo} la propiedad indicada por @var{indicador}.
 777 @code{rem} deshace la asignación realizada por @code{put}.
 778
 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.
 782
 783 @end deffn
 784
 785
 786
 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})
 792
 793 Elimina propiedades asociadas con átomos.
 794
 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}.
 797
 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.
 800
 801 La llamada @code{remove (all, @var{p})} elimina la propiedad @var{p} de todos los átomos que la tengan.
 802
 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}.
 806
 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.
 808
 809 La función @code{remove} devuelve siempre @code{done} independientemente que haya algún átomo con la propiedad especificada.
 810
 811 La función @code{remove} no evalúa sus argumentos.
 812 @end deffn
 813
 814
 815 @defvr {Propiedad} scalar
 816
 817 @code{declare(@var{a}, scalar)} indica a Maxima que considere a @var{a} como
 818 una variable escalar.
 819
 820 Véase también @code{declare}.
 821 @end defvr
 822
 823
 824
 825 @deffn {Función} scalarp (@var{expr})
 826
 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
 831
 832
 833
 834
 835
 836
 837
 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
 840
 841
 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 ()}.
 846
 847 La variable @code{activecontexts} es la lista de contextos que se han activado por medio de la función @code{activate}.
 848
 849 @end deffn
 850
 851
 852
 853
 854 @defvr {Variable del sistema} activecontexts
 855 Valor por defecto: @code{[]}
 856
 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.
 858
 859 @end defvr
 860
 861
 862
 863
 864
 865
 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)
 870
 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)}.
 875
 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.
 877
 878 @end deffn
 879
 880
 881
 882
 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}.
 885
 886 @end deffn
 887
 888
 889
 890
 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}.
 896
 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.
 900
 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}.
 906
 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.
 913
 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.
 917
 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}.
 921
 922 La función @code{assume} evalúa sus argumentos.
 923
 924 Véanse también @code{is}, @code{facts}, @code{forget}, @code{context} y @code{declare}.
 925
 926 Ejemplos:
 927
 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===
 940
 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
 963
 964 @end deffn
 965
 966
 967
 968
 969 @defvr {Variable opcional} assumescalar
 970 Valor por defecto: @code{true}
 971
 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.
 973
 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}.
 975
 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{.}.
 977
 978 Si @code{assumescalar} vale @code{false}, la expresión se comportará como un no escalar.
 979
 980 Si @code{assumescalar} vale @code{all}, la expresión se comportará como un escalar para todas las operaciones.
 981
 982 @end defvr
 983
 984 @defvr {Variable opcional} assume_pos
 985 Valor por defecto: @code{false}
 986
 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.
 988
 989 By default, a parameter is @var{x} such that @code{symbolp (@var{x})}
 990 or @code{subvarp (@var{x})}.
 991
 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}.
 994
 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.
 996
 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.
 998
 999 @c NEED EXAMPLES HERE
1000 @end defvr
1001
1002
1003
1004 @defvr {Variable opcional} assume_pos_pred
1005 Valor por defecto: @code{false}
1006
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}.
1009
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}.
1011
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}.
1013
1014 Véanse también @code{assume} y @code{assume_pos}.
1015
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);
1029
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
1040
1041 (%o6)                          pos
1042 (%i7) asksign (a[1]);
1043                              x = a
1044                                   1
1045
1046 (%o7)                          pos
1047 (%i8) asksign (foo (a));
1048                            x = foo(a)
1049
1050 (%o8)                          pos
1051 (%i9) asksign (foo (a) + bar (b));
1052                            x = foo(a)
1053
1054                            x = bar(b)
1055
1056 (%o9)                          pos
1057 (%i10) asksign (log (a));
1058                               x = a
1059
1060 Is  a - 1  positive, negative, or zero?
1061
1062 p;
1063 (%o10)                         pos
1064 (%i11) asksign (a - b);
1065                               x = a
1066
1067                               x = b
1068
1069                               x = a
1070
1071                               x = b
1072
1073 Is  b - a  positive, negative, or zero?
1074
1075 p;
1076 (%o11)                         neg
1077 @end example
1078
1079 @end defvr
1080
1081
1082
1083 @defvr {Variable opcional} context
1084 Valor por defecto: @code{initial}
1085
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}.
1088
1089 Véase @code{contexts} para una descripción general del mecanismo que siguen los contextos.
1090
1091 @end defvr
1092
1093 @defvr {Variable opcional} contexts
1094 Valor por defecto: @code{[initial, global]}
1095
1096 La variable @code{contexts} es una lista que contiene los contextos existentes, incluyendo el actualmente activo.
1097
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.
1099
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.
1101
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.
1103
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}.
1105
1106 Véanse también @code{facts}, @code{newcontext}, @code{supcontext}, @code{killcontext}, @code{activate}, @code{deactivate}, @code{assume} y @code{forget}.
1107
1108 @end defvr
1109
1110
1111
1112 @deffn {Función} deactivate (@var{contexto_1}, ..., @var{contexto_n})
1113 Desactiva los contextos especificados @var{contexto_1}, ..., @var{contexto_n}.
1114
1115 @end deffn
1116
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.
1122
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.
1125
1126 La llamada @code{facts ()}, sin argumentos, muestra el contexto actual.
1127
1128 @end deffn
1129
1130
1131
1132
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}.
1136
1137 La llamada @code{forget (@var{L})}, siendo @var{L} una lista de predicados, borra todos los predicados contenidos en ella.
1138
1139 @end deffn
1140
1141
1142
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}.
1145
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}.
1151
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})}.
1155
1156 Véanse también @code{assume}, @code{facts} y @code{maybe}.
1157
1158 Ejemplos:
1159
1160 @code{is} evalúa los predicados,
1161
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
1172
1173 @code{is} intenta evaluar predicados a partir
1174 del conocimiento almacenado en la base de datos de @code{assume}.
1175
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
1195
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}.
1199
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
1219
1220 @end deffn
1221
1222
1223 @deffn {Función} killcontext (@var{contexto_1}, ..., @var{contexto_n})
1224 Elimina los contextos @var{contexto_1}, ..., @var{contexto_n}.
1225
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.
1227
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}.
1229
1230 La función @code{killcontext} evalúa sus argumentos y devuelve @code{done}.
1231
1232 @end deffn
1233
1234
1235
1236
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}.
1239
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}.
1243
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}.
1246
1247 Véanse también @code{assume}, @code{facts} y @code{is}.
1248
1249 Ejemplos:
1250
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
1264
1265 @end deffn
1266
1267
1268
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.
1271
1272 La función @code{newcontext} evalúa sus argumentos y devuelve @var{nombre}.
1273
1274 @end deffn
1275
1276
1277
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).
1282
1283 @end deffn
1284
1285
1286
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.
1291
1292 Si no se especifica @var{context}, se tomará como tal el actual.
1293
1294 @end deffn
1295
1296
1297
1298
1299
1300
1301
1302
1303
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
1306
1307
1308 @deffn {Función} charfun (@var{p})
1309
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.
1313
1314 Ejemplos:
1315
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
1331
1332 @end deffn
1333
1334
1335
1336
1337 @deffn {Función} compare (@var{x}, @var{y})
1338
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}.
1345
1346 Ejemplos:
1347
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
1370
1371 La función @code{compare} no intenta determinar si los dominios reales de sus argumentos son conjuntos no vacíos; así,
1372
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
1380
1381 Aquí, el dominio real de @code{acos (x^2 + 1)} es el conjunto vacío.
1382
1383 @end deffn
1384
1385
1386
1387 @deffn {Función} equal (@var{a}, @var{b})
1388 Representa la equivalencia, esto es, la igualdad de los valores.
1389
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).
1399
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}.
1404
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}.
1407
1408 La negación de @code{equal} es @code{notequal}.
1409
1410 Ejemplos:
1411
1412 Por sí misma, @code{equal} no evalúa ni simplifica.
1413
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
1428
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).
1434
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
1466
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}.
1469
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
1496
1497 Otros operadores evalúan @code{equal} y @code{notequal}
1498 a  @code{true} o @code{false}.
1499
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
1517
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}))}.
1521
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
1533
1534
1535
1536
1537 @deffn {Función} notequal (@var{a}, @var{b})
1538 Representa la negación de @code{equal (@var{a}, @var{b})}.
1539
1540 Ejemplos:
1541
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
1576
1577 @end deffn
1578
1579
1580
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.
1583
1584 @end deffn
1585
1586
1587
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}.
1591
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
1603
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}.
1607
1608 @end deffn
1609
1610
1611