Maxima Manual: Функции и переменные для выражений

Previous: Синтаксис, Up: Выражения [Contents][Index]

### 6.8 Функции и переменные для выражений

Функция: at (expr, [eqn_1, ..., eqn_n])
Функция: at (expr, eqn)

  Вычисляет выражение expr, предполагая значения для переменных, заданные в списке уравнений `[eqn_1, ..., eqn_n]` или одном уравнении eqn.

  Если подвыражение зависит от переменных, для которых заданы значения, но нет, заданного при помощи `atvalue` значения, или оно не может быть вычислено иным способом, то возвращается невычисляемая форма `at`, которая выводится в двумерном формате.

  Функция `at` выполняет множественные подстановки последовательно, не параллельно.

  См. также `atvalue`. Для описания других функций, которые выполняют подстановки, см. также `subst` и `ev`.

  Примеры:

      (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                      2
      (%o1)                          a
      (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
      (%o2)                        @2 + 1
      (%i3) printprops (all, atvalue);
                                      !
                        d             !
                       --- (f(@1, @2))!       = @2 + 1
                       d@1            !
                                      !@1 = 0

                                           2
                                f(0, 1) = a

      (%o3)                         done
      (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x);
                        d                          d
      (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                        dx                         dx
      (%i5) at (%, [x = 0, y = 1]);
                                               !
                    2              d           !
      (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                   dx          !
                                               !x = 0, y = 1

Категории:Вычисление ·Дифференциальные уравнения ·

Функция: box (expr)
Функция: box (expr, a)

  Возвращает expr, заключенное в бокс (box). Возвращаемое значение есть выражение с `box` в качестве оператора и expr как аргумент. Бокс изображается при выводе, когда `display2d` есть `true`.

  `box (expr, a)` заключает expr в бокс, обозначенный символом a. Эта метка обрезается, если она длиннее чем ширина бокса.

  `box` вычисляет свои аргументы. Однако, выражение, взятое в бокс, не вычисляется до его содержимого, так что выражения в боксе эффективно исключается из вычислений.

  `boxchar` есть символ, используемый для отображения бокса в функциях `box`, в `dpart` и в `lpart`.

  Примеры:

      (%i1) box (a^2 + b^2);
                                  """""""""
                                  " 2    2"
      (%o1)                       "b  + a "
                                  """""""""
      (%i2) a : 1234;
      (%o2)                         1234
      (%i3) b : c - d;
      (%o3)                         c - d
      (%i4) box (a^2 + b^2);
                            """"""""""""""""""""
                            "       2          "
      (%o4)                 "(c - d)  + 1522756"
                            """"""""""""""""""""
      (%i5) box (a^2 + b^2, term_1);
                            term_1""""""""""""""
                            "       2          "
      (%o5)                 "(c - d)  + 1522756"
                            """"""""""""""""""""
      (%i6) 1729 - box (1729);
                                       """"""
      (%o6)                     1729 - "1729"
                                       """"""
      (%i7) boxchar: "-";
      (%o7)                           -
      (%i8) box (sin(x) + cos(y));
                              -----------------
      (%o8)                   -cos(y) + sin(x)-
                              -----------------

  Категории:Выражения ·

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

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

  `boxchar` есть символ, который используется для изображения бокса в функциях `box`, в `dpart` и в `lpart` .

  Все боксы в выражении изображаются с текущим значением `boxchar`. Изображаемый символ не сохраняется в выражении бокса.

  Категории:Выражения ·

Функция: carg (z)

  Возвращает комплексный аргумент z. Этот комплексный аргумент есть угол `theta` в пределах `(-%pi, %pi]` такой что `r exp (theta %i) = z`, где `r` есть модуль z.

  `carg` есть вычислительная функция, но не функция упрощения.

  `carg` игнорирует декларацию `declare (x, complex)` и рассматривает x как вещественную переменную. Это ошибка.

  См. также `abs` (комплексный модуль), `polarform`, `rectform`, `realpart` и `imagpart`.

  Примеры:

      (%i1) carg (1);
      (%o1)                           0
      (%i2) carg (1 + %i);
                                     %pi
      (%o2)                          ---
                                      4
      (%i3) carg (exp (%i));
      (%o3)                           1
      (%i4) carg (exp (%pi * %i));
      (%o4)                          %pi
      (%i5) carg (exp (3/2 * %pi * %i));
                                      %pi
      (%o5)                         - ---
                                       2
      (%i6) carg (17 * exp (2 * %i));
      (%o6)                           2

  Категории:Комплексные переменные ·

Специальный оператор: constant

  `declare (a, constant)` объявляет a как константу. См. `declare`.

  Категории:Факты и выводы ·Константы ·

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

  Возвращает `true`, если expr есть константное выражение, иначе возвращает `false`.

  Выражение рассматривается как константное, если его аргументы есть числа (включая рациональные числа, которые отображаются с помощью `/R/`), символьные константы, такие как `%pi`, `%e` и `%i`, переменные, равные константами, или объявленные константами с помощью `declare`, или функции, чьи аргументы есть константы.

  `constantp` вычисляет свои аргументы.

  Примеры:

      (%i1) constantp (7 * sin(2));
      (%o1)                                true
      (%i2) constantp (rat (17/29));
      (%o2)                                true
      (%i3) constantp (%pi * sin(%e));
      (%o3)                                true
      (%i4) constantp (exp (x));
      (%o4)                                false
      (%i5) declare (x, constant);
      (%o5)                                done
      (%i6) constantp (exp (x));
      (%o6)                                true
      (%i7) constantp (foo (x) + bar (%e) + baz (2));
      (%o7)                                false
      (%i8)

  Категории:Функции предикаты ·Константы ·

Функция: declare (a_1, p_1, a_2, p_2, ...)

  Присваивает атому или списку атомов a_i свойство или список свойств p_i. Когда a_i и/или p_i есть списки, каждый из атомом получает все свойства.

  `declare` не вычисляет свои аргументы. `declare` всегда возвращает `done`.

  Как отмечено в описании для каждого флага декларации, для некоторых флагов `featurep(object, feature)` возвращает `true`, если object был объявлен, как имеющий feature. Однако, `featurep` не распознает некоторые флаги. Это ошибка.

  См. также `features`.

  `declare` распознает следующие свойства:

  `evfun`

    Делает a_i известным для `ev` так, что эта функция названная как a_i, применяется когда a_i появляется как флаговый аргумент `ev`. См. `evfun`.

  `evflag`

    Делает a_i известным для функции `ev` так, что a_i связывается с `true` во время выполнение `ev`, когда a_i появляется как флаговый аргумент `ev`. См. `evflag`.

  `bindtest`

    Указывает Maxima то, что следует вызвать ошибку, когда при вычислении значение a_i не определено.

  `noun`

    Указывает Maxima считать a_i невычисляемой формой. Эффект состоит в замене a_i на `'a_i` или `nounify(a_i)`, в зависимости от контекста.

  `constant`

    Указывает Maxima рассматривать a_i как символьную константу.

  `scalar`

    Указывает Maxima рассматривать a_i как скалярную переменную.

  `nonscalar`

    Указывает Maxima рассматривать a_i как нескалярную переменную. Обычное применение состоит в том, чтобы объявлять переменная как символьный вектор или матрицу.

  `mainvar`

    Указывает Maxima рассматривать a_i как "главную переменную" (`mainvar`). `ordergreatp` определяет упорядочивание атомов таким образом:

    (главные переменные) > (другие переменные) > (скалярный переменные) > (константы) > (числа)

  `alphabetic`

    Указывает Maxima рассматривать a_i как алфавитный символ.

  `feature`

    Указывает Maxima рассматривать a_i как имя свойства. Тогда другие атомы могут иметь свойство a_i.

  `rassociative`, `lassociative`

    Указывает Maxima рассматривать a_i как право-ассоциативную или лево-ассоциативную функцию.

  `nary`

    Указывает Maxima рассматривать a_i как n-арную функцию.

    Декларация `nary` это не тоже, что вызов функции `nary`. Единственный эффект `declare(foo, nary)` состоит в том, чтобы обучить упрощатель Maxima упрощать вложенные выражения, например, чтобы `foo(x, foo(y, z))` упрощалось до `foo(x, y, z)`.

  `symmetric`, `antisymmetric`, `commutative`

    Указывает Maxima рассматривать a_i как симметричную или антисимметричную функцию. `commutative` это тоже самое, что `symmetric`.

  `oddfun`, `evenfun`

    Указывает Maxima рассматривать a_i как нечетную или четную функцию.

  `outative`

    Указывает Maxima упрощать выражения с a_i путем выноса константных множителей за пределы первого аргумента.

    Когда a_i имеет один аргумент, множитель рассматривается константным, если он есть литерал или объявлен константой.

    Когда a_i имеет два или более аргументов, множитель рассматривается константой, если второй аргумент есть символ и этот множитель свободен от этого второго аргумента.

  `multiplicative`

    Указывает Maxima упрощать выражения a_i путем подстановки `a_i(x * y * z * ...)` `-->` `a_i(x) * a_i(y) * a_i(z) * ...`. Эта подстановка выполняется только для первого аргумента.

  `additive`

    Указывает Maxima упрощать a_i выражения путем подстановки `a_i(x + y + z + ...)` `-->` `a_i(x) + a_i(y) + a_i(z) + ...`. Эта подстановка выполняется только для первого аргумента.

  `linear`

    Эквивалентно объявлению a_i совместно `outative` и `additive`.

  `integer`, `noninteger`

    Указывает Maxima рассматривать a_i как целую или нецелую переменную.

  `even`, `odd`

    Указывает Maxima рассматривать a_i как четную или нечетную целую переменную.

  `rational`, `irrational`

    Указывает Maxima рассматривать a_i как рациональную или иррациональную вещественную переменную.

  `real`, `imaginary`, `complex`

    Указывает Maxima рассматривать a_i как вещественную, чисто мнимую или комплексную переменную.

  `increasing`, `decreasing`

    Указывает Maxima рассматривать a_i как растущую или убывающую функцию.

  `posfun`

    Указывает Maxima рассматривать a_i как положительную функцию.

  `integervalued`

    Указывает Maxima рассматривать a_i как целочисленную функцию.

  Примеры:

  Декларации `evfun` и `evflag`.

      (%i1) declare (expand, evfun);
      (%o1)                         done
      (%i2) (a + b)^3;
                                         3
      (%o2)                       (b + a)
      (%i3) (a + b)^3, expand;
                           3        2      2      3
      (%o3)               b  + 3 a b  + 3 a  b + a
      (%i4) declare (demoivre, evflag);
      (%o4)                         done
      (%i5) exp (a + b*%i);
                                   %i b + a
      (%o5)                      %e
      (%i6) exp (a + b*%i), demoivre;
                            a
      (%o6)               %e  (%i sin(b) + cos(b))

  Декларация `bindtest`.

      (%i1) aa + bb;
      (%o1)                        bb + aa
      (%i2) declare (aa, bindtest);
      (%o2)                         done
      (%i3) aa + bb;
      aa unbound variable
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) aa : 1234;
      (%o4)                         1234
      (%i5) aa + bb;
      (%o5)                       bb + 1234

  Декларация `noun`.

      (%i1) factor (12345678);
                                   2
      (%o1)                     2 3  47 14593
      (%i2) declare (factor, noun);
      (%o2)                         done
      (%i3) factor (12345678);
      (%o3)                   factor(12345678)
      (%i4) ''%, nouns;
                                   2
      (%o4)                     2 3  47 14593

  Декларации `constant`, `scalar`, `nonscalar` и `mainvar`.

  Декларация `alphabetic`.

      (%i1) xx\~yy : 1729;
      (%o1)                         1729
      (%i2) declare ("~", alphabetic);
      (%o2)                         done
      (%i3) xx~yy + yy~xx + ~xx~~yy~;
      (%o3)                ~xx~~yy~ + yy~xx + 1729

  Декларация `feature`.

      (%i1) declare (FOO, feature);
      (%o1)                         done
      (%i2) declare (x, FOO);
      (%o2)                         done
      (%i3) featurep (x, FOO);
      (%o3)                         true

  Декларации `rassociative` и `lassociative`.

  Декларация `nary`.

      (%i1) H (H (a, b), H (c, H (d, e)));
      (%o1)               H(H(a, b), H(c, H(d, e)))
      (%i2) declare (H, nary);
      (%o2)                         done
      (%i3) H (H (a, b), H (c, H (d, e)));
      (%o3)                   H(a, b, c, d, e)

  Декларации `symmetric` и `antisymmetric`.

      (%i1) S (b, a);
      (%o1)                        S(b, a)
      (%i2) declare (S, symmetric);
      (%o2)                         done
      (%i3) S (b, a);
      (%o3)                        S(a, b)
      (%i4) S (a, c, e, d, b);
      (%o4)                   S(a, b, c, d, e)
      (%i5) T (b, a);
      (%o5)                        T(b, a)
      (%i6) declare (T, antisymmetric);
      (%o6)                         done
      (%i7) T (b, a);
      (%o7)                       - T(a, b)
      (%i8) T (a, c, e, d, b);
      (%o8)                   T(a, b, c, d, e)

  Декларации `oddfun` и `evenfun`.

      (%i1) o (- u) + o (u);
      (%o1)                     o(u) + o(- u)
      (%i2) declare (o, oddfun);
      (%o2)                         done
      (%i3) o (- u) + o (u);
      (%o3)                           0
      (%i4) e (- u) - e (u);
      (%o4)                     e(- u) - e(u)
      (%i5) declare (e, evenfun);
      (%o5)                         done
      (%i6) e (- u) - e (u);
      (%o6)                           0

  Декларация `outative`.

      (%i1) F1 (100 * x);
      (%o1)                       F1(100 x)
      (%i2) declare (F1, outative);
      (%o2)                         done
      (%i3) F1 (100 * x);
      (%o3)                       100 F1(x)
      (%i4) declare (zz, constant);
      (%o4)                         done
      (%i5) F1 (zz * y);
      (%o5)                       zz F1(y)

  Декларация `multiplicative`.

      (%i1) F2 (a * b * c);
      (%o1)                       F2(a b c)
      (%i2) declare (F2, multiplicative);
      (%o2)                         done
      (%i3) F2 (a * b * c);
      (%o3)                   F2(a) F2(b) F2(c)

  Декларация `additive`.

      (%i1) F3 (a + b + c);
      (%o1)                     F3(c + b + a)
      (%i2) declare (F3, additive);
      (%o2)                         done
      (%i3) F3 (a + b + c);
      (%o3)                 F3(c) + F3(b) + F3(a)

  Декларация `linear`.

      (%i1) 'sum (F(k) + G(k), k, 1, inf);
                             inf
                             ====
                             \
      (%o1)                   >    (G(k) + F(k))
                             /
                             ====
                             k = 1
      (%i2) declare (nounify (sum), linear);
      (%o2)                         done
      (%i3) 'sum (F(k) + G(k), k, 1, inf);
                           inf          inf
                           ====         ====
                           \            \
      (%o3)                 >    G(k) +  >    F(k)
                           /            /
                           ====         ====
                           k = 1        k = 1

  Категории:Факты и выводы ·

Функция: disolate (expr, x_1, ..., x_n)

  аналогична `isolate (expr, x)`, за исключением того, что она дает возможность пользователю изолировать более чем одну переменную одновременно. Это может быть полезно, например, если пользователь пытается заменить переменные в многократном интегрировании и эта замена переменных включает две или более переменных интегрирования. Данная функция автоматически загружается из `simplification/disol.mac`. Демонстрация доступна по `demo("disol")$`.

  Категории:Выражения ·

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

  Возвращает внешнее представление expr по отношению к его главному оператору. Это может быть полезно в сочетании с `part`, которая также имеет дело с внешним представлением. Предположим expr есть -A. Тогда внутреннее представление expr есть "*"(-1,A), в то время как внешнее представление есть "-"(A). `dispform (expr, all)` конвертирует все выражение (не только верхний уровень) в внешний формат. Например, если `expr: sin (sqrt (x))`, то `freeof (sqrt, expr)` и `freeof (sqrt, dispform (expr))` дают `true`, в то время как `freeof (sqrt, dispform (expr, all))` дает `false`.

  Категории:Выражения ·

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

  Распространяет суммы над произведениями. Она отличается от `expand` тем, что она работает только на самом верхнем уровне выражения, то есть она не рекурсивная и работает быстрее чем `expand`. Она отличается от `multthru` тем, что раскрывает все суммы на этом уровне.

  Примеры:

      (%i1) distrib ((a+b) * (c+d));
      (%o1)                 b d + a d + b c + a c
      (%i2) multthru ((a+b) * (c+d));
      (%o2)                 (b + a) d + (b + a) c
      (%i3) distrib (1/((a+b) * (c+d)));
                                      1
      (%o3)                    ---------------
                               (b + a) (d + c)
      (%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                      1
      (%o4)                 ---------------------
                            b d + a d + b c + a c

  Категории:Выражения ·

Функция: dpart (expr, n_1, ..., n_k)

  Выбирает тоже подвыражение что и `part`, но вместо только возвращения этого подвыражения как значения, она возвращает все выражение с выбранным подвыражением, изображенным внутри бокса. Данный бокс в действительности является частью выражения.

      (%i1) dpart (x+y/z^2, 1, 2, 1);
                                   y
      (%o1)                       ---- + x
                                     2
                                  """
                                  "z"
                                  """

  Категории:Выражения ·

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

  Представляет собой экспоненциальную функцию. Все экземпляры `exp (x)` при вводе упрощаются до `%e^x`. `exp` не присутствует в упрощенных выражениях.

  Если `demoivre` равно `true`, то `%e^(a + b %i)` упрощается до `%e^(a (cos(b) + %i sin(b)))`, если `b` свободна от `%i`. См. `demoivre`.

  Если `%emode`, равно `true`, то `%e^(%pi %i x)` упрощается. См. `%emode`.

  Если `%enumer`, равно `true`, то `%e` заменяется на 2.718..., когда `numer` есть `true`. См. `%enumer`.

  Категории:Экспоненциальные и логарифмические функции ·

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

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

  Когда `%emode` есть `true`, то `%e^(%pi %i x)` упрощается следующим образом.

  `%e^(%pi %i x)` упрощается до `cos (%pi x) + %i sin (%pi x)`, если `x` есть число с плавающей точкой, целое или произведение 1/2, 1/3, 1/4 или 1/6 и тогда в дальнейшем упрощается.

  Для других численных `x`, `%e^(%pi %i x)` упрощается до `%e^(%pi %i y)`, где `y` есть `x - 2 k` для некоторых целых `k`, таких что `abs(y) < 1`.

  Когда `%emode` есть `false`, специальное упрощение `%e^(%pi %i x)` не выполняется.

  Категории:Экспоненциальные и логарифмические функции ·Флаги и переменные упрощения ·

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

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

  Когда `%enumer` есть `true`, то `%e` заменяется своим численным значением 2.718..., когда `numer` есть `true`.

  Когда `%enumer` есть `false`, эта подстановка выполняется только если экспонента в `%e^x` вычисляется до численного значения.

  См. также `ev` и `numer`.

  Категории:Экспоненциальные и логарифмические функции ·Флаги вычисления ·

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

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

  Если `exptisolate` равно `true`, то `isolate (expr, var)` исследует показатели атомов (таких как `%e`), которые содержат `var`.

  Категории:Выражения ·

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

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

  Если `exptsubst` равно `true`, то позволяется выполнять подстановки, такие как `y` для `%e^x` в `%e^(a x)`.

  Категории:Экспоненциальные и логарифмические функции ·Выражения ·

Функция: freeof (x_1, ..., x_n, expr)

  `freeof (x_1, expr)` Возвращает `true`, если никакое подвыражение expr не равно x_1 или если x_1 возникает только как немая переменная в expr, иначе возвращает `false`.

  `freeof (x_1, ..., x_n, expr)` эквивалентно `freeof (x_1, expr) and ... and freeof (x_n, expr)`.

  Аргументы x_1, ..., x_n могут быть именами функций или переменных, именами с индексами, операторами (заключенными в двойные кавычки) или выражениями общего вида. `freeof` вычисляет свои аргументы.

  `freeof` действует только на expr в том виде, в как оно есть, (после упрощения и вычисления) и не пытается определить, может ли некоторое эквивалентное выражение дать другой результат. В частности, упрощение может давать эквивалентное, но другое выражение, которое содержит некоторые различные элементы чем исходная форма expr.

  Переменная является немой переменной в некотором выражении, если она не имеет значения за пределами выражения. Немые переменные, распознаваемые `freeof`, есть индекс суммы или произведения, переменная предела в `limit`, переменная интегрирования в определенном интеграле `integrate`, исходная переменная в `laplace`, формальные переменные в выражениях `at` и аргументы в `lambda` выражениях. Локальные переменные в `block` не распознаются `freeof` как немые переменные. Это ошибка.

  Неопределенное интегрирование `integrate` не свободно от переменной интегрирования.

  - Аргументы есть имена функций, переменные, имена с индексами, операторы и выражения. `freeof (a, b, expr)` эквивалентно `freeof (a, expr) and freeof (b, expr)`.

        (%i1) expr: z^3 * cos (a[1]) * b^(c+d);
                                         d + c  3
        (%o1)                   cos(a ) b      z
                                     1
        (%i2) freeof (z, expr);
        (%o2)                         false
        (%i3) freeof (cos, expr);
        (%o3)                         false
        (%i4) freeof (a[1], expr);
        (%o4)                         false
        (%i5) freeof (cos (a[1]), expr);
        (%o5)                         false
        (%i6) freeof (b^(c+d), expr);
        (%o6)                         false
        (%i7) freeof ("^", expr);
        (%o7)                         false
        (%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr);
        (%o8)                         true

  - `freeof` вычисляет свои аргументы.

        (%i1) expr: (a+b)^5$
        (%i2) c: a$
        (%i3) freeof (c, expr);
        (%o3)                         false

  - `freeof` не учитывает эквивалентные выражения. Упрощение может дать эквивалентное, но отличное выражение.

        (%i1) expr: (a+b)^5$
        (%i2) expand (expr);
                  5        4       2  3       3  2      4      5
        (%o2)    b  + 5 a b  + 10 a  b  + 10 a  b  + 5 a  b + a
        (%i3) freeof (a+b, %);
        (%o3)                         true
        (%i4) freeof (a+b, expr);
        (%o4)                         false
        (%i5) exp (x);
                                         x
        (%o5)                          %e
        (%i6) freeof (exp, exp (x));
        (%o6)                         true

  - Суммирование или определенный интеграл свободно от своих немых переменных. Неопределенный интеграл не свободен от своей переменной интегрирования.

        (%i1) freeof (i, 'sum (f(i), i, 0, n));
        (%o1)                         true
        (%i2) freeof (x, 'integrate (x^2, x, 0, 1));
        (%o2)                         true
        (%i3) freeof (x, 'integrate (x^2, x));
        (%o3)                         false

  Категории:Выражения ·

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

  Возвращает обобщенный факториал, заданный как `x (x-z) (x - 2 z) ... (x - (y - 1) z)`. Таким образом, для целого x, `genfact (x, x, 1) = x!` и `genfact (x, x/2, 2) = x!!`.

  Категории:Гамма функция и факториал ·

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

  Возвращает мнимую часть выражения expr.

  `imagpart` есть вычислительная функция, а не функция упрощения.

  См. также `abs`, `carg`, `polarform`, `rectform` и `realpart`.

  Категории:Комплексные переменные ·

Функция: infix (op)
Функция: infix (op, lbp, rbp)
Функция: infix (op, lbp, rbp, lpos, rpos, pos)

  Объявляет op инфиксным оператором. Инфиксный оператор есть функция двух аргументов, с именем функции, записанным между этими аргументами. Например, оператор вычитания `-` есть инфиксный оператор.

  `infix (op)` объявляет op инфиксным оператором со степенями связывания по умолчанию (левая и правая, обе равны 180) и частями речи по умолчанию (левая и правая, обе равны `any`).

  `infix (op, lbp, rbp)` объявляет op инфиксным оператором с указанными левой и правой степени связывания и частями речи по умолчанию (левая и правая, обе равны `any`).

  `infix (op, lbp, rbp, lpos, rpos, pos)` объявляет op инфиксным оператором с указанными левой и правой степенями связывания и частями речи lpos, rpos и pos для левого операнда, правого операнда и результата соответственно.

  Термин "часть речи" по отношению к объявлению операторов, означает тип выражения. Различается три типа: `expr`, `clause` и `any`, которые означают алгебраическое выражение, логическое выражение и выражение произвольного типа соответственно. Maxima может обнаружить некоторые синтаксические ошибки, сравнивая объявленные для оператора части речи с актуальными выражениями.

  Приоритет op по отношению к другим операторам выводится из левой и правой степеней связывания рассматриваемых операторов. Если левые и правые степени связывания op обе больше левых и правых степеней связывания другого оператора, то op имеет более высокий приоритет чем этот оператор. Если степени связывания обе не больше или меньше, то имеют место некоторые более сложные соотношения.

  Ассоциативность op зависит от его степени связывания. Большая левая степень связывания (lbp) означает, что op вычисляется до других операторов, стоящих слева от него в выражении, в то время как большая правая степень связывания (rbp) означает, что op вычисляется до других операторов, стоящих справа от него в выражении. Таким образом, большее lbp делает op право-ассоциативным, в то время как большее rbp делает op лево-ассоциативным. Если lbp равно rbp, то op является лево-ассоциативный.

  См. также `Syntax`.

  Примеры:

  - Если левые и правые степени связывания op обе больше левых и правых степеней связывания другого оператора, то op имеет более высокий приоритет чем этот оператор.

      (%i1) "@"(a, b) := sconcat("(", a, ",", b, ")")$
      (%i2) :lisp (get '$+ 'lbp)
      100
      (%i2) :lisp (get '$+ 'rbp)
      100
      (%i2) infix ("@", 101, 101)$
      (%i3) 1 + a@b + 2;
      (%o3)                       (a,b) + 3
      (%i4) infix ("@", 99, 99)$
      (%i5) 1 + a@b + 2;
      (%o5)                       (a+1,b+2)

  - Большее lbp делает op право-ассоциативным, в том время как большее rbp делает op лево-ассоциативным.

      (%i1) "@"(a, b) := sconcat("(", a, ",", b, ")")$
      (%i2) infix ("@", 100, 99)$
      (%i3) foo @ bar @ baz;
      (%o3)                    (foo,(bar,baz))
      (%i4) infix ("@", 100, 101)$
      (%i5) foo @ bar @ baz;
      (%o5)                    ((foo,bar),baz)

  Maxima может обнаружить некоторые синтаксические ошибки, сравнивая объявленные для оператора части речи с актуальными выражениями.

      (%i1) infix ("##", 100, 99, expr, expr, expr);
      (%o1)                          ##
      (%i2) if x ## y then 1 else 0;
      Incorrect syntax: Found algebraic expression where logical expression expected
      if x ## y then
                   ^
      (%i2) infix ("##", 100, 99, expr, expr, clause);
      (%o2)                          ##
      (%i3) if x ## y then 1 else 0;
      (%o3)                if x ## y then 1 else 0

  Категории:Операторы ·Факты и выводы ·Синтаксис ·

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

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

  Когда `inflag` есть `true`, функции для извлечения частей выражения работает с внутренней формой `expr`.

  Заметим, что упрощатель переупорядочивает выражения. Таким образом, `first (x + y)` возвращает `x` если `inflag` есть `true`, и `y`, если `inflag` есть `false` (`first (y + x)` дает те же результаты.)

  Также, установка `inflag` равным `true` и вызов `part` или `substpart` есть тоже самое, что вызов `inpart` или `substinpart`.

  Функции, на которые влияет значение `inflag`: `part`, `substpart`, `first`, `rest`, `last`, `length`, конструкция `for` ... `in`, `map`, `fullmap`, `maplist`, `reveal` и `pickapart`.

  Категории:Выражения ·

Функция: inpart (expr, n_1, ..., n_k)

  аналогична `part`, но работает с внутренним представлением выражения, а не с выводимой формой, и, таким образом, может быть быстрее, так как форматирование не выполняется. Нужно быть осторожным по отношению к порядку подвыражений в суммах и произведениях (так как этот порядок переменных в внутренней форме часто отличается от порядка в выводимой форме) и в работе с унарным минусом, вычитанием и делением (так как эти операторы удаляются из выражения). `part (x+y, 0)` или `inpart (x+y, 0)` дает `+`, хотя для ссылки на оператор он должен быть заключен в двойные кавычки. Например `... if inpart (%o9,0) = "+" then ...`.

  Примеры:

      (%i1) x + y + w*z;
      (%o1)                      w z + y + x
      (%i2) inpart (%, 3, 2);
      (%o2)                           z
      (%i3) part (%th (2), 1, 2);
      (%o3)                           z
      (%i4) 'limit (f(x)^g(x+1), x, 0, minus);
                                        g(x + 1)
      (%o4)                 limit   f(x)
                            x -> 0-
      (%i5) inpart (%, 1, 2);
      (%o5)                       g(x + 1)

  Категории:Выражения ·

Функция: isolate (expr, x)

  Возвращает expr с подвыражениями, которые есть суммы, и которые не содержат переменную var, замененные метками промежуточных выражений (атомарными символами, такими как `%t1`, `%t2`, ...). Это часто бывает полезно, чтобы избежать ненужного раскрытия подвыражений, которые не содержат интересующих переменных. Так как данные метки промежуточных выражений имеют подвыражения в качестве своих значений, то они могут быть подставлены обратно вычислением этого выражения.

  Если `exptisolate` (значение по умолчанию: `false`) равно `true`, то `isolate` исследует показатели атомов (таких как `%e`), которые содержат переменную var.

  Если `isolate_wrt_times` равно `true`, то `isolate` изолирует также по отношению к произведениям. См. `isolate_wrt_times`.

  Выполните `example (isolate)` для других примеров.

  Категории:Выражения ·

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

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

  Когда `isolate_wrt_times` равно `true`, то `isolate` также изолирует по отношению к произведениям. Например, сравнивает обе установки

      (%i1) isolate_wrt_times: true$
      (%i2) isolate (expand ((a+b+c)^2), c);

      (%t2)                          2 a

      (%t3)                          2 b

                                2            2
      (%t4)                    b  + 2 a b + a

                           2
      (%o4)               c  + %t3 c + %t2 c + %t4
      (%i4) isolate_wrt_times: false$
      (%i5) isolate (expand ((a+b+c)^2), c);
                           2
      (%o5)               c  + 2 b c + 2 a c + %t4

  Категории:Выражения ·

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

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

  Когда `listconstvars` есть `true`, то в список, возвращаемый `listofvars`, включаются `%e`, `%pi`, `%i` и другие переменные, объявленные константами. По умолчанию они опускаются.

  Категории:Выражения ·

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

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

  Когда `listdummyvars` есть `false`, "немые переменные" в выражении не будут включаться в список, возвращаемый `listofvars`. (Смысл "немых переменных" тот же, что и в `freeof`. "Немые переменные" – это математические объекты, такие как индекс суммы или произведения, переменная предела и переменная интегрирования в определенном интеграле).

  Пример:

      (%i1) listdummyvars: true$
      (%i2) listofvars ('sum(f(i), i, 0, n));
      (%o2)                        [i, n]
      (%i3) listdummyvars: false$
      (%i4) listofvars ('sum(f(i), i, 0, n));
      (%o4)                          [n]

  Категории:Выражения ·

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

  Возвращает список переменных в expr.

  Когда `listconstvars` есть `true`, то в список, возвращаемый `listofvars`, включаются `%e`, `%pi`, `%i` и другие переменные, объявленные константами. По умолчанию они опускаются.

      (%i1) listofvars (f (x[1]+y) / g^(2+a));
      (%o1)                     [g, a, x , y]
                                        1

  Категории:Выражения ·

Функция: lfreeof (list, expr)

  Для каждого члена m списка list, вызывает `freeof (m, expr)`. Возвращает `false`, если какой либо из вызовов `freeof` дает `false`, иначе возвращает `true`.

  Категории:Выражения ·

Функция: lopow (expr, x)

  Возвращает наименьший показатель степени x, который явно присутствует в expr. Таким образом,

      (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
      (%o1)                       min(a, 2)

  Категории:Выражения ·

Функция: lpart (label, expr, n_1, ..., n_k)

  Аналогично `dpart`, но использует помеченный бокс. Помеченный бокс аналогичен боксу сделанному с помощью `dpart`, но имеет имя в верхней строке.

  Категории:Выражения ·

Функция: multthru (expr)
Функция: multthru (expr_1, expr_2)

  Умножает множитель expr (который должен быть суммой) на другие множители expr. То есть, expr есть `f_1 f_2 ... f_n`, где по крайней мере один множитель, скажем f_i, есть сумма членов. Каждый член в той сумме умножается на остальные множители в этом произведении. (А именно на все множители, за исключением f_i). `multthru` не раскрывает суммы, возведенные в степень. Эта функция есть самый быстрый способ распространять произведения (коммутативные или некоммутативные) на суммы. Так как дроби представляются как произведения, то `multthru` может также использоваться для деления сумм на произведения.

  `multthru (expr_1, expr_2)` умножает каждый член в expr_2 (который должен быть суммой или уравнением) на expr_1. Если expr_1 сам по себе не является суммой, то эта форма эквивалентна `multthru (expr_1*expr_2)`.

      (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                            1        x         f(x)
      (%o1)             - ----- + -------- - --------
                          x - y          2          3
                                  (x - y)    (x - y)
      (%i2) multthru ((x-y)^3, %);
                                 2
      (%o2)             - (x - y)  + x (x - y) - f(x)
      (%i3) ratexpand (%);
                                 2
      (%o3)                   - y  + x y - f(x)
      (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                              10  2              2  2
                       (b + a)   s  + 2 a b s + a  b
      (%o4)            ------------------------------
                                        2
                                   a b s
      (%i5) multthru (%);  /* note that this does not expand (b+a)^10 */
                                              10
                             2   a b   (b + a)
      (%o5)                  - + --- + ---------
                             s    2       a b
                                 s
      (%i6) multthru (a.(b+c.(d+e)+f));
      (%o6)            a . f + a . c . (e + d) + a . b
      (%i7) expand (a.(b+c.(d+e)+f));
      (%o7)         a . f + a . c . e + a . c . d + a . b

  Категории:Выражения ·

Функция: nounify (f)

  Возвращает невычисляемую форму функции с именем f. Это необходимо, если требуется представить имя вычисляемой функции так, если бы она была невычисляемой. Заметим, что некоторые вычисляемые функции возвращают их невычисляемые формы, если они не могут быть вычислены для определенных значений аргументов. Невычисляемая форма возвращается также в случае, если перед функцией стоит кавычка.

  Категории:Невычисляемые и вычисляемые формы ·

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

  Возвращает число членов, которое выражение expr имело бы, если оно было бы полностью раскрыто и не возникло бы сокращений или комбинаций членов. Заметим, что выражения такие как `sin (expr)`, `sqrt (expr)`, `exp (expr)` и др. считаются только как один член, вне независимости от того, как много членов expr имеет (если оно сумма).

  Категории:Выражения ·

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

  Возвращает главный оператор выражения expr. `op (expr)` эквивалентно `part (expr, 0)`.

  `op` возвращает строку, если главный оператор встроенный или определенный пользователем префиксный, бинарный или n-арный инфиксный, постфиксный, матчфиксный или безфиксный оператор. Иначе `op` возвращает символ.

  `op` следит за значением глобального флага `inflag`.

  `op` вычисляет свой аргумент.

  См. также `args`.

  Примеры:

      (%i1) stringdisp: true$
      (%i2) op (a * b * c);
      (%o2)                          "*"
      (%i3) op (a * b + c);
      (%o3)                          "+"
      (%i4) op ('sin (a + b));
      (%o4)                          sin
      (%i5) op (a!);
      (%o5)                          "!"
      (%i6) op (-a);
      (%o6)                          "-"
      (%i7) op ([a, b, c]);
      (%o7)                          "["
      (%i8) op ('(if a > b then c else d));
      (%o8)                         "if"
      (%i9) op ('foo (a));
      (%o9)                          foo
      (%i10) prefix (foo);
      (%o10)                        "foo"
      (%i11) op (foo a);
      (%o11)                        "foo"

  Категории:Выражения ·Операторы ·

Функция: operatorp (expr, op)
Функция: operatorp (expr, [op_1, ..., op_n])

  `operatorp (expr, op)` возвращает `true`, если op равен оператору expr.

  `operatorp (expr, [op_1, ..., op_n])` возвращает `true`, если какой-нибудь элемент op_1, ..., op_n равен оператору expr.

  Категории:Функции предикаты ·Операторы ·

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

  Возвращает выражение, которое выдает тоже самое значение и побочные эффекты, как и expr, но выполняется более эффективно за счет устранения лишних повторных вычислений общих подвыражений. `optimize` также имеет побочный эффект "сворачивания" своего аргумента так что все общие подвыражения используются совместно. Выполните `example (optimize)` для примеров.

  Категории:Выражения ·

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

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

  `optimprefix` это префикс, используемый для генерации символов командой `optimize`.

  Категории:Выражения ·

Функция: ordergreat (v_1, ..., v_n)

  Устанавливает синонимы для переменных v_1, ..., v_n, такие, что v_1 > v_2 > ... > v_n, и v_n > любой другой переменной, не включенной в аргументы.

  См. также `orderless`.

  Категории:Выражения ·

Функция: ordergreatp (expr_1, expr_2)

  Возвращает `true`, если expr_2 предшествует expr_1 в упорядочивании, установленном с помощью функции `ordergreat`.

  Категории:Выражения ·Функции предикаты ·

Функция: orderless (v_1, ..., v_n)

  Устанавливает синонимы для переменных v_1, ..., v_n, такие, что v_1 < v_2 < ... < v_n, и v_n < любой другой переменная, не включенной в аргументы.

  Таким образом, полная шкала упорядочивания такова: численные константы < объявленные константы < объявленные скаляры < первый аргумент `orderless` < ... < последний аргумент `orderless` < переменные, которые начинаются с A < ... < переменные, которые начинаются с Z < последний аргумент `ordergreat` < ... < первый аргумент `ordergreat` < объявленные главные переменные `mainvar`.

  См. также `ordergreat` и `mainvar`.

  Категории:Выражения ·

Функция: orderlessp (expr_1, expr_2)

  Возвращает `true`, если expr_1 предшествует expr_2 в упорядочивании, установленном командой `orderless`.

  Категории:Выражения ·Функции предикаты ·

Функция: part (expr, n_1, ..., n_k)

  Возвращает части внешней формы `expr`. Функция получает часть `expr`, которая определена индексами n_1, ..., n_k. Когда первая часть n_1 `expr` взята, берется часть n_2 от нее и т.д. Результат есть часть n_k от ... части n_2, от части n_1 выражения `expr`.

  `part` может быть использована для того, чтобы получить элемент списка, строку матрицы и т.п.

  Если последний аргумент функции `part` есть список индексов, то выбираются несколько подвыражений, каждое из которых соответствует индексу в списке. Таким образом, `part (x + y + z, [1, 3])` есть `z+x`.

  `piece` запоминает последнее выражение, выбранное при использовании функции `part`. Оно доступно во время выполнения этой функция и, таким образом, может быть использовано в самой функции, как показано ниже.

  Если `partswitch` установлен равным `true`, то `end` возвращается когда выбранная часть выражения не существует, иначе выдается сообщение об ошибке.

  Пример: `part (z+2*y, 2, 1)` дает 2.

  `example (part)` показывает дополнительные примеры.

  Категории:Выражения ·

Функция: partition (expr, x)

  Возвращает список из двух выражений. Они есть (1) множители expr (если оно произведение), члены expr (если оно является суммой), или список (если оно является списком), которые не содержит x и, (2) те множители, члены или список, которые содержат.

      (%i1) partition (2*a*x*f(x), x);
      (%o1)                     [2 a, x f(x)]
      (%i2) partition (a+b, x);
      (%o2)                      [b + a, 0]
      (%i3) partition ([a, b, f(a), c], a);
      (%o3)                  [[b, c], [a, f(a)]]

  Категории:Выражения ·

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

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

  Когда `partswitch` есть `true`, то `end` возвращается, если выбранная часть выражения не существует, иначе выдается сообщение об ошибке.

  Категории:Выражения ·

Функция: pickapart (expr, n)

  Присваивает меткам промежуточных выражений все подвыражения expr глубины n (целое число). Подвыражения большей или меньшей глубин меткам не присваиваются. `pickapart` возвращает выражение в терминах промежуточных выражений эквивалентное исходному expr.

  См. также `part`, `dpart`, `lpart`, `inpart` и `reveal`.

  Примеры:

      (%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
                                                2
                                           sin(x )   b + a
      (%o1)       - log(sqrt(x + 1) + 1) + ------- + -----
                                              3        2
      (%i2) pickapart (expr, 0);

                                                2
                                           sin(x )   b + a
      (%t2)       - log(sqrt(x + 1) + 1) + ------- + -----
                                              3        2

      (%o2)                          %t2
      (%i3) pickapart (expr, 1);

      (%t3)                - log(sqrt(x + 1) + 1)

                                        2
                                   sin(x )
      (%t4)                        -------
                                      3

                                    b + a
      (%t5)                         -----
                                      2

      (%o5)                    %t5 + %t4 + %t3
      (%i5) pickapart (expr, 2);

      (%t6)                 log(sqrt(x + 1) + 1)

                                        2
      (%t7)                        sin(x )

      (%t8)                         b + a

                               %t8   %t7
      (%o8)                    --- + --- - %t6
                                2     3
      (%i8) pickapart (expr, 3);

      (%t9)                    sqrt(x + 1) + 1

                                      2
      (%t10)                         x

                        b + a              sin(%t10)
      (%o10)            ----- - log(%t9) + ---------
                          2                    3
      (%i10) pickapart (expr, 4);

      (%t11)                     sqrt(x + 1)

                            2
                       sin(x )   b + a
      (%o11)           ------- + ----- - log(%t11 + 1)
                          3        2
      (%i11) pickapart (expr, 5);

      (%t12)                        x + 1

                         2
                    sin(x )   b + a
      (%o12)        ------- + ----- - log(sqrt(%t12) + 1)
                       3        2
      (%i12) pickapart (expr, 6);
                        2
                   sin(x )   b + a
      (%o12)       ------- + ----- - log(sqrt(x + 1) + 1)
                      3        2

  Категории:Выражения ·

Системная переменная: piece

  Содержит последнее выражение, выбранное при использовании функции `part`. Оно доступно во время выполнения функции и, таким образом, может быть в ней использовано.

  Категории:Выражения ·

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

  Возвращает выражение `r %e^(%i theta)` эквивалентное expr, такое, что `r` и `theta` чисто вещественные.

  Категории:Комплексные переменные ·Экспоненциальные и логарифмические функции ·

Функция: powers (expr, x)

  Выдает степени x, встречающиеся в expr.

  `load ("powers")` загружает эту функцию.

  Категории:Выражения ·Многочлены ·

Функция: product (expr, i, i_0, i_1)

  Представляет произведение значений expr с индексом i, меняющимся от i_0 до i_1. Невычисляемая форма `'product` изображается как заглавная буква пи.

  `product` вычисляет expr и нижний и верхний пределы i_0 и i_1, `product` не вычисляет индекс i.

  Если верхний и нижний пределы различаются на целое число, expr вычисляется для каждого значения индекса i, и результат есть точное произведение.

  Иначе, диапазон индекса является неопределенным. Для упрощения произведения применяются некоторые правила. Когда глобальная переменная `simpproduct` есть `true`, применяются дополнительные правила. В некоторых случаях, упрощение дает результат, который не является произведением, иначе, результат есть невычисляемая форма `'product`.

  См. также `nouns` и `evflag`.

  Примеры:

      (%i1) product (x + i*(i+1)/2, i, 1, 4);
      (%o1)           (x + 1) (x + 3) (x + 6) (x + 10)
      (%i2) product (i^2, i, 1, 7);
      (%o2)                       25401600
      (%i3) product (a[i], i, 1, 7);
      (%o3)                 a  a  a  a  a  a  a
                             1  2  3  4  5  6  7
      (%i4) product (a(i), i, 1, 7);
      (%o4)          a(1) a(2) a(3) a(4) a(5) a(6) a(7)
      (%i5) product (a(i), i, 1, n);
                                   n
                                 /===\
                                  ! !
      (%o5)                       ! !  a(i)
                                  ! !
                                 i = 1
      (%i6) product (k, k, 1, n);
                                     n
                                   /===\
                                    ! !
      (%o6)                         ! !  k
                                    ! !
                                   k = 1
      (%i7) product (k, k, 1, n), simpproduct;
      (%o7)                          n!
      (%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
                                   n
                                 /===\
                                  ! !    1
      (%o8)                       ! !  -----
                                  ! !  k + 1
                                 k = 1
      (%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
                                    15  40
      (%o9)                        a   b

  Категории:Суммы и произведения ·

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

  Возвращает вещественную часть expr. `realpart` и `imagpart` будут работать для выражений, включающих тригонометрические и гипергеометрические функции, также как и квадратный корень, логарифм и возведение в степень.

  Категории:Комплексные числа ·

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

  Возвращает выражение `a + b %i`, эквивалентное expr, такое, что a и b чисто вещественные.

  Категории:Комплексные числа ·

Функция: rembox (expr, unlabelled)
Функция: rembox (expr, label)
Функция: rembox (expr)

  Удаляет боксы из expr.

  `rembox (expr, unlabelled)` удаляет все непомеченные боксы из expr.

  `rembox (expr, label)` удаляет только боксы, содержащие label.

  `rembox (expr)` удаляет все боксы, помеченные и непомеченные.

  Боксы рисуются функциями `box`, `dpart` и `lpart`.

  Примеры:

      (%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
                                        a d - b c
      (%o1)                sin(%pi x) + ---------
                                            2
                                           h
      (%i2) dpart (dpart (expr, 1, 1), 2, 2);
                              """""""    a d - b c
      (%o2)               sin("%pi x") + ---------
                              """""""      """"
                                           " 2"
                                           "h "
                                           """"
      (%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
                        FOO"""""""""""   BAR""""""""
                        "    """"""" "   "a d - b c"
      (%o3)             "sin("%pi x")" + "---------"
                        "    """"""" "   "  """"   "
                        """"""""""""""   "  " 2"   "
                                         "  "h "   "
                                         "  """"   "
                                         """""""""""
      (%i4) rembox (expr2, unlabelled);
                                        BAR""""""""
                         FOO"""""""""   "a d - b c"
      (%o4)              "sin(%pi x)" + "---------"
                         """"""""""""   "    2    "
                                        "   h     "
                                        """""""""""
      (%i5) rembox (expr2, FOO);
                                        BAR""""""""
                             """""""    "a d - b c"
      (%o5)              sin("%pi x") + "---------"
                             """""""    "  """"   "
                                        "  " 2"   "
                                        "  "h "   "
                                        "  """"   "
                                        """""""""""
      (%i6) rembox (expr2, BAR);
                         FOO"""""""""""
                         "    """"""" "   a d - b c
      (%o6)              "sin("%pi x")" + ---------
                         "    """"""" "     """"
                         """"""""""""""     " 2"
                                            "h "
                                            """"
      (%i7) rembox (expr2);
                                        a d - b c
      (%o7)                sin(%pi x) + ---------
                                            2
                                           h

  Категории:Выражения ·

Функция: sum (expr, i, i_0, i_1)

  Представляет собой суммирование значений expr для индекса i, изменяющегося от i_0 до i_1. Невычисляемая форма `'sum` изображается как заглавная буква сигма.

  `sum` вычисляет свое слагаемое expr и нижний и верхний пределы i_0 и i_1, `sum` не вычисляет индекс i.

  Если верхний и нижний пределы отличаются на целое число, слагаемое expr вычисляется для каждого значения индекса суммирования i, и результат есть точная сумма.

  Иначе, диапазон индекса является неопределенным. Для упрощения суммирования применяются некоторые правила. Когда глобальная переменная `simpsum` есть `true`, дополнительные правила применяются. В некоторых случаях, упрощение дает результат, который не есть суммирование, иначе, результат есть невычисляемая форма `'sum`.

  Когда `evflag` (флаг вычисления) `cauchysum` есть `true`, произведение суммирования выражается как произведение Коши, в котром индекс внутреннего суммирования есть функция индекса внешнего суммирования, а не меняющейся независимо индекс.

  Глобальная переменная `genindex` есть буквенный префикс, используемый для генерации следующего индекса суммирования, если требуется автоматически сгенерированный индекс.

  `gensumnum` есть численный суффикс, используемый для генерирования следующего используемый для генерации следующего индекса суммирования, если требуется автоматически сгенерированный индекс. Когда `gensumnum` есть `false`, автоматически сгенерированный индекс есть только `genindex` без численного суффикса.

  См. также `sumcontract`, `intosum`, `bashindices`, `niceindices`, `nouns`, `evflag` и `zeilberger`.

  Примеры:

      (%i1) sum (i^2, i, 1, 7);
      (%o1)                          140
      (%i2) sum (a[i], i, 1, 7);
      (%o2)           a  + a  + a  + a  + a  + a  + a
                       7    6    5    4    3    2    1
      (%i3) sum (a(i), i, 1, 7);
      (%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
      (%i4) sum (a(i), i, 1, n);
                                  n
                                 ====
                                 \
      (%o4)                       >    a(i)
                                 /
                                 ====
                                 i = 1
      (%i5) sum (2^i + i^2, i, 0, n);
                                n
                               ====
                               \       i    2
      (%o5)                     >    (2  + i )
                               /
                               ====
                               i = 0
      (%i6) sum (2^i + i^2, i, 0, n), simpsum;
                                    3      2
                         n + 1   2 n  + 3 n  + n
      (%o6)             2      + --------------- - 1
                                        6
      (%i7) sum (1/3^i, i, 1, inf);
                                  inf
                                  ====
                                  \     1
      (%o7)                        >    --
                                  /      i
                                  ====  3
                                  i = 1
      (%i8) sum (1/3^i, i, 1, inf), simpsum;
                                      1
      (%o8)                           -
                                      2
      (%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                                    inf
                                    ====
                                    \     1
      (%o9)                      30  >    --
                                    /      2
                                    ====  i
                                    i = 1
      (%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                        2
      (%o10)                       5 %pi
      (%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                  n
                                 ====
                                 \       1
      (%o11)                      >    -----
                                 /     k + 1
                                 ====
                                 k = 1
      (%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10);
                10    9    8    7    6    5    4    3    2
      (%o12)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a

  Категории:Суммы и произведения ·

Функция: lsum (expr, x, L)

  Представляет собой сумму expr для каждого элемента x в L.

  Невычисляемая форма `'lsum` возвращается, если аргумент L не вычисляется до списка.

  Примеры:

      (%i1) lsum (x^i, i, [1, 2, 7]);
                                  7    2
      (%o1)                      x  + x  + x
      (%i2) lsum (i^2, i, rootsof (x^3 - 1, x));
                           ====
                           \      2
      (%o2)                 >    i
                           /
                           ====
                                         3
                           i in rootsof(x  - 1, x)

  Категории:Суммы и произведения ·

Функция: verbify (f)

  Возвращает вычисляемую форму функции с именем f.

  См. также `verb`, `noun` и `nounify`.

  Примеры:

      (%i1) verbify ('foo);
      (%o1)                          foo
      (%i2) :lisp $%
      $FOO
      (%i2) nounify (foo);
      (%o2)                          foo
      (%i3) :lisp $%
      %FOO

  Категории:Невычисляемые и вычисляемые формы ·

Previous: Синтаксис, Up: Выражения [Contents][Index]