Funciones y variables para los predicados (Manual de Maxima 5.45.0)

Anterior: Funciones y variables para los hechos, Subir: Base de datos de Maxima [Índice general][Índice]

### 11.4 Funciones y variables para los predicados

Función: charfun (p)

  Devuelve 0 cuando el predicado p toma el valor `false`, y devuelve 1 cuando vale `true`. Si el predicado toma un valor diferente de `true` y `false` (desconocido), entonces devuelve una forma nominal.

  Ejemplos:

      (%i1) charfun(x<1);
      (%o1) charfun(x<1)
      (%i2) subst(x=-1,%);
      (%o2) 1
      (%i3) e : charfun('"and"(-1 < x, x < 1))$
      (%i4) [subst(x=-1,e), subst(x=0,e), subst(x=1,e)];
      (%o4) [0,1,0]

Función: compare (x, y)

  Devuelve un operador de comparación op (`<`, `<=`, `>`, `>=`, `=` o `#`) de manera que `is (x op y)` tome el valor `true`; cuando tanto x como y dependan de `%i` y `x # y`, devuelve `notcomparable`; cuando no exista tal operador o Maxima sea incapaz de determinarlo, devolverá `unknown`.

  Ejemplos:

      (%i1) compare(1,2);
      (%o1) <
      (%i2) compare(1,x);
      (%o2) unknown
      (%i3) compare(%i,%i);
      (%o3) =
      (%i4) compare(%i,%i+1);
      (%o4) notcomparable
      (%i5) compare(1/x,0);
      (%o5) #
      (%i6) compare(x,abs(x));
      (%o6) <=

  La función `compare` no intenta determinar si los dominios reales de sus argumentos son conjuntos no vacíos; así,

      (%i1) compare(acos(x^2+1), acos(x^2+1) + 1);
      (%o1) <

  Aquí, el dominio real de `acos (x^2 + 1)` es el conjunto vacío.

Función: equal (a, b)

  Representa la equivalencia, esto es, la igualdad de los valores.

  Por sí misma, `equal` no evalúa ni simplifica. La función `is` intenta evaluar `equal` a un resultado booleano. La instrucción `is(equal(a, b))` devuelve `true` (o `false`) si y sólo si a y b son iguales (o no iguales) para todos los posibles valores de sus variables, tal como lo determina `ratsimp(a - b)`; si `ratsimp` devuelve 0, las dos expresiones se consideran equivalentes. Dos expresiones pueden ser equivalentes sin ser sintácticamente iguales (es decir, idénticas).

  Si `is` no consigue reducir `equal` a `true` o `false`, el resultado está controlado por la variable global `prederror`. Si `prederror` vale `true`, `is` emite un mensaje de error; en caso contrario, `is` devuelve `unknown`.

  Además de `is`, otros operadores evalúan `equal` y `notequal` a `true` o `false`; a saber, `if`, `and`, `or` y `not`.

  La negación de `equal` es `notequal`.

  Ejemplos:

  Por sí misma, `equal` no evalúa ni simplifica.

      (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                              2
      (%o1)            equal(x  - 1, (x - 1) (x + 1))
      (%i2) equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) equal (x, y);
      (%o3)                      equal(x, y)

  La función `is` intenta evaluar `equal` a un resultado booleano. La instrucción `is(equal(a, b))` devuelve `true` si `ratsimp(a - b)` devuelve 0. Dos expresiones pueden ser equivalentes sin ser sintácticamente iguales (es decir, idénticas).

      (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
      (%o1)                           0
      (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
      (%o2)                         true
      (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
      (%o3)                         false
      (%i4) ratsimp (x - (x + 1));
      (%o4)                          - 1
      (%i5) is (equal (x, x + 1));
      (%o5)                         false
      (%i6) is (x = x + 1);
      (%o6)                         false
      (%i7) ratsimp (x - y);
      (%o7)                         x - y
      (%i8) is (equal (x, y));
      (%o8)                        unknown
      (%i9) is (x = y);
      (%o9)                         false

  Si `is` no consigue reducir `equal` a `true` o `false`, el resultado está controlado por la variable global `prederror`.

      (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                          2             2
      (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
      (%i2) ratsimp (aa - bb);
      (%o2)                        4 x + 2
      (%i3) prederror : true;
      (%o3)                         true
      (%i4) is (equal (aa, bb));
      Maxima was unable to evaluate the predicate:
             2             2
      equal(x  + 2 x + 1, x  - 2 x - 1)
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i5) prederror : false;
      (%o5)                         false
      (%i6) is (equal (aa, bb));
      (%o6)                        unknown

  Otros operadores evalúan `equal` y `notequal` a `true` o `false`.

      (%i1) if equal (y, y - 1) then FOO else BAR;
      (%o1)                          BAR
      (%i2) eq_1 : equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                               2                   2
      (%o3)             equal(y  + 2 y + 1, (y + 1) )
      (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
      (%o4)                  [false, true, true]

  Debido a que `not expr` obliga a la evaluación previa de expr, `not equal(a, b)` equivale a `is(notequal(a, b))`.

      (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
      (%o1)            [notequal(2 z, 2 z - 1), true]
      (%i2) is (notequal (2*z, 2*z - 1));
      (%o2)                         true

Función: notequal (a, b)

  Representa la negación de `equal (a, b)`.

  Ejemplos:

      (%i1) equal (a, b);
      (%o1)                      equal(a, b)
      (%i2) maybe (equal (a, b));
      (%o2)                        unknown
      (%i3) notequal (a, b);
      (%o3)                    notequal(a, b)
      (%i4) not equal (a, b);
      (%o4)                    notequal(a, b)
      (%i5) maybe (notequal (a, b));
      (%o5)                        unknown
      (%i6) assume (a > b);
      (%o6)                        [a > b]
      (%i7) equal (a, b);
      (%o7)                      equal(a, b)
      (%i8) maybe (equal (a, b));
      (%o8)                         false
      (%i9) notequal (a, b);
      (%o9)                    notequal(a, b)
      (%i10) maybe (notequal (a, b));
      (%o10)                        true

Función: unknown (expr)

  Devuelve `true` si y sólo si expr contiene un operador o función no reconocido por el simplificador de Maxima.

Función: zeroequiv (expr, v)

  Analiza si la expresión expr de variable v equivale a cero, devolviendo `true`, `false` o `dontknow`.

  La función `zeroequiv` tiene estas restricciones:

  1. No utilizar funciones que Maxima no sepa derivar y evaluar.
  2. Si la expresión tiene polos en la recta real, pueden aparecer errores en el resultado, aunque es poco probable.
  3. 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.
  4. El algoritmo utiliza evaluaciones en puntos aleatoriamente seleccionados. Esto conlleva un riesgo,aunque el algoritmo intenta minimizar el error.

  Por ejemplo, `zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)` devuelve `true` y `zeroequiv (%e^x + x, x)` devuelve `false`. Por otro lado `zeroequiv (log(a*b) - log(a) - log(b), a)` devuelve `dontknow` debido a la presencia del parámetro `b`.

Anterior: Funciones y variables para los hechos, Subir: Base de datos de Maxima [Índice general][Índice]