[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 10. Funciones matemáticas

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 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`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 10.2 Funciones para los números complejos

Función: cabs (expr)

  Calcula el valor absoluto de una expresión que representa a un número complejo. Al contrario que `abs`, la función `cabs` siempre descompone su argumento en sus partes real e imaginaria. Si `x` e `y` representan variables o expresiones reales, la función `cabs` calcula el valor absoluto de `x + %i*y` como

                                 2    2
                           sqrt(y  + x )

  La función `cabs` puede utilizar propiedades como la simetría de funciones complejas para calcular el valor absoluto de una expresión.

  `cabs` no es una función apropiada para cálculos simbólicos; en tales casos, que incluyen la integración, diferenciación y límites que contienen valores absolutos, es mejor utilizar `abs`.

  El resultado devuelto por `cabs` puede incluir la función de valor absoluto, `abs`, y el arco tangente, `atan2`.

  Cuando se aplica a una lista o matriz, `cabs` automáticamente se distribuye sobre sus elementos. También se distribuye sobre los dos miembros de una igualdad.

  Para otras formas de operar con números complejos, véanse las funciones `rectform`, `realpart`, `imagpart`, `carg`, `conjugate` y `polarform`.

  Ejemplos:

  Ejemplos con `sqrt` and `sin`:

      (%i1) cabs(sqrt(1+%i*x));
                                   2     1/4
      (%o1)                      (x  + 1)
      (%i2) cabs(sin(x+%i*y));
                          2        2         2        2
      (%o2)       sqrt(cos (x) sinh (y) + sin (x) cosh (y))

  La simetría especular de la función de error `erf` se utiliza para calcular el valor absoluto del argumento complejo:

      (%i3) cabs(erf(x+%i*y));
                                                2
                 (erf(%i y + x) - erf(%i y - x))
      (%o3) sqrt(--------------------------------
                                4
                                                                     2
                                      (erf(%i y + x) + erf(%i y - x))
                                    - --------------------------------)
                                                     4

  Dado que Maxima reconoce algunas identidades complejas de las funciones de Bessel, le permite calcular su valor absoluto cuando tiene argumentos complejos. Un ejemplo para `bessel_j`:

      (%i4) cabs(bessel_j(1,%i));
      (%o4)                 abs(bessel_j(1, %i))

Función: carg (z)

  Devuelve el argumento complejo de z. El argumento complejo es un ángulo `theta` en `(-%pi, %pi]` tal que `r exp (theta %i) = z` donde `r` es la magnitud de z.

  La función `carg` es computacional, no simplificativa.

  Véanse también `abs` (módulo complejo), `polarform`, `rectform`, `realpart` y `imagpart`.

  Ejemplos:

      (%i1) carg (1);
      (%o1)                           0
      (%i2) carg (1 + %i);
                                     %pi
      (%o2)                          ---
                                      4
      (%i3) carg (exp (%i));
      (%o3)                           1
      (%i4) carg (exp (%pi * %i));
      (%o4)                          %pi
      (%i5) carg (exp (3/2 * %pi * %i));
                                      %pi
      (%o5)                         - ---
                                       2
      (%i6) carg (17 * exp (2 * %i));
      (%o6)                           2

Función: conjugate (x)

  Devuelve el conjugado complejo de x.

      (%i1) declare ([aa, bb], real, cc, complex, ii, imaginary);

      (%o1)                         done
      (%i2) conjugate (aa + bb*%i);

      (%o2)                      aa - %i bb
      (%i3) conjugate (cc);

      (%o3)                     conjugate(cc)
      (%i4) conjugate (ii);

      (%o4)                         - ii
      (%i5) conjugate (xx + yy);

      (%o5)             conjugate(yy) + conjugate(xx)

Función: imagpart (expr)

  Devuelve la parte imaginaria de la expresión expr.

  La función `imagpart` es computacional, no simplificativa.

  Véanse también `abs`, `carg`, `polarform`, `rectform` y `realpart`.

Función: polarform (expr)

  Devuelve una expresión de la forma `r %e^(%i theta)` equivalente a expr, con `r` y `theta` son reales.

Función: realpart (expr)

  Devuelve la parte real de expr. La funciones `realpart` y `imagpart` operan también con expresiones que contengan funciones trigonométricas e hiperbólicas, raíces cuadradas, logaritmos y exponentes.

Función: rectform (expr)

  Devuelve una expresión de la forma `a + b %i` equivalente a expr, con a y b reales.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 10.3 Funciones combinatorias

Operador: !!

  El operador doble factorial.

  Para un número entero, de punto flotante o racional `n`, `n!!` se evaluará como el producto de `n (n-2) (n-4) (n-6) ... (n - 2 (k-1))` donde `k` es igual a `entier(n/2)`, que es, el mayor entero menor o igual a `n/2`. Note que esta definición no coincide con otras definciones publicadas para argumentos, los cuales no son enteros.

  Para un entero par (o impar) `n`, `n!` se evalua el producto de todos los enteros pares (o impares) consecutivos desde 2 (o 1) por `n` inclusive.

  Para un argumento `n` el cual no es un número entero, punto flotante o racional, `n!!` produce una forma de nombre `genfact (n, n/2, 2)`.

Función: binomial (x, y)

  Es el coeficiente binomial `x!/(y! (x - y)!)`. Si x y y son enteros, entonces se calcula el valor numérico del coeficiente binomial. Si y o x - y son enteros, el coeficiente binomial se expresa como un polinomio.

  Ejemplos:

      (%i1) binomial (11, 7);
      (%o1)                          330
      (%i2) 11! / 7! / (11 - 7)!;
      (%o2)                          330
      (%i3) binomial (x, 7);
              (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x
      (%o3)   -------------------------------------------------
                                    5040
      (%i4) binomial (x + 7, x);
            (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7)
      (%o4) -------------------------------------------------------
                                     5040
      (%i5) binomial (11, y);
      (%o5)                    binomial(11, y)

Función: factcomb (expr)

  Trata de combinar los coeficientes de los factoriales de expr con los mismos factoriales, convirtiendo, por ejemplo, `(n + 1)*n!` en `(n + 1)!`.

  Si la variable `sumsplitfact` vale `false` hará que `minfactorial` se aplique después de `factcomb`.

Función: factorial (x)
Operador: !

  Representa la función factorial. Maxima considera `factorial (x)` y `x!` como sinónimos.

  Para cualquier número complejo `x`, excepto para enteros negativos, `x!` se define como `gamma(x+1)`.

  Para un entero `x`, `x!` se reduce al producto de los enteros desde 1 hasta `x` inclusive. `0!` se reduce a 1. Para un número real o complejo en formato de coma flotante `x`, `x!` se reduce al valor de `gamma(x+1)`. Cuando `x` es igual a `n/2`, siendo `n` un entero impar, entonces `x!` se reduce a un factor racional multiplicado por `sqrt(%pi)` (pues `gamma(1/2)`) es igual a `sqrt(%pi)`).

  Las variables opcionales `factlim` y `gammalim` controlan la evaluación numérica de factoriales de argumentos enteros y racionales.

  Las funciones `minfactorial` y `factcomb` simplifican expresiones que contiene factoriales.

  Véanse también `factlim`, `gammalim`, `minfactorial` y `factcomb`.

  Las funciones `gamma`, `bffac` y `cbffac` son variaciones de la función matemática gamma. Las funciones `bffac` y `cbffac` son llamadas internamente desde `gamma` para evaluar la función gamma de números reales y complejos decimales con precisión de reales grandes (bigfloats).

  Las funciones `makegamma` substituye a `gamma` para factoriales y funciones relacionadas.

  Maxima reconoce la derivada de la función factorial y los límites para ciertos valores específicos, tales como los enteros negativos.

  La variable opcional `factorial_expand` controla la simplificación de expresiones como `(n+x)!`, para `n` entero.

  Véase también `binomial`.

  Ejemplos:

  El factorial de un entero se reduce a un número exacto, a menos que el argumento sea mayor que `factlim`. Los factoriales de números reales o complejos se evalúan como decimales de coma flotante.

      (%i1) factlim:10;
      (%o1)                                 10
      (%i2) [0!, (7/2)!, 8!, 20!];
                                  105 sqrt(%pi)
      (%o2)                   [1, -------------, 40320, 20!]
                                       16
      (%i3) [4.77!, (1.0+%i)!];
      (%o3)    [81.44668037931197,
                .3430658398165454 %i + .6529654964201665]
      (%i4) [2.86b0!, (1.0b0+%i)!];
      (%o4) [5.046635586910012b0,
             3.430658398165454b-1 %i + 6.529654964201667b-1]

  El factorial de una constante conocida o de una expresión general no se calcula. Pero puede ser posible reducir el factorial después de evaluado el argumento.

      (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
      (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
      (%i2) ev (%, numer, %enumer);
      (%o2) [.3430658398165454 %i + .6529654964201665,
             7.188082728976031,
             4.260820476357003, 1.227580202486819]

  Los factoriales son simplificados o reducidos, no evaluados. Así `x!` puede ser reemplazado en una expresión nominal.

      (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
                105 sqrt(%pi)
      (%o1) [1, -------------, 81.44668037931199, 40320,
                     16
                                   2432902008176640000]

  Maxima reconoce la derivada de la función factorial.

      (%i1) diff(x!,x);
      (%o1)                           x! psi (x + 1)
                                            0

  La variable opcional `factorial_expand` controla la simplificación de expresiones con la función factorial.

      (%i1) (n+1)!/n!,factorial_expand:true;
      (%o1)                                n + 1

Variable opcional: factlim

  Valor por defecto: -1

  La variable `factlim` especifica el mayor factorial que será expandido automáticamente. Si su valor es -1, entonces se expandirán todos los enteros.

Variable opcional: factorial_expand

  Valor por defecto: false

  La variable `factorial_expand` controla la simplificación de expresiones tales como `(n+1)!`, siendo `n` un entero.

  Véase `!` para un ejemplo.

Función: genfact (x, y, z)

  Devuelve el factorial generalizado, definido como `x (x-z) (x - 2 z) ... (x - (y - 1) z)`. Así, para el entero x, `genfact (x, x, 1) = x!` y `genfact (x, x/2, 2) = x!!`.

Función: minfactorial (expr)

  Busca en expr la presencia de dos factoriales que solo se diferencien en una unidad; en tal caso, `minfactorial` devuelve una expresión simplificada.

      (%i1) n!/(n+2)!;
                                     n!
      (%o1)                       --------
                                  (n + 2)!
      (%i2) minfactorial (%);
                                      1
      (%o2)                    ---------------
                               (n + 1) (n + 2)

Variable opcional: sumsplitfact

  Valor por defecto: `true`

  Si `sumsplitfact` vale `false`, `minfactorial` se aplica después de `factcomb`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 10.4 Funciones radicales, exponenciales y logarítmicas

Variable opcional: %e_to_numlog

  Valor por defecto: `false`

  Si `%e_to_numlog` vale `true`, `r` es un número racional y `x` una expresión, `%e^(r*log(x))` se reduce a `x^r` . Téngase en cuenta que la instrucción `radcan` también hace este tipo de transformaciones, así como otras más complicadas. La instrucción `logcontract` "contrae" expresiones que contienen algún `log`.

Variable opcional: %emode

  Valor por defecto: `true`

  Si `%emode` vale `true`, `%e^(%pi %i x)` se simplifica como sigue.

  `%e^(%pi %i x)` se simplifica a `cos (%pi x) + %i sin (%pi x)` si `x` es un número decimal de coma flotante, un entero o un múltiplo de 1/2, 1/3, 1/4 o 1/6, y luego se sigue simplificando.

  Para otros valores numéricos de `x`, `%e^(%pi %i x)` se simplifica a `%e^(%pi %i y)` donde `y` es `x - 2 k` para algún entero `k` tal que `abs(y) < 1`.

  Si `%emode` vale `false`, no se realizan simplificaciones especiales a `%e^(%pi %i x)`.

Variable opcional: %enumer

  Valor por defecto: `false`

  Si la variable `%enumer` vale `true` hace que `%e` se reemplace por 2.718... siempre que `numer` valga `true`.

  Si `%enumer` vale `false`, esta sustitución se realiza sólo si el exponente en `%e^x` tiene un valor numérico.

  Véanse también `ev` y `numer`.

Función: exp (x)

  Representa la función exponencial. La expresión `exp (x)` en la entrada se simplifica en `%e^x`; `exp` no aparece en expresiones simplificadas.

  Si la variable `demoivre` vale `true` hace que `%e^(a + b %i)` se simplifique a `%e^(a (cos(b) + %i sin(b)))` si `b` no contiene a `%i`. Véase `demoivre`.

  Si la variable `%emode` vale `true`, hace que `%e^(%pi %i x)` se simplifique. Véase `%emode`.

  Si la variable `%enumer` vale `true` hace que `%e` se reemplace por 2.718... siempre que `numer` valga `true`. Véase `%enumer`.

Función: li [s] (z)

  Representa la función polilogarítmica de orden s y argumento z, definida por la serie infinita

                                       inf
                                       ====   k
                                       \     z
                              Li (z) =  >    --
                                s      /      s
                                       ====  k
                                       k = 1

  `li [1]` es `- log (1 - z)`. `li [2]` y `li [3]` son las funciones di- y trilogaritmo, respectivamente.

  Cuando el orden es 1, el polilogaritmo se simplifica a `- log (1 - z)`, el cual a su vez se reduce a un valor numérico si z es un número real o complejo en coma flotante o si está presente el término `numer`.

  Cuando el orden es 2 ó 3, el polilogaritmo se reduce a un valor numérico si z es un número real en coma flotante o si está presente el término `numer`.

  Ejemplos:

      (%i1) assume (x > 0);
      (%o1)                        [x > 0]
      (%i2) integrate ((log (1 - t)) / t, t, 0, x);
      (%o2)                       - li (x)
                                      2
      (%i3) li [2] (7);
      (%o3)                        li (7)
                                     2
      (%i4) li [2] (7), numer;
      (%o4)        1.24827317833392 - 6.113257021832577 %i
      (%i5) li [3] (7);
      (%o5)                        li (7)
                                     3
      (%i6) li [2] (7), numer;
      (%o6)        1.24827317833392 - 6.113257021832577 %i
      (%i7) L : makelist (i / 4.0, i, 0, 8);
      (%o7)   [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
      (%i8) map (lambda ([x], li [2] (x)), L);
      (%o8) [0, .2676526384986274, .5822405249432515,
      .9784693966661848, 1.64493407, 2.190177004178597
       - .7010261407036192 %i, 2.374395264042415
       - 1.273806203464065 %i, 2.448686757245154
       - 1.758084846201883 %i, 2.467401098097648
       - 2.177586087815347 %i]
      (%i9) map (lambda ([x], li [3] (x)), L);
      (%o9) [0, .2584613953442624, 0.537213192678042,
      .8444258046482203, 1.2020569, 1.642866878950322
       - .07821473130035025 %i, 2.060877505514697
       - .2582419849982037 %i, 2.433418896388322
       - .4919260182322965 %i, 2.762071904015935
       - .7546938285978846 %i]

Función: log (x)

  Representa el logaritmo natural (en base e) de x.

  Maxima no tiene definida una función para el logaritmo de base 10 u otras bases. El usuario puede hacer uso de la definición `log10(x) := log(x) / log(10)`.

  La simplificación y evaluación de logaritmos se controla con ciertas variables globales:

  ``logexpand``

    hace que `log(a^b)` se convierta en `b*log(a)`. Si toma el valor `all`, `log(a*b)` también se reducirá a `log(a)+log(b)`. Si toma el valor `super`, entonces `log(a/b)` también se reducirá a `log(a)-log(b)`, siendo `a/b` racional con `a#1`, (la expresión `log(1/b)`, para `b` entero, se simplifica siempre). Si toma el valor `false`, se desactivarán todas estas simplificaciones.

  ``logsimp``

    si vale `false`, entonces no se transforma `%e` a potencias que contengan logaritmos.

  ``lognegint``

    si vale `true` se aplica la regla `log(-n)` -> `log(n)+%i*%pi`, siendo `n` un entero positivo.

  ``%e_to_numlog``

    si vale `true`, `r` es un número racional y `x` una expresión, `%e^(r*log(x))` se reduce a `x^r`. Téngase en cuenta que la instrucción `radcan` también hace este tipo de transformaciones, así como otras más complicadas. La instrucción `logcontract` "contrae" expresiones que contengan algún `log`.

Variable opcional: logabs

  Valor por defecto: `false`

  Cuando se calculan integrales indefinidas en las que se generan logaritmos, como en `integrate(1/x,x)`, el resultado se devuelve de la forma `log(abs(...))` si `logabs` vale `true`, o de la forma `log(...)` si `logabs` vale `false`. En la integración definida se hace la asignación `logabs:true`, ya que aquí es normalmente necesario evaluar la integral indefinida en los extremos del intervalo de integración.

Variable opcional: logarc
Función: logarc (expr)

  Si la variable global `logarc` toma el valor `true`, las funciones circulares e hiperbólicas inversas se reemplazan por funciones logarítmicas equivalentes. El valor por defecto de `logarc` es `false`.

  La función `logarc(expr)` realiza la anterior transformación en la expresión expr sin necesidad de alterar el valor de la variable global `logarc`.

Variable opcional: logconcoeffp

  Valor por defecto: `false`

  Controla qué coeficientes se contraen cuando se utiliza `logcontract`. Se le puede asignar el nombre de una función de predicado de un argumento; por ejemplo, si se quiere introducir raíces cuadradas, se puede hacer `logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$` . Entonces `logcontract(1/2*log(x));` devolverá `log(sqrt(x))`.

Función: logcontract (expr)

  Analiza la expresión expr recursivamente, transformando subexpresiones de la forma `a1*log(b1) + a2*log(b2) + c` en `log(ratsimp(b1^a1 * b2^a2)) + c`

      (%i1) 2*(a*log(x) + 2*a*log(y))$
      (%i2) logcontract(%);
                                       2  4
      (%o2)                     a log(x  y )

  Si se hace `declare(n,integer);` entonces `logcontract(2*a*n*log(x));` da `a*log(x^(2*n))`. Los coeficientes que se contraen de esta manera son aquellos que como el 2 y el `n` satisfacen `featurep(coeff,integer)`. El usuario puede controlar qué coeficientes se contraen asignándole a la variable global `logconcoeffp` el nombre de una función de predicado de un argumento; por ejemplo, si se quiere introducir raíces cuadradas, se puede hacer `logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$` . Entonces `logcontract(1/2*log(x));` devolverá `log(sqrt(x))`.

Variable opcional: logexpand

  Valor por defecto: `true`

  Si `logexpand` vale `true` hace que `log(a^b)` se convierta en `b*log(a)`. Si toma el valor `all`, `log(a*b)` también se reducirá a `log(a)+log(b)`. Si toma el valor `super`, entonces `log(a/b)` también se reducirá a `log(a)-log(b)`, siendo `a/b` racional con `a#1`, (la expresión `log(1/b)`, para `b` entero, se simplifica siempre). Si toma el valor `false`, se desactivarán todas estas simplificaciones.

Variable opcional: lognegint

  Valor por defecto: `false`

  Si `lognegint` vale `true` se aplica la regla `log(-n)` -> `log(n)+%i*%pi` siendo `n` un entero positivo.

Variable opcional: logsimp

  Valor por defecto: `true`

  Si `logsimp` vale `false`, entonces no se transforma `%e` a potencias que contengan logaritmos.

Función: plog (x)

  Representa la rama principal del logaritmo natural complejo con `-%pi` < `carg(x)` <= `+%pi` .

Función: sqrt (x)

  Raíz cuadrada de x. Se representa internamente por `x^(1/2)`. Véase también `rootscontract`.

  Si la variable `radexpand` vale `true` hará que las raíces `n`-ésimas de los factores de un producto que sean potencias de `n` sean extraídas del radical; por ejemplo, `sqrt(16*x^2)` se convertirá en `4*x` sólo si `radexpand` vale `true`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 10.5 Funciones trigonométricas

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 10.5.1 Introducción a la trigonometría

Maxima reconoce muchas funciones trigonométricas. No están programadas todas las identidades trigonométricas, pero el usuario puede añadir muchas de ellas haciendo uso de las técnicas basadas en patrones. Las funciones trigonométricas definidas en Maxima son: `acos`, `acosh`, `acot`, `acoth`, `acsc`, `acsch`, `asec`, `asech`, `asin`, `asinh`, `atan`, `atanh`, `cos`, `cosh`, `cot`, `coth`, `csc`, `csch`, `sec`, `sech`, `sin`, `sinh`, `tan` y `tanh`. Hay también un determinado número de instrucciones especiales para manipular funciones trigonométricas; véanse a este respecto `trigexpand`, `trigreduce` y la variable `trigsign`. Dos paquetes adicionales amplían las reglas de simplificación de Maxima, `ntrig` y `atrig1`. Ejecútese `describe(command)` para más detalles.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 10.5.2 Funciones y variables para trigonometría

Variable opcional: %piargs

  Valor por defecto: `true`

  Cuando `%piargs` vale `true`, las funciones trigonométricas se simplifican a constantes algebraicas cuando el argumento es múltiplo entero de %pi, %pi/2, %pi/3, %pi/4 o %pi/6.

  Maxima conoce algunas identidades aplicables cuando %pi, etc., se multiplican por una variable entera (esto es, un símbolo declarado como entero).

  Ejemplo:

      (%i1) %piargs : false$
      (%i2) [sin (%pi), sin (%pi/2), sin (%pi/3)];
                                      %pi       %pi
      (%o2)            [sin(%pi), sin(---), sin(---)]
                                       2         3
      (%i3) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
                            %pi       %pi       %pi
      (%o3)            [sin(---), sin(---), sin(---)]
                             4         5         6
      (%i4) %piargs : true$
      (%i5) [sin (%pi), sin (%pi/2), sin (%pi/3)];
                                      sqrt(3)
      (%o5)                    [0, 1, -------]
                                         2
      (%i6) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
                               1         %pi   1
      (%o6)                [-------, sin(---), -]
                            sqrt(2)       5    2
      (%i7) [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3),
             cos (sqrt(2)*%pi/3)];
                      1    1               sqrt(2) %pi
      (%o7)          [-, - -, sqrt(3), cos(-----------)]
                      2    2                    3

  Se aplican ciertas identidades cuando %pi o %pi/2 se multiplican por una variable entera.

      (%i1) declare (n, integer, m, even)$
      (%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m),
             cos (%pi/2 * m)];
                                            m/2
      (%o2)                  [0, 1, 0, (- 1)   ]

