Funciones para los números (Manual de Maxima 5.45.0)

Siguiente: Funciones para los números complejos, Anterior: Funciones matemáticas, Subir: Funciones matemáticas [Índice general][Índice]

### 10.1 Funciones para los números

Función: abs (z)

  La función `abs` representa el valor absoluto y se puede aplicar tanto a argumentos numéricos como simbólicos. Si el argumento z es un número real o complejo, `abs` devuelve el valor absoluto de z. Si es posible, las expresiones simbólicas que utilizan la función del valor absoluto también se simplifican.

  Maxima puede derivar, integrar y calcular límites de expresiones que contengan a `abs`. El paquete `abs_integrate` extiende las capacidades de Maxima para calcular integrales que contengan llamadas a `abs`. Véase `(%i12)` en el ejemplo de más abajo.

  Cuando se aplica a una lista o matriz, `abs` se distribuye automáticamente sobre sus elementos. De forma similar, también se distribuye sobre los dos miembros de una igualdad. Para cambiar este comportamiento por defecto, véase la variable `distribute_over`.

  Ejemplos:

  Cálculo del valor absoluto de números reales y complejos, incluyendo constantes numéricas e infinitos. El primer ejemplo muestra cómo `abs` se distribuye sobre los elementos de una lista.

      (%i1) abs([-4, 0, 1, 1+%i]);
      (%o1)                  [4, 0, 1, sqrt(2)]

      (%i2) abs((1+%i)*(1-%i));
      (%o2)                           2
      (%i3) abs(%e+%i);
                                      2
      (%o3)                    sqrt(%e  + 1)
      (%i4) abs([inf, infinity, minf]);
      (%o4)                   [inf, inf, inf]

  Simplificación de expresiones que contienen `abs`:

      (%i5) abs(x^2);
                                      2
      (%o5)                          x
      (%i6) abs(x^3);
                                   2
      (%o6)                       x  abs(x)

      (%i7) abs(abs(x));
      (%o7)                       abs(x)
      (%i8) abs(conjugate(x));
      (%o8)                       abs(x)

  Integrando y derivando con la función `abs`. Nótese que se pueden calcular más integrales que involucren la función `abs` si se carga el paquete `abs_integrate`. El último ejemplo muestra la transformada de Laplace de `abs`. Véase `laplace`.

      (%i9) diff(x*abs(x),x),expand;
      (%o9)                       2 abs(x)

      (%i10) integrate(abs(x),x);
                                   x abs(x)
      (%o10)                       --------
                                      2

      (%i11) integrate(x*abs(x),x);
                                 /
                                 [
      (%o11)                     I x abs(x) dx
                                 ]
                                 /

      (%i12) load(abs_integrate)$
      (%i13) integrate(x*abs(x),x);
                            2           3
                           x  abs(x)   x  signum(x)
      (%o13)               --------- - ------------
                               2            6

      (%i14) integrate(abs(x),x,-2,%pi);
                                     2
                                  %pi
      (%o14)                      ---- + 2
                                   2

      (%i15) laplace(abs(x),x,s);
                                     1
      (%o15)                         --
                                      2
                                     s

Función: ceiling (x)

  Si x es un número real, devuelve el menor entero mayor o igual que x.

  Si x es una expresión constante (por ejemplo, `10 * %pi`), `ceiling` evalúa x haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación `ceiling` al número decimal obtenido. Puesto que `ceiling` hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para `fpprec`.

  Para argumentos no constantes, `ceiling` intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que `ceiling` es capaz de hacer:

      (%i1) ceiling (ceiling (x));
      (%o1)                      ceiling(x)
      (%i2) ceiling (floor (x));
      (%o2)                       floor(x)
      (%i3) declare (n, integer)$
      (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
      (%o4)                [n, abs(n), max(n, 6)]
      (%i5) assume (x > 0, x < 1)$
      (%i6) ceiling (x);
      (%o6)                           1
      (%i7) tex (ceiling (a));
      $$\left \lceil a \right \rceil$$
      (%o7)                                false

  La función `ceiling` no se extiende automáticamente a los elementos de listas y matrices. Por último, para todos los argumentos que tengan una forma compleja, `ceiling` devuelve una forma nominal.

  Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como `integervalued`. Tanto `ceiling` como `floor` son funciones que hacen uso de esta información; por ejemplo:

      (%i1) declare (f, integervalued)$
      (%i2) floor (f(x));
      (%o2)                         f(x)
      (%i3) ceiling (f(x) - 1);
      (%o3)                       f(x) - 1

  Ejemplo de uso:

      (%i1) unitfrac(r) := block([uf : [], q],
          if not(ratnump(r)) then
             error("unitfrac: argument must be a rational number"),
          while r # 0 do (
              uf : cons(q : 1/ceiling(1/r), uf),
              r : r - q),
          reverse(uf))$

      (%i2) unitfrac (9/10);
                                  1  1  1
      (%o2)                      [-, -, --]
                                  2  3  15
      (%i3) apply ("+", %);
                                     9
      (%o3)                          --
                                     10
      (%i4) unitfrac (-9/10);
                                        1
      (%o4)                       [- 1, --]
                                        10
      (%i5) apply ("+", %);
                                      9
      (%o5)                         - --
                                      10
      (%i6) unitfrac (36/37);
                              1  1  1  1    1
      (%o6)                  [-, -, -, --, ----]
                              2  3  8  69  6808
      (%i7) apply ("+", %);
                                     36
      (%o7)                          --
                                     37

