[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

31. Teoria dos Números


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

31.1 Funções e Variáveis Definidas para Teoria dos Números

Função: bern (n)

Retorna o n'ésimo número de Bernoulli para o inteiro n. Números de Bernoulli iguais a zero são suprimidos se zerobern for false.

Veja também 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
Função: bernpoly (x, n)

Retorna o n'ésimo polinômio de Bernoulli na variável x.

Função: bfzeta (s, n)

Retorna a função zeta de Riemann para o argumento s. O valor de retorno é um grande inteiro em ponto flutuante (bfloat); n é o número de dígitos no valor de retorno.

load ("bffac") chama essa função.

Função: bfhzeta (s, h, n)

Retorna a função zeta de Hurwitz para os argumentos s e h. O valor de retorno é um grande inteiro em ponto flutuante (bfloat); n é o números de dígitos no valor de retorno.

A função zeta de Hurwitz é definida como

sum ((k+h)^-s, k, 0, inf)

load ("bffac") chama essa função.

Função: binomial (x, y)

O coeficiente binomial x!/(y! (x - y)!). Se x e y forem inteiros, então o valor numérico do coeficiente binomial é calculado. Se y, ou x - y, for um inteiro, o the coeficiente binomial é expresso como um polinômio.

Exemplos:

(%i1) binomial (11, 7);
(%o1)                          330
(%i2) 11! / 7! / (11 - 7)!;
(%o2)                          330
(%i3) binomial (x, 7);
        (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x
(%o3)   -------------------------------------------------
                              5040
(%i4) binomial (x + 7, x);
      (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7)
(%o4) -------------------------------------------------------
                               5040
(%i5) binomial (11, y);
(%o5)                    binomial(11, y)
Função: burn (n)

Retorna o n'ésimo número de Bernoulli para o inteiro n. burn pode ser mais eficitente que bern para valores grandes e isolados de n (talvez n maior que 105 ou algo parecido), como bern calcula todos os números de Bernoulli até o índice n antes de retornar.

burn explora a observação que números de Bernoulli (racionais) podem ser aproximados através de zetas (transcendentes) com eficiência tolerável.

load ("bffac") chama essa função.

Função: cf (expr)

Converte expr em uma fração contínua. expr é uma expressão compreendendo frações contínuas e raízes quadradas de inteiros. Operandos na expressão podem ser combinados com operadores aritméticos. Com excessão de frações contínuas e raízes quadradas, fatores na expressão devem ser números inteiros ou racionais. Maxima não conhece operações sobre frações contínuas fora de cf.

cf avalia seus argumentos após associar listarith a false. cf retorna uma fração contínua, representada como uma lista.

Uma fração contínua a + 1/(b + 1/(c + ...)) é representada através da lista [a, b, c, ...]. Os elementos da lista a, b, c, ... devem avaliar para inteiros. expr pode também conter sqrt (n) onde n é um inteiro. Nesse caso cf fornecerá tantos termos de fração contínua quantos forem o valor da variável cflength vezes o período.

Uma fração contínua pode ser avaliada para um número através de avaliação da representação aritmética retornada por cfdisrep. Veja também cfexpand para outro caminho para avaliar uma fração contínua.

Veja também cfdisrep, cfexpand, e cflength.

Exemplos:

Função: cfdisrep (list)

Constrói e retorna uma expressão aritmética comum da forma a + 1/(b + 1/(c + ...)) a partir da representação lista de uma fração contínua [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
Função: cfexpand (x)

Retorna uma matriz de numeradores e denominadores dos último (columa 1) e penúltimo (columa 2) convergentes da fração contínua 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
Variável de opção: cflength

Valor padrão: 1

cflength controla o número de termos da fração contínua que a função cf fornecerá, como o valor de cflength vezes o período. Dessa forma o padrão é fornecer um 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]
Função: divsum (n, k)
Função: divsum (n)

divsum (n, k) retorna a adição dos divisores de n elevados à k'ésima potência.

divsum (n) retorna a adição dos 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
Função: euler (n)

Retorna o n'ésimo número de Euler para o inteiro n não negativo.

Para a constante de Euler-Mascheroni, veja %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]
Constante: %gamma

A constante de Euler-Mascheroni, 0.5772156649015329 ....

Função: factorial (x)

Representa a função fatorial. Maxima trata factorial (x) da mesma forma que x!. Veja !.

Função: fib (n)

Retorna o n'ésimo número de Fibonacci. fib(0) igual a 0 e fib(1) igual a 1, e fib (-n) igual a (-1)^(n + 1) * fib(n).

Após chamar fib, prevfib é iguala fib (x - 1), o número de Fibonacci anterior ao ú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]
Função: fibtophi (expr)

Expressa números de Fibonacci que aparecem em expr em termos da constante %phi, que é (1 + sqrt(5))/2, aproximadamente 1.61803399.

Exemplos:

(%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
Função: ifactors (n)

Para um inteiro positivo n retorna a fatoração de n. Se n=p1^e1..pk^nk for a decomposição de n em fatores primos, ifactors retorna [[p1, e1], ... , [pk, ek]].

Os métodos de fatoração usados são divisões triviais por primos até 9973, o método rho de Pollard e o método da 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
Função: inrt (x, n)

Retorna a parte inteira da n'ésima raíz do 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]
Função: inv_mod (n, m)

Calcula o inverso de n módulo m. inv_mod (n,m) retorna false, se n modulo m for zero.

(%i1) inv_mod(3, 41);
(%o1)                           14
(%i2) ratsimp(3^-1), modulus=41;
(%o2)                           14
(%i3) inv_mod(3, 42);
(%o3)                          false
Função: jacobi (p, q)

Retorna símbolo de Jacobi de p e 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]
Função: lcm (expr_1, ..., expr_n)

Retorna o menor múltiplo comum entre seus argumentos. Os argumentos podem ser expressões gerais também inteiras.

load ("functs") chama essa função.

Função: minfactorial (expr)

Examina expr procurando por ocorrências de dois fatoriais que diferem por um inteiro. minfactorial então converte um em um polinômio vezes o outro.

(%i1) n!/(n+2)!;
                               n!
(%o1)                       --------
                            (n + 2)!
(%i2) minfactorial (%);
                                1
(%o2)                    ---------------
                         (n + 1) (n + 2)
Função: next_prime (n)

Retorna o menor primo maior que n.

(%i1) next_prime(27);
(%o1)                       29
Função: partfrac (expr, var)

Expande a expressão expr em frações parciais com relação à variável principal var. partfrac faz uma decomposição completa de fração parcial. O algorítmo utilizado é baseado no fato que os denominadores de uma expansão de fração parcial (os fatores do denominador original) são relativamente primos. Os numeradores podem ser escritos como combinação linear dos denominadores, e a expansão acontece.

(%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)
Função: power_mod (a, n, m)

Usa um algorítmo modular para calcular a^n mod m onde a e n são inteiros e m é um inteiro positivo. Se n for negativo, inv_mod é usada para encontrar o 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
Função: primep (n)

Teste de primalidade. Se primep (n) retornar false, n é um número compostro e se esse teste retornar true, n é um número primo com grande probabilidade.

Para n menor que 341550071728321 uma versão deterministra do teste de Miller-Rabin é usada. Se primep (n) retornar true, então n é um número primo.

Para n maior que 34155071728321 primep usa primep_number_of_tests que é os testes de pseudo-primalidade de Miller-Rabin e um teste de pseudo-primalidade de Lucas. A probabilidade que n irá passar por um teste de Miller-Rabin é menor que 1/4. Usando o valor padrão 25 para primep_number_of_tests, a probabilidade de n passar no teste sendo composto é muito menor que 10^-15.

Variável de opção: primep_number_of_tests

Valor padrão: 25

Número de testes de Miller-Rabin usados em primep.

Função: prev_prime (n)

Retorna o maior primo menor que n.

(%i1) prev_prime(27);
(%o1)                       23
Função: qunit (n)

Retorna a principal unidade do campo dos números quadráticos reais sqrt (n) onde n é um inteiro, i.e., o elemento cuja norma é unidade. Isso é importante para resolver a equação de Pell a^2 - n b^2 = 1.

(%i1) qunit (17);
(%o1)                     sqrt(17) + 4
(%i2) expand (% * (sqrt(17) - 4));
(%o2)                           1
Função: totient (n)

Retorna o número de inteiros menores que ou iguais a n que são relativamente primos com n.

Variável de opção: zerobern

Valor padrão: true

Quando zerobern for false, bern exclui os números de Bernoulli que forem iguais a zero. Veja bern.

Função: zeta (n)

Retorna a função zeta de Riemann se x for um inteiro negativo, 0, 1, ou número par positivo, e retorna uma forma substantiva zeta (n) para todos os outros argumentos, incluindo não inteiros racionais, ponto flutuante, e argumentos complexos.

Veja também bfzeta e zeta%pi.

(%i1) map (zeta, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5]);
                                     2              4
           1        1     1       %pi            %pi
(%o1) [0, ---, 0, - --, - -, inf, ----, zeta(3), ----, zeta(5)]
          120       12    2        6              90
Variável de opção: zeta%pi

Valor padrão: true

Quando zeta%pi for true, zeta retorna uma expressão proporcional a %pi^n para inteiro par n. De outra forma, zeta retorna uma forma substantiva zeta (n) para inteiro par n.

(%i1) zeta%pi: true$
(%i2) zeta (4);
                                 4
                              %pi
(%o2)                         ----
                               90
(%i3) zeta%pi: false$
(%i4) zeta (4);
(%o4)                        zeta(4)

[ << ] [ >> ]           [Top] [Contents] [Índice] [ ? ]

This document was generated by Jaime Villate on Outubro, 14 2014 using texi2html 1.76.