Variable opcional: %iargs

  Valor por defecto: `true`

  Cuando `%iargs` vale `true`, las funciones trigonométricas se simplifican a funciones hiperbólicas si el argumento es aparentemente un múltiplo de la unidad imaginaria %i.

  La simplificación se lleva a cabo incluso cuando el argumento es manifiestamente real; Maxima sólo se fija en si el argumento es un múltiplo literal de %i.

  Ejemplos:

      (%i1) %iargs : false$
      (%i2) [sin (%i * x), cos (%i * x), tan (%i * x)];
      (%o2)           [sin(%i x), cos(%i x), tan(%i x)]
      (%i3) %iargs : true$
      (%i4) [sin (%i * x), cos (%i * x), tan (%i * x)];
      (%o4)           [%i sinh(x), cosh(x), %i tanh(x)]

  La simplificación se aplica incluso en el caso de que el argumento se reduzca a un número real.

      (%i1) declare (x, imaginary)$
      (%i2) [featurep (x, imaginary), featurep (x, real)];
      (%o2)                     [true, false]
      (%i3) sin (%i * x);
      (%o3)                      %i sinh(x)

Function: acos (x)

  Arco coseno.

Función: acosh (x)

  Arco coseno hiperbólico.

Función: acot (x)

  Arco cotangente.

