File: maxima_141.html

package info (click to toggle)
maxima 5.47.0-9
links: PTS
area: main
in suites: forky, sid
size: 193,104 kB
sloc: lisp: 434,678; fortran: 14,665; tcl: 10,990; sh: 4,577; makefile: 2,763; ansic: 447; java: 328; python: 262; perl: 201; xml: 60; awk: 28; sed: 15; javascript: 2
file content (1972 lines) | stat: -rw-r--r-- 90,003 bytes
parent folder | download | duplicates (2)
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.1, http://www.gnu.org/software/texinfo/ -->
<head>
<title>Maxima Manual: Функции и переменные для работы с множествами</title>

<meta name="description" content="Maxima Manual: Функции и переменные для работы с множествами">
<meta name="keywords" content="Maxima Manual: Функции и переменные для работы с множествами">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<link href="maxima_toc.html#Top" rel="start" title="Top">
<link href="maxima_264.html#g_t_0423_043a_0430_0437_0430_0442_0435_043b_044c-_0444_0443_043d_043a_0446_0438_0439-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0445" rel="index" title="Указатель функций и переменных">
<link href="maxima_toc.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="maxima_139.html#g_t_041c_043d_043e_0436_0435_0441_0442_0432_0430" rel="up" title="Множества">
<link href="maxima_142.html#g_t_041e_043f_0440_0435_0434_0435_043b_0435_043d_0438_0435-_0444_0443_043d_043a_0446_0438_0439" rel="next" title="Определение функций">
<link href="maxima_140.html#g_t_0412_0432_0435_0434_0435_043d_0438_0435-_0432-_0440_0430_0431_043e_0442_0443-_0441-_043c_043d_043e_0436_0435_0441_0442_0432_0430_043c_0438" rel="previous" title="Введение в работу с множествами">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
body {color: black; background: white;  margin-left: 8%; margin-right: 13%;
      font-family: "FreeSans", sans-serif}
h1 {font-size: 150%; font-family: "FreeSans", sans-serif}
h2 {font-size: 125%; font-family: "FreeSans", sans-serif}
h3 {font-size: 100%; font-family: "FreeSans", sans-serif}
a[href] {color: rgb(0,0,255); text-decoration: none;}
a[href]:hover {background: rgb(220,220,220);}
div.textbox {border: solid; border-width: thin; padding-top: 1em;
    padding-bottom: 1em; padding-left: 2em; padding-right: 2em}
div.titlebox {border: none; padding-top: 1em; padding-bottom: 1em;
    padding-left: 2em; padding-right: 2em; background: rgb(200,255,255);
    font-family: sans-serif}
div.synopsisbox {
    border: none; padding-top: 1em; padding-bottom: 1em; padding-left: 2em;
    padding-right: 2em; background: rgb(255,220,255);}
pre.example {border: 1px solid rgb(180,180,180); padding-top: 1em;
    padding-bottom: 1em; padding-left: 1em; padding-right: 1em;
    background-color: rgb(238,238,255)}
div.spacerbox {border: none; padding-top: 2em; padding-bottom: 2em}
div.image {margin: 0; padding: 1em; text-align: center}
div.categorybox {border: 1px solid gray; padding-top: 1em; padding-bottom: 1em;
    padding-left: 1em; padding-right: 1em; background: rgb(247,242,220)}
img {max-width:80%; max-height: 80%; display: block; margin-left: auto; margin-right: auto}

-->
</style>

<link rel="icon" href="figures/favicon.ico">
<script src="https://polyfill.io/v3/polyfill.min.js?features=es6>"></script>
<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head>

<body lang="ru" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="g_t_0424_0443_043d_043a_0446_0438_0438-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0435-_0434_043b_044f-_0440_0430_0431_043e_0442_044b-_0441-_043c_043d_043e_0436_0435_0441_0442_0432_0430_043c_0438"></a>
<div class="header">
<p>
Previous: <a href="maxima_140.html#g_t_0412_0432_0435_0434_0435_043d_0438_0435-_0432-_0440_0430_0431_043e_0442_0443-_0441-_043c_043d_043e_0436_0435_0441_0442_0432_0430_043c_0438" accesskey="p" rel="previous">Введение в работу с множествами</a>, Up: <a href="maxima_139.html#g_t_041c_043d_043e_0436_0435_0441_0442_0432_0430" accesskey="u" rel="up">Множества</a> &nbsp; [<a href="maxima_toc.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="maxima_264.html#g_t_0423_043a_0430_0437_0430_0442_0435_043b_044c-_0444_0443_043d_043a_0446_0438_0439-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0445" title="Index" rel="index">Index</a>]</p>
</div>
<a name="Funkcii-i-peremennye-dlya-raboty-s-mnozhestvami"></a>
<h3 class="section">36.2 Функции и переменные для работы с множествами</h3>

<a name="adjoin"></a><a name="Item_003a-nset_002fdeffn_002fadjoin"></a><dl>
<dt><a name="index-adjoin"></a>Функция: <strong>adjoin</strong> <em>(<var>x</var>, <var>a</var>) </em></dt>
<dd>
<p>Возвращает объединение множества <var>a</var> с <code>{<var>x</var>}</code>.
</p>
<p>Функция <code>adjoin</code> вызывает ошибку, если <var>a</var> не является множеством.
</p>
<p>Вызовы <code>adjoin(<var>x</var>, <var>a</var>)</code> и <code>union(set(<var>x</var>), <var>a</var>)</code>
эквивалентны, однако <code>adjoin</code> может быть несколько быстрее, чем <code>union</code>.
</p>
<p>См. также <code>disjoin</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) adjoin (c, {a, b});
(%o1)                       {a, b, c}
(%i2) adjoin (a, {a, b});
(%o2)                        {a, b}
</pre></div>

</dd></dl>





<a name="belln"></a><a name="Item_003a-nset_002fdeffn_002fbelln"></a><dl>
<dt><a name="index-belln"></a>Функция: <strong>belln</strong> <em>(<var>n</var>)</em></dt>
<dd>
<p>Представляет <em>n</em>-ое число Белла.
<code>belln(n)</code> есть число разбиений множества с <var>n</var> элементами.
</p>
<p>Для неотрицательного целого <var>n</var>,
<code>belln(<var>n</var>)</code> упрощается в <em>n</em>-ое число Белла.
Для других значений аргумента <code>belln</code> не упрощается.
</p>
<p>Функция <code>belln</code> дистрибутивна по отношению к уравнениям, спискам, матрицам и множествам.
</p>
<p>Примеры:
</p>
<p>Функция <code>belln</code>, примененная к неотрицательным целым числам.
</p>
<div class="example">
<pre class="example">(%i1) makelist (belln (i), i, 0, 6);
(%o1)               [1, 1, 2, 5, 15, 52, 203]
(%i2) is (cardinality (set_partitions ({})) = belln (0));
(%o2)                         true
(%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) =
                       belln (6));
(%o3)                         true
</pre></div>

<p>Функция <code>belln</code>, примененная к аргументам, не являющимися неотрицательными 
целыми числами.
</p>
<div class="example">
<pre class="example">(%i1) [belln (x), belln (sqrt(3)), belln (-9)];
(%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]
</pre></div>





</dd></dl>

<a name="cardinality"></a><a name="Item_003a-nset_002fdeffn_002fcardinality"></a><dl>
<dt><a name="index-cardinality"></a>Функция: <strong>cardinality</strong> <em>(<var>a</var>)</em></dt>
<dd>
<p>Возвращает число различных элементов множества <var>a</var>. 
</p>
<p>Функция <code>cardinality</code> игнорирует повторяющиеся элементы даже если упрощение
отключено.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) cardinality ({});
(%o1)                           0
(%i2) cardinality ({a, a, b, c});
(%o2)                           3
(%i3) simp : false;
(%o3)                         false
(%i4) cardinality ({a, a, b, c});
(%o4)                           3
</pre></div>





</dd></dl>

<a name="cartesian_005fproduct"></a><a name="Item_003a-nset_002fdeffn_002fcartesian_005fproduct"></a><dl>
<dt><a name="index-cartesian_005fproduct"></a>Функция: <strong>cartesian_product</strong> <em>(<var>b_1</var>, ... , <var>b_n</var>)</em></dt>
<dd><p>Возвращает множество списков формы <code>[<var>x_1</var>, ..., <var>x_n</var>]</code>, где
<var>x_1</var>, ..., <var>x_n</var> есть элементы множеств <var>b_1</var>, ... , <var>b_n</var> соответственно.
</p>
<p>Функция <code>cartesian_product</code> вызывает ошибку, если хотя бы один из ее аргументов
не является множеством.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) cartesian_product ({0, 1});
(%o1)                      {[0], [1]}
(%i2) cartesian_product ({0, 1}, {0, 1});
(%o2)           {[0, 0], [0, 1], [1, 0], [1, 1]}
(%i3) cartesian_product ({x}, {y}, {z});
(%o3)                      {[x, y, z]}
(%i4) cartesian_product ({x}, {-1, 0, 1});
(%o4)              {[x, - 1], [x, 0], [x, 1]}
</pre></div>





</dd></dl>


<a name="disjoin"></a><a name="Item_003a-nset_002fdeffn_002fdisjoin"></a><dl>
<dt><a name="index-disjoin"></a>Функция: <strong>disjoin</strong> <em>(<var>x</var>, <var>a</var>)</em></dt>
<dd><p>Возвращает множество <var>a</var> без элемента <var>x</var>.
Если <var>x</var> не является элементом <var>a</var>, то <var>a</var> 
возвращается неизменным.
</p>
<p>Функция <code>disjoin</code> вызывает ошибку, если <var>a</var> не является множеством.
</p>
<p><code>disjoin(<var>x</var>, <var>a</var>)</code>, <code>delete(<var>x</var>, <var>a</var>)</code> и
<code>setdifference(<var>a</var>, set(<var>x</var>))</code> эквивалентны. 
Из этих вариантов <code>disjoin</code> обычно быстрее других.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) disjoin (a, {a, b, c, d});
(%o1)                       {b, c, d}
(%i2) disjoin (a + b, {5, z, a + b, %pi});
(%o2)                      {5, %pi, z}
(%i3) disjoin (a - b, {5, z, a + b, %pi});
(%o3)                  {5, %pi, b + a, z}
</pre></div>





