Funciones y variables para logaritmos
=====================================

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

 -- 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 cciertas 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 y 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.

     lognumer - si vale true, entonces los argumentos de log que sean números decimales negativos en coma flotante se convertirán siempre a su valor absoluto antes de aplicar log.  Si numer vale también true, entonces los argumentos enteros negativos de log también se convertirán en su valor absoluto.

     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 contienen 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 y 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: lognumer
     Valor por defecto: false

     Si lognumer vale true, entonces los argumentos de log que sean números decimales negativos en coma flotante se convertirán siempre a su valor absoluto antes de aplicar log.  Si numer vale también true, entonces los argumentos enteros negativos de log también se convertirán en su valor absoluto.

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