Función: acoth (x)

  Arco cotangente hiperbólica.

Función: acsc (x)

  Arco cosecante.

Función: acsch (x)

  Arco cosecante hiperbólica.

Función: asec (x)

  Arco secante.

Función: asech (x)

  Arco secante hiperbólica.

Función: asin (x)

  Arco seno.

Función: asinh (x)

  Arco seno hiperbólico.

Función: atan (x)

  Arco tangente.

Función: atan2 (y, x)

  Calcula el valor de `atan(y/x)` en el intervalo de `-%pi` a `%pi`.

Función: atanh (x)

  Arco tangente hiperbólica.

Paquete: atrig1

  El paquete `atrig1` contiene ciertas reglas de simplificación adicionales para las funciones trigonométricas inversas. Junto con las reglas que ya conoce Maxima, los siguientes ángulos están completamente implementados: `0`, `%pi/6`, `%pi/4`, `%pi/3` y `%pi/2`. Los ángulos correspondientes en los otros tres cuadrantes también están disponibles. Para hacer uso de estas reglas, ejecútese `load(atrig1);`.

Función: cos (x)

  Coseno.

Función: cosh (x)

  Coseno hiperbólico.

Función: cot (x)

  Cotangente.

Función: coth (x)

  Cotangente hiperbólica.

