@c English version 2013-07-30
@menu
* Funciones y variables para teoría de números::  
@end menu

@node Funciones y variables para teoría de números,  , Teoría de Números, Teoría de Números
@section Funciones y variables para teoría de números


@deffn {Función} bern (@var{n})
Devuelve el @var{n}-ésimo número de Bernoulli del entero @var{n}.
@c WELL, ACTUALLY bern SIMPLIFIES, LIKE FACTORIAL -- DO WE WANT TO GET INTO THAT ???
@c OR JUST PRETEND IT'S "RETURNED" ???
Los números de Bernoulli iguales a cero son suprimidos si @code{zerobern} vale @code{false}.

Véase también @code{burn}.

@example
(%i1) zerobern: true$
(%i2) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
                      1  1       1      1        1
(%o2)           [1, - -, -, 0, - --, 0, --, 0, - --]
                      2  6       30     42       30
(%i3) zerobern: false$
(%i4) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
                      1  1    1   1     1   5     691   7
(%o4)           [1, - -, -, - --, --, - --, --, - ----, -]
                      2  6    30  42    30  66    2730  6
@end example



@end deffn

@deffn {Función} bernpoly (@var{x}, @var{n})
Devuelve el @var{n}-ésimo polinomio de Bernoulli de variable @var{x}.

@end deffn

@deffn {Función} bfzeta (@var{s}, @var{n})
Devuelve la función zeta de Riemann para el argumento @var{s}. El valor que devuelve es del tipo "big float" (bfloat) y 
@var{n}  es su número de dígitos.

Es necesario cargar en memoria esta función haciendo @code{load ("bffac")}.

@end deffn

@deffn {Función} bfhzeta (@var{s}, @var{h}, @var{n})
Devuelve la función zeta de Hurwitz para los argumentos @var{s} y @var{h}. El valor que devuelve es del tipo "big float" (bfloat) y @var{n}  es su número de dígitos.

La función zeta de Hurwitz se define como

@tex
$$\zeta \left(s,h\right) = \sum_{k=0}^\infty {1 \over \left(k+h\right)^{s}}$$
@end tex
@ifnottex
@example
                        inf
                        ====
                        \        1
         zeta (s,h)  =   >    --------
                        /            s
                        ====  (k + h)
                        k = 0
@end example
@end ifnottex

Ejecútese @code{load (bffac)} antes de hacer uso de esta función.

@end deffn




@deffn {Función} burn (@var{n})
Siendo @var{n} entero, Devuelve un número racional que aproxima el 
@var{n}-ésimo número de Bernoulli. La función @code{burn} aprovecha
el hecho de que los números de Bernoulli racionales se pueden aproximar
con notable precisión gracias a 

@example
                   n - 1  1 - 2 n
              (- 1)      2        zeta(2 n) (2 n)!
     B(2 n) = ------------------------------------
                                2 n
                             %pi
@end example

La función @code{burn} puede ser más eficiente que @code{bern} cuando 
@var{n} es un número grande, ya que @code{bern} calcula todos los números
de Bernoulli hasta el @var{n}-ésimo. Por el contrario, @code{burn} hace 
uso de la aproximación para enteros pares @var{n} > 255. En caso de
enteros impares y @var{n} <= 255, se hace uso de la función @code{bern}.

Para utilizar esta función hay que cargarla antes en memoria escribiendo
@code{load ("bffac")}. Véase también @code{bern}.

@end deffn



@deffn {Función} chinese ([@var{r_1}, @dots{}, @var{r_n}], [@var{m_1}, @dots{}, @var{m_n}])

Resulve el sistema de congruencias @code{x = r_1 mod m_1}, @dots{}, @code{x = r_n mod m_n}.
Los restos @var{r_n} pueden ser enteros arbitrarios, mientras que los módulos @var{m_n}
deben ser positivos y primos dos a dos. 

