Definicedilhaões para Teoria dos Números
========================================

 -- Funcedilhaã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

 -- Funcedilhaão: bernpoly (X, N)
     Retorna o N'ésimo polinómio de Bernoulli na variável X.

 -- Funcedilhaão: bfzeta (S, N)
     Retorna a funcedilhaã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 funcedilhaão.

 -- Funcedilhaão: bfhzeta (S, H, N)
     Retorna a funcedilhaã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 funcedilhaão zeta de Hurwitz é definida como

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

     load ("bffac") chama essa funcedilhaão.

 -- Funcedilhaã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)

 -- Funcedilhaã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 observacedilhaão que números de Bernoulli (racionais) podem ser aproximados através de zetas (transcendentes) com eficiência tolerável.

     load ("bffac") chama essa funcedilhaão.

 -- Funcedilhaão: cf (EXPR)
     Converte EXPR em uma fracedilhaão contínua. EXPR é uma expressão compreendendo fracedilhaões contínuas e raízes quadradas de inteiros. Operandos na expressão podem ser combinados com operadores aritméticos. Com excessão de fracedilhaões contínuas e raízes quadradas, factores na expressão devem ser números inteiros ou racionais. Maxima não conhece operacedilhaões sobre fracedilhaões contínuas fora de cf.

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

     Uma fracedilhaã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 fracedilhaão contínua quantos forem o valor da variável cflength vezes o período.

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

     Veja também cfdisrep, cfexpand, e cflength.

     Exemplos:

       * EXPR é uma expressão compreendendo fracedilhaões contínuas e raízes quadradas de inteiros.

               (%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 quantos períodos de fracedilhaão contínua são computados para números algébricos, números irracionais.

               (%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]

       * Um fracedilhaão contínua pode ser avaliado através da avaliacedilhaão da representacedilhaão aritmética retornada por cfdisrep.

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

       * Maxima não conhece operacedilhaões sobre fracedilhaões contínuas fora de 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]

 -- Funcedilhaão: cfdisrep (LIST)
     Constrói e retorna uma expressão aritmética comum da forma a + 1/(b + 1/(c + ...)) a partir da representacedilhaão lista de uma fracedilhaã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

 -- Funcedilhaão: cfexpand (X)
     Retorna uma matriz de numeradores e denominadores dos último (columa 1) e penúltimo (columa 2) convergentes da fracedilhaã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 opcedilhaão: cflength
     Valor por omissão: 1

     cflength controla o número de termos da fracedilhaão contínua que a funcedilhaã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]

 -- Funcedilhaão: divsum (N, K)
 -- Funcedilhaão: divsum (N)

     divsum (N, K) retorna a adicedilhaão dos divisores de N elevados à K'ésima potência.

     divsum (N) retorna a adicedilhaã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

 -- Funcedilhaã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 ....

 -- Funcedilhaão: factorial (X)
     Representa a funcedilhaão factorial. Maxima trata factorial (X) da mesma forma que X!. Veja !.

 -- Funcedilhaã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]

 -- Funcedilhaã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

 -- Funcedilhaão: ifactors (N)
     Para um inteiro positivo N retorna a factoracedilhaão de N. Se n=p1^e1..pk^nk for a decomposicedilhaão de N em factores primos, ifactors retorna [[p1, e1], ... , [pk, ek]].

     Os métodos de factoracedilhaã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

 -- Funcedilhaã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]

 -- Funcedilhaã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

 -- Funcedilhaã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]

 -- Funcedilhaã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 funcedilhaão.

 -- Funcedilhaão: minfactorial (EXPR)
     Examina EXPR procurando por ocorrências de dois factoriais 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)

 -- Funcedilhaão: next_prime (N)
     Retorna o menor primo maior que N.

          (%i1) next_prime(27);
          (%o1)                       29

 -- Funcedilhaão: partfrac (EXPR, VAR)
     Expande a expressão EXPR em fracedilhaões parciais com relacedilhaão à variável principal VAR.  partfrac faz uma decomposicedilhaão completa de fracedilhaão parcial.  O algoritmo utilizado é baseado no facto que os denominadores de uma expansão de fracedilhaão parcial (os factores do denominador original) são relativamente primos.  Os numeradores podem ser escritos como combinacedilhaã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)

 -- Funcedilhaão: power_mod (A, N, M)
     Usa um algoritmo 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

 -- Funcedilhaã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 opcedilhaão: primep_number_of_tests
     Valor por omissão: 25

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

 -- Funcedilhaão: prev_prime (N)
     Retorna o maior primo menor que N.

          (%i1) prev_prime(27);
          (%o1)                       23

 -- Funcedilhaã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 equacedilhaão de Pell a^2 - N b^2 = 1.

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

 -- Funcedilhaã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 opcedilhaão: zerobern
     Valor por omissão: true

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

 -- Funcedilhaão: zeta (N)
     Retorna a funcedilhaã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 opcedilhaão: zeta%pi
     Valor por omissã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)