</dd></dl>

<a name="disjointp"></a><a name="Item_003a-nset_002fdeffn_002fdisjointp"></a><dl>
<dt><a name="index-disjointp"></a>Функция: <strong>disjointp</strong> <em>(<var>a</var>, <var>b</var>) </em></dt>
<dd><p>Возвращает <code>true</code> тогда и только тогда, когда множества <var>a</var> и <var>b</var> не пересекаются.
</p>
<p>Функция <code>disjointp</code> вызывает ошибку, если <var>a</var> или <var>b</var> не являются множествами.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) disjointp ({a, b, c}, {1, 2, 3});
(%o1)                         true
(%i2) disjointp ({a, b, 3}, {1, 2, 3});
(%o2)                         false
</pre></div>






</dd></dl>

<a name="divisors"></a><a name="Item_003a-nset_002fdeffn_002fdivisors"></a><dl>
<dt><a name="index-divisors"></a>Функция: <strong>divisors</strong> <em>(<var>n</var>)</em></dt>
<dd>
<p>Представляет множество делителей <var>n</var>.
</p>
<p>Функция <code>divisors(<var>n</var>)</code> упрощается до множества целых чисел, при этом
<var>n</var> является ненулевым целым числом.
Множество делителей включает 1 и <var>n</var>.
Делители отрицательного числа совпадают с таковыми для его абсолютного значения.
</p>
<p>Функция <code>divisors</code> дистрибутивна по отношению к уравнениям, спискам, матрицам и множествам.
</p>
<p>Примеры:
</p>
<p>Мы можем проверить, что число 28 является совершенным,
т.е. сумма делителей, за исключением самого числа, равна 28.
</p>
<div class="example">
<pre class="example">(%i1) s: divisors(28);
(%o1)                 {1, 2, 4, 7, 14, 28}
(%i2) lreduce (&quot;+&quot;, args(s)) - 28;
(%o2)                          28
</pre></div>

<p>Функция <code>divisors</code> является упрощающей.
Подстановка 8 для <code>a</code> в <code>divisors(a)</code>
дает делители без перевычисления <code>divisors(8)</code>.
</p>
<div class="example">
<pre class="example">(%i1) divisors (a);
(%o1)                      divisors(a)
(%i2) subst (8, a, %);
(%o2)                     {1, 2, 4, 8}
</pre></div>

<p>Функция <code>divisors</code> дистрибутивна по отношению к уравнениям, спискам, матрицам и множествам.
</p>
<div class="example">
<pre class="example">(%i1) divisors (a = b);
(%o1)               divisors(a) = divisors(b)
(%i2) divisors ([a, b, c]);
(%o2)        [divisors(a), divisors(b), divisors(c)]
(%i3) divisors (matrix ([a, b], [c, d]));
                  [ divisors(a)  divisors(b) ]
(%o3)             [                          ]
                  [ divisors(c)  divisors(d) ]
(%i4) divisors ({a, b, c});
(%o4)        {divisors(a), divisors(b), divisors(c)}
</pre></div>





</dd></dl>

<a name="elementp"></a><a name="Item_003a-nset_002fdeffn_002felementp"></a><dl>
<dt><a name="index-elementp"></a>Функция: <strong>elementp</strong> <em>(<var>x</var>, <var>a</var>)</em></dt>
<dd><p>Возвращает <code>true</code> тогда и только тогда, когда <var>x</var> является элементом множества <var>a</var>.
</p>
<p>Функция <code>elementp</code> вызывает ошибку, если <var>a</var> не является множеством.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
(%o1)                         true
(%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
(%o2)                         false
</pre></div>






</dd></dl>

<a name="emptyp"></a><a name="Item_003a-nset_002fdeffn_002femptyp"></a><dl>
<dt><a name="index-emptyp"></a>Функция: <strong>emptyp</strong> <em>(<var>a</var>)</em></dt>
<dd><p>Возвращает <code>true</code> тогда и только тогда, когда <var>a</var> есть пустое множество или список.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) map (emptyp, [{}, []]);
(%o1)                     [true, true]
(%i2) map (emptyp, [a + b, {{}}, %pi]);
(%o2)                 [false, false, false]
</pre></div>






</dd></dl>
       
<a name="equiv_005fclasses"></a><a name="Item_003a-nset_002fdeffn_002fequiv_005fclasses"></a><dl>
<dt><a name="index-equiv_005fclasses"></a>Функция: <strong>equiv_classes</strong> <em>(<var>s</var>, <var>F</var>)</em></dt>
<dd><p>Возвращает множество классов эквивалентности множества <var>s</var> по отношению эквивалентности <var>F</var>.
</p>
<p><var>F</var> &ndash; есть функция двух переменных, определенная на Декартовом произведении <var>s</var> на <var>s</var>.
Возвращаемое <var>F</var> значение есть <code>true</code> или <code>false</code>,
либо выражение <var>expr</var> такое, что <code>is(<var>expr</var>)</code> дает <code>true</code> или <code>false</code>.
</p>
<p>Если <var>F</var> не является отношением эквивалентности, то <code>equiv_classes</code> 
применит его без возражения, но результат будет скорее всего неправильным.
</p>

<p>Примеры:
</p>
<p>Отношение эквивалентности является лямбда-выражением, возвращающим <code>true</code> или <code>false</code>.
</p>
<div class="example">
<pre class="example">(%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
                        lambda ([x, y], is (equal (x, y))));
(%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}
</pre></div>

<p>Отношение эквивалентности есть имя реляционной функции <code>is</code>, дающей <code>true</code> или <code>false</code>.
</p>
<div class="example">
<pre class="example">(%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
(%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}
</pre></div>

<p>Классы эквивалентности &ndash; числа отличающиеся на несколько чисел 3.
</p>
<div class="example">
<pre class="example">(%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7},
                     lambda ([x, y], remainder (x - y, 3) = 0));
(%o1)              {{1, 4, 7}, {2, 5}, {3, 6}}
</pre></div>





</dd></dl>