Función: entier (x)

  Devuelve el mayor entero menor o igual a x, siendo x numérico. La función `fix` (como en `fixnum`) es un sinónimo, de modo que `fix(x)` hace justamente lo mismo.

Función: floor (x)

  Si x es un número real, devuelve el mayor entero menor o igual que x.

  Si x es una expresión constante (por ejemplo, `10 * %pi`), `floor` evalúa x haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación `floor` al número decimal obtenido. Puesto que `floor` hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para `fpprec`.

  Para argumentos no constantes, `floor` intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que `floor` es capaz de hacer:

      (%i1) floor (ceiling (x));
      (%o1)                      ceiling(x)
      (%i2) floor (floor (x));
      (%o2)                       floor(x)
      (%i3) declare (n, integer)$
      (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
      (%o4)                [n, abs(n), min(n, 6)]
      (%i5) assume (x > 0, x < 1)$
      (%i6) floor (x);
      (%o6)                           0
      (%i7) tex (floor (a));
      $$\left \lfloor a \right \rfloor$$
      (%o7)                         false

  La función `floor` no se extiende automáticamente a los elementos de listas y matrices. Por último, para todos los argumentos que tengan una forma compleja, `floor` devuelve una forma nominal.

  Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como `integervalued`. Tanto `ceiling` como `floor` son funciones que hacen uso de esta información; por ejemplo:

      (%i1) declare (f, integervalued)$
      (%i2) floor (f(x));
      (%o2)                         f(x)
      (%i3) ceiling (f(x) - 1);
      (%o3)                       f(x) - 1

Función: fix (x)

  Es un sinónimo de `entier (x)`.

Función: lmax (L)

  Si L es una lista o conjunto, devuelve `apply ('max, args (L))`. Si L no es una lista o conjunto, envía un mensaje de error.

Función: lmin (L)

  Si L es una lista o conjunto, devuelve `apply ('min, args (L))`. Si L no es una lista o conjunto, envía un mensaje de error.

Función: max (x_1, ..., x_n)

  Devuelve un valor simplificado de la mayor de las expresiones desde x_1 hasta x_n. Si `get (trylevel, maxmin)` es 2 o más, `max` aplica la simplificación `max (e, -e) --> |e|`. Si `get (trylevel, maxmin)` es 3 o más, max intenta eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo, `max (x, 2*x, 3*x) --> max (x, 3*x)`. Para asignar el valor 2 a `trylevel` se puede hacer `put (trylevel, 2, maxmin)`.

Función: min (x_1, ..., x_n)

  Devuelve un valor simplificado de la menor de las expresiones desde x_1 hasta x_n. Si `get (trylevel, maxmin)` es 2 o más, `min` aplica la simplificación `min (e, -e) --> |e|`. Si `get (trylevel, maxmin)` es 3 o más, min intenta eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo, `min (x, 2*x, 3*x) --> min (x, 3*x)`. Para asignar el valor 2 a `trylevel` se puede hacer `put (trylevel, 2, maxmin)`.

Función: round (x)

  Si x es un número real, la función devuelve el entero más próximo a x. Los múltiplos de 1/2 se redondean al entero par más próximo. La evaluación de x es similar a `floor` y `ceiling`.

Función: signum (x)

  Tanto sea x real o complejo, la función `signum` devuelve 0 si x es cero. Para un valor no nulo de x, la función devuelve `x/abs(x)`.

  Para valores no numéricos de x, Maxima intenta determinar el signo del argumento. Cuando es negativo, cero o positivo, `signum` devuelve -1, 0 o 1, respectivamente. En caso de no poder determinarse, `signum` devuelve una forma simplificada equivalente. Estas simplificaciones incluyen la transformación de `signum(-x)` en `-signum(x)` y la de `signum(x*y)` en `signum(x) * signum(y)`.

  La función `signum` es distributiva respecto de listas, matrices o ecuaciones. Véase `distribute_over`.

Siguiente: Funciones para los números complejos, Anterior: Funciones matemáticas, Subir: Funciones matemáticas [Índice general][Índice]