Maxima Manual: Функции и переменные для теории чисел

Previous: Теория чисел, Up: Теория чисел [Contents][Index]

### 29.1 Функции и переменные для теории чисел

Функция: bern (n)

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

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

Функция: bernpoly (x, n)

  Возвращает значение многочлена Бернулли порядка n в точке x.

Функция: bfzeta (s, n)

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

Функция: bfhzeta (s, h, n)

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

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

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

Функция: binomial (x, y)

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

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

  Примеры:

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

Функция: burn (n)

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

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

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

Функция: cf (expr)

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

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

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

  См. также `cfdisrep`, `cfexpand` и `cflength`.

  Примеры:

  - expr - выражение, составленное из цепных дробей и квадратных корней целых чисел.

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

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

  - Цепная дробь может быть рассчитана через арифметическое представление, возвращаемое `cfdisrep`.

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

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

Функция: cfdisrep (list)

  Возвращает простое выражение вида `a + 1/(b + 1/(c + ...))` для списочного представления цепной дроби `[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

Функция: cfexpand (x)

  Возвращает матрицу числителей и знаменателей последней (первый столбец) и предпоследней (второй столбец) подходящей дроби для цепной дроби 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

Управляющая переменная: cflength

  Значение по умолчанию: 1

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

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

Функция: divsum (n, k)
Функция: divsum (n)

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

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

Функция: euler (n)

  Возвращает n-е число Эйлера для неотрицательного целого n. Для постоянной Эйлера-Маскерони см. `%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]

Константа: %gamma

  Постоянная Эйлера-Маскерони, 0.5772156649015329 ....

Функция: factorial (x)

  Представляет факториал x. Maxima работает с `factorial (x)` аналогично `x!`. См. `!`.

Функция: fib (n)

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

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

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

Функция: fibtophi (expr)

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

  Примеры:

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

Функция: ifactors (n)

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

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

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

Функция: inrt (x, n)

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

Функция: inv_mod (n, m)

  Рассчитывает число, обратное n по модулю m. `inv_mod (n,m)` возвращает `false`, если n есть делитель нуля по модулю m.

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

Функция: jacobi (p, q)

  Символ Якоби для p и 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]

Функция: lcm (expr_1, ..., expr_n)

  Возвращает наибольший общий делитель аргументов. Аргументы могут быть как целыми числами, так и общими выражениями.

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

Функция: minfactorial (expr)

  Проверяет expr на наличие двух факториалов, различающихся на целое число. После этого `minfactorial` заменяет выражение произведением многочленов.

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

Функция: next_prime (n)

  Возвращает наименьшее простое число, большее n.

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

Функция: partfrac (expr, var)

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

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

Функция: power_mod (a, n, m)

  Использует модулярный алгоритм вычисления `a^n mod m`, где a и n - целые и m - положительное целое. Если n отрицательно, для поиска обратного по модулю m числа используется `inv_mod`.

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

Функция: primep (n)

  Проверка на простоту. Если `primep (n)` возвращает `false`, то n является составным числом; если возвращает `true`, то n с большой вероятностью является простым числом.

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

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

Управляющая переменная: primep_number_of_tests

  Значение по умолчанию: 25

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

Функция: prev_prime (n)

  Возвращает наибольшее простое число, меньшее n.

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

Функция: qunit (n)

  Возвращает элемент поля `sqrt (n)` с единичной нормой, что равносильно решению уравнения Пелля `a^2 - n b^2 = 1`.

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

Функция: totient (n)

  Возвращает число целых чисел, меньших или равных n, которые взаимно просты с n.

Управляющая переменная: zerobern

  Значение по умолчанию: `true`

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

Функция: zeta (n)

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

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

Управляющая переменная: zeta%pi

  Значение по умолчанию: `true`

  Значение по умолчанию: `true`

  Если `zeta%pi` равно `true`, `zeta` возвращает выражение, пропорциональное `%pi^n` для целого четного `n`. В противном случае для целого четного `n` возвращается невычисляемая форма `zeta (n)`.

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

Previous: Теория чисел, Up: Теория чисел [Contents][Index]