@example
(%i1) mods : [1000, 1001, 1003, 1007];
(%o1)                   [1000, 1001, 1003, 1007]
(%i2) lreduce('gcd, mods);
(%o2)                               1
(%i3) x : random(apply("*", mods));
(%o3)                         685124877004
(%i4) rems : map(lambda([z], mod(x, z)), mods);
(%o4)                       [4, 568, 54, 624]
(%i5) chinese(rems, mods);
(%o5)                         685124877004
(%i6) chinese([1, 2], [3, n]);
(%o6)                    chinese([1, 2], [3, n])
(%i7) %, n = 4;
(%o7)                              10
@end example
@end deffn



@deffn {Función} cf (@var{expr})

Calcula aproximaciones con fracciones continuas. @var{expr} es una expresión
que contiene fracciones continuas, raíces cuadradas de enteros,
y números reales (enteros, racionales, decimales en coma flotante y decimales de
precisión arbitraria). @code{cf} calcula expansiones exactas de números 
racionales, pero las expansiones de nÃºmeros decimales de coma flotante se truncan
de acuerdo con el valor de @code{ratepsilon}, y la de los de decimales de precisión
arbitraria (bigfloats) lo hacen respecto de @code{10^(-fpprec)}.

En las expresiones se pueden combinar operandos con operadores aritméticos.
Maxima no conoce operaciones con fracciones continuas más allá de
la función @code{cf}.

La función @code{cf} evalúa sus argumentos después de asignar a la 
variable @code{listarith} el valor @code{false}, retornando una fracción
continua en forma de lista.

Una fracción continua @code{a + 1/(b + 1/(c + ...))} se representa como la
lista @code{[a, b, c, ...]}, donde los elementos @code{a}, @code{b}, @code{c}, ... 
se evalúan como enteros. La expresión @var{expr} puede contener también  
@code{sqrt (n)} donde @code{n} es un entero; en tal caso, @code{cf} devolverá 
tantos términos de la fracción continua como indique el valor de la variable 
@code{cflength} multiplicado por el período.

Una fracción continua puede reducirse a un número evaluando la representación 
aritmética que devuelve @code{cfdisrep}. Véase también  @code{cfexpand}, 
que es otra alternativa para evaluar fracciones continuas.

Véanse asimismo @code{cfdisrep}, @code{cfexpand} y @code{cflength}.

Ejemplos:

@itemize @bullet
@item
La expresión @var{expr} contiene fracciones continuas y raíces
cuadradas de enteros.

@example
(%i1) cf ([5, 3, 1]*[11, 9, 7] + [3, 7]/[4, 3, 2]);
(%o1)               [59, 17, 2, 1, 1, 1, 27]
(%i2) cf ((3/17)*[1, -2, 5]/sqrt(11) + (8/13));
(%o2)        [0, 1, 1, 1, 3, 2, 1, 4, 1, 9, 1, 9, 2]
@end example

@item
La variable @code{cflength} controla cuantos períodos de la fracción 
continua se calculan para números irracionales algebraicos.

@example
(%i1) cflength: 1$
(%i2) cf ((1 + sqrt(5))/2);
(%o2)                    [1, 1, 1, 1, 2]
(%i3) cflength: 2$
(%i4) cf ((1 + sqrt(5))/2);
(%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
(%i5) cflength: 3$
(%i6) cf ((1 + sqrt(5))/2);
(%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
@end example

@item
Una fracción continua puede calcularse evaluando la representación aritmética 
que devuelve @code{cfdisrep}.

@example
(%i1) cflength: 3$
(%i2) cfdisrep (cf (sqrt (3)))$
(%i3) ev (%, numer);
(%o3)                   1.731707317073171
@end example

@item
Maxima no sabe sobre operaciones con fracciones continuas más de lo que aporta 
la función @code{cf}.

@example
(%i1) cf ([1,1,1,1,1,2] * 3);
(%o1)                     [4, 1, 5, 2]
(%i2) cf ([1,1,1,1,1,2]) * 3;
(%o2)                  [3, 3, 3, 3, 3, 6]
@end example

@end itemize
@end deffn




@deffn {Función} cfdisrep (@var{lista})
Construye y devuelve una expresión aritmética ordinaria de la forma  @code{a + 1/(b + 1/(c + ...))} a partir de la representación en formato lista de la fracción continua  @code{[a, b, c, ...]}.

@example
(%i1) cf ([1, 2, -3] + [1, -2, 1]);
(%o1)                     [1, 1, 1, 2]
(%i2) cfdisrep (%);
                                  1
(%o2)                     1 + ---------
                                    1
                              1 + -----
                                      1
                                  1 + -
                                      2
@end example

@end deffn




@deffn {Función} cfexpand (@var{x})
Devuelve la matriz con los numeradores y denominadores de la última (columna 1) y penúltima (columna 2) convergentes de la fracción continua @var{x}.

@example
(%i1) cf (rat (ev (%pi, numer)));

`rat' replaced 3.141592653589793 by 103993/33102 =3.141592653011902
(%o1)                  [3, 7, 15, 1, 292]
(%i2) cfexpand (%); 
                         [ 103993  355 ]
(%o2)                    [             ]
                         [ 33102   113 ]
(%i3) %[1,1]/%[2,1], numer;
(%o3)                   3.141592653011902
@end example

@end deffn

@defvr {Variable opcional} cflength
Valor por defecto: 1

La variable @code{cflength} controla el número de términos de la fracción continua que devuelve la función @code{cf}, que será @code{cflength} multiplicado por el período. Así, el valor por defecto será el de un período.

@example
(%i1) cflength: 1$
(%i2) cf ((1 + sqrt(5))/2);
(%o2)                    [1, 1, 1, 1, 2]
(%i3) cflength: 2$
(%i4) cf ((1 + sqrt(5))/2);
(%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
(%i5) cflength: 3$
(%i6) cf ((1 + sqrt(5))/2);
(%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
@end example

@end defvr




@deffn {Función} divsum (@var{n}, @var{k})
@deffnx {Función} divsum (@var{n})

La llamada @code{divsum (@var{n}, @var{k})} devuelve la suma de los divisores de @var{n} elevados a la @var{k}-ésima potencia.

La llamada @code{divsum (@var{n})} devuelve la suma de los divisores de @var{n}.

@example
(%i1) divsum (12);
(%o1)                          28
(%i2) 1 + 2 + 3 + 4 + 6 + 12;
(%o2)                          28
(%i3) divsum (12, 2);
(%o3)                          210
(%i4) 1^2 + 2^2 + 3^2 + 4^2 + 6^2 + 12^2;
(%o4)                          210
@end example

@end deffn


@deffn {Función} euler (@var{n})
Devuelve el @var{n}-ésimo número de Euler del entero no negativo @var{n}.
Los número de Euler iguales a cero se eliminan si @code{zerobern} vale @code{false}.

Para la constante de Euler-Mascheroni, véase @code{%gamma}.

@example
(%i1) zerobern: true$
(%i2) map (euler, [0, 1, 2, 3, 4, 5, 6]);
(%o2)               [1, 0, - 1, 0, 5, 0, - 61]
(%i3) zerobern: false$
(%i4) map (euler, [0, 1, 2, 3, 4, 5, 6]);
(%o4)               [1, - 1, 5, - 61, 1385, - 50521, 2702765]
@end example

@end deffn



@defvr {Variable opcional} factors_only
Valor por defecto: @code{false}

Controla el resultado devuelto por @code{ifactors}. El valor por defecto
@code{false} hace que @code{ifactors} no dé información sobre las
multiplicidades de los factores primos calculados. Cuando @code{factors_only}
vale @code{true}, @code{ifactors} solo devuelve la lista de factores primos.

Para ejemplos, véase @code{ifactors}.
@end defvr



@deffn {Función} fib (@var{n})
Devuelve el @var{n}-ésimo número de Fibonacci. La llamada @code{fib(0)} 
devuelve 0, @code{fib(1)} devuelve 1 y @code{fib (-@var{n})} es igual a 
@code{(-1)^(@var{n} + 1) * fib(@var{n})}.

Después de llamar a @code{fib}, la variable @code{prevfib} toma el valor 
@code{fib (@var{n} - 1)}, que es el número de Fibonacci que precede al último calculado.

@example
(%i1) map (fib, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
(%o1)           [- 3, 2, - 1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21]
@end example

@end deffn

@deffn {Función} fibtophi (@var{expr})
Expresa los números de Fibonacci en @var{expr} en términos de la razón áurea @code{%phi},
que es @code{(1 + sqrt(5))/2}, aproximadamente 1.61803399.

Ejemplos:

@c ===beg===
@c fibtophi (fib (n));
@c fib (n-1) + fib (n) - fib (n+1);
@c fibtophi (%);
@c ratsimp (%);
@c ===end===
@example
(%i1) fibtophi (fib (n));
                           n             n
                       %phi  - (1 - %phi)
(%o1)                  -------------------
                           2 %phi - 1
(%i2) fib (n-1) + fib (n) - fib (n+1);
(%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
(%i3) fibtophi (%);
            n + 1             n + 1       n             n
        %phi      - (1 - %phi)        %phi  - (1 - %phi)
(%o3) - --------------------------- + -------------------
                2 %phi - 1                2 %phi - 1
                                          n - 1             n - 1
                                      %phi      - (1 - %phi)
                                    + ---------------------------
                                              2 %phi - 1
(%i4) ratsimp (%);
(%o4)                           0
@end example

@end deffn




@deffn {Función} ifactors (@var{n})
Devuelve la factorización del entero positivo @var{n}. Si @code{n=p1^e1..pk^nk} es
la descomposición de @var{n} en números primos, @code{ifactors} devuelve 
@code{[[p1, e1], ... , [pk, ek]]}.

Los métodos de factorización se basan en divisiones tentativas con números primos
hasta 9973, en los métodos rho y p-1 de Pollard y en curvas elípticas.

La respuesta que se obtiene de @code{ifactors} está controlada por la variable opcional
@code{factors_only}. El valor por defecto @code{false} hace que @code{ifactors} no 
dé información sobre las multiplicidades de los factores primos calculados. 
Cuando @code{factors_only} vale @code{true}, @code{ifactors} solo devuelve la lista 
de factores primos.

@example
(%i1) ifactors(51575319651600);
(%o1)     [[2, 4], [3, 2], [5, 2], [1583, 1], [9050207, 1]]
(%i2) apply("*", map(lambda([u], u[1]^u[2]), %));
(%o2)                        51575319651600
(%i3) ifactors(51575319651600), factors_only : true;
(%o3)                   [2, 3, 5, 1583, 9050207]
@end example

@end deffn



@deffn {Función} igcdex (@var{n}, @var{k})

Devuelve la lista @code{[@var{a}, @var{b}, @var{u}]}, donde @var{u} es
el máximo común divisor de @var{n} y @var{k}, siendo @var{u}
igual a @code{@var{a} @var{n} + @var{b} @var{k}}. Los argumentos
@var{n} y @var{k} deben ser enteros.

@code{igcdex} implementa el algoritmo de Euclides. Véase también @code{gcdex}.

La instrucción @code{load(gcdex)} carga esta función.

Ejemplos:

@example
(%i1) load(gcdex)$

(%i2) igcdex(30,18);
(%o2)                      [- 1, 2, 6]
(%i3) igcdex(1526757668, 7835626735736);
(%o3)            [845922341123, - 164826435, 4]
(%i4) igcdex(fib(20), fib(21));
(%o4)                   [4181, - 2584, 1]
@end example

@end deffn




@deffn {Función} inrt (@var{x}, @var{n})
Devuelve la raíz entera @var{n}-ésima del valor absoluto de  @var{x}.

@example
(%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
(%i2) map (lambda ([a], inrt (10^a, 3)), l);
(%o2) [2, 4, 10, 21, 46, 100, 215, 464, 1000, 2154, 4641, 10000]
@end example

@end deffn

@deffn {Función} inv_mod (@var{n}, @var{m})
Calcula el inverso de @var{n} módulo @var{m}. 
La llamada @code{inv_mod (n,m)} devuelve @code{false}
si @var{n} es un divisor nulo módulo @var{m}.

@example
(%i1) inv_mod(3, 41);
(%o1)                           14
(%i2) ratsimp(3^-1), modulus = 41;
(%o2)                           14
(%i3) inv_mod(3, 42);
(%o3)                          false
@end example

@end deffn


@deffn {Función} isqrt (@var{x})
Devuelve la "raíz cuadrada entera"
del valor absoluto de @var{x},
el cual debe ser un entero.

@end deffn



@deffn {Función} jacobi (@var{p}, @var{q})
Devuelve el símbolo de Jacobi para @var{p} y @var{q}.

@example
(%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
(%i2) map (lambda ([a], jacobi (a, 9)), l);
(%o2)         [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0]
@end example

@end deffn

@deffn {Función} lcm (@var{expr_1}, ..., @var{expr_n})
Devuelve el mínimo común múltiplo de sus argumentos. 
Los argumentos pueden ser tanto expresiones en general como enteros.

Es necesario cargar en memoria esta función haciendo @code{load ("functs")}.

@end deffn





@deffn {Función} lucas (@var{n})
Devuelve el @var{n}-ésimo número de Lucas.
@code{lucas(0)} es igual a 2, @code{lucas(1)} es igual a 1 y 
@code{lucas(-@var{n})} es igual a @code{(-1)^(-@var{n}) * lucas(@var{n})}.

@example
(%i1) map (lucas, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
(%o1)             [7, - 4, 3, - 1, 2, 1, 3, 4, 7, 11, 18, 29, 47]
@end example

Después de llamar a @code{lucas}, la variable global @code{next_lucas}
es igual a @code{lucas (@var{n} + 1)}, el número de Lucas que sigue al
último que se ha devuelto. El ejemplo muestra como los números de
Fibonacci se pueden calcular mediante  @code{lucas} y @code{next_lucas}.

@example
(%i1) fib_via_lucas(n) := 
         block([lucas : lucas(n)],
         signum(n) * (2*next_lucas - lucas)/5 )$
(%i2) map (fib_via_lucas, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
(%o2)             [- 3, 2, - 1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21]
@end example
@end deffn






@deffn {Función} mod (@var{x}, @var{y})

Si @var{x} e @var{y} son números reales e @var{y} es distinto de cero,
devuelve @code{@var{x} - @var{y} * floor(@var{x} / @var{y})}.
Para todos los reales @var{x}, se tiene @code{mod (@var{x}, 0) = @var{x}}. Para información sobre la definición de  @code{mod (@var{x}, 0) = @var{x}}, véase la sección 3.4 de "Concrete Mathematics", 
by Graham, Knuth, and Patashnik. La función @code{mod (@var{x}, 1)} es de diente de sierra con periodo unidad y con @code{mod (1, 1) = 0} y @code{mod (0, 1) = 0}.

Para encontrar el argumento principal (un número del intervalo @code{(-%pi, %pi]}) de un número complejo, hágase uso de la función @code{@var{x} |-> %pi - mod (%pi - @var{x}, 2*%pi)}, donde @var{x} es un argumento.

Si @var{x} e @var{y} son expresiones constantes (por ejemplo, @code{10 * %pi}), @code{mod} utiliza el mismo esquema de evaluación basado en números grandes en coma flotante (big floats) que @code{floor} y @code{ceiling}. También es posible, pero improbable, que @code{mod} pueda retornar un valor erróneo en tales casos.

Para argumentos no numéricos @var{x} o @var{y}, @code{mod} aplica algunas reglas de simplificación:

@c ===beg===
@c mod (x, 0);
@c mod (a*x, a*y);
@c mod (0, x);
@c ===end===
@example
(%i1) mod (x, 0);
(%o1)                           x
(%i2) mod (a*x, a*y);
(%o2)                      a mod(x, y)
(%i3) mod (0, x);
(%o3)                           0
@end example
@end deffn



@deffn {Función} next_prime (@var{n})
Devuelve el menor de los primos mayores que @var{n}.

@example
(%i1) next_prime(27);
(%o1)                       29
@end example

@end deffn


@deffn {Función} partfrac (@var{expr}, @var{var})
Expande la expresión @var{expr} en fracciones parciales respecto de la variable principal @var{var}. La función @code{partfrac} hace una descomposición completa en fracciones parciales. El algoritmo que se utiliza se basa en el hecho de que los denominadores de la expansión en fracciones parciales (los factores del denominador original) son primos relativos. Los numeradores se pueden escribir como combinaciones lineales de los denominadores.

@example
(%i1) 1/(1+x)^2 - 2/(1+x) + 2/(2+x);
                      2       2        1
(%o1)               ----- - ----- + --------
                    x + 2   x + 1          2
                                    (x + 1)
(%i2) ratsimp (%);
                                 x
(%o2)                 - -------------------
                         3      2
                        x  + 4 x  + 5 x + 2
(%i3) partfrac (%, x);
                      2       2        1
(%o3)               ----- - ----- + --------
                    x + 2   x + 1          2
                                    (x + 1)
@end example

@end deffn




@deffn {Función} power_mod (@var{a}, @var{n}, @var{m})
Utiliza un algoritmo modular para calcular @code{a^n mod m},
siendo @var{a} y @var{n} enteros cualesquiera y @var{m} un entero positivo.
Si @var{n} es negativo, se utilizará @code{inv_mod} para encontrar el
inverso modular.

@example
(%i1) power_mod(3, 15, 5);
(%o1)                          2
(%i2) mod(3^15,5);
(%o2)                          2
(%i3) power_mod(2, -1, 5);
(%o3)                          3
(%i4) inv_mod(2,5);
(%o4)                          3
@end example

@end deffn

@deffn {Función} primep (@var{n})
Comprueba si el número entero @var{n} es o no primo, devolviendo @code{true}
o @code{false} según el caso.

Cuando el resultado de @code{primep (@var{n})} es @code{false}, @var{n} es un
número compuesto, y si es @code{true}, @var{n} es primo con alta probabilidad.

Si @var{n} es menor que 341550071728321, se utiliza una versión 
determinística de la prueba de Miller-Rabin. En tal caso,
si @code{primep (@var{n})} devuelve @code{true}, entonces @var{n} es un número primo.

Para @var{n} mayor que 341550071728321 @code{primep} realiza 
@code{primep_number_of_tests} pruebas de seudo-primalidad de Miller-Rabin y una 
prueba de seudo-primalidad de Lucas. La probabilidad de que un número compuesto 
@var{n} pase una prueba de Miller-Rabin es menor que 1/4. Con el valor por defecto de 
@code{primep_number_of_tests}, que es 25, la probabilidad de que @var{n}
sea compuesto es menor que 10^-15.

@end deffn




@defvr {Variable opcional} primep_number_of_tests
Valor por defecto: 25

Número de pruebas de Miller-Rabin a realizar por @code{primep}.
@end defvr

@deffn {Función} prev_prime (@var{n})
Devuelve el mayor de los primos menores que @var{n}.

@example
(%i1) prev_prime(27);
(%o1)                       23
@end example
@end deffn


@deffn {Función} qunit (@var{n})
Devuelve la unidad principal de @code{sqrt (@var{n})}, siendo @var{n} un entero; consiste en la resolución de la ecuación de Pell  @code{a^2 - @var{n} b^2 = 1}.

@example
(%i1) qunit (17);
(%o1)                     sqrt(17) + 4
(%i2) expand (% * (sqrt(17) - 4));
(%o2)                           1
@end example

@end deffn



@deffn {Función} totient (@var{n})
Devuelve el número de enteros menores o iguales a @var{n} que son primos relativos con @var{n}.
@end deffn

@defvr {Variable opcional} zerobern
Valor por defecto: @code{true}

Si @code{zerobern} vale @code{false}, @code{bern} excluye los números de Bernoulli
y @code{euler} excluye los números de Euler que sean iguales a cero.
Véase @code{bern} y @code{euler}.
@end defvr




@deffn {Función} zeta (@var{n})
Devuelve la función zeta de Riemann. Si @var{n} es entero negativo,
0 o número par positivo, la función zeta de Riemann devuelve un
valor exacto; en el caso de número par positivo, la variable opcional
@code{zeta%pi}, además, tiene que tener el valor @code{true} 
(véase @code{zeta%pi}). 
Cuando el argumento es un número decimal o bigfloat,
entonces la función zeta de Riemann se calcula numéricamente.
Maxima devuelve una forma nominal @code{zeta (@var{n})} para
cualesquiera otros argumentos, incluidos los racionales no enteros,
los números complejos y los enteros pares si @code{zeta%pi} vale
@code{false}.

@code{zeta(1)} no está definida, pero Maxima conce el límite 
de @code{limit(zeta(x), x, 1)} por ambos lados.

La función zeta de Riemann se distribuye sobre las listas, matrices
y ecuaciones.

Véanse también @code{bfzeta} y @code{zeta%pi}.

Ejemplos:

@c ===beg===
@c zeta([-2,-1,0,0.5,2,3,1+%i]);
@c limit(zeta(x),x,1,plus);
@c limit(zeta(x),x,1,minus);
@c ===end===
@example
(%i1) zeta([-2,-1,0,0.5,2,3,1+%i]);
                                              2
             1     1                       %pi
(%o1)  [0, - --, - -, - 1.460354508809587, ----, zeta(3), zeta(%i + 1)]
             12    2                        6 

(%i2) limit(zeta(x),x,1,plus);
(%o2)                                 inf
(%i3) limit(zeta(x),x,1,minus);
(%o3)                                minf
@end example

@end deffn





@defvr {Variable opcional} zeta%pi
Valor por defecto: @code{true}

Si @code{zeta%pi} vale @code{true}, @code{zeta} devuelve una expresión proporcional a @code{%pi^n} si @code{n} es un número par positivo. En caso contrario, @code{zeta} no se evalúa y devuelve la forma nominal @code{zeta (n)}.

Ejemplos:

@c ===beg===
@c zeta%pi: true$
@c zeta (4);
@c zeta%pi: false$
@c zeta (4);
@c ===end===
@example
(%i1) zeta%pi: true$
(%i2) zeta (4);
                                 4
                              %pi
(%o2)                         ----
                               90
(%i3) zeta%pi: false$
(%i4) zeta (4);
(%o4)                        zeta(4)
@end example

@end defvr






@deffn {Función} zn_add_table (@var{n}) 
Muestra la tabla de la suma de todos los elementos de (Z/@var{n}Z).

Véanse también @code{zn_mult_table} y @code{zn_power_table}.

@end deffn







@deffn {Función} zn_determinant (@var{matrix}, @var{p}) 
Utiliza el procedimiento de la descomposición LU para calcular el determinante
de @var{matrix} sobre (Z/@var{p}Z). El argumento @var{p} debe ser un número primo.

Si el determinante es igual a cero, el procedimiento puede fallar, en cuyo caso
@code{zn_determinant} calcula el determinante no modular y luego reduce.

Véase también @code{zn_invert_by_lu}.

Ejemplo:

@example
(%i1) m : matrix([1,3],[2,4]);
                                [ 1  3 ]
(%o1)                           [      ]
                                [ 2  4 ]
(%i2) zn_determinant(m, 5);
(%o2)                               3
(%i3) m : matrix([2,4,1],[3,1,4],[4,3,2]);
                               [ 2  4  1 ]
                               [         ]
(%o3)                          [ 3  1  4 ]
                               [         ]
                               [ 4  3  2 ]
(%i4) zn_determinant(m, 5);
(%o4)                               0
@end example

@end deffn





@deffn {Función} zn_invert_by_lu (@var{matrix}, @var{p}) 
Utiliza el procedimiento de la descomposición LU para calcular la inversa
modular de @var{matrix} sobre (Z/@var{p}Z). El argumento @var{p} debe ser 
un número primo y @var{matrix} invertible. La función @code{zn_invert_by_lu}
devuelve @code{false} si @var{matrix} no es invertible.

Véase @code{zn_determinant}.

Ejemplo:

@example
(%i1) m : matrix([1,3],[2,4]);
                                [ 1  3 ]
(%o1)                           [      ]
                                [ 2  4 ]
(%i2) zn_determinant(m, 5);
(%o2)                               3
(%i3) mi : zn_invert_by_lu(m, 5);
                                [ 3  4 ]
(%o3)                           [      ]
                                [ 1  2 ]
(%i4) matrixmap(lambda([a], mod(a, 5)), m . mi);
                                [ 1  0 ]
(%o4)                           [      ]
                                [ 0  1 ]
@end example

@end deffn






@deffn {Función} zn_log (@var{a}, @var{g}, @var{n}) 
@deffnx {Función} zn_log (@var{a}, @var{g}, @var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
Calcula el logaritmo discreto. Sea (Z/@var{n}Z)* un grupo cíclico,
@var{g} una raíz primitiva módulo @var{n} y @var{a} un miembro
de este grupo, entonces @code{zn_log (a, g, n)} calcula la congruencia @code{g^x = a mod n}.

El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta 
factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
cuarto argumento. La lista debe ser de la misma forma que las lista devuelta por 
@code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.

El algoritmo utiliza la reducción de Pohlig-Hellman y el método Rho de Pollard
para los logaritmos discretos. El tiempo de ejecución de @code{zn_log} depende en
primer lugar del número de bits del mayor factor primo del totient.

Véanse también @code{zn_primroot}, @code{zn_order}, @code{ifactors} y @code{totient}.

Ejemplos:

@code{zn_log (a, g, n)} resuelve la congruencia @code{g^x = a mod n}.

@example
(%i1) n : 22$
(%i2) g : zn_primroot(n);
(%o2)                               7
(%i3) ord_7 : zn_order(7, n);
(%o3)                              10
(%i4) powers_7 : makelist(power_mod(g, x, n), x, 0, ord_7 - 1);
(%o4)              [1, 7, 5, 13, 3, 21, 15, 17, 9, 19]
(%i5) zn_log(21, g, n);
(%o5)                               5
(%i6) map(lambda([x], zn_log(x, g, n)), powers_7);
(%o6)                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
@end example

El cuarto argumento opcional debe ser de la misma forma que la lista devuelta por
@code{ifactors(totient(n))}. 

@example
(%i1) (p : 2^127-1, primep(p));
(%o1)                             true
(%i2) ifs : ifactors(p - 1)$
(%i3) g : zn_primroot(p, ifs);
(%o3)                              43
(%i4) a : power_mod(g, 1234567890, p)$
(%i5) zn_log(a, g, p, ifs);
(%o5)                          1234567890
(%i6) time(%o5);  
(%o6)                            [1.204]
(%i7) f_max : last(ifs);
(%o7)                       [77158673929, 1]
(%i8) slength( printf(false, "~b", f_max[1]) );
(%o8)                              37
@end example

@end deffn






@deffn {Función} zn_mult_table (@var{n}) 
@deffnx {Función} zn_mult_table (@var{n}, all)
Sin el argumento opcional @var{all}, @code{zn_mult_table(n)} 
muestra la tabla de multiplicación de los elementos de (Z/@var{n}Z)*,
que son todos elementos invertibles módulo @var{n}.

El argumento opcional @var{all} hace que la tabla se genere para todos los 
elementos no nulos.

Véanse también @code{zn_add_table} y @code{zn_power_table}.

Ejemplo:

@example
(%i1) zn_mult_table(4);
                                [ 1  3 ]
(%o1)                           [      ]
                                [ 3  1 ]
(%i2) zn_mult_table(4, all);
                               [ 1  2  3 ]
                               [         ]
(%o2)                          [ 2  0  2 ]
                               [         ]
                               [ 3  2  1 ]
@end example

@end deffn







@deffn {Función} zn_order (@var{x}, @var{n}) 
@deffnx {Función} zn_order (@var{x}, @var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
Devuelve el orden de @var{x} si es una unidad del grupo finito (Z/@var{n}Z)*, o devuelve @code{false}.
@var{x} una unidad módulo @var{n} si es coprimo con @var{n}.

El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta 
factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
tercer argumento. La lista debe ser de la misma forma que las lista devuelta por 
@code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.

Véanse también @code{zn_primroot}, @code{ifactors} y @code{totient}.

Ejemplos:

@code{zn_order} calcula el orden de la unidad @var{x} en (Z/@var{n}Z)*.

@example
(%i1) n : 22$
(%i2) g : zn_primroot(n);
(%o2)                               7
(%i3) units_22 : sublist(makelist(i,i,1,21), lambda([x], gcd(x, n) = 1));
(%o3)              [1, 3, 5, 7, 9, 13, 15, 17, 19, 21]
(%i4) (ord_7 : zn_order(7, n)) = totient(n);
(%o4)                            10 = 10
(%i5) powers_7 : makelist(power_mod(g,i,n), i,0,ord_7 - 1);
(%o5)              [1, 7, 5, 13, 3, 21, 15, 17, 9, 19]
(%i6) map(lambda([x], zn_order(x, n)), powers_7);
(%o6)              [1, 10, 5, 10, 5, 2, 5, 10, 5, 10]
(%i7) map(lambda([x], ord_7/gcd(x, ord_7)), makelist(i, i,0,ord_7 - 1));
(%o7)              [1, 10, 5, 10, 5, 2, 5, 10, 5, 10]
(%i8) totient(totient(n));
(%o8)                               4
@end example

El tercer argumento opcional debe ser de la misma forma que la lista devuelta
por @code{ifactors(totient(n))}.

@example
(%i1) (p : 2^142 + 217, primep(p));
(%o1)                             true
(%i2) ifs : ifactors( totient(p) )$
(%i3) g : zn_primroot(p, ifs);
(%o3)                               3
(%i4) is( (ord_3 : zn_order(g, p, ifs)) = totient(p) );
(%o4)                             true
(%i5) map(lambda([x], ord_3/zn_order(x, p, ifs)), makelist(i,i,2,15));
(%o5)        [22, 1, 44, 10, 5, 2, 22, 2, 8, 2, 1, 1, 20, 1]
@end example

@end deffn





@deffn {Función} zn_power_table (@var{n}) 
@deffnx {Función} zn_power_table (@var{n}, all)
Sin el argumento opcional @var{all}, @code{zn_power_table(n)} 
muestra la tabla de potencias de los elementos de (Z/@var{n}Z)*,
que son todos elementos invertibles módulo @var{n}. El exponente 
se obtiene con un bucle desde @code{1} hasta @code{totient(n)}
y la tabla termina con una columna de unos al lado derecho.

El argumento opcional @var{all} hace que la tabla se genere para todos los 
elementos no nulos. En este caso, el exponente se calcula con un bucle desde
@code{1} hasta @code{totient(n) + 1} y la última columna es por lo tanto 
igual a la primera.

Véanse también @code{zn_add_table} y @code{zn_mult_table}.

Ejemplo:

@example
(%i1) zn_power_table(6);
                                [ 1  1 ]
(%o1)                           [      ]
                                [ 5  1 ]
(%i2) zn_power_table(6, all);
                               [ 1  1  1 ]
                               [         ]
                               [ 2  4  2 ]
                               [         ]
(%o2)                          [ 3  3  3 ]
                               [         ]
                               [ 4  4  4 ]
                               [         ]
                               [ 5  1  5 ]
@end example

@end deffn






@deffn {Función} zn_primroot (@var{n}) 
@deffnx {Función} zn_primroot (@var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
Si el grupo multiplicativo es cíclico, @code{zn_primroot}
calcula la menor raíz primitiva de módulo @var{n}. (Z/@var{n}Z)* es
cíclico si @var{n} es igual a @code{2}, @code{4}, @code{p^k} o @code{2*p^k},
siendo @code{p} primo y mayor que @code{2} y @code{k} un número natural.
Si a la variable opcional @code{zn_primroot_pretest}, cuyo valor por defecto es
@code{false}, se le da el valor @code{true}, entonces @code{zn_primroot} 
realiza una prueba previa. En cualquier caso, el cálculo está limitado por la
cota superior @code{zn_primroot_limit}.

Si (Z/@var{n}Z)* no es cíclico o si no tiene raíces
primitivas menores que @code{zn_primroot_limit}, @code{zn_primroot} devuelve
@code{false}.

El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta 
factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
argumento adicional. La lista debe ser de la misma forma que las lista devuelta por 
@code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.

Véanse también @code{zn_primroot_p}, @code{zn_order}, @code{ifactors} y @code{totient}.

Ejemplos:

@code{zn_primroot} calcula la menor raíz primitiva de módulo @var{n} o
devuelve @code{false}.

@example
(%i1) n : 14$
(%i2) g : zn_primroot(n);
(%o2)                               3
(%i3) zn_order(g, n) = totient(n);
(%o3)                             6 = 6
(%i4) n : 15$
(%i5) zn_primroot(n);
(%o5)                             false
@end example

El argumento opcional debe ser de la misma forma que la lista devuelta
por @code{ifactors(totient(n))}.

@example
(%i1) (p : 2^142 + 217, primep(p));
(%o1)                             true
(%i2) ifs : ifactors( totient(p) )$
(%i3) g : zn_primroot(p, ifs);
(%o3)                               3
(%i4) [time(%o2), time(%o3)];
(%o4)                    [[15.556972], [0.004]]
(%i5) is(zn_order(g, p, ifs) = p - 1);
(%o5)                             true
(%i6) n : 2^142 + 216$
(%i7) ifs : ifactors(totient(n))$
(%i8) zn_primroot(n, ifs), 
      zn_primroot_limit : 200, zn_primroot_verbose : true;
`zn_primroot' stopped at zn_primroot_limit = 200
(%o8)                             false
@end example

@end deffn






@defvr {Option variable} zn_primroot_limit
Valor por defecto: @code{1000} 

Si @code{zn_primroot} no puede encontrar una raíz primitiva,
entonces se para en esta cota superior. Si a la variable opcional 
@code{zn_primroot_verbose} se le da el valor @code{true}, se imprimirá un
mensaje cuando @code{zn_primroot_limit} sea alcanzado.

@end defvr







@deffn {Función} zn_primroot_p (@var{x}, @var{n}) 
@deffnx {Función} zn_primroot_p (@var{x}, @var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
Comprueba si @var{x} es una raíz primitiva en el 
grupo multiplizativo (Z/@var{n}Z)*.

El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta 
factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
tercer argumento. La lista debe ser de la misma forma que las lista devuelta por 
@code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.

Véanse también @code{zn_primroot}, @code{zn_order}, @code{ifactors} y @code{totient}.

Ejemplos:

@code{zn_primroot_p} como función de predicado.

@example
(%i1) n : 14$
(%i2) units_14 : sublist(makelist(i,i,1,13), lambda([i], gcd(i, n) = 1));
(%o2)                     [1, 3, 5, 9, 11, 13]
(%i3) zn_primroot_p(13, n);
(%o3)                            false
(%i4) sublist(units_14, lambda([x], zn_primroot_p(x, n)));
(%o4)                            [3, 5]
(%i5) map(lambda([x], zn_order(x, n)), units_14);
(%o5)                      [1, 6, 6, 3, 3, 2]
@end example

El tercer argumento opcional debe ser de la misma forma que la lista
devuelta por @code{ifactors(totient(n))}.

@example
(%i1) (p : 2^142 + 217, primep(p));
(%o1)                             true
(%i2) ifs : ifactors( totient(p) )$
(%i3) sublist(makelist(i,i,1,50), lambda([x], zn_primroot_p(x, p, ifs)));
(%o3)      [3, 12, 13, 15, 21, 24, 26, 27, 29, 33, 38, 42, 48]
(%i4) [time(%o2), time(%o3)];
(%o4)                   [[7.748484], [0.036002]]
@end example

@end deffn






@defvr {Option variable} zn_primroot_pretest
Valor por defecto: @code{false} 

El grupo multiplicativo (Z/@var{n}Z)* es cíclico si if @var{n}
es igual a @code{2}, @code{4}, @code{p^k} o @code{2*p^k}, siendo @code{p}
un número primo mayor que @code{2} y @code{k} es un número natural.

La variable @code{zn_primroot_pretest} controla si @code{zn_primroot} debe
comprobar si sucede alguna de estas situaciones antes de calcular la menor
raíz primitiva. Solo se realizará esta comprobación si
@code{zn_primroot_pretest} toma el valor @code{true}.

@end defvr







@defvr {Option variable} zn_primroot_verbose
Valor por defecto: @code{false} 

Controla si @code{zn_primroot} imprime un mensaje cuando alcanza @code{zn_primroot_limit}.

@end defvr




