Operadores Aritméticos (Manual do Maxima 5.45.0)

Próximo: Operadores Relacionais, Anterior: Operador Préfixado, Acima: Operadores [Conteúdo][Índice]

### 5.5, Operadores Aritméticos

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

  Os símbolos `+` `*` `/` e `^` representam adição, multiplicação, divisão, e exponenciação, respectivamente. O nome desses operadores são `"+"` `"*"` `"/"` e `"^"`, os quais podem aparecer em lugares onde o nome da função ou operador é requerido.

  Os símbolos `+` e `-` representam a adição unária e a negação unária, respectivamente, e os nomes desses operadores são `"+"` e `"-"`, respectivamente.

  A subtração `a - b` é representada dentro do Maxima como a adição, `a + (- b)`. Expressões tais como `a + (- b)` são mostradas como subtração. Maxima reconhece `"-"` somente como o nome do operador unário de negação, e não como o nome do operador binário de subração.

  A divisão `a / b` é representada dentro do Maxima como multiplicação, `a * b^(- 1)`. Expressões tais como `a * b^(- 1)` são mostradas como divisão. Maxima reconhece `"/"` como o nome do operador de divisão.

  A adição e a multiplicação são operadores enários e comutativos. a divisão e a exponenciação são operadores binários e não comutativos.

  Maxima ordena os operandos de operadores não comutativos para construir uma representação canónica. Para armazenamento interno, a ordem é determinada por `orderlessp`. Para mostrar na tela, a ordem para adição é determinada por `ordergreatp`, e para a multiplicação, a ordem é a mesma da ordenação para armazenamento interno.

  Computações aritiméticas são realizadas sobre números literais (inteiro, racionais, números comuns em ponto flutuante, e grandes números em ponto flutuante de dupla precisão). Execto a exponenciação, todas as operações aritméticas sobre números são simplificadas para números. A exponenciação é simplificada para um número se ou o operando é um número comum em ponto flutuante ou um grande número em ponto flutuante de dupla precisão ou se o resultado for um inteiro exato ou um racional exato; de outra forma uma exponenciação pode ser simplificada para `sqrt` ou outra exponenciação ou permanecer inalterada.

  A propagação de números em ponto flutuante aplica-se a computações aritiméticas: Se qualquer operando for um grande número em ponto flutuante, o resultado é um grande número em ponto flutuante; de outra forma, se qualquer operando for um número em ponto flutuante comum, o resultado é um número comum em ponto flutuante; de outra forma, se os operandos forem racioanis ou inteiros e o resultado será um racional ou inteiro.

  Computaçãoes aritiméticas são uma simplificação, não uma avaliação. Dessa forma a aritmética é realizada em expressões com apóstrofo (mas simplificadas).

  Operações aritméticas são aplicadas elemento-por-elemento para listas quando a variável global `listarith` for `true`, e sempre aplicada elemento-por-elemento para matrizes. Quando um operando for uma lista ou uma matriz e outro for um operando de algum outro tipo, o outro operando é combinado com cada um dos elementos da lista ou matriz.

  Exemplos:

  Adição e multiplicação são opeadores enários comutativos. Maxima ordena os operandos para construir uma representação canónica. Os nomes desses operadores são `"+"` e `"*"`.

      (%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

  Divisão e exponenciação são operadores binários e não comutativos. Os nomes desses operadores são `"/"` e `"^"`.

      (%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

  Subtração e divisão são representados internamente em termos de adição e multiplicação, 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

  Cálculos são realizados sobre números lterais. A propagação de números em poto flutuante aplica-se.

      (%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]

  Computações aritméticas são uma simplificação, não uma avaliação.

      (%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

  A aritmética é realizada elemento-por-elemento para listas lists (dependendo de `listarith`) e dependendo de matrizes.

      (%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 exponenciação. Maxima reconhece `**` como o mesmo operador que `^` em entrada, e `**` é mostrado como `^` em saída unidimensional, ou colocando o expoente como sobrescrito em saída bidimensional.

  A função `fortran` mostra o operador de exponenciação com como `**`, independente de a entrada ter sido na forma `**` ou a forma `^`.

  Exemplos:

      (%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

Próximo: Operadores Relacionais, Anterior: Operador Préfixado, Acima: Operadores [Conteúdo][Índice]