<a name="every"></a><a name="Item_003a-nset_002fdeffn_002fevery"></a><dl>
<dt><a name="index-every"></a>Функция: <strong>every</strong> <em>(<var>f</var>, <var>s</var>)</em></dt>
<dt><a name="index-every-1"></a>Функция: <strong>every</strong> <em>(<var>f</var>, <var>L_1</var>, ..., <var>L_n</var>)</em></dt>
<dd>
<p>Возвращает <code>true</code>, если предикат <var>f</var> дает <code>true</code> для всех аргументов.
</p>
<p>Если второй аргумент является множеством, то  
<code>every(<var>f</var>, <var>s</var>)</code> возвращает <code>true</code>,
если <code>is(<var>f</var>(<var>a_i</var>))</code> возвращает <code>true</code> для всех <var>a_i</var> в <var>s</var>.
<code>every</code> может вычислять <var>f</var> для всех <var>a_i</var> в <var>s</var>, а может и не для всех.
Т.к. множества не упорядочены, то <code>every</code> может вычислять <code><var>f</var>(<var>a_i</var>)</code> 
в произвольном порядке.
</p>
<p>Примененная к одному или нескольким спискам,
<code>every(<var>f</var>, <var>L_1</var>, ..., <var>L_n</var>)</code> возвращает <code>true</code>,
если <code>is(<var>f</var>(<var>x_1</var>, ..., <var>x_n</var>))</code> возвращает <code>true</code> 
для всех <var>x_1</var>, ..., <var>x_n</var> в <var>L_1</var>, ..., <var>L_n</var> соответственно.
<code>every</code> может вычислять <var>f</var> для всех комбинаций <var>x_1</var>, ..., <var>x_n</var>, а может и не для всех.
<code>every</code> вычисляет списки в порядке возрастания индекса.
</p>
<p>Для пустого множества <code>{}</code> и пустого списка <code>[]</code> <code>every</code> возвращает <code>false</code>.
</p>
<p>Если глобальный флаг <code>maperror</code> равен <code>true</code>, то все списки 
<var>L_1</var>, ..., <var>L_n</var> должны иметь одинаковую длину.
Если <code>maperror</code> равен <code>false</code>, то списки обрезаются до длины 
самого короткого. 
</p>
<p>Значение предиката <var>f</var>, который вычисляется посредством <code>is</code>
в значение, отличное от <code>true</code> или <code>false</code>,
управляется глобальным флагом <code>prederror</code>.
Если <code>prederror</code> равен <code>true</code>, то данные
значения рассматриваются как <code>false</code>, и возвращаемое
<code>every</code> значение есть <code>false</code>.
Если  <code>prederror</code> равен  <code>false</code>, то такие значения
рассматриваются как <code>unknown</code>, и возвращаемое
<code>every</code> значение равно <code>unknown</code>.
</p>
<p>Примеры:
</p>
<p><code>every</code>, примененная к одному списку.
Предикат является функцией одного аргумента.
</p>
<div class="example">
<pre class="example">(%i1) every (integerp, {1, 2, 3, 4, 5, 6});
(%o1)                         true
(%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
(%o2)                         false
</pre></div>

<p><code>every</code>, примененная к двум спискам.
Предикат &ndash; функция двух аргументов.
</p>
<div class="example">
<pre class="example">(%i1) every (&quot;=&quot;, [a, b, c], [a, b, c]);
(%o1)                         true
(%i2) every (&quot;#&quot;, [a, b, c], [a, b, c]);
(%o2)                         false
</pre></div>

<p>Значение предиката <var>f</var>, вычисляемого в значение,
отличное от <code>true</code> или <code>false</code>,
управляется глобальным флагом <code>prederror</code>.
</p>
<div class="example">
<pre class="example">(%i1) prederror : false;
(%o1)                         false
(%i2) map (lambda ([a, b], is (a &lt; b)), [x, y, z],
                   [x^2, y^2, z^2]);
(%o2)              [unknown, unknown, unknown]
(%i3) every (&quot;&lt;&quot;, [x, y, z], [x^2, y^2, z^2]);
(%o3)                        unknown
(%i4) prederror : true;
(%o4)                         true
(%i5) every (&quot;&lt;&quot;, [x, y, z], [x^2, y^2, z^2]);
(%o5)                         false
</pre></div>





</dd></dl>
 
<a name="extremal_005fsubset"></a><a name="Item_003a-nset_002fdeffn_002fextremal_005fsubset"></a><dl>
<dt><a name="index-extremal_005fsubset"></a>Функция: <strong>extremal_subset</strong> <em>(<var>s</var>, <var>f</var>, max)</em></dt>
<dt><a name="index-extremal_005fsubset-1"></a>Функция: <strong>extremal_subset</strong> <em>(<var>s</var>, <var>f</var>, min)</em></dt>
<dd>
<p>Возвращает подмножество <var>s</var>, на котором функция <var>f</var> принимает минимальное или максимальное значение.
</p>
<p><code>extremal_subset(<var>s</var>, <var>f</var>, max)</code> возвращает подмножество множества или списка 
<var>s</var>, для которого вещественнозначная функция <var>f</var> принимает максимальное значение.
</p>
<p><code>extremal_subset(<var>s</var>, <var>f</var>, min)</code> возвращает подмножество множества или списка 
<var>s</var>, для которого вещественнозначная функция <var>f</var> принимает минимальное значение.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
(%o1)                       {- 2, 2}
(%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
(%o2)                       {sqrt(2)}
</pre></div>





</dd></dl>

<a name="flatten"></a><a name="Item_003a-nset_002fdeffn_002fflatten"></a><dl>
<dt><a name="index-flatten"></a>Функция: <strong>flatten</strong> <em>(<var>expr</var>)</em></dt>
<dd>
<p>Собирает аргументы подвыражений, имеющих оператор верхнего уровня такой же как у <var>expr</var>,
и строит выражение из этих собранных аргументов.
</p>
<p>Аргументы, имеющие оператор верхнего уровня отличный от главного оператора <code>expr</code>,
копируются без модификации даже если они, в свою очередь, имеют некоторые подвыражения
с главным оператором <code>expr</code>.
</p>
<p>Возможно, что <code>flatten</code> построит выражение с числом аргументов
недопустимым для данного типа оператора, что может привести к ошибке
упрощателя или вычислителя.
Функция <code>flatten</code> не пытается определить подобные ситуации.
</p>
<p>Выражения, имеющие специальные представления, например, канонические рациональные выражения (КРВ),
не обрабатываются <code>flatten</code>.  В этом случае <code>flatten</code> возвращает аргумент
без изменения.
</p>
<p>Примеры:
</p>
<p>Примененная к списку, <code>flatten</code> собирает все элементы, являющиеся списками.
</p>
<div class="example">
<pre class="example">(%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
(%o1)            [a, b, c, d, e, f, g, h, i, j]
</pre></div>

<p>Примененная к множеству, <code>flatten</code> собирает все элементы, являющиеся множествами.
</p>
<div class="example">
<pre class="example">(%i1) flatten ({a, {b}, {{c}}});
(%o1)                       {a, b, c}
(%i2) flatten ({a, {[a], {a}}});
(%o2)                       {a, [a]}
</pre></div>

<p>Функция <code>flatten</code> похожа на объявление оператора n-арным.
Однако <code>flatten</code> не влияет на подвыражения, имеющие оператор, отличный от 
главного оператора выражения, тогда как декларация оператора n-арным действует на них.
</p>
<div class="example">
<pre class="example">(%i1) expr: flatten (f (g (f (f (x)))));
(%o1)                     f(g(f(f(x))))
(%i2) declare (f, nary);
(%o2)                         done
(%i3) ev (expr);
(%o3)                      f(g(f(x)))
</pre></div>

<p><code>flatten</code> трактует функции с индексом также как любые другие операторы.
</p>
<div class="example">
<pre class="example">(%i1) flatten (f[5] (f[5] (x, y), z));
(%o1)                      f (x, y, z)
                            5
</pre></div>

<p>Функция <code>flatten</code> может составить выражение, в котором число аргументов
отличается от объявленного числа аргументов оператора.
</p>
<div class="example">
<pre class="example">(%i1) 'mod (5, 'mod (7, 4));
(%o1)                   mod(5, mod(7, 4))
(%i2) flatten (%);
(%o2)                     mod(5, 7, 4)
(%i3) ''%, nouns;
Wrong number of arguments to mod
 -- an error.  Quitting.  To debug this try debugmode(true);
</pre></div>






</dd></dl>

<a name="full_005flistify"></a><a name="Item_003a-nset_002fdeffn_002ffull_005flistify"></a><dl>
<dt><a name="index-full_005flistify"></a>Функция: <strong>full_listify</strong> <em>(<var>a</var>)</em></dt>
<dd><p>Заменяет в <var>a</var> все множества на списки и возвращает результат.
<code>full_listify</code> заменяет операторы множества на операторы списка во вложенных подвыражениях,
даже если главный оператор не есть <code>set</code>.
</p>
<p>Функция <code>listify</code> заменяет только главный оператор.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) full_listify ({a, b, {c, {d, e, f}, g}});
(%o1)               [a, b, [c, [d, e, f], g]]
(%i2) full_listify (F (G ({a, b, H({c, d, e})})));
(%o2)              F(G([a, b, H([c, d, e])]))
</pre></div>





</dd></dl>

<a name="fullsetify"></a><a name="Item_003a-nset_002fdeffn_002ffullsetify"></a><dl>
<dt><a name="index-fullsetify"></a>Функция: <strong>fullsetify</strong> <em>(<var>a</var>)</em></dt>
<dd><p>Если <var>a</var> является списком, то <code>fullsetify</code> заменяет оператор списка на оператор множества и
применяет <code>fullsetify</code> ко всем членам этого множества.
Если аргумент <var>a</var> не является списком, то он возвращается неизменным.
</p>
<p>Функция <code>setify</code> заменяет только главный оператор.
</p>
<p>Примеры:
</p>
<p>В строке <code>(%o2)</code> аргумент <code>f</code> не преобразован в множество, т.к.
главный оператор не является списком <code>f([b])</code>.
</p>
<div class="example">
<pre class="example">(%i1) fullsetify ([a, [a]]);
(%o1)                       {a, {a}}
(%i2) fullsetify ([a, f([b])]);
(%o2)                      {a, f([b])}
</pre></div>





</dd></dl>

<a name="identity"></a><a name="Item_003a-nset_002fdeffn_002fidentity"></a><dl>
<dt><a name="index-identity"></a>Функция: <strong>identity</strong> <em>(<var>x</var>)</em></dt>
<dd>
<p>Возвращает <var>x</var> для любого аргумента <var>x</var>.
</p>
<p>Примеры:
</p>
<p>Функция <code>identity</code> может использоваться как предикат, если параметры уже
являются логическими значениями.
</p>
<div class="example">
<pre class="example">(%i1) every (identity, [true, true]);
(%o1)                         true
</pre></div>

</dd></dl>

<a name="integer_005fpartitions"></a><a name="Item_003a-nset_002fdeffn_002finteger_005fpartitions"></a><dl>
<dt><a name="index-integer_005fpartitions"></a>Функция: <strong>integer_partitions</strong> <em>(<var>n</var>)</em></dt>
<dt><a name="index-integer_005fpartitions-1"></a>Функция: <strong>integer_partitions</strong> <em>(<var>n</var>, <var>len</var>)</em></dt>
<dd>
<p>Возвращает целочисленные разбиения <var>n</var>, т.е. списки целых чисел,
сумма которых равна <var>n</var>.
</p>
<p>Функция <code>integer_partitions(<var>n</var>)</code> возвращает множество
всех разбиений <var>n</var>.
Каждое разбиение есть список, отсортированный от большего значения к меньшему.
</p>
<p>Вызов <code>integer_partitions(<var>n</var>, <var>len</var>)</code>
возвращает все разбиения длины <var>len</var> или менее. 
В этом случае к разбиениям, имеющим число членов меньшее, чем <var>len</var>,
добавляются нули, чтобы сделать все возвращаемые разбиения одинаковой
длины <var>len</var>.
</p>
<p>Список <em>[a_1, ..., a_m]</em> есть разбиение неотрицательного целого числа 
<em>n</em>, если (1) каждое <em>a_i</em> есть ненулевое положительное число и (2) 
<em>a_1 + ... + a_m = n</em>.  Таким образом, 0 не имеет разбиений.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) integer_partitions (3);
(%o1)               {[1, 1, 1], [2, 1], [3]}
(%i2) s: integer_partitions (25)$
(%i3) cardinality (s);
(%o3)                         1958
(%i4) map (lambda ([x], apply (&quot;+&quot;, x)), s);
(%o4)                         {25}
(%i5) integer_partitions (5, 3);
(%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]}
(%i6) integer_partitions (5, 2);
(%o6)               {[3, 2], [4, 1], [5, 0]}
</pre></div>

<p>Для того, чтобы найти все разбиения, удовлетворяющие определенному условию, можно использовать функцию <code>subset</code>.
В следующем примере находятся все разбиения 10, состоящие из простых чисел.
</p>
<div class="example">
<pre class="example">(%i1) s: integer_partitions (10)$
(%i2) cardinality (s);
(%o2)                          42
(%i3) xprimep(x) := integerp(x) and (x &gt; 1) and primep(x)$
(%i4) subset (s, lambda ([x], every (xprimep, x)));
(%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]}
</pre></div>





</dd></dl>

<a name="intersect"></a><a name="Item_003a-nset_002fdeffn_002fintersect"></a><dl>
<dt><a name="index-intersect"></a>Функция: <strong>intersect</strong> <em>(<var>a_1</var>, ..., <var>a_n</var>)</em></dt>
<dd>
<p>Функция <code>intersect</code> идентична <code>intersection</code>.
</p>




</dd></dl>

