Operadores para ecuaciones (Manual de Maxima 5.44.0)

Siguiente: Operadores de asignación, Anterior: Operadores lógicos, Subir: Operadores [Índice general][Índice]

### 6.5 Operadores para ecuaciones

Operador: #

  Representa la negación de la igualdad sintáctica `=`.

  Nótese que debido a las reglas de evaluación de expresiones de tipo predicado (en concreto debido a que `not expr` obliga a la evaluación previa de expr), `not a = b` equivale a `is(a # b)`, pero no a `a # b`.

  Ejemplos:

      (%i1) a = b;
      (%o1)                         a = b
      (%i2) is (a = b);
      (%o2)                         false
      (%i3) a # b;
      (%o3)                         a # b
      (%i4) not a = b;
      (%o4)                         true
      (%i5) is (a # b);
      (%o5)                         true
      (%i6) is (not a = b);
      (%o6)                         true

Operador: =

  Operador de ecuación.

  La expresión `a = b` representa una ecuación sin evaluar, la cual puede verificarse o no. Las ecuaciones sin evaluar pueden aparecer como argumentos de `solve`, `algsys` y de algunas otras funciones.

  La función `is` evalúa el operador `=` a un resultado booleano; `is(a = b)` asigna un valor de verdad a `a = b`, siendo `true` si a y b son idénticos, lo cual acontece si ambos a y b son átomos idénticos, o si no siendo átomos, sus operadores y argumentos respectivos son idénticos; en caso contrario, `is(a = b)` devuelve el valor `false`. Nunca se devuelve el valor `unknown`. Cuando `is(a = b)` toma el valor `true`, se dice que a y b son sintácticamente iguales, no expresiones equivalentes, para las cuales `is(equal(a, b))` devuelve `true`. Las expresiones pueden ser equivalentes, pero no sintácticamente iguales.

  La negación de `=` se representa por `#`. Como en el caso de `=`, la expresión `a # b` no está evaluada; sin embargo, `is(a # b)` evalúa `a # b` a `true` o `false`.

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

  Nótese que debido a las reglas de evaluación de expresiones de tipo predicado (en concreto debido a que `not expr` obliga a la evaluación previa de expr), `not a = b` equivale a `is(a # b)`, pero no a `a # b`.

  Las funciones `rhs` y `lhs` devuelven los miembros derecho e izquierdo, respectivamente, de una ecuación o inecuación.

  Véanse también `equal` y `notequal`.

  Ejemplos:

  La expresión `a = b` representa una ecuación sin evaluar, la cual puede verificarse o no.

      (%i1) eq_1 : a * x - 5 * y = 17;
      (%o1)                    a x - 5 y = 17
      (%i2) eq_2 : b * x + 3 * y = 29;
      (%o2)                    3 y + b x = 29
      (%i3) solve ([eq_1, eq_2], [x, y]);
                              196         29 a - 17 b
      (%o3)          [[x = ---------, y = -----------]]
                           5 b + 3 a       5 b + 3 a
      (%i4) subst (%, [eq_1, eq_2]);
               196 a     5 (29 a - 17 b)
      (%o4) [--------- - --------------- = 17,
             5 b + 3 a      5 b + 3 a
                                        196 b     3 (29 a - 17 b)
                                      --------- + --------------- = 29]
                                      5 b + 3 a      5 b + 3 a
      (%i5) ratsimp (%);
      (%o5)                  [17 = 17, 29 = 29]

  `is(a = b)` evalúa `a = b` a `true` si a y b son sintácticamente iguales (es decir, idénticas). Las expresiones pueden ser equivalentes, pero no sintácticamente iguales.

      (%i1) a : (x + 1) * (x - 1);
      (%o1)                    (x - 1) (x + 1)
      (%i2) b : x^2 - 1;
                                    2
      (%o2)                        x  - 1
      (%i3) [is (a = b), is (a # b)];
      (%o3)                     [false, true]
      (%i4) [is (equal (a, b)), is (notequal (a, b))];
      (%o4)                     [true, false]

  Algunos operadores evalúan `=` y `#` a `true` o `false`.

      (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2
              then FOO else BAR;
      (%o1)                          FOO
      (%i2) eq_3 : 2 * x = 3 * x;
      (%o2)                       2 x = 3 x
      (%i3) eq_4 : exp (2) = %e^2;
                                    2     2
      (%o3)                       %e  = %e
      (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
      (%o4)                  [false, true, true]

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

      (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
      (%o1)                   [2 x # 3 x, true]
      (%i2) is (2 * x # 3 * x);
      (%o2)                         true

Siguiente: Operadores de asignación, Anterior: Operadores lógicos, Subir: Operadores [Índice general][Índice]