@c Language=Russian
@c Encoding=UTF-8
@c File=Number.texi
@c OriginalRevision=1.27
@c TranslatedBy: (c) 2007-09-07 Alexey V. Beshenov <al@beshenov.ru>

@menu
* Функции и переменные для теории чисел::  
@end menu

@node Функции и переменные для теории чисел,  , Теория чисел, Теория чисел
@section Функции и переменные для теории чисел

@deffn {Функция} bern (@var{n})

Возвращает @var{n}-е число Бернулли для целого @var{n}.
Числа Бернулли, равные нулю, опускаются, если @code{zerobern} равно @code{false}.

См. также @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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} bernpoly (@var{x}, @var{n})
Возвращает значение многочлена Бернулли порядка @var{n} в точке @var{x}.

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} bfzeta (@var{s}, @var{n})

Возвращает дзэта-функцию Римана для аргумента @var{s}.
Возвращаемое значение - число с плавающей точкой повышенной точности (bfloat);
@var{n} - количество цифр в возвращаемом значении.

@opencatbox{Категории:}
@category{Теория чисел}
@category{Численное вычисление}
@closecatbox
@end deffn

@deffn {Функция} bfhzeta (@var{s}, @var{h}, @var{n})


Возвращает дзэта-функцию Гурвица для аргументов @var{s} и @var{h}.
Возвращаемое значение - число с плавающей точкой повышенной точности (bfloat);
@var{n} - количество цифр в возвращаемом значении.
Дзэта-функция Гурвица определяется как

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

Функцию загружает команда @code{load ("bffac")}.

@opencatbox{Категории:}
@category{Теория чисел}
@category{Численное вычисление}
@closecatbox
@end deffn

@deffn {Функция} binomial (@var{x}, @var{y})

Биномиальный коэффициент @code{@var{x}!/(@var{y}! (@var{x} - @var{y})!)}.

Если @var{x} и @var{y} - целые, рассчитывается численное значение биномиального коэффициента.
Если @var{y} или @var{x - y} - целое, биномиальный коэффициент выражается через многочлен.

Примеры:

@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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} burn (@var{n})

Возвращает @var{n}-е число Бернулли для целого @var{n}.
@code{burn} может быть более эффективным, чем @code{bern} для отдельных больших @var{n}
(возможно, если @var{n} больше 105 или в районе этого), так как @code{bern} рассчитывает все
числа Бернулли до @var{n}-го перед выдачей результата.

@code{burn} использует выражение чисел Бернулли через дзэта-функцию Римана.

Функцию загружает команда @code{load ("bffac")}.

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} cf (@var{expr})

Преобразует @var{expr} в цепную дробь.
@var{expr} - выражение, составленное из цепных дробей и квадратных корней из целых чисел.
Операнды выражения могут комбинироваться арифметическими операторами. Помимо цепных дробей и
квадратных корней, сомножители выражения должны быть целыми или рациональными числами. Maxima
не работает с операциями над цепными дробями вне @code{cf}.

@code{cf} вычисляет аргументы после установки @code{listarith} равной @code{false}.
Цепная дробь @code{a + 1/(b + 1/(c + ...))} представляется в виде списка @code{[a, b, c, ...]}.

Элементы списка @code{a}, @code{b}, @code{c}, ... должны раскрываться в целые числа.
@var{expr} может содержать @code{sqrt (n)}, где @code{n} - целое.
В этом случае @code{cf} даст число членов цепной дроби, равное произведению
@code{cflength} на период. Цепная дробь может раскрываться в число через арифметическое
представление, возвращенное @code{cfdisrep}. См. также @code{cfexpand} для другого способа
вычисления цепной дроби.

См. также @code{cfdisrep}, @code{cfexpand} и @code{cflength}.

Примеры:

@itemize @bullet
@item
@var{expr} - выражение, составленное из цепных дробей и квадратных корней целых чисел.

@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} определяет число периодов цепной дроби, рассчитываемых для алгебраических
иррациональных чисел.