<a name="intersection"></a><a name="Item_003a-nset_002fdeffn_002fintersection"></a><dl>
<dt><a name="index-intersection"></a>Функция: <strong>intersection</strong> <em>(<var>a_1</var>, ..., <var>a_n</var>)</em></dt>
<dd><p>Возвращает множество, содержащие элементы, общие для всех множеств <var>a_1</var>, ..., <var>a_n</var>.
</p>
<p>Функция <code>intersection</code> вызывает ошибку, если хотя бы один из аргументов не является множеством.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) S_1 : {a, b, c, d};
(%o1)                     {a, b, c, d}
(%i2) S_2 : {d, e, f, g};
(%o2)                     {d, e, f, g}
(%i3) S_3 : {c, d, e, f};
(%o3)                     {c, d, e, f}
(%i4) S_4 : {u, v, w};
(%o4)                       {u, v, w}
(%i5) intersection (S_1, S_2);
(%o5)                          {d}
(%i6) intersection (S_2, S_3);
(%o6)                       {d, e, f}
(%i7) intersection (S_1, S_2, S_3);
(%o7)                          {d}
(%i8) intersection (S_1, S_2, S_3, S_4);
(%o8)                          {}
</pre></div>





</dd></dl>

<a name="Item_003a-nset_002fdeffn_002fkron_005fdelta"></a><dl>
<dt><a name="index-kron_005fdelta"></a>Функция: <strong>kron_delta</strong> <em>(<var>x</var>, <var>y</var>)</em></dt>
<dd>
<p>Дельта-функция Кронекера.
</p>
<p><code>kron_delta</code> упрощается в 1, если <var>x</var> и <var>y</var> идентичны или очевидно эквивалентны,
и упрощается в 0, если <var>x</var> и <var>y</var> очевидно не эквивалентны.
Иначе, если эквивалентность или неэквивалентность <var>x</var> и <var>y</var> не ясна,
то <code>kron_delta</code> упрощается в невычисляемую форму (noun).
По отношению к числам с плавающей точкой <code>kron_delta</code> реализует осторожный подход.
Если разница <code><var>x</var> - <var>y</var></code> является числом с плавающей точкой, то 
<code>kron_delta</code> упрощается в невычисляемую форму, даже когда <var>x</var> по-видимому эквивалентно <var>y</var>.
</p>
<p>Функция
<code>kron_delta(<var>x</var>, <var>y</var>)</code> упрощается в 1,
если <code>is(x = y)</code> равно <code>true</code>.
<code>kron_delta</code> тоже упрощается в 1,
если <code>sign(abs(<var>x</var> - <var>y</var>))</code> есть <code>zero</code>
и <code><var>x</var> - <var>y</var></code> не является числом с плавающей точкой
(ни обычное число с плавающей точкой, ни число с плавающей точкой повышенной точности).
<code>kron_delta</code> упрощается в 0, если <code>sign(abs(<var>x</var> - <var>y</var>))</code> равно <code>pos</code>.
</p>
<p>Если же <code>sign(abs(<var>x</var> - <var>y</var>))</code> дает
что-то отличное от <code>pos</code> или <code>zero</code>,
или <code>zero</code> но <code><var>x</var> - <var>y</var></code>
есть число с плавающей точкой,
то <code>kron_delta</code> возвращает невычисляемое выражение.
</p>
<p>Функция <code>kron_delta</code> объявлена симметричной.
Т.е. 
<code>kron_delta(<var>x</var>, <var>y</var>)</code> равно <code>kron_delta(<var>y</var>, <var>x</var>)</code>.
</p>
<p>Примеры:
</p>
<p>Аргументы <code>kron_delta</code> идентичны.
<code>kron_delta</code> упрощается в 1.
</p>
<div class="example">
<pre class="example">(%i1) kron_delta (a, a);
(%o1)                           1
(%i2) kron_delta (x^2 - y^2, x^2 - y^2);
(%o2)                           1
(%i3) float (kron_delta (1/10, 0.1));
(%o3)                           1
</pre></div>

<p>Аргументы <code>kron_delta</code> эквивалентны, и их
разница не есть число с плавающей точкой.
<code>kron_delta</code> упрощается в 1.
</p>
<div class="example">
<pre class="example">(%i1) assume (equal (x, y));
(%o1)                     [equal(x, y)]
(%i2) kron_delta (x, y);
(%o2)                           1
</pre></div>

<p>Аргументы <code>kron_delta</code> не эквивалентны.
<code>kron_delta</code> упрощается в 0.
</p>
<div class="example">
<pre class="example">(%i1) kron_delta (a + 1, a);
(%o1)                           0
(%i2) assume (a &gt; b)$
(%i3) kron_delta (a, b);
(%o3)                           0
(%i4) kron_delta (1/5, 0.7);
(%o4)                           0
</pre></div>

<p>Аргументы <code>kron_delta</code> могут быть, а могут и не быть эквивалентны.
<code>kron_delta</code> упрощается в невычисляемое выражение.
</p>
<div class="example">
<pre class="example">(%i1) kron_delta (a, b);
(%o1)                   kron_delta(a, b)
(%i2) assume(x &gt;= y)$
(%i3) kron_delta (x, y);
(%o3)                   kron_delta(x, y)
</pre></div>

<p>Аргументы <code>kron_delta</code> эквивалентны, но их разница
является числом с плавающей точкой.
<code>kron_delta</code> упрощается в невычисляемое выражение.
</p>
<div class="example">
<pre class="example">(%i1) 1/4 - 0.25;
(%o1)                          0.0
(%i2) 1/10 - 0.1;
(%o2)                          0.0
(%i3) 0.25 - 0.25b0;
Warning:  Float to bigfloat conversion of 0.25
(%o3)                         0.0b0
(%i4) kron_delta (1/4, 0.25);
                                  1
(%o4)                  kron_delta(-, 0.25)
                                  4
(%i5) kron_delta (1/10, 0.1);
                                  1
(%o5)                  kron_delta(--, 0.1)
                                  10
(%i6) kron_delta (0.25, 0.25b0);
Warning:  Float to bigfloat conversion of 0.25
(%o6)               kron_delta(0.25, 2.5b-1)
</pre></div>

<p>Функция <code>kron_delta</code> симметрична.
</p>
<div class="example">
<pre class="example">(%i1) kron_delta (x, y);
(%o1)                   kron_delta(x, y)
(%i2) kron_delta (y, x);
(%o2)                   kron_delta(x, y)
(%i3) kron_delta (x, y) - kron_delta (y, x);
(%o3)                           0
(%i4) is (equal (kron_delta (x, y), kron_delta (y, x)));
(%o4)                         true
(%i5) is (kron_delta (x, y) = kron_delta (y, x));
(%o5)                         true
</pre></div>

</dd></dl>

<a name="listify"></a><a name="Item_003a-nset_002fdeffn_002flistify"></a><dl>
<dt><a name="index-listify"></a>Функция: <strong>listify</strong> <em>(<var>a</var>)</em></dt>
<dd>
<p>Возвращает список с элементами <var>a</var>, если <var>a</var> есть множество.
В противном случае <code>listify</code> возвращает <var>a</var>.
</p>
<p>Функция <code>full_listify</code> заменяет все операторы множества в <var>a</var> на операторы списка.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) listify ({a, b, c, d});
(%o1)                     [a, b, c, d]
(%i2) listify (F ({a, b, c, d}));
(%o2)                    F({a, b, c, d})
</pre></div>

</dd></dl>





<a name="lreduce"></a><a name="Item_003a-nset_002fdeffn_002flreduce"></a><dl>
<dt><a name="index-lreduce"></a>Функция: <strong>lreduce</strong> <em>(<var>F</var>, <var>s</var>)</em></dt>
<dt><a name="index-lreduce-1"></a>Функция: <strong>lreduce</strong> <em>(<var>F</var>, <var>s</var>, <var>s_0</var>)</em></dt>
<dd>
<p>Расширяет бинарную функцию <var>F</var> до n-арной методом композиции.
Аргумент <var>s</var> является списком.
</p>
<p><code>lreduce(<var>F</var>, <var>s</var>)</code> возвращает <code>F(... F(F(s_1, s_2), s_3), ... s_n)</code>.
Если присутствует необязательный аргумент <var>s_0</var>, то
результат эквивалентен <code>lreduce(<var>F</var>, cons(<var>s_0</var>, <var>s</var>))</code>.
</p>
<p>Функция <var>F</var> сначала применяется к <i>левой</i> паре элементов списка, 
откуда происходит название &quot;lreduce&quot; (left reduce). 
</p>
<p>См. также <code>rreduce</code>, <code>xreduce</code> и <code>tree_reduce</code>.
</p>
<p>Примеры:
</p>
<p><code>lreduce</code> без необязательного аргумента.
</p>
<div class="example">
<pre class="example">(%i1) lreduce (f, [1, 2, 3]);
(%o1)                     f(f(1, 2), 3)
(%i2) lreduce (f, [1, 2, 3, 4]);
(%o2)                  f(f(f(1, 2), 3), 4)
</pre></div>

<p><code>lreduce</code> с необязательным аргументом.
</p>
<div class="example">
<pre class="example">(%i1) lreduce (f, [1, 2, 3], 4);
(%o1)                  f(f(f(4, 1), 2), 3)
</pre></div>

<p><code>lreduce</code> примененная к встроенным бинарным операторам.
<code>/</code> &ndash; есть оператор деления.
</p>
<div class="example">
<pre class="example">(%i1) lreduce (&quot;^&quot;, args ({a, b, c, d}));
                               b c d
(%o1)                       ((a ) )
(%i2) lreduce (&quot;/&quot;, args ({a, b, c, d}));
                                a
(%o2)                         -----
                              b c d
</pre></div>





</dd></dl>

<a name="makeset"></a><a name="Item_003a-nset_002fdeffn_002fmakeset"></a><dl>
<dt><a name="index-makeset"></a>Функция: <strong>makeset</strong> <em>(<var>expr</var>, <var>x</var>, <var>s</var>)</em></dt>
<dd>
<p>Возвращает множество с элементами, сгенерированными из выражения <var>expr</var>,
где <var>x</var> есть список переменных <var>expr</var>,
а <var>s</var> есть множество или список списков.
Для определения элемента результирующего списка
выражение <var>expr</var> вычисляется при переменных <var>x</var>, равным значениям из <var>s</var> (параллельное присваивание).
</p>
<p>Каждый член <var>s</var> должен иметь ту же длину, что и <var>x</var>.
Список переменных <var>x</var> должен быть списком символов без индексов.
Даже если символ только один, то <var>x</var> должен быть одноэлементным списком,
а каждый член <var>s</var> должен быть одноэлементным списком.
</p>