Función: csc (x)

  Cosecante.

Función: csch (x)

  Cosecante hiperbólica.

Variable opcional: halfangles

  Valor por defecto: `false`

  Si `halfangles` vale `true`, las funciones trigonométricas con argumentos del tipo `expr/2` se simplifican a funciones con argumentos expr.

  Para un argumento real x en el intervalo `0 < x < 2*%pi` el seno del semiángulo se simplifica como

                          sqrt(1 - cos(x))
                          ----------------
                              sqrt(2)

  Se necesita un factor relativamente complicado para que esta fórmula sea también válida para cualquier argumento complejo z:

                 realpart(z)
           floor(-----------)
                    2 %pi
      (- 1)                   (1 - unit_step(- imagpart(z))

                            realpart(z)            realpart(z)
                      floor(-----------) - ceiling(-----------)
                               2 %pi                  2 %pi
                ((- 1)                                          + 1))

  Maxima reconoce este factor y otros similares para las funciones `sin`, `cos`, `sinh` y `cosh`. Para valores especiales del argumento z, estos factores se simplifican de forma apropiada.

  Ejemplos:

      (%i1) halfangles:false;
      (%o1)                                false
      (%i2) sin(x/2);
                                              x
      (%o2)                               sin(-)
                                              2
      (%i3) halfangles:true;
      (%o3)                                true
      (%i4) sin(x/2);
                                                          x
                                                  floor(-----)
                                                        2 %pi
                            sqrt(1 - cos(x)) (- 1)
      (%o4)                 ----------------------------------
                                         sqrt(2)
      (%i5) assume(x>0, x<2*%pi)$
      (%i6) sin(x/2);
                                     sqrt(1 - cos(x))
      (%o6)                          ----------------
                                         sqrt(2)

