Manual de Maxima 5.46.0: Operadores aritméticos

Siguiente: Operadores relacionales, Previous: Introducción a los operadores, Subir: Operadores [Índice general][Índice]

### 6.2 Operadores aritméticos

Operador: +
Operador: -
Operador: *
Operador: /
Operador: ^

  Los símbolos `+` `*` `/` y `^` representan la suma, resta, multiplicación, división y exponenciación, respectivamente. Los nombres de estos operadores son `"+"` `"*"` `"/"` y `"^"`, que pueden aparecer allá donde se requiera el nombre de una función u operador.

  Los símbolos `+` y `-` representan el positivo y negativo unario, siendo los nombres de estos operadores `"+"` y `"-"`, respectivamente.

  En Maxima, la resta `a - b` se representa como la suma `a + (- b)`. Expresiones tales como `a + (- b)` se muestran como restas. Maxima reconoce `"-"` tan solo como el operador de negación unaria, no como el nombre del operador de resta binaria.

  La división `a / b` se representa en maxima como la multiplicación `a * b^(- 1)`. Expresiones tales como `a * b^(- 1)` se muestran como divisiones. Maxima reconoce `"/"` como el nombre del operador de división.

  La suma y la multiplicación son operadores conmutativos n-arios. La división y la exponenciación son operadores no conmutativos binarios.

  Maxima ordena los operandos de los operadores conmutativos para formar lo que se conoce como representación canónica. A efectos de almacenamiento interno, la ordenación viene determinada por `orderlessp`. A efectos de presentación de las expresiones, la ordenación de la suma la determina `ordergreatp`, y en el caso de la multiplicación, la ordenación coincide con la del almacenamiento interno.

  Los cálculos aritméticos se realizan con números literales (enteros, racionales, decimales ordinarios y decimales grandes). Excepto en el caso de la exponenciación, todas las operaciones aritméticas con números dan lugar a resultados en forma de números. La exponenciación da como resultado un número si alguno de los operandos es decimal ordinario o grande (bigfloat), o si el resultado es un entero o racional; en caso contrario, la exponenciación puede expresarse como una raíz cuadrada (`sqrt`), como otra potencia, o simplemente no sufre cambios.

  Se produce contagio de los decimales en coma flotante en los cálculos aritméticos: si algún operando es un número decimal grande (bigfloat), el resultado será también un número decimal grande; no habiendo decimales grandes, pero sí ordinarios, el resultado srá también un decimal ordinario; de no haber operandos decimales, el resultado será un número racional o entero.

  Los cálculos aritméticos son simplificaciones, no evaluaciones, por lo que se realizan en expresiones comentadas.

  Las operaciones aritméticas se aplican elemento a elemento en el caso de las listas cuando la variable global `listarith` vale `true`; pero en el caso de las matrices, siempre se aplican elemento a elemento. Cuando un operando es una lista o matriz y otro operando lo es de otro tipo cualquiera, éste se combina con cada uno de los elementos de la lista o matriz.

  Ejemplos:

  La suma y la multiplicación son operadores conmutativos n-arios. Maxima ordena los operandos para formar lo que se conoce como representación canónica. Los nombres de estos operadores son `"+"` y `"-"`.

      (%i1) c + g + d + a + b + e + f;
      (%o1)               g + f + e + d + c + b + a
      (%i2) [op (%), args (%)];
      (%o2)              [+, [g, f, e, d, c, b, a]]
      (%i3) c * g * d * a * b * e * f;
      (%o3)                     a b c d e f g
      (%i4) [op (%), args (%)];
      (%o4)              [*, [a, b, c, d, e, f, g]]
      (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
      (%o5)                    3 x + 2 a + 19
      (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
                                       2  3
      (%o6)                       144 a  x

  La división y la exponenciación son operadores no conmutativos binarios. Los nombres de estos operadores son `"/"` y `"^"`.

      (%i1) [a / b, a ^ b];
                                    a   b
      (%o1)                        [-, a ]
                                    b
      (%i2) [map (op, %), map (args, %)];
      (%o2)              [[/, ^], [[a, b], [a, b]]]
      (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
                                    a   b
      (%o3)                        [-, a ]
                                    b

  La resta y la división se representan internamente en términos de la suma y multiplicación, respectivamente.

      (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
      (%o1)                      [+, a, - b]
      (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
                                         1
      (%o2)                       [*, a, -]
                                         b

  Los cálculos se realizan con números literales. Se produce el contagio de los números decimales.

      (%i1) 17 + b - (1/2)*29 + 11^(2/4);
                                             5
      (%o1)                   b + sqrt(11) + -
                                             2
      (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
      (%o2)                   [46, 46.0, 4.6b1]

  Los cálculos aritméticos son una simplificación, no una evaluación.

      (%i1) simp : false;
      (%o1)                         false
      (%i2) '(17 + 29*11/7 - 5^3);
                                    29 11    3
      (%o2)                    17 + ----- - 5
                                      7
      (%i3) simp : true;
      (%o3)                         true
      (%i4) '(17 + 29*11/7 - 5^3);
                                      437
      (%o4)                         - ---
                                       7

  Los cálculos aritméticos se realizan elemento a elemento en las listas (según sea el valor de `listarith`) y matrices.

      (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
                              [ a - 1  x - 2 ]
      (%o1)                   [              ]
                              [ h - 3  u - 4 ]
      (%i2) 5 * matrix ([a, x], [h, u]);
                                [ 5 a  5 x ]
      (%o2)                     [          ]
                                [ 5 h  5 u ]
      (%i3) listarith : false;
      (%o3)                         false
      (%i4) [a, c, m, t] / [1, 7, 2, 9];
                                [a, c, m, t]
      (%o4)                     ------------
                                [1, 7, 2, 9]
      (%i5) [a, c, m, t] ^ x;
                                            x
      (%o5)                     [a, c, m, t]
      (%i6) listarith : true;
      (%o6)                         true
      (%i7) [a, c, m, t] / [1, 7, 2, 9];
                                    c  m  t
      (%o7)                     [a, -, -, -]
                                    7  2  9
      (%i8) [a, c, m, t] ^ x;
                                x   x   x   x
      (%o8)                   [a , c , m , t ]

Operador: **

  Operador de exponenciación. Maxima identifica `**` con el operador `^` en la entrada de expresiones, pero se representa como `^` en las salidas no formateadas (`display2d=false`), o colocando un superíndice en la salida formateada (`display2d=true`).

  La función `fortran` representa el operador de exponenciación con `**`, tanto si se ha introducido como `**` o como `^`.

  Ejemplos:

      (%i1) is (a**b = a^b);
      (%o1)                         true
      (%i2) x**y + x^z;
                                    z    y
      (%o2)                        x  + x
      (%i3) string (x**y + x^z);
      (%o3)                        x^z+x^y
      (%i4) fortran (x**y + x^z);
            x**z+x**y
      (%o4)                         done

Operator: ^^

  Operador de exponenciación no conmutativa. Se trata del operador de exponenciación correspondiente a la multiplicación no conmutativa `.`, del mismo modo que el operador de exponenciación ordinario `^` se corresponde con la multiplicación conmutativa `*`.

  La exponenciación no conmutativa se representa como `^^` en las salidas no formateadas (`display2d=false`), o colocando un superíndice entre ángulos (`< >`) en la salida formateada (`display2d=true`).

  Ejemplos:

      (%i1) a . a . b . b . b + a * a * a * b * b;
                              3  2    <2>    <3>
      (%o1)                  a  b  + a    . b
      (%i2) string (a . a . b . b . b + a * a * a * b * b);
      (%o2)                  a^3*b^2+a^^2 . b^^3

Operador: .

  El operador punto, para multiplicación de matrices (no-conmutativo). Cuando `"."` se usa de esta forma, se dejarán espacios a ambos lados de éste, como en `A . B`. Así se evita que se confunda con el punto decimal de los números.

  Véanse: `dot`, `dot0nscsimp`, `dot0simp`, `dot1simp`, `dotassoc`, `dotconstrules`, `dotdistrib`, `dotexptsimp`, `dotident` y `dotscrules`.

Siguiente: Operadores relacionales, Previous: Introducción a los operadores, Subir: Operadores [Índice general][Índice]