Funciones radicales exponenciales y logarítmicas (Manual de Maxima 5.44.0)

Siguiente: Funciones trigonométricas, Anterior: Funciones combinatorias, Subir: Funciones matemáticas [Índice general][Índice]

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

Siguiente: Funciones trigonométricas, Anterior: Funciones combinatorias, Subir: Funciones matemáticas [Índice general][Índice]