Paquete: ntrig

  El paquete `ntrig` contiene un conjunto de reglas de simplificación que se pueden usar para simplificar funciones trigonométricas cuyos argumentos son de la forma `f(n %pi/10)` donde f es cualquiera de las funciones `sin`, `cos`, `tan`, `csc`, `sec` o `cot`.

Función: sec (x)

  Secante.

Función: sech (x)

  Secante hiperbólica.

Función: sin (x)

  Seno.

Función: sinh (x)

  Seno hiperbólico.

Función: tan (x)

  Tangente.

Función: tanh (x)

  Tangente hiperbólica.

Función: trigexpand (expr)

  Expande funciones trigonométricas e hiperbólicas de sumas de ángulos y de múltiplos de ángulos presentes en expr. Para mejorar los resultados, expr debería expandirse. Para facilitar el control por parte del usuario de las simplificaciones, esta función tan solo expande un nivel de cada vez, expandiendo sumas de ángulos o de múltiplos de ángulos. A fin de obtener una expansión completa en senos y coseno, se le dará a la variable `trigexpand` el valor `true`.

  La función `trigexpand` está controlada por las siguientes variables:

  `trigexpand`

    Si vale `true`, provoca la expansión de todas las expresiones que contengan senos y cosenos.

  `trigexpandplus`

    Controla la regla de la suma para `trigexpand`, la expansión de una suma como `sin(x + y)` se llevará a cabo sólo si `trigexpandplus` vale `true`.

  `trigexpandtimes`

    Controla la regla del producto para `trigexpand`, la expansión de un producto como `sin(2 x)` se llevará a cabo sólo si `trigexpandtimes` vale `true`.

  Ejemplos:

      (%i1) x+sin(3*x)/sin(x),trigexpand=true,expand;
                               2           2
      (%o1)               - sin (x) + 3 cos (x) + x
      (%i2) trigexpand(sin(10*x+y));
      (%o2)          cos(10 x) sin(y) + sin(10 x) cos(y)

