@c /Number.texi/1.22/Sat Nov 25 04:02:55 2006/-ko/
@c end concepts Number Theory
@menu
* Definições para Teoria dos Números::  
@end menu

@node Definições para Teoria dos Números,  , Teoria dos Números, Teoria dos Números
@section Definições para Teoria dos Números

@deffn {Função} bern (@var{n})
Retorna o @var{n}'ésimo número de Bernoulli para o inteiro @var{n}.
@c WELL, ACTUALLY bern SIMPLIFIES, LIKE FACTORIAL -- DO WE WANT TO GET INTO THAT ???
@c OR JUST PRETEND IT'S "RETURNED" ???
Números de Bernoulli iguais a zero são suprimidos se @code{zerobern} for @code{false}.

Veja também @code{burn}.

@example
(%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
@end example

@end deffn

@deffn {Função} bernpoly (@var{x}, @var{n})
Retorna o @var{n}'ésimo polinómio de Bernoulli na
variável @var{x}.

@end deffn

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

@code{load ("bffac")} chama essa função.

@end deffn

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

A função zeta de Hurwitz é definida como

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

@code{load ("bffac")} chama essa função.

@end deffn

@deffn {Função} binomial (@var{x}, @var{y})
O coeficiente binomial @code{@var{x}!/(@var{y}! (@var{x} - @var{y})!)}.
Se @var{x} e @var{y} forem inteiros, então o valor numérico do coeficiente
binomial é calculado.
Se @var{y}, ou @var{x - y}, for um inteiro,
o the coeficiente binomial é expresso como um polinómio.

Exemplos:

@c ===beg===
@c binomial (11, 7);
@c 11! / 7! / (11 - 7)!;
@c binomial (x, 7);
@c binomial (x + 7, x);
@c binomial (11, y);
@c ===end===
@example
(%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)
@end example

@end deffn

@deffn {Função} burn (@var{n})
Retorna o @var{n}'ésimo número de Bernoulli para o inteiro @var{n}.
@code{burn} pode ser mais eficitente que @code{bern} para valores grandes e isolados de @var{n}
(talvez @var{n} maior que 105 ou algo parecido), @c CLAIM MADE IN bffac.usg !!!
como @code{bern} calcula todos os números de Bernoulli até o índice @var{n} antes de retornar.

@c STATEMENTS ABOUT TIMING NEED VERIFICATION !!!
@c CAN'T VERIFY NOW AS burn IS BROKEN IN 5.9.1 AND CVS BUILD AT PRESENT !!!
@c (BERN(402) takes about 645 secs vs 13.5 secs for BURN(402).
@c The time to compute @code{bern} is approximately exponential,
@c while the time to compute @code{burn} is approximately cubic.
@c But if next you do BERN(404), it only takes 12 secs,
@c since BERN remembers all in an array, whereas BURN(404) will take
@c maybe 14 secs or maybe 25, depending on whether Maxima needs to
@c BFLOAT a better value of %PI.)

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

@code{load ("bffac")} chama essa função.

@end deffn

@deffn {Função} cf (@var{expr})
Converte @var{expr} em uma fração contínua.
@var{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,
factores na expressão devem ser números inteiros ou racionais.
Maxima não conhece operações sobre frações contínuas fora de @code{cf}.

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

Uma fração contínua @code{a + 1/(b + 1/(c + ...))}
é representada através da lista @code{[a, b, c, ...]}.
Os elementos da lista @code{a}, @code{b}, @code{c}, ... devem avaliar para inteiros. 
@var{expr} pode também conter @code{sqrt (n)} onde @code{n} é um inteiro.
Nesse caso @code{cf} fornecerá tantos
termos de fração contínua quantos forem o valor da variável
@code{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 @code{cfdisrep}.
Veja também @code{cfexpand} para outro caminho para avaliar uma fração contínua.

Veja também @code{cfdisrep}, @code{cfexpand}, e @code{cflength}.

Exemplos:

@itemize @bullet
@item
@var{expr} é uma expressão compreendendo frações contínuas e raízes quadradas de inteiros.

@example
(%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]
@end example

@item
@code{cflength} controla quantos períodos de fração contínua
são computados para números algébricos, números irracionais.

@example
(%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]
@end example

@item
Um fração contínua pode ser avaliado através da avaliação da representação aritmética
retornada por @code{cfdisrep}.

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

@item
Maxima não conhece operações sobre frações contínuas fora de @code{cf}.

@example
(%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]
@end example

@end itemize
@end deffn

@c NEEDS CLARIFICATION -- MAKE EXPLICIT HOW list IS RELATED TO a, b, c, ...
@c ALSO, CAN list CONTAIN ANYTHING OTHER THAN LITERAL INTEGERS ??
@deffn {Função} cfdisrep (@var{list})
Constrói e retorna uma expressão aritmética comum
da forma @code{a + 1/(b + 1/(c + ...))}
a partir da representação lista de uma fração contínua @code{[a, b, c, ...]}.

@example
(%i1) cf ([1, 2, -3] + [1, -2, 1]);
(%o1)                     [1, 1, 1, 2]
(%i2) cfdisrep (%);
                                  1
(%o2)                     1 + ---------
                                    1
                              1 + -----
                                      1
                                  1 + -
                                      2
@end example

@end deffn

@deffn {Função} cfexpand (@var{x})
Retorna uma matriz de numeradores e denominadores dos
último (columa 1) e penúltimo (columa 2) convergentes da fração contínua @var{x}.

@example
(%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
@end example

@end deffn

@defvr {Variável de opção} cflength
Valor por omissão: 1

@code{cflength} controla o número de termos da fração
contínua que a função @code{cf} fornecerá, como o valor de @code{cflength} vezes o
período.  Dessa forma o padrão é fornecer um período.

@example
(%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]
@end example

@end defvr

@deffn {Função} divsum (@var{n}, @var{k})
@deffnx {Função} divsum (@var{n})

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

@code{divsum (@var{n})} retorna a adição dos divisores de @var{n}.

@example
(%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
@end example

@end deffn

@deffn {Função} euler (@var{n})
Retorna o @var{n}'ésimo número de Euler para o inteiro @var{n} não negativo.

Para a constante de Euler-Mascheroni, veja @code{%gamma}.

@example
(%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]
@end example

@end deffn

@defvr {Constante} %gamma
@ifinfo
@vrindex Constante de Euler-Mascheroni
@end ifinfo
A constante de Euler-Mascheroni, 0.5772156649015329 ....
@c DOUBTLESS THERE IS MORE TO SAY HERE.

@end defvr

@deffn {Função} factorial (@var{x})
Representa a função factorial. Maxima trata @code{factorial (@var{x})} da mesma forma que @code{@var{x}!}.
Veja @code{!}.

@end deffn

@deffn {Função} fib (@var{n})
Retorna o @var{n}'ésimo número de Fibonacci.
@code{fib(0)} igual a 0 e @code{fib(1)} igual a 1,
e
@code{fib (-@var{n})} igual a @code{(-1)^(@var{n} + 1) * fib(@var{n})}.

Após chamar @code{fib},
@code{prevfib} é iguala @code{fib (@var{x} - 1)},
o número de Fibonacci anterior ao último calculado.

@example
(%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]
@end example

@end deffn

@deffn {Função} fibtophi (@var{expr})
Expressa números de Fibonacci que aparecem em @var{expr} em termos da constante @code{%phi},
que é @code{(1 + sqrt(5))/2}, aproximadamente 1.61803399.

Exemplos:
 
@c ===beg===
@c fibtophi (fib (n));
@c fib (n-1) + fib (n) - fib (n+1);
@c fibtophi (%);
@c ratsimp (%);
@c ===end===

@example
(%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
@end example

@end deffn

@deffn {Função} ifactors (@var{n})
Para um inteiro positivo @var{n} retorna a factoração de @var{n}. Se
@code{n=p1^e1..pk^nk} for a decomposição de @var{n} em factores
primos, @code{ifactors} retorna @code{[[p1, e1], ... , [pk, ek]]}.

Os métodos de factoraçã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.

@example
(%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
@end example

@end deffn

@deffn {Função} inrt (@var{x}, @var{n})
Retorna a parte inteira da @var{n}'ésima raíz do valor absoluto de @var{x}.

@example
(%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]
@end example

@end deffn

@deffn {Função} inv_mod (@var{n}, @var{m})
Calcula o  inverso de @var{n} módulo @var{m}. 
@code{inv_mod (n,m)} retorna @code{false}, 
se @var{n} modulo @var{m} for zero.

@example
(%i1) inv_mod(3, 41);
(%o1)                           14
(%i2) ratsimp(3^-1), modulus=41;
(%o2)                           14
(%i3) inv_mod(3, 42);
(%o3)                          false
@end example

@end deffn

@deffn {Função} jacobi (@var{p}, @var{q})
Retorna símbolo de Jacobi de @var{p} e @var{q}.

@example
(%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]
@end example

@end deffn

@deffn {Função} lcm (@var{expr_1}, ..., @var{expr_n})
Retorna o menor múltiplo comum entre seus argumentos.
Os argumentos podem ser expressões gerais também inteiras.

@code{load ("functs")} chama essa função.

@end deffn

@deffn {Função} minfactorial (@var{expr})
Examina @var{expr} procurando por ocorrências de dois factoriais
que diferem por um inteiro.  
@code{minfactorial} então converte um em um polinómio vezes o outro.

@c I CAN'T TELL WHAT THIS IS SUPPOSED TO MEAN. !!!
@c minfactorial DOESN'T SEEM TO DO ANYTHING binomial DOESN'T DO BY ITSELF !!!
@c LOOKING AT THE minfactorial CODE DOESN'T HELP !!!
@c If exp involves binomial coefficients then they will be
@c converted into ratios of factorials.

@example
(%i1) n!/(n+2)!;
                               n!
(%o1)                       --------
                            (n + 2)!
(%i2) minfactorial (%);
                                1
(%o2)                    ---------------
                         (n + 1) (n + 2)
@end example

@end deffn

@deffn {Função} next_prime (@var{n})
Retorna o menor primo maior que @var{n}.

@example
(%i1) next_prime(27);
(%o1)                       29
@end example

@end deffn

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

@example
(%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)
@end example

@end deffn

@deffn {Função} power_mod (@var{a}, @var{n}, @var{m})
Usa um algoritmo modular para calcular @code{a^n mod m} 
onde @var{a} e @var{n} são inteiros e @var{m} é um inteiro positivo. 
Se @var{n} for negativo, @code{inv_mod} é usada para encontrar o inverso modular.

@example
(%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
@end example

@end deffn

@deffn {Função} primep (@var{n})
Teste de primalidade. Se @code{primep (n)} retornar @code{false}, @var{n} é um
número compostro e se esse teste retornar @code{true}, @var{n} é um número primo
com grande probabilidade.

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

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

@end deffn

@defvr {Variável de opção} primep_number_of_tests
Valor por omissão: 25

Número de testes de Miller-Rabin usados em @code{primep}.
@end defvr

@deffn {Função} prev_prime (@var{n})
Retorna o maior primo menor que @var{n}.

@example
(%i1) prev_prime(27);
(%o1)                       23
@end example
@end deffn

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

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

@end deffn

@deffn {Função} totient (@var{n})
Retorna o número de inteiros menores que ou iguais a @var{n} que
são relativamente primos com @var{n}.

@end deffn

@defvr {Variável de opção} zerobern
Valor por omissão: @code{true}

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

@end defvr

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

Veja também @code{bfzeta} e @code{zeta%pi}.

@example
(%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
@end example

@end deffn

@defvr {Variável de opção} zeta%pi
Valor por omissão: @code{true}

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

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

@end defvr