<p>См. также <code>makelist</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
                           1  2  3  4
(%o1)                     {-, -, -, -}
                           a  b  c  d
(%i2) S : {x, y, z}$
(%i3) S3 : cartesian_product (S, S, S);
(%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y], 
[x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x], 
[y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z], 
[y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y], 
[z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x], 
[z, z, y], [z, z, z]}
(%i4) makeset (i + j + k, [i, j, k], S3);
(%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x, 
                                       z + 2 y, 2 z + x, 2 z + y}
(%i5) makeset (sin(x), [x], {[1], [2], [3]});
(%o5)               {sin(1), sin(2), sin(3)}
</pre></div>





</dd></dl>

<a name="moebius"></a><a name="Item_003a-nset_002fdeffn_002fmoebius"></a><dl>
<dt><a name="index-moebius"></a>Функция: <strong>moebius</strong> <em>(<var>n</var>)</em></dt>
<dd>
<p>Представляет функцию Мебиуса.
</p>
<p>Если <var>n</var> есть произведение <em>k</em> различных простых чисел, то 
<code>moebius(<var>n</var>)</code> упрощается до <em>(-1)^k</em>.
Если <em><var>n</var> = 1</em>, то функция упрощается в 1.
Для всех остальных положительных целых функция упрощается в 0. 
</p>
<p>Функция <code>moebius</code> дистрибутивна по отношению к уравнениям, спискам, матрицам и множествам.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) moebius (1);
(%o1)                           1
(%i2) moebius (2 * 3 * 5);
(%o2)                          - 1
(%i3) moebius (11 * 17 * 29 * 31);
(%o3)                           1
(%i4) moebius (2^32);
(%o4)                           0
(%i5) moebius (n);
(%o5)                      moebius(n)
(%i6) moebius (n = 12);
(%o6)                    moebius(n) = 0
(%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
(%o7)                      [- 1, 1, 1]
(%i8) moebius (matrix ([11, 12], [13, 14]));
                           [ - 1  0 ]
(%o8)                      [        ]
                           [ - 1  1 ]
(%i9) moebius ({21, 22, 23, 24});
(%o9)                      {- 1, 0, 1}
</pre></div>





</dd></dl>
 
<a name="multinomial_005fcoeff"></a><a name="Item_003a-nset_002fdeffn_002fmultinomial_005fcoeff"></a><dl>
<dt><a name="index-multinomial_005fcoeff"></a>Функция: <strong>multinomial_coeff</strong> <em>(<var>a_1</var>, ..., <var>a_n</var>)</em></dt>
<dt><a name="index-multinomial_005fcoeff-1"></a>Функция: <strong>multinomial_coeff</strong> <em>()</em></dt>
<dd>
<p>Возвращает мультиномиальный коэффициент.
</p>
<p>Если каждое <var>a_k</var> есть неотрицательное целое число, то мультиномиальный коэффициент
дает число способов положить <code><var>a_1</var> + ... + <var>a_n</var></code> различных объектов
в <em>n</em> ящиков с <var>a_k</var> элементами в <em>k</em>-ом ящике. 
В целом, <code>multinomial_coeff (<var>a_1</var>, ..., <var>a_n</var>)</code>
равна <code>(<var>a_1</var> + ... + <var>a_n</var>)!/(<var>a_1</var>! ... <var>a_n</var>!)</code>.
</p>
<p><code>multinomial_coeff()</code> (без аргументов) дает 1.
</p>
<p><code>minfactorial</code> может упрощать значения, возвращаемые <code>multinomial_coeff</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) multinomial_coeff (1, 2, x);
                            (x + 3)!
(%o1)                       --------
                              2 x!
(%i2) minfactorial (%);
                     (x + 1) (x + 2) (x + 3)
(%o2)                -----------------------
                                2
(%i3) multinomial_coeff (-6, 2);
                             (- 4)!
(%o3)                       --------
                            2 (- 6)!
(%i4) minfactorial (%);
(%o4)                          10
</pre></div>





</dd></dl>

<a name="num_005fdistinct_005fpartitions"></a><a name="Item_003a-nset_002fdeffn_002fnum_005fdistinct_005fpartitions"></a><dl>
<dt><a name="index-num_005fdistinct_005fpartitions"></a>Функция: <strong>num_distinct_partitions</strong> <em>(<var>n</var>)</em></dt>
<dt><a name="index-num_005fdistinct_005fpartitions-1"></a>Функция: <strong>num_distinct_partitions</strong> <em>(<var>n</var>, list)</em></dt>
<dd>
<p>Возвращает число целочисленных разбиений с различными частями для <var>n</var>, если <var>n</var> &ndash; неотрицательное целое.
Иначе <code>num_distinct_partitions</code> возвращает невычисляемую форму.
</p>
<p><code>num_distinct_partitions(<var>n</var>, list)</code> возвращает список чисел
целочисленных разбиений с различными частями для 1, 2, 3, ..., <var>n</var> . 
</p>
<p>Разбиение числа <var>n</var> с различными частями есть список различных положительных целых
<em>k_1</em>, ..., <em>k_m</em>, таких что <em><var>n</var> = k_1 + ... + k_m</em>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) num_distinct_partitions (12);
(%o1)                          15
(%i2) num_distinct_partitions (12, list);
(%o2)      [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
(%i3) num_distinct_partitions (n);
(%o3)              num_distinct_partitions(n)
</pre></div>





</dd></dl>

<a name="num_005fpartitions"></a><a name="Item_003a-nset_002fdeffn_002fnum_005fpartitions"></a><dl>
<dt><a name="index-num_005fpartitions"></a>Функция: <strong>num_partitions</strong> <em>(<var>n</var>)</em></dt>
<dt><a name="index-num_005fpartitions-1"></a>Функция: <strong>num_partitions</strong> <em>(<var>n</var>, list)</em></dt>
<dd>
<p>Возвращает число целочисленных разбиений числа <var>n</var>,
если <var>n</var> &ndash; неотрицательное целое.
Иначе <code>num_partitions</code> возвращает невычисляемую форму.
</p>
<p><code>num_partitions(<var>n</var>, list)</code> возвращает список чисел
целочисленных разбиений для 1, 2, 3, ..., <var>n</var>.
</p>
<p>Для неотрицательного целого <var>n</var>, <code>num_partitions(<var>n</var>)</code> равна 
<code>cardinality(integer_partitions(<var>n</var>))</code>.
На самом деле <code>num_partitions</code> не строит полное множество разбиений
и поэтому работает значительно быстрее.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) num_partitions (5) = cardinality (integer_partitions (5));
(%o1)                         7 = 7
(%i2) num_partitions (8, list);
(%o2)            [1, 1, 2, 3, 5, 7, 11, 15, 22]
(%i3) num_partitions (n);
(%o3)                   num_partitions(n)
</pre></div>





</dd></dl>



<a name="partition_005fset"></a><a name="Item_003a-nset_002fdeffn_002fpartition_005fset"></a><dl>
<dt><a name="index-partition_005fset"></a>Функция: <strong>partition_set</strong> <em>(<var>a</var>, <var>f</var>)</em></dt>
<dd>
<p>Разбивает множество <var>a</var> в соответствии с предикатом <var>f</var>.
</p>
<p>Функция <code>partition_set</code> возвращает список двух множеств.
Первое множество состоит из элементов <var>a</var>, для которых <var>f</var> равен <code>false</code>,
а второе включает все остальные элементы <var>a</var>.
Функция <code>partition_set</code> не применяет <code>is</code> к возвращаемым <var>f</var> значениям.
</p>
<p><code>partition_set</code> вызывает ошибку, если <var>a</var> не является множеством.
</p>
<p>См. также <code>subset</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp);
(%o1)                   [{1, 7}, {2, 8}]
(%i2) partition_set ({x, rat(y), rat(y) + z, 1},
                     lambda ([x], ratp(x)));
(%o2)/R/              [{1, x}, {y, y + z}]
</pre></div>





</dd></dl>

<a name="permutations"></a><a name="Item_003a-nset_002fdeffn_002fpermutations"></a><dl>
<dt><a name="index-permutations"></a>Функция: <strong>permutations</strong> <em>(<var>a</var>)</em></dt>
<dd>
<p>Возвращает множество различных перестановок членов списка или множества <var>a</var>. 
Каждая перестановка является списком. 
</p>
<p>Если <var>a</var> является списком, то повторные члены <var>a</var> включаются в перестановки.
</p>
<p><code>permutations</code> вызывает ошибку, если <var>a</var> не является списком или множеством.
</p>
<p>См. также <code>random_permutation</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) permutations ([a, a]);
(%o1)                       {[a, a]}
(%i2) permutations ([a, a, b]);
(%o2)           {[a, a, b], [a, b, a], [b, a, a]}
</pre></div>






</dd></dl>

<a name="powerset"></a><a name="Item_003a-nset_002fdeffn_002fpowerset"></a><dl>
<dt><a name="index-powerset"></a>Функция: <strong>powerset</strong> <em>(<var>a</var>)</em></dt>
<dt><a name="index-powerset-1"></a>Функция: <strong>powerset</strong> <em>(<var>a</var>, <var>n</var>)</em></dt>
<dd>
<p>Возвращает множество всех подмножеств <var>a</var> или подмножество этого множества подмножеств.
</p>
<p><code>powerset(<var>a</var>)</code> возвращает множество всех подмножеств множества <var>a</var>.
<code>powerset(<var>a</var>)</code> имеет <code>2^cardinality(<var>a</var>)</code> членов.
</p>
<p><code>powerset(<var>a</var>, <var>n</var>)</code> возвращает множество подмножеств <var>a</var>, которые имеют
мощность <var>n</var>.
</p>
<p><code>powerset</code> вызывает ошибку, если <var>a</var> не является множеством или <var>n</var> 
не есть целое число.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) powerset ({a, b, c});
(%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}}
(%i2) powerset ({w, x, y, z}, 4);
(%o2)                    {{w, x, y, z}}
(%i3) powerset ({w, x, y, z}, 3);
(%o3)     {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}}
(%i4) powerset ({w, x, y, z}, 2);
(%o4)   {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}}
(%i5) powerset ({w, x, y, z}, 1);
(%o5)                 {{w}, {x}, {y}, {z}}
(%i6) powerset ({w, x, y, z}, 0);
(%o6)                         {{}}
</pre></div>





