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

33. Teoria dos Números


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

33.1 Definições 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 em termos da constante %phi, que é (1 + sqrt(5))/2, aproximadamente 1.61803399.

Por padrão, Maxima não conhece %phi. Após executar tellrat (%phi^2 - %phi - 1) e algebraic: true, ratsimp pode simplificar algumas expressões contendo %phi.

 
(%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) ratsimp (fibtophi (%));
(%o3)                           0
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: 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: 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: primep (n)

Retorna true se n for um primo, false se não.

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 root on Outubro, 3 2006 using texi2html 1.76.