@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
Цепная дробь может быть рассчитана через арифметическое представление, возвращаемое
@code{cfdisrep}.

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

@item
Maxima не работает с операциями над цепными дробями вне @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

@opencatbox{Категории:}
@category{Цепные дроби}
@closecatbox
@end deffn

@deffn {Функция} cfdisrep (@var{list})
Возвращает простое выражение вида @code{a + 1/(b + 1/(c + ...))} для списочного
представления цепной дроби @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

@opencatbox{Категории:}
@category{Цепные дроби}
@closecatbox
@end deffn

@deffn {Функция} cfexpand (@var{x})
Возвращает матрицу числителей и знаменателей последней (первый столбец) и предпоследней
(второй столбец) подходящей дроби для цепной дроби @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

@opencatbox{Категории:}
@category{Цепные дроби}
@closecatbox
@end deffn

@defvr {Управляющая переменная} cflength
Значение по умолчанию: 1

Функция @code{cf} возвращает число членов цепной дроби, равное произведению
@code{cflength} на период. Таким образом, по умолчанию возвращается один период.

@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

@opencatbox{Категории:}
@category{Цепные дроби}
@closecatbox
@end defvr

@deffn {Функция} divsum (@var{n}, @var{k})
@deffnx {Функция} divsum (@var{n})

@code{divsum (@var{n}, @var{k})} возвращает сумму делителей @var{n}, возведенных
в степень @var{k}.

@code{divsum (@var{n})} возвращает сумму делителей @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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} euler (@var{n})
Возвращает @var{n}-е число Эйлера для неотрицательного целого @var{n}.
Для постоянной Эйлера-Маскерони см. @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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@defvr {Константа} %gamma
@ifinfo
@vrindex Euler-Mascheroni constant
@end ifinfo
Постоянная Эйлера-Маскерони, 0.5772156649015329 ....

@opencatbox{Категории:}
@category{Константы}
@closecatbox
@end defvr

@deffn {Функция} factorial (@var{x})
Представляет факториал @var{x}. Maxima работает с @code{factorial (@var{x})}
аналогично @code{@var{x}!}. См. @code{!}.

@opencatbox{Категории:}
@category{Гамма функция и факториал}
@closecatbox
@end deffn

@deffn {Функция} fib (@var{n})

Возвращает @var{n}-е число Фибоначчи.
@code{fib(0)} равно 0, @code{fib(1)} равно 1, @code{fib (-@var{n})} равно
@code{(-1)^(@var{n} + 1) * fib(@var{n})}.

После вызова @code{fib} @code{prevfib} равно @code{fib (@var{x} - 1)},
числу Фибоначчи, предшествующему последнему рассчитанному.

@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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} fibtophi (@var{expr})

Выражает числа Фибоначчи в @var{expr} через постоянную @code{%phi},
равную @code{(1 + sqrt(5))/2}, приблизительно 1.61803399.

Примеры:

@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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@anchor{ifactors}
@deffn {Функция} ifactors (@var{n})

Для целого положительного @var{n} возвращает факторизацию @var{n}.
Если @code{n=p1^e1..pk^nk} есть разложение @var{n} на простые множители, @code{ifactors}
возвращает @code{[[p1, e1], ... , [pk, ek]]}.

Используемые методы факторизации - обычное деление на простые числа (до 9973),
ро-алгоритм Полларда и метод эллиптических кривых.

@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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} inrt (@var{x}, @var{n})

Возвращает целый @var{n}-й корень абсолютного значения @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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} inv_mod (@var{n}, @var{m})
Рассчитывает число, обратное @var{n} по модулю @var{m}.
@code{inv_mod (n,m)} возвращает @code{false}, если @var{n} есть делитель нуля
по модулю  @var{m}.

@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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} jacobi (@var{p}, @var{q})
Символ Якоби для @var{p} и @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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} lcm (@var{expr_1}, ..., @var{expr_n})
Возвращает наибольший общий делитель аргументов.
Аргументы могут быть как целыми числами, так и общими выражениями.