</dd></dl>

<a name="Item_003a-nset_002fdeffn_002frandom_005fpermutation"></a><dl>
<dt><a name="index-random_005fpermutation"></a>Функция: <strong>random_permutation</strong> <em>(<var>a</var>)</em></dt>
<dd>
<p>Возвращает случайную перестановку множества или списка <var>a</var>,
построенную при помощи алгоритма тасования Кнута.
</p>
<p>Возвращаемое значение есть новый список, который отличен от исходного аргумента даже
если все элементы совпадают.  Однако элементы списка не копируются.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) random_permutation ([a, b, c, 1, 2, 3]);
(%o1)                  [c, 1, 2, 3, a, b]
(%i2) random_permutation ([a, b, c, 1, 2, 3]);
(%o2)                  [b, 3, 1, c, a, 2]
(%i3) random_permutation ({x + 1, y + 2, z + 3});
(%o3)                 [y + 2, z + 3, x + 1]
(%i4) random_permutation ({x + 1, y + 2, z + 3});
(%o4)                 [x + 1, y + 2, z + 3]
</pre></div>






</dd></dl>

<a name="rreduce"></a><a name="Item_003a-nset_002fdeffn_002frreduce"></a><dl>
<dt><a name="index-rreduce"></a>Функция: <strong>rreduce</strong> <em>(<var>F</var>, <var>s</var>)</em></dt>
<dt><a name="index-rreduce-1"></a>Функция: <strong>rreduce</strong> <em>(<var>F</var>, <var>s</var>, <var>s_{n + 1}</var>)</em></dt>
<dd>
<p>Расширяет бинарную функцию <var>F</var> до n-арной методом композиции.
Аргумент <var>s</var> является списком.
</p>
<p><code>rreduce(<var>F</var>, <var>s</var>)</code> возвращает <code>F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n)))</code>.
Если присутствует необязательный аргумент <var>s_{n + 1}</var>, то
результат эквивалентен <code>rreduce(<var>F</var>, endcons(<var>s_{n + 1}</var>, <var>s</var>))</code>.
</p>
<p>Функция <var>F</var> сначала применяется к <i>правой</i> паре элементов списка, 
откуда происходит название &quot;rreduce&quot; (right reduce). 
</p>
<p>См. также <code>lreduce</code>, <code>tree_reduce</code> и <code>xreduce</code>.
</p>
<p>Примеры:
</p>
<p><code>rreduce</code> без необязательного аргумента.
</p>
<div class="example">
<pre class="example">(%i1) rreduce (f, [1, 2, 3]);
(%o1)                     f(1, f(2, 3))
(%i2) rreduce (f, [1, 2, 3, 4]);
(%o2)                  f(1, f(2, f(3, 4)))
</pre></div>

<p><code>rreduce</code> с необязательным аргументом.
</p>
<div class="example">
<pre class="example">(%i1) rreduce (f, [1, 2, 3], 4);
(%o1)                  f(1, f(2, f(3, 4)))
</pre></div>

<p><code>rreduce</code> примененный к встроенным операторам.
<code>/</code> &ndash; есть оператор деления.
</p>
<div class="example">
<pre class="example">(%i1) rreduce (&quot;^&quot;, args ({a, b, c, d}));
                                 d
                                c
                               b
(%o1)                         a
(%i2) rreduce (&quot;/&quot;, args ({a, b, c, d}));
                               a c
(%o2)                          ---
                               b d
</pre></div>





</dd></dl>

<a name="setdifference"></a><a name="Item_003a-nset_002fdeffn_002fsetdifference"></a><dl>
<dt><a name="index-setdifference"></a>Функция: <strong>setdifference</strong> <em>(<var>a</var>, <var>b</var>)</em></dt>
<dd>
<p>Возвращает множество, содержащее элементы множества <var>a</var>, которые
отсутствуют в множестве <var>b</var>.
</p>
<p><code>setdifference</code> вызывает ошибку, если <var>a</var> или <var>b</var> не являются множествами.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) S_1 : {a, b, c, x, y, z};
(%o1)                  {a, b, c, x, y, z}
(%i2) S_2 : {aa, bb, c, x, y, zz};
(%o2)                 {aa, bb, c, x, y, zz}
(%i3) setdifference (S_1, S_2);
(%o3)                       {a, b, z}
(%i4) setdifference (S_2, S_1);
(%o4)                     {aa, bb, zz}
(%i5) setdifference (S_1, S_1);
(%o5)                          {}
(%i6) setdifference (S_1, {});
(%o6)                  {a, b, c, x, y, z}
(%i7) setdifference ({}, S_1);
(%o7)                          {}
</pre></div>





</dd></dl>