Variable optativa: trigexpandplus

  Valor por defecto: `true`

  La variable `trigexpandplus` controla la regla de la suma para `trigexpand`. Así, si la instrucción `trigexpand` se utiliza o si la variable `trigexpand` vale `true`, se realizará la expansión de sumas como `sin(x+y)` sólo si `trigexpandplus` vale `true`.

Variable optativa: trigexpandtimes

  Valor por defecto: `true`

  La variable `trigexpandtimes` controla la regla del producto para `trigexpand`. Así, si la instrucción `trigexpand` se utiliza o si la variable `trigexpand` vale `true`, se realizará la expansión de productos como `sin(2*x)` sólo si `trigexpandtimes` vale `true`.

Variable optativa: triginverses

  Valor por defecto: `true`

  La variable `triginverses` controla la simplificación de la composición de funciones trigonométricas e hiperbólicas con sus funciones inversas.

  Si vale `all`, tanto `atan(tan(x))` como `tan(atan(x))` se reducen a x.

  Si vale `true`, se desactiva la simplificación de `arcfun(fun(x))`.

  Si vale `false`, se desactivan las simplificaciones de `arcfun(fun(x))` y `fun(arcfun(x))`.

Función: trigreduce (expr, x)
Función: trigreduce (expr)

  Combina productos y potencias de senos y cosenos trigonométricos e hiperbólicos de x, transformándolos en otros que son múltiplos de x. También intenta eliminar estas funciones cuando aparecen en los denominadores. Si no se introduce el argumento x, entonces se utilizan todas las variables de expr.

  Véase también `poissimp`.

      (%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x);
                     cos(2 x)      cos(2 x)   1        1
      (%o1)          -------- + 3 (-------- + -) + x - -
                        2             2       2        2

  Las rutinas de simplificación trigonométrica utilizan información declarada en algunos casos sencillos. Las declaraciones sobre variables se utilizan como se indica a continuación:

      (%i1) declare(j, integer, e, even, o, odd)$
      (%i2) sin(x + (e + 1/2)*%pi);
      (%o2)                        cos(x)
      (%i3) sin(x + (o + 1/2)*%pi);
      (%o3)                       - cos(x)

