[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
29.1 Funciones y variables para teoría de números |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Devuelve el n-ésimo número de Bernoulli del entero n.
Los números de Bernoulli iguales a cero son suprimidos si zerobern
vale false
.
Véase también burn
.
(%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 5 691 7 3617 43867 (%o4) [1, - -, -, - --, --, - ----, -, - ----, -----] 2 6 30 66 2730 6 510 798
Devuelve el n-ésimo polinomio de Bernoulli de variable x.
Devuelve la función zeta de Riemann para el argumento s. El valor que devuelve es del tipo "big float" (bfloat) y n es su número de dígitos.
Es necesario cargar en memoria esta función haciendo load ("bffac")
.
Devuelve la función zeta de Hurwitz para los argumentos s y h. El valor que devuelve es del tipo "big float" (bfloat) y n es su número de dígitos.
La función zeta de Hurwitz se define como
inf ==== \ 1 zeta (s,h) = > -------- / s ==== (k + h) k = 0
Ejecútese load (bffac)
antes de hacer uso de esta función.
Siendo n entero, Devuelve un número racional que aproxima el
n-ésimo número de Bernoulli. La función burn
aprovecha
el hecho de que los números de Bernoulli racionales se pueden aproximar
con notable precisión gracias a
n - 1 1 - 2 n (- 1) 2 zeta(2 n) (2 n)! B(2 n) = ------------------------------------ 2 n %pi
La función burn
puede ser más eficiente que bern
cuando
n es un número grande, ya que bern
calcula todos los números
de Bernoulli hasta el n-ésimo. Por el contrario, burn
hace
uso de la aproximación para enteros pares n > 255. En caso de
enteros impares y n <= 255, se hace uso de la función bern
.
Para utilizar esta función hay que cargarla antes en memoria escribiendo
load ("bffac")
. Véase también bern
.
Transforma expr a fracciones continuas. La expresión expr debe contener fracciones continuas y raíces cuadradas de números enteros. Los operandos de la expresión pueden combinarse con operadores aritméticos. Además de fracciones continuas y raíces cuadradas, los factores de la expresión deben ser enteros o números racionales. Maxima no tiene más conocimiento sobre operaciones con fracciones continuas que el que aporta la función cf
.
La función cf
evalúa sus argumentos después de asignar a la variable listarith
el valor false
, retornando una fracción continua en forma de lista.
Una fracción continua a + 1/(b + 1/(c + ...))
se representa como la lista [a, b, c, ...]
, donde los elementos a
, b
, c
, ... se evalúan como enteros. La expresión expr puede contener también sqrt (n)
donde n
es un entero; en tal caso, cf
devolverá tantos términos de la fracción continua como indique el valor de la variable cflength
multiplicado por el período.
Una fracción continua puede reducirse a un número evaluando la representación aritmética que devuelve cfdisrep
. Véase también cfexpand
, que es otra alternativa para evaluar fracciones continuas.
Véanse asimismo cfdisrep
, cfexpand
y cflength
.
Ejemplos:
(%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]
cflength
controla cuantos períodos de la fracción continua se calculan para números irracionales algebraicos.
(%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]
cfdisrep
.
(%i1) cflength: 3$ (%i2) cfdisrep (cf (sqrt (3)))$ (%i3) ev (%, numer); (%o3) 1.731707317073171
cf
.
(%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]
Construye y devuelve una expresión aritmética ordinaria de la forma a + 1/(b + 1/(c + ...))
a partir de la representación en formato lista de la fracción continua [a, b, c, ...]
.
(%i1) cf ([1, 2, -3] + [1, -2, 1]); (%o1) [1, 1, 1, 2] (%i2) cfdisrep (%); 1 (%o2) 1 + --------- 1 1 + ----- 1 1 + - 2
Devuelve la matriz con los numeradores y denominadores de la última (columna 1) y penúltima (columna 2) convergentes de la fracción continua x.
(%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
Valor por defecto: 1
La variable cflength
controla el número de términos de la fracción continua que devuelve la función cf
, que será cflength
multiplicado por el período. Así, el valor por defecto será el de un período.
(%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]
La llamada divsum (n, k)
devuelve la suma de los divisores de n elevados a la k-ésima potencia.
La llamada divsum (n)
devuelve la suma de los divisores de n.
(%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
Devuelve el n-ésimo número de Euler del entero no negativo n.
Para la constante de Euler-Mascheroni, véase %gamma
.
(%i1) map (euler, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); (%o1) [1, 0, - 1, 0, 5, 0, - 61, 0, 1385, 0, - 50521]
Devuelve el n-ésimo número de Fibonacci. La llamada fib(0)
es igual a 0, fib(1)
devuelve 1 y
fib (-n)
es igual a (-1)^(n + 1) * fib(n)
.
Después de llamar a fib
, la variable prevfib
toma el valor fib (x - 1)
, que es el número de Fibonacci que precede al último calculado.
(%i1) map (fib, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); (%o1) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
Expresa los números de Fibonacci en expr en términos de la razón áurea %phi
,
que es (1 + sqrt(5))/2
, aproximadamente 1.61803399.
Ejemplos:
(%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
Devuelve la factorización del argumento n, siendo éste un
número entero positivo. Si n=p1^e1..pk^nk
es la descomposición
de n en números primos, ifactors
devuelve [[p1, e1], ... , [pk, ek]]
.
Los métodos de factorización son las divisones tentativas hasta el 9973, así como los métodos rho de Pollard y el de la curva elíptica.
(%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
Devuelve la lista [a, b, u]
, donde u es
el máximo común divisor de n y k, siendo u
igual a a n + b k
. Los argumentos
n y k deben ser enteros.
igcdex
implementa el algoritmo de Euclides. Véase también gcdex
.
La instrucción load(gcdex)
carga esta función.
Ejemplos:
(%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]
Devuelve la raíz entera n-ésima del valor absoluto de x.
(%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]
Calcula el inverso de n módulo m.
La llamada inv_mod (n,m)
devuelve false
si n es un divisor nulo módulo m.
(%i1) inv_mod(3, 41); (%o1) 14 (%i2) ratsimp(3^-1), modulus=41; (%o2) 14 (%i3) inv_mod(3, 42); (%o3) false
Devuelve la "raíz cuadrada entera" del valor absoluto de x, el cual debe ser un entero.
Devuelve el símbolo de Jacobi para p y q.
(%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]
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 load ("functs")
.
Si x e y son números reales e y es distinto de cero,
devuelve x - y * floor(x / y)
.
Para todos los reales x, se tiene mod (x, 0) = x
. Para información sobre la definición de mod (x, 0) = x
, véase la sección 3.4 de "Concrete Mathematics",
by Graham, Knuth, and Patashnik. La función mod (x, 1)
es de diente de sierra con periodo unidad y con mod (1, 1) = 0
y mod (0, 1) = 0
.
Para encontrar el argumento principal (un número del intervalo (-%pi, %pi]
) de un número complejo, hágase uso de la función x |-> %pi - mod (%pi - x, 2*%pi)
, donde x es un argumento.
Si x e y son expresiones constantes (por ejemplo, 10 * %pi
), mod
utiliza el mismo esquema de evaluación basado en números grandes en coma flotante (big floats) que floor
y ceiling
. También es posible, pero improbable, que mod
pueda retornar un valor erróneo en tales casos.
Para argumentos no numéricos x o y, mod
aplica algunas reglas de simplificación:
(%i1) mod (x, 0); (%o1) x (%i2) mod (a*x, a*y); (%o2) a mod(x, y) (%i3) mod (0, x); (%o3) 0
Devuelve el menor de los primos mayores que n.
(%i1) next_prime(27); (%o1) 29
Expande la expresión expr en fracciones parciales respecto de la variable principal var. La función 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.
(%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)
Utiliza un algoritmo modular para calcular a^n mod m
,
siendo a y n enteros cualesquiera y m un entero positivo.
Si n es negativo, se utilizará inv_mod
para encontrar el
inverso modular.
(%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
Comprueba si el número entero n es o no primo, devolviendo true
o false
según el caso.
Cuando el resultado de primep (n)
es false
, n es un
número compuesto, y si es true
, n es primo con alta probabilidad.
Si n es menor que 341550071728321, se utiliza una versión
determinística de la prueba de Miller-Rabin. En tal caso,
si primep (n)
devuelve true
, entonces n es un número primo.
Para n mayor que 341550071728321 primep
realiza un número de pruebas
de seudo-primalidad de Miller-Rabin igual a primep_number_of_tests
y una
prueba de seudo-primalidad de Lucas. La probabilidad de que n pase una
prueba de Miller-Rabin es menor que 1/4. Con el valor por defecto de
primep_number_of_tests
, que es 25, la probabilidad de que n
sea compuesto es menor que 10^-15.
Valor por defecto: 25
Número de pruebas de Miller-Rabin a realizar por primep
.
Devuelve el mayor de los primos menores que n.
(%i1) prev_prime(27); (%o1) 23
Devuelve la unidad principal de sqrt (n)
, siendo n un entero; consiste en la resolución de la ecuación de Pell a^2 - n b^2 = 1
.
(%i1) qunit (17); (%o1) sqrt(17) + 4 (%i2) expand (% * (sqrt(17) - 4)); (%o2) 1
Devuelve el número de enteros menores o iguales a n que son primos relativos con n.
Valor por defecto: true
Si zerobern
vale false
, bern
excluye los números de Bernoulli
y euler
excluye los números de Euler que sean iguales a cero.
Véase bern
y euler
.
Devuelve la función zeta de Riemann. Si 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
zeta%pi
, además, tiene que tener el valor true
(véase 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 zeta (n)
para
cualesquiera otros argumentos, incluidos los racionales no enteros,
los números complejos y los enteros pares si zeta%pi
vale
false
.
zeta(1)
no está definida, pero Maxima conce el límite
de 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 bfzeta
y zeta%pi
.
Ejemplos:
(%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
Valor por defecto: true
Si zeta%pi
vale true
, zeta
devuelve una expresión proporcional a %pi^n
si n
es un número par positivo. En caso contrario, zeta
no se evalúa y devuelve la forma nominal zeta (n)
.
Ejemplos:
(%i1) zeta%pi: true$ (%i2) zeta (4); 4 %pi (%o2) ---- 90 (%i3) zeta%pi: false$ (%i4) zeta (4); (%o4) zeta(4)
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Robert Dodier on agosto, 1 2011 using texi2html 1.76.