[ < ] [ > ]   [ << ] [ 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 Jaime Villate on octubre, 13 2014 using texi2html 1.76.