Variable optativa: trigsign

  Valor por defecto: `true`

  Si `trigsign` vale `true`, se permite la simplificación de argumentos negativos en funciones trigonométricas, como en `sin(-x)`, que se transformará en `-sin(x)` sólo si `trigsign` vale `true`.

Función: trigsimp (expr)

  Utiliza las identidades sin(x)^2 + cos(x)^2 = 1 y cosh(x)^2 - sinh(x)^2 = 1 para simplificar expresiones que contienen `tan`, `sec`, etc., en expresiones con `sin`, `cos`, `sinh`, `cosh`.

  Las funciones `trigreduce`, `ratsimp` y `radcan` puden seguir siendo útiles para continuar el proceso de simplificación.

  La instrucción `demo ("trgsmp.dem")` muestra algunos ejemplos de `trigsimp`.

Función: trigrat (expr)

  Devuelve una forma canónica simplificada cuasi-lineal de una expresión trigonométrica; expr es una fracción racional que contiene `sin`, `cos` o `tan`, cuyos argumentos son formas lineales respecto de ciertas variables (o kernels) y `%pi/n` (n entero) con coeficientes enteros. El resultado es una fracción simplificada con el numerador y denominador lineales respecto de `sin` y `cos`. Así, `trigrat` devuelve una expresión lineal siempre que sea posible.

      (%i1) trigrat(sin(3*a)/sin(a+%pi/3));
      (%o1)            sqrt(3) sin(2 a) + cos(2 a) - 1

  El siguiente ejemplo se ha tomado de Davenport, Siret y Tournier, Calcul Formel, Masson (o en inglés, Addison-Wesley), sección 1.5.5, teorema de Morley.

      (%i1) c : %pi/3 - a - b$
      (%i2) bc : sin(a)*sin(3*c)/sin(a+b);
                                                %pi
                        sin(a) sin(3 (- b - a + ---))
                                                 3
      (%o2)             -----------------------------
                                 sin(b + a)
      (%i3) ba : bc, c=a, a=c;
                                               %pi
                          sin(3 a) sin(b + a - ---)
                                                3
      (%o3)               -------------------------
                                        %pi
                                sin(a - ---)
                                         3
      (%i4) ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b);
               2         2         %pi
            sin (3 a) sin (b + a - ---)
                                    3
      (%o4) ---------------------------
                      2     %pi
                   sin (a - ---)
                             3
                                             %pi
       - (2 sin(a) sin(3 a) sin(3 (- b - a + ---)) cos(b)
                                              3
                   %pi            %pi
       sin(b + a - ---))/(sin(a - ---) sin(b + a))
                    3              3
            2       2              %pi
         sin (a) sin (3 (- b - a + ---))
                                    3
       + -------------------------------
                      2
                   sin (b + a)
      (%i5) trigrat (ac2);
      (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a)
       - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a)
       - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a)
       + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a)
       + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b)
       + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a)
       - 9)/4

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 10.6 Números aleatorios

