| blob | b97cb9d149a7cacc93c71de9b2c808d3f3a6cf28 |
1 @c English version 2013-07-30
2 @menu
3 * Funciones y variables para teoría de números::
4 @end menu
6 @node Funciones y variables para teoría de números, , Teoría de Números, Teoría de Números
7 @section Funciones y variables para teoría de números
10 @deffn {Función} bern (@var{n})
11 Devuelve el @var{n}-ésimo número de Bernoulli del entero @var{n}.
12 @c WELL, ACTUALLY bern SIMPLIFIES, LIKE FACTORIAL -- DO WE WANT TO GET INTO THAT ???
13 @c OR JUST PRETEND IT'S "RETURNED" ???
14 Los números de Bernoulli iguales a cero son suprimidos si @code{zerobern} vale @code{false}.
16 Véase también @code{burn}.
18 @example
19 (%i1) zerobern: true$
20 (%i2) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
21 1 1 1 1 1
22 (%o2) [1, - -, -, 0, - --, 0, --, 0, - --]
23 2 6 30 42 30
24 (%i3) zerobern: false$
25 (%i4) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
26 1 1 1 1 1 5 691 7
27 (%o4) [1, - -, -, - --, --, - --, --, - ----, -]
28 2 6 30 42 30 66 2730 6
29 @end example
33 @end deffn
35 @deffn {Función} bernpoly (@var{x}, @var{n})
36 Devuelve el @var{n}-ésimo polinomio de Bernoulli de variable @var{x}.
38 @end deffn
40 @deffn {Función} bfzeta (@var{s}, @var{n})
41 Devuelve la función zeta de Riemann para el argumento @var{s}. El valor que devuelve es del tipo "big float" (bfloat) y
42 @var{n} es su número de dígitos.
44 Es necesario cargar en memoria esta función haciendo @code{load ("bffac")}.
46 @end deffn
48 @deffn {Función} bfhzeta (@var{s}, @var{h}, @var{n})
49 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.
51 La función zeta de Hurwitz se define como
53 @tex
54 $$\zeta \left(s,h\right) = \sum_{k=0}^\infty {1 \over \left(k+h\right)^{s}}$$
55 @end tex
56 @ifnottex
57 @example
58 inf
59 ====
60 \ 1
61 zeta (s,h) = > --------
62 / s
63 ==== (k + h)
64 k = 0
65 @end example
66 @end ifnottex
68 Ejecútese @code{load ("bffac")} antes de hacer uso de esta función.
70 @end deffn
75 @deffn {Función} burn (@var{n})
76 Siendo @var{n} entero, Devuelve un número racional que aproxima el
77 @var{n}-ésimo número de Bernoulli. La función @code{burn} aprovecha
78 el hecho de que los números de Bernoulli racionales se pueden aproximar
79 con notable precisión gracias a
81 @example
82 n - 1 1 - 2 n
83 (- 1) 2 zeta(2 n) (2 n)!
84 B(2 n) = ------------------------------------
85 2 n
86 %pi
87 @end example
89 La función @code{burn} puede ser más eficiente que @code{bern} cuando
90 @var{n} es un número grande, ya que @code{bern} calcula todos los números
91 de Bernoulli hasta el @var{n}-ésimo. Por el contrario, @code{burn} hace
92 uso de la aproximación para enteros pares @var{n} > 255. En caso de
93 enteros impares y @var{n} <= 255, se hace uso de la función @code{bern}.
95 Para utilizar esta función hay que cargarla antes en memoria escribiendo
96 @code{load ("bffac")}. Véase también @code{bern}.
98 @end deffn
102 @deffn {Función} chinese ([@var{r_1}, @dots{}, @var{r_n}], [@var{m_1}, @dots{}, @var{m_n}])
104 Resulve el sistema de congruencias @code{x = r_1 mod m_1}, @dots{}, @code{x = r_n mod m_n}.
105 Los restos @var{r_n} pueden ser enteros arbitrarios, mientras que los módulos @var{m_n}
106 deben ser positivos y primos dos a dos.
108 @example
109 (%i1) mods : [1000, 1001, 1003, 1007];
110 (%o1) [1000, 1001, 1003, 1007]
111 (%i2) lreduce('gcd, mods);
112 (%o2) 1
113 (%i3) x : random(apply("*", mods));
114 (%o3) 685124877004
115 (%i4) rems : map(lambda([z], mod(x, z)), mods);
116 (%o4) [4, 568, 54, 624]
117 (%i5) chinese(rems, mods);
118 (%o5) 685124877004
119 (%i6) chinese([1, 2], [3, n]);
120 (%o6) chinese([1, 2], [3, n])
121 (%i7) %, n = 4;
122 (%o7) 10
123 @end example
124 @end deffn
128 @deffn {Función} cf (@var{expr})
130 Calcula aproximaciones con fracciones continuas. @var{expr} es una expresión
131 que contiene fracciones continuas, raíces cuadradas de enteros,
132 y números reales (enteros, racionales, decimales en coma flotante y decimales de
133 precisión arbitraria). @code{cf} calcula expansiones exactas de números
134 racionales, pero las expansiones de números decimales de coma flotante se truncan
135 de acuerdo con el valor de @code{ratepsilon}, y la de los de decimales de precisión
136 arbitraria (bigfloats) lo hacen respecto de @code{10^(-fpprec)}.
138 En las expresiones se pueden combinar operandos con operadores aritméticos.
139 Maxima no conoce operaciones con fracciones continuas más allá de
140 la función @code{cf}.
142 La función @code{cf} evalúa sus argumentos después de asignar a la
143 variable @code{listarith} el valor @code{false}, retornando una fracción
144 continua en forma de lista.
146 Una fracción continua @code{a + 1/(b + 1/(c + ...))} se representa como la
147 lista @code{[a, b, c, ...]}, donde los elementos @code{a}, @code{b}, @code{c}, ...
148 se evalúan como enteros. La expresión @var{expr} puede contener también
149 @code{sqrt (n)} donde @code{n} es un entero; en tal caso, @code{cf} devolverá
150 tantos términos de la fracción continua como indique el valor de la variable
151 @code{cflength} multiplicado por el período.
153 Una fracción continua puede reducirse a un número evaluando la representación
154 aritmética que devuelve @code{cfdisrep}. Véase también @code{cfexpand},
155 que es otra alternativa para evaluar fracciones continuas.
157 Véanse asimismo @code{cfdisrep}, @code{cfexpand} y @code{cflength}.
159 Ejemplos:
161 @itemize @bullet
162 @item
163 La expresión @var{expr} contiene fracciones continuas y raíces
164 cuadradas de enteros.
166 @example
167 (%i1) cf ([5, 3, 1]*[11, 9, 7] + [3, 7]/[4, 3, 2]);
168 (%o1) [59, 17, 2, 1, 1, 1, 27]
169 (%i2) cf ((3/17)*[1, -2, 5]/sqrt(11) + (8/13));
170 (%o2) [0, 1, 1, 1, 3, 2, 1, 4, 1, 9, 1, 9, 2]
171 @end example
173 @item
174 La variable @code{cflength} controla cuantos períodos de la fracción
175 continua se calculan para números irracionales algebraicos.
177 @example
178 (%i1) cflength: 1$
179 (%i2) cf ((1 + sqrt(5))/2);
180 (%o2) [1, 1, 1, 1, 2]
181 (%i3) cflength: 2$
182 (%i4) cf ((1 + sqrt(5))/2);
183 (%o4) [1, 1, 1, 1, 1, 1, 1, 2]
184 (%i5) cflength: 3$
185 (%i6) cf ((1 + sqrt(5))/2);
186 (%o6) [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
187 @end example
189 @item
190 Una fracción continua puede calcularse evaluando la representación aritmética
191 que devuelve @code{cfdisrep}.
193 @example
194 (%i1) cflength: 3$
195 (%i2) cfdisrep (cf (sqrt (3)))$
196 (%i3) ev (%, numer);
197 (%o3) 1.731707317073171
198 @end example
200 @item
201 Maxima no sabe sobre operaciones con fracciones continuas más de lo que aporta
202 la función @code{cf}.
204 @example
205 (%i1) cf ([1,1,1,1,1,2] * 3);
206 (%o1) [4, 1, 5, 2]
207 (%i2) cf ([1,1,1,1,1,2]) * 3;
208 (%o2) [3, 3, 3, 3, 3, 6]
209 @end example
211 @end itemize
212 @end deffn
217 @deffn {Función} cfdisrep (@var{lista})
218 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, ...]}.
220 @example
221 (%i1) cf ([1, 2, -3] + [1, -2, 1]);
222 (%o1) [1, 1, 1, 2]
223 (%i2) cfdisrep (%);
224 1
225 (%o2) 1 + ---------
226 1
227 1 + -----
228 1
229 1 + -
230 2
231 @end example
233 @end deffn
238 @deffn {Función} cfexpand (@var{x})
239 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}.
241 @example
242 (%i1) cf (rat (ev (%pi, numer)));
244 `rat' replaced 3.141592653589793 by 103993/33102 =3.141592653011902
245 (%o1) [3, 7, 15, 1, 292]
246 (%i2) cfexpand (%);
247 [ 103993 355 ]
248 (%o2) [ ]
249 [ 33102 113 ]
250 (%i3) %[1,1]/%[2,1], numer;
251 (%o3) 3.141592653011902
252 @end example
254 @end deffn
256 @defvr {Variable opcional} cflength
257 Valor por defecto: 1
259 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.
261 @example
262 (%i1) cflength: 1$
263 (%i2) cf ((1 + sqrt(5))/2);
264 (%o2) [1, 1, 1, 1, 2]
265 (%i3) cflength: 2$
266 (%i4) cf ((1 + sqrt(5))/2);
267 (%o4) [1, 1, 1, 1, 1, 1, 1, 2]
268 (%i5) cflength: 3$
269 (%i6) cf ((1 + sqrt(5))/2);
270 (%o6) [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
271 @end example
273 @end defvr
278 @deffn {Función} divsum (@var{n}, @var{k})
279 @deffnx {Función} divsum (@var{n})
281 La llamada @code{divsum (@var{n}, @var{k})} devuelve la suma de los divisores de @var{n} elevados a la @var{k}-ésima potencia.
283 La llamada @code{divsum (@var{n})} devuelve la suma de los divisores de @var{n}.
285 @example
286 (%i1) divsum (12);
287 (%o1) 28
288 (%i2) 1 + 2 + 3 + 4 + 6 + 12;
289 (%o2) 28
290 (%i3) divsum (12, 2);
291 (%o3) 210
292 (%i4) 1^2 + 2^2 + 3^2 + 4^2 + 6^2 + 12^2;
293 (%o4) 210
294 @end example
296 @end deffn
299 @deffn {Función} euler (@var{n})
300 Devuelve el @var{n}-ésimo número de Euler del entero no negativo @var{n}.
301 Los número de Euler iguales a cero se eliminan si @code{zerobern} vale @code{false}.
303 Para la constante de Euler-Mascheroni, véase @code{%gamma}.
305 @example
306 (%i1) zerobern: true$
307 (%i2) map (euler, [0, 1, 2, 3, 4, 5, 6]);
308 (%o2) [1, 0, - 1, 0, 5, 0, - 61]
309 (%i3) zerobern: false$
310 (%i4) map (euler, [0, 1, 2, 3, 4, 5, 6]);
311 (%o4) [1, - 1, 5, - 61, 1385, - 50521, 2702765]
312 @end example
314 @end deffn
318 @defvr {Variable opcional} factors_only
319 Valor por defecto: @code{false}
321 Controla el resultado devuelto por @code{ifactors}. El valor por defecto
322 @code{false} hace que @code{ifactors} no dé información sobre las
323 multiplicidades de los factores primos calculados. Cuando @code{factors_only}
324 vale @code{true}, @code{ifactors} solo devuelve la lista de factores primos.
326 Para ejemplos, véase @code{ifactors}.
327 @end defvr
331 @deffn {Función} fib (@var{n})
332 Devuelve el @var{n}-ésimo número de Fibonacci. La llamada @code{fib(0)}
333 devuelve 0, @code{fib(1)} devuelve 1 y @code{fib (-@var{n})} es igual a
334 @code{(-1)^(@var{n} + 1) * fib(@var{n})}.
336 Después de llamar a @code{fib}, la variable @code{prevfib} toma el valor
337 @code{fib (@var{n} - 1)}, que es el número de Fibonacci que precede al último calculado.
339 @example
340 (%i1) map (fib, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
341 (%o1) [- 3, 2, - 1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21]
342 @end example
344 @end deffn
346 @deffn {Función} fibtophi (@var{expr})
347 Expresa los números de Fibonacci en @var{expr} en términos de la razón áurea @code{%phi},
348 que es @code{(1 + sqrt(5))/2}, aproximadamente 1.61803399.
350 Ejemplos:
352 @c ===beg===
353 @c fibtophi (fib (n));
354 @c fib (n-1) + fib (n) - fib (n+1);
355 @c fibtophi (%);
356 @c ratsimp (%);
357 @c ===end===
358 @example
359 (%i1) fibtophi (fib (n));
360 n n
361 %phi - (1 - %phi)
362 (%o1) -------------------
363 2 %phi - 1
364 (%i2) fib (n-1) + fib (n) - fib (n+1);
365 (%o2) - fib(n + 1) + fib(n) + fib(n - 1)
366 (%i3) fibtophi (%);
367 n + 1 n + 1 n n
368 %phi - (1 - %phi) %phi - (1 - %phi)
369 (%o3) - --------------------------- + -------------------
370 2 %phi - 1 2 %phi - 1
371 n - 1 n - 1
372 %phi - (1 - %phi)
373 + ---------------------------
374 2 %phi - 1
375 (%i4) ratsimp (%);
376 (%o4) 0
377 @end example
379 @end deffn
384 @deffn {Función} ifactors (@var{n})
385 Devuelve la factorización del entero positivo @var{n}. Si @code{n=p1^e1..pk^nk} es
386 la descomposición de @var{n} en números primos, @code{ifactors} devuelve
387 @code{[[p1, e1], ... , [pk, ek]]}.
389 Los métodos de factorización se basan en divisiones tentativas con números primos
390 hasta 9973, en los métodos rho y p-1 de Pollard y en curvas elípticas.
392 La respuesta que se obtiene de @code{ifactors} está controlada por la variable opcional
393 @code{factors_only}. El valor por defecto @code{false} hace que @code{ifactors} no
394 dé información sobre las multiplicidades de los factores primos calculados.
395 Cuando @code{factors_only} vale @code{true}, @code{ifactors} solo devuelve la lista
396 de factores primos.
398 @example
399 (%i1) ifactors(51575319651600);
400 (%o1) [[2, 4], [3, 2], [5, 2], [1583, 1], [9050207, 1]]
401 (%i2) apply("*", map(lambda([u], u[1]^u[2]), %));
402 (%o2) 51575319651600
403 (%i3) ifactors(51575319651600), factors_only : true;
404 (%o3) [2, 3, 5, 1583, 9050207]
405 @end example
407 @end deffn
411 @deffn {Función} igcdex (@var{n}, @var{k})
413 Devuelve la lista @code{[@var{a}, @var{b}, @var{u}]}, donde @var{u} es
414 el máximo común divisor de @var{n} y @var{k}, siendo @var{u}
415 igual a @code{@var{a} @var{n} + @var{b} @var{k}}. Los argumentos
416 @var{n} y @var{k} deben ser enteros.
418 @code{igcdex} implementa el algoritmo de Euclides. Véase también @code{gcdex}.
420 La instrucción @code{load("gcdex")} carga esta función.
422 Ejemplos:
424 @example
425 (%i1) load("gcdex")$
427 (%i2) igcdex(30,18);
428 (%o2) [- 1, 2, 6]
429 (%i3) igcdex(1526757668, 7835626735736);
430 (%o3) [845922341123, - 164826435, 4]
431 (%i4) igcdex(fib(20), fib(21));
432 (%o4) [4181, - 2584, 1]
433 @end example
435 @end deffn
440 @deffn {Función} inrt (@var{x}, @var{n})
441 Devuelve la raíz entera @var{n}-ésima del valor absoluto de @var{x}.
443 @example
444 (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
445 (%i2) map (lambda ([a], inrt (10^a, 3)), l);
446 (%o2) [2, 4, 10, 21, 46, 100, 215, 464, 1000, 2154, 4641, 10000]
447 @end example
449 @end deffn
451 @deffn {Función} inv_mod (@var{n}, @var{m})
452 Calcula el inverso de @var{n} módulo @var{m}.
453 La llamada @code{inv_mod (n,m)} devuelve @code{false}
454 si @var{n} es un divisor nulo módulo @var{m}.
456 @example
457 (%i1) inv_mod(3, 41);
458 (%o1) 14
459 (%i2) ratsimp(3^-1), modulus = 41;
460 (%o2) 14
461 (%i3) inv_mod(3, 42);
462 (%o3) false
463 @end example
465 @end deffn
468 @deffn {Función} isqrt (@var{x})
469 Devuelve la "raíz cuadrada entera"
470 del valor absoluto de @var{x},
471 el cual debe ser un entero.
473 @end deffn
477 @deffn {Función} jacobi (@var{p}, @var{q})
478 Devuelve el símbolo de Jacobi para @var{p} y @var{q}.
480 @example
481 (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
482 (%i2) map (lambda ([a], jacobi (a, 9)), l);
483 (%o2) [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0]
484 @end example
486 @end deffn
488 @deffn {Función} lcm (@var{expr_1}, ..., @var{expr_n})
489 Devuelve el mínimo común múltiplo de sus argumentos.
490 Los argumentos pueden ser tanto expresiones en general como enteros.
492 Es necesario cargar en memoria esta función haciendo @code{load ("functs")}.
494 @end deffn
500 @deffn {Función} lucas (@var{n})
501 Devuelve el @var{n}-ésimo número de Lucas.
502 @code{lucas(0)} es igual a 2, @code{lucas(1)} es igual a 1 y
503 @code{lucas(-@var{n})} es igual a @code{(-1)^(-@var{n}) * lucas(@var{n})}.
505 @example
506 (%i1) map (lucas, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
507 (%o1) [7, - 4, 3, - 1, 2, 1, 3, 4, 7, 11, 18, 29, 47]
508 @end example
510 Después de llamar a @code{lucas}, la variable global @code{next_lucas}
511 es igual a @code{lucas (@var{n} + 1)}, el número de Lucas que sigue al
512 último que se ha devuelto. El ejemplo muestra como los números de
513 Fibonacci se pueden calcular mediante @code{lucas} y @code{next_lucas}.
515 @example
516 (%i1) fib_via_lucas(n) :=
517 block([lucas : lucas(n)],
518 signum(n) * (2*next_lucas - lucas)/5 )$
519 (%i2) map (fib_via_lucas, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
520 (%o2) [- 3, 2, - 1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21]
521 @end example
522 @end deffn
529 @deffn {Función} mod (@var{x}, @var{y})
531 Si @var{x} e @var{y} son números reales e @var{y} es distinto de cero,
532 devuelve @code{@var{x} - @var{y} * floor(@var{x} / @var{y})}.
533 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",
534 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}.
536 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.
538 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.
540 Para argumentos no numéricos @var{x} o @var{y}, @code{mod} aplica algunas reglas de simplificación:
542 @c ===beg===
543 @c mod (x, 0);
544 @c mod (a*x, a*y);
545 @c mod (0, x);
546 @c ===end===
547 @example
548 (%i1) mod (x, 0);
549 (%o1) x
550 (%i2) mod (a*x, a*y);
551 (%o2) a mod(x, y)
552 (%i3) mod (0, x);
553 (%o3) 0
554 @end example
555 @end deffn
559 @deffn {Función} next_prime (@var{n})
560 Devuelve el menor de los primos mayores que @var{n}.
562 @example
563 (%i1) next_prime(27);
564 (%o1) 29
565 @end example
567 @end deffn
570 @deffn {Función} partfrac (@var{expr}, @var{var})
571 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.
573 @example
574 (%i1) 1/(1+x)^2 - 2/(1+x) + 2/(2+x);
575 2 2 1
576 (%o1) ----- - ----- + --------
577 x + 2 x + 1 2
578 (x + 1)
579 (%i2) ratsimp (%);
580 x
581 (%o2) - -------------------
582 3 2
583 x + 4 x + 5 x + 2
584 (%i3) partfrac (%, x);
585 2 2 1
586 (%o3) ----- - ----- + --------
587 x + 2 x + 1 2
588 (x + 1)
589 @end example
591 @end deffn
596 @deffn {Función} power_mod (@var{a}, @var{n}, @var{m})
597 Utiliza un algoritmo modular para calcular @code{a^n mod m},
598 siendo @var{a} y @var{n} enteros cualesquiera y @var{m} un entero positivo.
599 Si @var{n} es negativo, se utilizará @code{inv_mod} para encontrar el
600 inverso modular.
602 @example
603 (%i1) power_mod(3, 15, 5);
604 (%o1) 2
605 (%i2) mod(3^15,5);
606 (%o2) 2
607 (%i3) power_mod(2, -1, 5);
608 (%o3) 3
609 (%i4) inv_mod(2,5);
610 (%o4) 3
611 @end example
613 @end deffn
615 @deffn {Función} primep (@var{n})
616 Comprueba si el número entero @var{n} es o no primo, devolviendo @code{true}
617 o @code{false} según el caso.
619 Cuando el resultado de @code{primep (@var{n})} es @code{false}, @var{n} es un
620 número compuesto, y si es @code{true}, @var{n} es primo con alta probabilidad.
622 Si @var{n} es menor que 3317044064679887385961981, se utiliza una versión
623 determinística de la prueba de Miller-Rabin. En tal caso,
624 si @code{primep (@var{n})} devuelve @code{true}, entonces @var{n} es un número primo.
626 Para @var{n} mayor que 3317044064679887385961981 @code{primep} realiza
627 @code{primep_number_of_tests} pruebas de seudo-primalidad de Miller-Rabin y una
628 prueba de seudo-primalidad de Lucas. La probabilidad de que un número compuesto
629 @var{n} pase una prueba de Miller-Rabin es menor que 1/4. Con el valor por defecto de
630 @code{primep_number_of_tests}, que es 25, la probabilidad de que @var{n}
631 sea compuesto es menor que 10^-15.
633 @end deffn
638 @defvr {Variable opcional} primep_number_of_tests
639 Valor por defecto: 25
641 Número de pruebas de Miller-Rabin a realizar por @code{primep}.
642 @end defvr
644 @deffn {Función} prev_prime (@var{n})
645 Devuelve el mayor de los primos menores que @var{n}.
647 @example
648 (%i1) prev_prime(27);
649 (%o1) 23
650 @end example
651 @end deffn
654 @deffn {Función} qunit (@var{n})
655 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}.
657 @example
658 (%i1) qunit (17);
659 (%o1) sqrt(17) + 4
660 (%i2) expand (% * (sqrt(17) - 4));
661 (%o2) 1
662 @end example
664 @end deffn
668 @deffn {Función} totient (@var{n})
669 Devuelve el número de enteros menores o iguales a @var{n} que son primos relativos con @var{n}.
670 @end deffn
672 @defvr {Variable opcional} zerobern
673 Valor por defecto: @code{true}
675 Si @code{zerobern} vale @code{false}, @code{bern} excluye los números de Bernoulli
676 y @code{euler} excluye los números de Euler que sean iguales a cero.
677 Véase @code{bern} y @code{euler}.
678 @end defvr
683 @deffn {Función} zeta (@var{n})
684 Devuelve la función zeta de Riemann. Si @var{n} es entero negativo,
685 0 o número par positivo, la función zeta de Riemann devuelve un
686 valor exacto; en el caso de número par positivo, la variable opcional
687 @code{zeta%pi}, además, tiene que tener el valor @code{true}
688 (véase @code{zeta%pi}).
689 Cuando el argumento es un número decimal o bigfloat,
690 entonces la función zeta de Riemann se calcula numéricamente.
691 Maxima devuelve una forma nominal @code{zeta (@var{n})} para
692 cualesquiera otros argumentos, incluidos los racionales no enteros,
693 los números complejos y los enteros pares si @code{zeta%pi} vale
694 @code{false}.
696 @code{zeta(1)} no está definida, pero Maxima conce el límite
697 de @code{limit(zeta(x), x, 1)} por ambos lados.
699 La función zeta de Riemann se distribuye sobre las listas, matrices
700 y ecuaciones.
702 Véanse también @code{bfzeta} y @code{zeta%pi}.
704 Ejemplos:
706 @c ===beg===
707 @c zeta([-2,-1,0,0.5,2,3,1+%i]);
708 @c limit(zeta(x),x,1,plus);
709 @c limit(zeta(x),x,1,minus);
710 @c ===end===
711 @example
712 (%i1) zeta([-2,-1,0,0.5,2,3,1+%i]);
713 2
714 1 1 %pi
715 (%o1) [0, - --, - -, - 1.460354508809587, ----, zeta(3), zeta(%i + 1)]
716 12 2 6
718 (%i2) limit(zeta(x),x,1,plus);
719 (%o2) inf
720 (%i3) limit(zeta(x),x,1,minus);
721 (%o3) minf
722 @end example
724 @end deffn
730 @defvr {Variable opcional} zeta%pi
731 Valor por defecto: @code{true}
733 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)}.
735 Ejemplos:
737 @c ===beg===
738 @c zeta%pi: true$
739 @c zeta (4);
740 @c zeta%pi: false$
741 @c zeta (4);
742 @c ===end===
743 @example
744 (%i1) zeta%pi: true$
745 (%i2) zeta (4);
746 4
747 %pi
748 (%o2) ----
749 90
750 (%i3) zeta%pi: false$
751 (%i4) zeta (4);
752 (%o4) zeta(4)
753 @end example
755 @end defvr
762 @deffn {Función} zn_add_table (@var{n})
763 Muestra la tabla de la suma de todos los elementos de (Z/@var{n}Z).
765 Véanse también @code{zn_mult_table} y @code{zn_power_table}.
767 @end deffn
775 @deffn {Función} zn_determinant (@var{matrix}, @var{p})
776 Utiliza el procedimiento de la descomposición LU para calcular el determinante
777 de @var{matrix} sobre (Z/@var{p}Z). El argumento @var{p} debe ser un número primo.
779 Si el determinante es igual a cero, el procedimiento puede fallar, en cuyo caso
780 @code{zn_determinant} calcula el determinante no modular y luego reduce.
782 Véase también @code{zn_invert_by_lu}.
784 Ejemplo:
786 @example
787 (%i1) m : matrix([1,3],[2,4]);
788 [ 1 3 ]
789 (%o1) [ ]
790 [ 2 4 ]
791 (%i2) zn_determinant(m, 5);
792 (%o2) 3
793 (%i3) m : matrix([2,4,1],[3,1,4],[4,3,2]);
794 [ 2 4 1 ]
795 [ ]
796 (%o3) [ 3 1 4 ]
797 [ ]
798 [ 4 3 2 ]
799 (%i4) zn_determinant(m, 5);
800 (%o4) 0
801 @end example
803 @end deffn
809 @deffn {Función} zn_invert_by_lu (@var{matrix}, @var{p})
810 Utiliza el procedimiento de la descomposición LU para calcular la inversa
811 modular de @var{matrix} sobre (Z/@var{p}Z). El argumento @var{p} debe ser
812 un número primo y @var{matrix} invertible. La función @code{zn_invert_by_lu}
813 devuelve @code{false} si @var{matrix} no es invertible.
815 Véase @code{zn_determinant}.
817 Ejemplo:
819 @example
820 (%i1) m : matrix([1,3],[2,4]);
821 [ 1 3 ]
822 (%o1) [ ]
823 [ 2 4 ]
824 (%i2) zn_determinant(m, 5);
825 (%o2) 3
826 (%i3) mi : zn_invert_by_lu(m, 5);
827 [ 3 4 ]
828 (%o3) [ ]
829 [ 1 2 ]
830 (%i4) matrixmap(lambda([a], mod(a, 5)), m . mi);
831 [ 1 0 ]
832 (%o4) [ ]
833 [ 0 1 ]
834 @end example
836 @end deffn
843 @deffn {Función} zn_log (@var{a}, @var{g}, @var{n})
844 @deffnx {Función} zn_log (@var{a}, @var{g}, @var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
845 Calcula el logaritmo discreto. Sea (Z/@var{n}Z)* un grupo cíclico,
846 @var{g} una raíz primitiva módulo @var{n} y @var{a} un miembro
847 de este grupo, entonces @code{zn_log (a, g, n)} calcula la congruencia @code{g^x = a mod n}.
849 El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta
850 factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
851 ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
852 cuarto argumento. La lista debe ser de la misma forma que las lista devuelta por
853 @code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.
855 El algoritmo utiliza la reducción de Pohlig-Hellman y el método Rho de Pollard
856 para los logaritmos discretos. El tiempo de ejecución de @code{zn_log} depende en
857 primer lugar del número de bits del mayor factor primo del totient.
859 Véanse también @code{zn_primroot}, @code{zn_order}, @code{ifactors} y @code{totient}.
861 Ejemplos:
863 @code{zn_log (a, g, n)} resuelve la congruencia @code{g^x = a mod n}.
865 @example
866 (%i1) n : 22$
867 (%i2) g : zn_primroot(n);
868 (%o2) 7
869 (%i3) ord_7 : zn_order(7, n);
870 (%o3) 10
871 (%i4) powers_7 : makelist(power_mod(g, x, n), x, 0, ord_7 - 1);
872 (%o4) [1, 7, 5, 13, 3, 21, 15, 17, 9, 19]
873 (%i5) zn_log(21, g, n);
874 (%o5) 5
875 (%i6) map(lambda([x], zn_log(x, g, n)), powers_7);
876 (%o6) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
877 @end example
879 El cuarto argumento opcional debe ser de la misma forma que la lista devuelta por
880 @code{ifactors(totient(n))}.
882 @example
883 (%i1) (p : 2^127-1, primep(p));
884 (%o1) true
885 (%i2) ifs : ifactors(p - 1)$
886 (%i3) g : zn_primroot(p, ifs);
887 (%o3) 43
888 (%i4) a : power_mod(g, 1234567890, p)$
889 (%i5) zn_log(a, g, p, ifs);
890 (%o5) 1234567890
891 (%i6) time(%o5);
892 (%o6) [1.204]
893 (%i7) f_max : last(ifs);
894 (%o7) [77158673929, 1]
895 (%i8) slength( printf(false, "~b", f_max[1]) );
896 (%o8) 37
897 @end example
899 @end deffn
906 @deffn {Función} zn_mult_table (@var{n})
907 @deffnx {Función} zn_mult_table (@var{n}, all)
908 Sin el argumento opcional @var{all}, @code{zn_mult_table(n)}
909 muestra la tabla de multiplicación de los elementos de (Z/@var{n}Z)*,
910 que son todos elementos invertibles módulo @var{n}.
912 El argumento opcional @var{all} hace que la tabla se genere para todos los
913 elementos no nulos.
915 Véanse también @code{zn_add_table} y @code{zn_power_table}.
917 Ejemplo:
919 @example
920 (%i1) zn_mult_table(4);
921 [ 1 3 ]
922 (%o1) [ ]
923 [ 3 1 ]
924 (%i2) zn_mult_table(4, all);
925 [ 1 2 3 ]
926 [ ]
927 (%o2) [ 2 0 2 ]
928 [ ]
929 [ 3 2 1 ]
930 @end example
932 @end deffn
940 @deffn {Función} zn_order (@var{x}, @var{n})
941 @deffnx {Función} zn_order (@var{x}, @var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
942 Devuelve el orden de @var{x} si es una unidad del grupo finito (Z/@var{n}Z)*, o devuelve @code{false}.
943 @var{x} una unidad módulo @var{n} si es coprimo con @var{n}.
945 El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta
946 factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
947 ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
948 tercer argumento. La lista debe ser de la misma forma que las lista devuelta por
949 @code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.
951 Véanse también @code{zn_primroot}, @code{ifactors} y @code{totient}.
953 Ejemplos:
955 @code{zn_order} calcula el orden de la unidad @var{x} en (Z/@var{n}Z)*.
957 @example
958 (%i1) n : 22$
959 (%i2) g : zn_primroot(n);
960 (%o2) 7
961 (%i3) units_22 : sublist(makelist(i,i,1,21), lambda([x], gcd(x, n) = 1));
962 (%o3) [1, 3, 5, 7, 9, 13, 15, 17, 19, 21]
963 (%i4) (ord_7 : zn_order(7, n)) = totient(n);
964 (%o4) 10 = 10
965 (%i5) powers_7 : makelist(power_mod(g,i,n), i,0,ord_7 - 1);
966 (%o5) [1, 7, 5, 13, 3, 21, 15, 17, 9, 19]
967 (%i6) map(lambda([x], zn_order(x, n)), powers_7);
968 (%o6) [1, 10, 5, 10, 5, 2, 5, 10, 5, 10]
969 (%i7) map(lambda([x], ord_7/gcd(x, ord_7)), makelist(i, i,0,ord_7 - 1));
970 (%o7) [1, 10, 5, 10, 5, 2, 5, 10, 5, 10]
971 (%i8) totient(totient(n));
972 (%o8) 4
973 @end example
975 El tercer argumento opcional debe ser de la misma forma que la lista devuelta
976 por @code{ifactors(totient(n))}.
978 @example
979 (%i1) (p : 2^142 + 217, primep(p));
980 (%o1) true
981 (%i2) ifs : ifactors( totient(p) )$
982 (%i3) g : zn_primroot(p, ifs);
983 (%o3) 3
984 (%i4) is( (ord_3 : zn_order(g, p, ifs)) = totient(p) );
985 (%o4) true
986 (%i5) map(lambda([x], ord_3/zn_order(x, p, ifs)), makelist(i,i,2,15));
987 (%o5) [22, 1, 44, 10, 5, 2, 22, 2, 8, 2, 1, 1, 20, 1]
988 @end example
990 @end deffn
996 @deffn {Función} zn_power_table (@var{n})
997 @deffnx {Función} zn_power_table (@var{n}, all)
998 Sin el argumento opcional @var{all}, @code{zn_power_table(n)}
999 muestra la tabla de potencias de los elementos de (Z/@var{n}Z)*,
1000 que son todos elementos invertibles módulo @var{n}. El exponente
1001 se obtiene con un bucle desde @code{1} hasta @code{totient(n)}
1002 y la tabla termina con una columna de unos al lado derecho.
1004 El argumento opcional @var{all} hace que la tabla se genere para todos los
1005 elementos no nulos. En este caso, el exponente se calcula con un bucle desde
1006 @code{1} hasta @code{totient(n) + 1} y la última columna es por lo tanto
1007 igual a la primera.
1009 Véanse también @code{zn_add_table} y @code{zn_mult_table}.
1011 Ejemplo:
1013 @example
1014 (%i1) zn_power_table(6);
1015 [ 1 1 ]
1016 (%o1) [ ]
1017 [ 5 1 ]
1018 (%i2) zn_power_table(6, all);
1019 [ 1 1 1 ]
1020 [ ]
1021 [ 2 4 2 ]
1022 [ ]
1023 (%o2) [ 3 3 3 ]
1024 [ ]
1025 [ 4 4 4 ]
1026 [ ]
1027 [ 5 1 5 ]
1028 @end example
1030 @end deffn
1037 @deffn {Función} zn_primroot (@var{n})
1038 @deffnx {Función} zn_primroot (@var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
1039 Si el grupo multiplicativo es cíclico, @code{zn_primroot}
1040 calcula la menor raíz primitiva de módulo @var{n}. (Z/@var{n}Z)* es
1041 cíclico si @var{n} es igual a @code{2}, @code{4}, @code{p^k} o @code{2*p^k},
1042 siendo @code{p} primo y mayor que @code{2} y @code{k} un número natural.
1043 Si a la variable opcional @code{zn_primroot_pretest}, cuyo valor por defecto es
1044 @code{false}, se le da el valor @code{true}, entonces @code{zn_primroot}
1045 realiza una prueba previa. En cualquier caso, el cálculo está limitado por la
1046 cota superior @code{zn_primroot_limit}.
1048 Si (Z/@var{n}Z)* no es cíclico o si no tiene raíces
1049 primitivas menores que @code{zn_primroot_limit}, @code{zn_primroot} devuelve
1050 @code{false}.
1052 El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta
1053 factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
1054 ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
1055 argumento adicional. La lista debe ser de la misma forma que las lista devuelta por
1056 @code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.
1058 Véanse también @code{zn_primroot_p}, @code{zn_order}, @code{ifactors} y @code{totient}.
1060 Ejemplos:
1062 @code{zn_primroot} calcula la menor raíz primitiva de módulo @var{n} o
1063 devuelve @code{false}.
1065 @example
1066 (%i1) n : 14$
1067 (%i2) g : zn_primroot(n);
1068 (%o2) 3
1069 (%i3) zn_order(g, n) = totient(n);
1070 (%o3) 6 = 6
1071 (%i4) n : 15$
1072 (%i5) zn_primroot(n);
1073 (%o5) false
1074 @end example
1076 El argumento opcional debe ser de la misma forma que la lista devuelta
1077 por @code{ifactors(totient(n))}.
1079 @example
1080 (%i1) (p : 2^142 + 217, primep(p));
1081 (%o1) true
1082 (%i2) ifs : ifactors( totient(p) )$
1083 (%i3) g : zn_primroot(p, ifs);
1084 (%o3) 3
1085 (%i4) [time(%o2), time(%o3)];
1086 (%o4) [[15.556972], [0.004]]
1087 (%i5) is(zn_order(g, p, ifs) = p - 1);
1088 (%o5) true
1089 (%i6) n : 2^142 + 216$
1090 (%i7) ifs : ifactors(totient(n))$
1091 (%i8) zn_primroot(n, ifs),
1092 zn_primroot_limit : 200, zn_primroot_verbose : true;
1093 `zn_primroot' stopped at zn_primroot_limit = 200
1094 (%o8) false
1095 @end example
1097 @end deffn
1104 @defvr {Option variable} zn_primroot_limit
1105 Valor por defecto: @code{1000}
1107 Si @code{zn_primroot} no puede encontrar una raíz primitiva,
1108 entonces se para en esta cota superior. Si a la variable opcional
1109 @code{zn_primroot_verbose} se le da el valor @code{true}, se imprimirá un
1110 mensaje cuando @code{zn_primroot_limit} sea alcanzado.
1112 @end defvr
1120 @deffn {Función} zn_primroot_p (@var{x}, @var{n})
1121 @deffnx {Función} zn_primroot_p (@var{x}, @var{n}, [[@var{p1}, @var{e1}], @dots{}, [@var{pk}, @var{ek}]])
1122 Comprueba si @var{x} es una raíz primitiva en el
1123 grupo multiplizativo (Z/@var{n}Z)*.
1125 El algoritmo que se aplica necesita una factorización prima de @code{totient(n)}. Esta
1126 factorización puede requerir mucho tiempo de cálculo, por lo que en ciertos casos puede
1127 ser aconsejable factorizar primero y luego pasar la lista de factores a @code{zn_log} como
1128 tercer argumento. La lista debe ser de la misma forma que las lista devuelta por
1129 @code{ifactors(totient(n))} utilizando la opción por defecto @code{factors_only : false}.
1131 Véanse también @code{zn_primroot}, @code{zn_order}, @code{ifactors} y @code{totient}.
1133 Ejemplos:
1135 @code{zn_primroot_p} como función de predicado.
1137 @example
1138 (%i1) n : 14$
1139 (%i2) units_14 : sublist(makelist(i,i,1,13), lambda([i], gcd(i, n) = 1));
1140 (%o2) [1, 3, 5, 9, 11, 13]
1141 (%i3) zn_primroot_p(13, n);
1142 (%o3) false
1143 (%i4) sublist(units_14, lambda([x], zn_primroot_p(x, n)));
1144 (%o4) [3, 5]
1145 (%i5) map(lambda([x], zn_order(x, n)), units_14);
1146 (%o5) [1, 6, 6, 3, 3, 2]
1147 @end example
1149 El tercer argumento opcional debe ser de la misma forma que la lista
1150 devuelta por @code{ifactors(totient(n))}.
1152 @example
1153 (%i1) (p : 2^142 + 217, primep(p));
1154 (%o1) true
1155 (%i2) ifs : ifactors( totient(p) )$
1156 (%i3) sublist(makelist(i,i,1,50), lambda([x], zn_primroot_p(x, p, ifs)));
1157 (%o3) [3, 12, 13, 15, 21, 24, 26, 27, 29, 33, 38, 42, 48]
1158 (%i4) [time(%o2), time(%o3)];
1159 (%o4) [[7.748484], [0.036002]]
1160 @end example
1162 @end deffn
1169 @defvr {Option variable} zn_primroot_pretest
1170 Valor por defecto: @code{false}
1172 El grupo multiplicativo (Z/@var{n}Z)* es cíclico si if @var{n}
1173 es igual a @code{2}, @code{4}, @code{p^k} o @code{2*p^k}, siendo @code{p}
1174 un número primo mayor que @code{2} y @code{k} es un número natural.
1176 La variable @code{zn_primroot_pretest} controla si @code{zn_primroot} debe
1177 comprobar si sucede alguna de estas situaciones antes de calcular la menor
1178 raíz primitiva. Solo se realizará esta comprobación si
1179 @code{zn_primroot_pretest} toma el valor @code{true}.
1181 @end defvr
1189 @defvr {Option variable} zn_primroot_verbose
1190 Valor por defecto: @code{false}
1192 Controla si @code{zn_primroot} imprime un mensaje cuando alcanza @code{zn_primroot_limit}.
1194 @end defvr