Функцию загружает @code{load ("functs")}.

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} minfactorial (@var{expr})
Проверяет @var{expr} на наличие двух факториалов, различающихся на целое число.
После этого @code{minfactorial} заменяет выражение произведением многочленов.

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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} next_prime (@var{n})
Возвращает наименьшее простое число, большее @var{n}.

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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@anchor{partfrac}
@deffn {Функция} partfrac (@var{expr}, @var{var})
Разлагает выражение @var{expr} на простые дроби относительно главной переменной @var{var}.
@code{partfrac} делает полное разложение на простые дроби. Используемый алгоритм
основан на том, что знаменатели в разложении на простые дроби (сомножители
исходного знаменателя) взаимно просты. Числители могут быть записаны как
линейные комбинации знаменателей, откуда вытекает разложение.

@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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} power_mod (@var{a}, @var{n}, @var{m})
Использует модулярный алгоритм вычисления @code{a^n mod m}, где @var{a} и @var{n} - целые
и @var{m} - положительное целое. Если @var{n} отрицательно,
для поиска обратного по модулю @var{m} числа используется @code{inv_mod}.

@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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} primep (@var{n})
Проверка на простоту. Если @code{primep (@var{n})} возвращает @code{false}, то @var{n}
является составным числом; если возвращает @code{true}, то @var{n} с большой
вероятностью является простым числом.

Для @var{n} меньше 3317044064679887385961981 используется детерминированная версия теста
Миллера-Рабина. Если @code{primep (@var{n})} возвращает @code{true}, то @var{n} есть простое число.

Для @var{n} больше 34155071728321 @code{primep} использует @code{primep_number_of_tests}
тестов Миллера-Рабина на псевдопростоту и один тест Люкаса на псевдопростоту.
Вероятность того, что @var{n} пройдет один тест Миллера-Рабина, менее 1/4. Для значения по
умолчанию 25 переменной @code{primep_number_of_tests} вероятность того, что @var{n}
будет составным, много меньше 10^-15.

@opencatbox{Категории:}
@category{Теория чисел}
@category{Функции предикаты}
@closecatbox
@end deffn

@defvr {Управляющая переменная} primep_number_of_tests
Значение по умолчанию: 25

Число тестов Миллера-Рабина, используемых в @code{primep}.

@opencatbox{Категории:}
@category{Теория чисел}
@category{Функции предикаты}
@closecatbox
@end defvr

@deffn {Функция} prev_prime (@var{n})
Возвращает наибольшее простое число, меньшее @var{n}.

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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} qunit (@var{n})
Возвращает элемент поля @code{sqrt (@var{n})} с единичной нормой, что равносильно
решению уравнения Пелля @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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@deffn {Функция} totient (@var{n})
Возвращает число целых чисел, меньших или равных @var{n}, которые взаимно просты с @var{n}.

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@defvr {Управляющая переменная} zerobern
Значение по умолчанию: @code{true}

Если @code{zerobern} равно @code{false}, @code{bern} исключает числа Бернулли, равные нулю.
См. @code{bern}.

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end defvr

@deffn {Функция} zeta (@var{n})
Возвращает дзэта-функцию Римана, если @var{n} - отрицательное целое, 0, 1,
или положительное четное число, и возвращает невычисляемую форму @code{zeta (@var{n})}
для всех других аргументов, включая не целые рациональные, числа с плавающей точкой и
комплексные.

См. также @code{bfzeta} и @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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end deffn

@defvr {Управляющая переменная} zeta%pi
Значение по умолчанию: @code{true}


Значение по умолчанию: @code{true}

Если @code{zeta%pi} равно @code{true}, @code{zeta} возвращает выражение,
пропорциональное @code{%pi^n} для целого четного @code{n}. В противном случае для
целого четного @code{n} возвращается невычисляемая форма @code{zeta (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

@opencatbox{Категории:}
@category{Теория чисел}
@closecatbox
@end defvr