Función: make_random_state (n)
Función: make_random_state (s)
Función: make_random_state (true)
Función: make_random_state (false)

  Un objeto de estado aleatorio representa el estado del generador de números aleatorios. El estado consiste en 627 cadenas binarias de 32 bits.

  La llamada `make_random_state (n)` devuelve un nuevo objeto de estado aleatorio creado a partir de una semilla entera igual a n módulo 2^32. El argumento n puede ser negativo.

  La llamada `make_random_state (s)` devuelve una copia del estado aleatorio s.

  La llamada `make_random_state (true)` devuelve un nuevo objeto de estado aleatorio, cuya semilla se genera a partir de la hora actual del reloj del sistema como semilla.

  La llamada `make_random_state (false)` devuelve una copia del estado actual del generador de números aleatorios.

Función: set_random_state (s)

  Establece s como estado del generador de números aleatorios.

  La función `set_random_state` devuelve `done` en todo caso.

Función: random (x)

  Devuelve un número seudoaleatorio. Si x es un entero, `random (x)` devuelve un entero entre 0 y `x - 1`, ambos inclusive. Si x es un decimal en punto flotante, `random (x)` devuelve un decimal no negativo en punto flotante menor que x. La función `random` emite un mensaje de error si x no es ni entero ni de punto flotante, o si x no es positivo.

  Las funciones `make_random_state` y `set_random_state` permiten controlar el estado del generador de números aleatorios.

  El generador de números aleatorios de Maxima implementa el algoritmo de Mersenne twister MT 19937.

  Ejemplos:

      (%i1) s1: make_random_state (654321)$
      (%i2) set_random_state (s1);
      (%o2)                         done
      (%i3) random (1000);
      (%o3)                          768
      (%i4) random (9573684);
      (%o4)                        7657880
      (%i5) random (2^75);
      (%o5)                11804491615036831636390
      (%i6) s2: make_random_state (false)$
      (%i7) random (1.0);
      (%o7)                   .2310127244107132
      (%i8) random (10.0);
      (%o8)                   4.394553645870825
      (%i9) random (100.0);
      (%o9)                   32.28666704056853
      (%i10) set_random_state (s2);
      (%o10)                        done
      (%i11) random (1.0);
      (%o11)                  .2310127244107132
      (%i12) random (10.0);
      (%o12)                  4.394553645870825
      (%i13) random (100.0);
      (%o13)                  32.28666704056853

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Viktor T. Toth on octubre, 3 2017 using texi2html 1.76.