<a name="setequalp"></a><a name="Item_003a-nset_002fdeffn_002fsetequalp"></a><dl>
<dt><a name="index-setequalp"></a>Функция: <strong>setequalp</strong> <em>(<var>a</var>, <var>b</var>)</em></dt>
<dd>
<p>Возвращает <code>true</code> если <var>a</var> и <var>b</var> имеют одинаковое количество элементов,
и <code>is(<var>x</var> = <var>y</var>)</code> равно <code>true</code>
для <code>x</code> из <var>a</var> и <code>y</code> из <var>b</var>,
в порядке, определяемом <code>listify</code>.
Иначе <code>setequalp</code> возвращает <code>false</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) setequalp ({1, 2, 3}, {1, 2, 3});
(%o1)                         true
(%i2) setequalp ({a, b, c}, {1, 2, 3});
(%o2)                         false
(%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
(%o3)                         false
</pre></div>






</dd></dl>

<a name="setify"></a><a name="Item_003a-nset_002fdeffn_002fsetify"></a><dl>
<dt><a name="index-setify"></a>Функция: <strong>setify</strong> <em>(<var>a</var>)</em></dt>
<dd>
<p>Составляет множество из элементов списка <var>a</var>. Повторяющиеся элементы списка <var>a</var> 
удаляются, а элементы результирующего множества сортируются в соответствии с предикатом
<code>orderlessp</code>.
</p>
<p><code>setify</code> вызывает ошибку, если <var>a</var> не является списком.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) setify ([1, 2, 3, a, b, c]);
(%o1)                  {1, 2, 3, a, b, c}
(%i2) setify ([a, b, c, a, b, c]);
(%o2)                       {a, b, c}
(%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
(%o3)                {1, 3, 5, 7, 9, 11, 13}
</pre></div>





</dd></dl>

<a name="setp"></a><a name="Item_003a-nset_002fdeffn_002fsetp"></a><dl>
<dt><a name="index-setp"></a>Функция: <strong>setp</strong> <em>(<var>a</var>)</em></dt>
<dd>
<p>Возвращает <code>true</code> тогда и только тогда, когда <var>a</var> является Maxima множеством.
</p>
<p><code>setp</code> возвращает <code>true</code> как для неупрощенных множеств (т.е. содержащих излишние элементы),
так и для упрощенных множеств.
</p>
<p><code>setp</code> is equivalent to the Maxima function
<code>setp(a) := not atom(a) and op(a) = 'set</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) simp : false;
(%o1)                         false
(%i2) {a, a, a};
(%o2)                       {a, a, a}
(%i3) setp (%);
(%o3)                         true
</pre></div>






</dd></dl>

<a name="set_005fpartitions"></a><a name="Item_003a-nset_002fdeffn_002fset_005fpartitions"></a><dl>
<dt><a name="index-set_005fpartitions"></a>Функция: <strong>set_partitions</strong> <em>(<var>a</var>)</em></dt>
<dt><a name="index-set_005fpartitions-1"></a>Функция: <strong>set_partitions</strong> <em>(<var>a</var>, <var>n</var>)</em></dt>
<dd>
<p>Возвращает множество разбиений <var>a</var> или подмножество этого множества.
</p>
<p><code>set_partitions(<var>a</var>, <var>n</var>)</code> возвращает множество всех разбиений <var>a</var> в 
<var>n</var> непустых непересекающихся подмножеств.
</p>
<p><code>set_partitions(<var>a</var>)</code> возвращает множество всех разбиений.
</p>
<p><code>stirling2</code> возвращает мощность множества всех разбиений множества.
</p>
<p>Множество множеств <em>P</em> есть разбиение множества <em>S</em>, если
</p>
<ol>
<li> каждый элемент <em>P</em> есть непустое множество,
</li><li> различные члены <em>P</em> не пересекаются,
</li><li> объединение всех членов <em>P</em> равно <em>S</em>.
</li></ol>

<p>Примеры:
</p>
<p>Пустое множество есть разбиение самого себя, т.к. условия  1 и 2 очевидно выполняются.
</p>
<div class="example">
<pre class="example">(%i1) set_partitions ({});
(%o1)                         {{}}
</pre></div>

<p>Мощность множества разбиений может быть определена при помощи <code>stirling2</code>.
</p>
<div class="example">
<pre class="example">(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$ 
(%i3) cardinality(p) = stirling2 (6, 3);
(%o3)                        90 = 90
</pre></div>

<p>Каждый элемент <code>p</code> должен иметь <var>n</var> = 3 члена. Проверим:
</p>
<div class="example">
<pre class="example">(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$ 
(%i3) map (cardinality, p);
(%o3)                          {3}
</pre></div>

<p>Наконец, для каждого члена <code>p</code> объединение всех членов должно совпадать с <code>s</code>.
Проверим:
</p>
<div class="example">
<pre class="example">(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$ 
(%i3) map (lambda ([x], apply (union, listify (x))), p);
(%o3)                 {{0, 1, 2, 3, 4, 5}}
</pre></div>





</dd></dl>

<a name="some"></a><a name="Item_003a-nset_002fdeffn_002fsome"></a><dl>
<dt><a name="index-some"></a>Функция: <strong>some</strong> <em>(<var>f</var>, <var>a</var>)</em></dt>
<dt><a name="index-some-1"></a>Функция: <strong>some</strong> <em>(<var>f</var>, <var>L_1</var>, ..., <var>L_n</var>)</em></dt>
<dd>
<p>Возвращает <code>true</code>, если предикат <var>f</var> дает <code>true</code> для одного или более
аргументов.
</p>
<p>Если второй параметр является множеством, то
<code>some(<var>f</var>, <var>s</var>)</code> возвращает <code>true</code>,
если <code>is(<var>f</var>(<var>a_i</var>))</code> дает <code>true</code> для одного или более <var>a_i</var> из <var>s</var>.
<code>some</code> может вычислять <var>f</var> для всех или не для всех <var>a_i</var> из <var>s</var>.
Т.к. множества не упорядочены, то
<code>some</code> может вычислять <code><var>f</var>(<var>a_i</var>)</code> в любом порядке.
</p>
<p>Если аргументы являются одним или несколькими списками, то
<code>some(<var>f</var>, <var>L_1</var>, ..., <var>L_n</var>)</code> возвращает <code>true</code>,
если  <code>is(<var>f</var>(<var>x_1</var>, ..., <var>x_n</var>))</code> дает <code>true</code> 
для одного или более <var>x_1</var>, ..., <var>x_n</var> из <var>L_1</var>, ..., <var>L_n</var> соответственно.
<code>some</code> может вычислять, а может и не вычислять <var>f</var> 
для некоторых комбинаций <var>x_1</var>, ..., <var>x_n</var>.
<code>some</code> вычисляет списки в порядке возрастания индекса.
</p>
<p>Для пустого множества <code>{}</code> или списка <code>[]</code> 
<code>some</code> возвращает <code>false</code>.
</p>
<p>Если глобальный флаг <code>maperror</code> равен <code>true</code>, то все списки 
<var>L_1</var>, ..., <var>L_n</var> должны иметь одинаковую длину.
Если <code>maperror</code> равен <code>false</code>, то списки обрезаются
до длины самого короткого.
</p>
<p>Значения предиката <var>f</var> (вычисляемое посредством <code>is</code>)
отличное от <code>true</code> или <code>false</code>
управляется глобальным флагом <code>prederror</code>.
Если <code>prederror</code> равен <code>true</code>, то
такие значения трактуются как  <code>false</code>.
Если <code>prederror</code> равен <code>false</code>, то
такие значения трактуются как <code>unknown</code>.
</p>
<p>Примеры:
</p>
<p>Функция <code>some</code>, примененная к одному множеству.
Предикат есть функция одного аргумента.
</p>
<div class="example">
<pre class="example">(%i1) some (integerp, {1, 2, 3, 4, 5, 6});
(%o1)                         true
(%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
(%o2)                         true
</pre></div>

<p>Функция <code>some</code>, примененная к спискам.
Предикат есть функция двух аргументов.
</p>
<div class="example">
<pre class="example">(%i1) some (&quot;=&quot;, [a, b, c], [a, b, c]);
(%o1)                         true
(%i2) some (&quot;#&quot;, [a, b, c], [a, b, c]);
(%o2)                         false
</pre></div>

<p>Значение предиката <var>f</var>, отличное от <code>true</code> или <code>false</code>,
управляется глобальным флагом <code>prederror</code>.
</p>
<div class="example">
<pre class="example">(%i1) prederror : false;
(%o1)                         false
(%i2) map (lambda ([a, b], is (a &lt; b)), [x, y, z],
           [x^2, y^2, z^2]);
(%o2)              [unknown, unknown, unknown]
(%i3) some (&quot;&lt;&quot;, [x, y, z], [x^2, y^2, z^2]);
(%o3)                        unknown
(%i4) some (&quot;&lt;&quot;, [x, y, z], [x^2, y^2, z + 1]);
(%o4)                         true
(%i5) prederror : true;
(%o5)                         true
(%i6) some (&quot;&lt;&quot;, [x, y, z], [x^2, y^2, z^2]);
(%o6)                         false
(%i7) some (&quot;&lt;&quot;, [x, y, z], [x^2, y^2, z + 1]);
(%o7)                         true
</pre></div>






</dd></dl>

<a name="stirling1"></a><a name="Item_003a-nset_002fdeffn_002fstirling1"></a><dl>
<dt><a name="index-stirling1"></a>Функция: <strong>stirling1</strong> <em>(<var>n</var>, <var>m</var>)</em></dt>
<dd>
<p>Представляет число Стирлинга первого рода.
</p>
<p>Для неотрицательных целых <var>n</var> и <var>m</var> величина 
<code>stirling1 (<var>n</var>, <var>m</var>)</code> есть число перестановок множества из 
<var>n</var> элементов, имеющих <var>m</var> циклов.
См. книгу Graham, Knuth и Patashnik <i>Concrete Mathematics</i> по поводу деталей.
Для определения <code>stirling1 (<var>n</var>, <var>m</var>)</code> с <var>m</var>,
меньшим нуля, Maxima использует рекуррентное соотношение.  
Для <var>n</var> меньших нуля и нецелых аргументов функция не определена.
</p>
<p><code>stirling1</code> является упрощающей функцией.
Maxima знает следующие тождества.
</p>
<ol>
<li> <em>stirling1(0, n) = kron_delta(0, n)</em> (См. [1])
</li><li> <em>stirling1(n, n) = 1</em> (См. [1])
</li><li> <em>stirling1(n, n - 1) = binomial(n, 2)</em> (См. [1])
</li><li> <em>stirling1(n + 1, 0) = 0</em> (См. [1])
</li><li> <em>stirling1(n + 1, 1) = n!</em> (См. [1])
</li><li> <em>stirling1(n + 1, 2) = 2^n  - 1</em> (См. [1])
</li></ol>

<p>Эти тождества применяются, если аргументы являются целыми или символами, которые объявлены
целыми, и первый аргумент неотрицателен.
Функция <code>stirling1</code> не упрощается для нецелых аргументов.
</p>
<p>Ссылки:
</p>
<p>[1] Donald Knuth, <i>The Art of Computer Programming,</i>
third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) declare (n, integer)$
(%i2) assume (n &gt;= 0)$
(%i3) stirling1 (n, n);
(%o3)                           1
</pre></div>

<p>Функция <code>stirling1</code> не упрощается для нецелых аргументов.
</p>
<div class="example">
<pre class="example">(%i1) stirling1 (sqrt(2), sqrt(2));
(%o1)              stirling1(sqrt(2), sqrt(2))
</pre></div>

<p>Maxima применяет тождества для <code>stirling1</code>.
</p>
<div class="example">
<pre class="example">(%i1) declare (n, integer)$
(%i2) assume (n &gt;= 0)$
(%i3) stirling1 (n + 1, n);
                            n (n + 1)
(%o3)                       ---------
                                2
(%i4) stirling1 (n + 1, 1);
(%o4)                          n!
</pre></div>





</dd></dl>

<a name="stirling2"></a><a name="Item_003a-nset_002fdeffn_002fstirling2"></a><dl>
<dt><a name="index-stirling2"></a>Функция: <strong>stirling2</strong> <em>(<var>n</var>, <var>m</var>)</em></dt>
<dd>
<p>Представляет число Стирлинга второго рода.
</p>
<p>Для неотрицательных целых <var>n</var> и <var>m</var> число <code>stirling2 (<var>n</var>, <var>m</var>)</code> 
есть число способов, которыми множество мощности <var>n</var> может быть разбито
на <var>m</var> непересекающихся подмножеств.
Для определения <code>stirling2 (<var>n</var>, <var>m</var>)</code> с <var>m</var>,
меньшим нуля, Maxima использует рекуррентное соотношение.  
Для <var>n</var> меньших нуля и нецелых аргументов функция не определена.
</p>
<p><code>stirling2</code> является упрощающей функцией.
Maxima знает следующие тождества.
</p>
<ol>
<li> <em>stirling2(0, n) = kron_delta(0, n)</em> (См. [1])
</li><li> <em>stirling2(n, n) = 1</em> (См. [1])
</li><li> <em>stirling2(n, n - 1) = binomial(n, 2)</em> (См. [1])
</li><li> <em>stirling2(n + 1, 1) = 1</em> (См. [1])
</li><li> <em>stirling2(n + 1, 2) = 2^n  - 1</em> (См. [1])
</li><li> <em>stirling2(n, 0) = kron_delta(n, 0)</em> (См. [2])
</li><li> <em>stirling2(n, m) = 0</em> when <em>m &gt; n</em> (См. [2])
</li><li> <em>stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m!</em>
если <em>m</em> и <em>n</em> целые и <em>n</em> неотрицательно. (См. [3])
</li></ol>

<p>Эти тождества применяются, если аргументы являются целыми или символами, которые объявлены
целыми, и первый аргумент неотрицателен.
Функция <code>stirling2</code> не упрощается для нецелых аргументов.
</p>
<p>Ссылки:
</p>
<p>[1] Donald Knuth. <i>The Art of Computer Programming</i>,
third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
</p>
<p>[2] Graham, Knuth, and Patashnik. <i>Concrete Mathematics</i>, Table 264.
</p>
<p>[3] Abramowitz and Stegun. <i>Handbook of Mathematical Functions</i>, Section 24.1.4.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) declare (n, integer)$
(%i2) assume (n &gt;= 0)$
(%i3) stirling2 (n, n);
(%o3)                           1
</pre></div>

<p>Функция <code>stirling2</code> не упрощается для нецелых аргументов.
</p>
<div class="example">
<pre class="example">(%i1) stirling2 (%pi, %pi);
(%o1)                  stirling2(%pi, %pi)
</pre></div>

<p>Maxima применяет тождества для <code>stirling2</code>.
</p>
<div class="example">
<pre class="example">(%i1) declare (n, integer)$
(%i2) assume (n &gt;= 0)$
(%i3) stirling2 (n + 9, n + 8);
                         (n + 8) (n + 9)
(%o3)                    ---------------
                                2
(%i4) stirling2 (n + 1, 2);
                              n
(%o4)                        2  - 1
</pre></div>





</dd></dl>

<a name="subset"></a><a name="Item_003a-nset_002fdeffn_002fsubset"></a><dl>
<dt><a name="index-subset"></a>Функция: <strong>subset</strong> <em>(<var>a</var>, <var>f</var>)</em></dt>
<dd>
<p>Возвращает подмножество множества <var>a</var>, которое удовлетворяет предикату <var>f</var>. 
</p>
<p>Функция <code>subset</code> возвращает множество, состоящее из элементов <var>a</var>,
для которых <var>f</var> возвращает любое значение, отличное от <code>false</code>.
Функция <code>subset</code> не применяет <code>is</code> к значению, возвращаемому <var>f</var>.
</p>
<p>Функция <code>subset</code> вызывает ошибку, если <var>a</var> не является множеством.
</p>
<p>См. также <code>partition_set</code>.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom);
(%o1)                     {1, 2, x, z}
(%i2) subset ({1, 2, 7, 8, 9, 14}, evenp);
(%o2)                      {2, 8, 14}
</pre></div>





</dd></dl>

<a name="subsetp"></a><a name="Item_003a-nset_002fdeffn_002fsubsetp"></a><dl>
<dt><a name="index-subsetp"></a>Функция: <strong>subsetp</strong> <em>(<var>a</var>, <var>b</var>)</em></dt>
<dd>
<p>Возвращает <code>true</code> тогда и только тогда, когда <var>a</var> есть подмножество <var>b</var>.
</p>
<p>Функция <code>subsetp</code> вызывает ошибку, если <var>a</var> или <var>b</var> не являются множествами.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
(%o1)                         true
(%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
(%o2)                         false
</pre></div>






</dd></dl>

<a name="symmdifference"></a><a name="Item_003a-nset_002fdeffn_002fsymmdifference"></a><dl>
<dt><a name="index-symmdifference"></a>Функция: <strong>symmdifference</strong> <em>(<var>a_1</var>, ..., <var>a_n</var>)</em></dt>
<dd>
<p>Возвращает симметричную разницу, т.е. множество, элементы
которого присутствуют только в одном множестве <var>a_k</var>.
</p>
<p>При задании двух аргументов, <code>symmdifference(<var>a</var>, <var>b</var>)</code> 
эквивалентно <code>union ( setdifference (<var>a</var>, <var>b</var> ), setdifference (<var>b</var>, <var>a</var>))</code>.
</p>
<p>Функция <code>symmdifference</code> вызывает ошибку, если любой из ее аргументов не является множеством.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) S_1 : {a, b, c};
(%o1)                       {a, b, c}
(%i2) S_2 : {1, b, c};
(%o2)                       {1, b, c}
(%i3) S_3 : {a, b, z};
(%o3)                       {a, b, z}
(%i4) symmdifference ();
(%o4)                          {}
(%i5) symmdifference (S_1);
(%o5)                       {a, b, c}
(%i6) symmdifference (S_1, S_2);
(%o6)                        {1, a}
(%i7) symmdifference (S_1, S_2, S_3);
(%o7)                        {1, z}
(%i8) symmdifference ({}, S_1, S_2, S_3);
(%o8)                        {1, z}
</pre></div>





</dd></dl>

<a name="tree_005freduce"></a><a name="Item_003a-nset_002fdeffn_002ftree_005freduce"></a><dl>
<dt><a name="index-tree_005freduce"></a>Функция: <strong>tree_reduce</strong> <em>(<var>F</var>, <var>s</var>)</em></dt>
<dt><a name="index-tree_005freduce-1"></a>Функция: <strong>tree_reduce</strong> <em>(<var>F</var>, <var>s</var>, <var>s_0</var>)</em></dt>
<dd>
<p>Расширяет бинарную функцию <var>F</var> до n-арной методом композиции.
Аргумент <var>s</var> является множеством или списком.
</p>
<p>Функция <code>tree_reduce</code> действует следующим образом:
<var>F</var> применяется к последовательным парам элементов, чтобы сформировать новый список
<code>[<var>F</var>(<var>s_1</var>, <var>s_2</var>), <var>F</var>(<var>s_3</var>, <var>s_4</var>), ...]</code>.
При этом если число элементов нечетно, то последний элемент остается неизменным.
Затем процесс повторяется до тех пор, пока не останется только один элемент списка,
который и возвращается в качестве значения.
</p>
<p>Если присутствует необязательный элемент <var>s_0</var>, то
результат эквивалентен <code>tree_reduce(<var>F</var>, cons(<var>s_0</var>, <var>s</var>)</code>.
</p>
<p>Для сложения чисел с плавающей точкой <code>tree_reduce</code> может возвращать сумму с меньшей
ошибкой округления, чем <code>rreduce</code> или <code>lreduce</code>.
</p>
<p>Элементы <var>s</var> и частичные результаты могут быть представлены в виде бинарного дерева 
минимальной глубины, откуда происходит название &quot;tree_reduce&quot;.
</p>
<p>Примеры:
</p>
<p>Функция <code>tree_reduce</code>, примененная к списку с четным числом элементов.
</p>
<div class="example">
<pre class="example">(%i1) tree_reduce (f, [a, b, c, d]);
(%o1)                  f(f(a, b), f(c, d))
</pre></div>

<p>Функция <code>tree_reduce</code>, примененная к списку с нечетным числом элементов.
</p>
<div class="example">
<pre class="example">(%i1) tree_reduce (f, [a, b, c, d, e]);
(%o1)               f(f(f(a, b), f(c, d)), e)
</pre></div>






</dd></dl>

<a name="union"></a><a name="Item_003a-nset_002fdeffn_002funion"></a><dl>
<dt><a name="index-union"></a>Функция: <strong>union</strong> <em>(<var>a_1</var>, ..., <var>a_n</var>)</em></dt>
<dd><p>Возвращает объединение множеств от <var>a_1</var> до <var>a_n</var>. 
</p>
<p>Вызов <code>union()</code> (без аргументов) возвращает пустое множество.
</p>
<p>Функция <code>union</code> возвращает ошибку, если любой из ее аргументов не является множеством.
</p>
<p>Примеры:
</p>
<div class="example">
<pre class="example">(%i1) S_1 : {a, b, c + d, %e};
(%o1)                   {%e, a, b, d + c}
(%i2) S_2 : {%pi, %i, %e, c + d};
(%o2)                 {%e, %i, %pi, d + c}
(%i3) S_3 : {17, 29, 1729, %pi, %i};
(%o3)                {17, 29, 1729, %i, %pi}
(%i4) union ();
(%o4)                          {}
(%i5) union (S_1);
(%o5)                   {%e, a, b, d + c}
(%i6) union (S_1, S_2);
(%o6)              {%e, %i, %pi, a, b, d + c}
(%i7) union (S_1, S_2, S_3);
(%o7)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}
(%i8) union ({}, S_1, S_2, S_3);
(%o8)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}
</pre></div>





</dd></dl>

<a name="xreduce"></a><a name="Item_003a-nset_002fdeffn_002fxreduce"></a><dl>
<dt><a name="index-xreduce"></a>Функция: <strong>xreduce</strong> <em>(<var>F</var>, <var>s</var>)</em></dt>
<dt><a name="index-xreduce-1"></a>Функция: <strong>xreduce</strong> <em>(<var>F</var>, <var>s</var>, <var>s_0</var>)</em></dt>
<dd>
<p>Расширяет функцию <var>F</var> до n-арной методом композиции или,
если <var>F</var> уже n-арная, применяет <var>F</var> к <var>s</var>.
Если <var>F</var> не является n-арной, то <code>xreduce</code> работает также, как <code>lreduce</code>.
Аргумент <var>s</var> является списком.
</p>
<p>Известны следующие n-арные функции: сложение <code>+</code>, 
умножение <code>*</code>, <code>and</code>, <code>or</code>, <code>max</code>,
<code>min</code> и <code>append</code>.
Функции могут быть объявлены n-арными при помощи <code>declare(<var>F</var>, nary)</code>.
Для таких функций, <code>xreduce</code> работает быстрее, чем <code>rreduce</code> или <code>lreduce</code>.
</p>
<p>Если задан необязательный аргумент <var>s_0</var>, то
результат эквивалентен <code>xreduce(<var>s</var>, cons(<var>s_0</var>, <var>s</var>))</code>.
</p>
<p>Сложение чисел с плавающей точкой, строго говоря, не является ассоциативным.
Функция <code>xreduce</code> применяет n-арное сложение, если <var>s</var> содержит числа с плавающей точкой.
</p>
<p>Примеры:
</p>
<p>Функция <code>xreduce</code>, примененная к n-арной функции.
<code>F</code> вызывается однажды со всеми аргументами.
</p>
<div class="example">
<pre class="example">(%i1) declare (F, nary);
(%o1)                         done
(%i2) F ([L]) := L;
(%o2)                      F([L]) := L
(%i3) xreduce (F, [a, b, c, d, e]);
(%o3)         [[[[[(&quot;[&quot;, simp), a], b], c], d], e]
</pre></div>

<p>Функция <code>xreduce</code>, примененная к не n-арной функции.
<code>G</code> вызывается несколько раз с двумя аргументами каждый раз.
</p>
<div class="example">
<pre class="example">(%i1) G ([L]) := L;
(%o1)                      G([L]) := L
(%i2) xreduce (G, [a, b, c, d, e]);
(%o2)         [[[[[(&quot;[&quot;, simp), a], b], c], d], e]
(%i3) lreduce (G, [a, b, c, d, e]);
(%o3)                 [[[[a, b], c], d], e]
</pre></div>






</dd></dl>


<hr>
<div class="header">
<p>
Previous: <a href="maxima_140.html#g_t_0412_0432_0435_0434_0435_043d_0438_0435-_0432-_0440_0430_0431_043e_0442_0443-_0441-_043c_043d_043e_0436_0435_0441_0442_0432_0430_043c_0438" accesskey="p" rel="previous">Введение в работу с множествами</a>, Up: <a href="maxima_139.html#g_t_041c_043d_043e_0436_0435_0441_0442_0432_0430" accesskey="u" rel="up">Множества</a> &nbsp; [<a href="maxima_toc.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="maxima_264.html#g_t_0423_043a_0430_0437_0430_0442_0435_043b_044c-_0444_0443_043d_043a_0446_0438_0439-_0438-_043f_0435_0440_0435_043c_0435_043d_043d_044b_0445" title="Index" rel="index">Index</a>]</p>
</div>



</body>
</html>