[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

# 35. Sets

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 35.1 Introduction to Sets

Maximaは、 明示的な列挙によって定義された有限集合用に、積集合や和集合のような集合関数を提供します。 Maximaはリストと集合を別のオブジェクトとして扱います。 この特長は、要素がリストであったり集合であったりする集合を扱うことを可能にします。

有限集合のための関数に加えて、 Maximaは組み合わせ論に関係したいくつかの関数を提供します; これらは、第一種と第二種スターリング数、ベル数、第一種と第二種の多項係数、 非負整数の分割、と2,3の他の関数を含みます。 Maximaはクロネッカーのデルタ関数も定義します。

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 35.1.1 Usage

要素 `a_1, ..., a_n`の集合を構成するには、 `set(a_1, ..., a_n)`または `{a_1, ..., a_n}`と書いてください; 空集合を構成するには `set()`または `{}`を書いてください。 入力では `set(...)`と `{ ... }`は同値です。 集合はいつも中括弧で表示されます。

もし要素が一度以上リストされているなら、整理によって冗長な要素は消去されます。

    (%i1) set();
    (%o1)                          {}
    (%i2) set(a, b, a);
    (%o2)                        {a, b}
    (%i3) set(a, set(b));
    (%o3)                       {a, {b}}
    (%i4) set(a, [b]);
    (%o4)                       {a, [b]}
    (%i5) {};
    (%o5)                          {}
    (%i6) {a, b, a};
    (%o6)                        {a, b}
    (%i7) {a, {b}};
    (%o7)                       {a, {b}}
    (%i8) {a, [b]};
    (%o8)                       {a, [b]}

２つの要素候補 xと yは、 `is(x = y)`が `true`をもたらす (すなわち、集合構成の目的で同じと見なされる)時だけ冗長です。 `is(x = y)`が `false`をもたらす一方、 `is(equal(x, y))`は `true`をもたらす可能性があることに 注意してください; その場合、要素 xと yは異なったものと見なされます。

    (%i1) x: a/c + b/c;
                                  b   a
    (%o1)                         - + -
                                  c   c
    (%i2) y: a/c + b/c;
                                  b   a
    (%o2)                         - + -
                                  c   c
    (%i3) z: (a + b)/c;
                                  b + a
    (%o3)                         -----
                                    c
    (%i4) is (x = y);
    (%o4)                         true
    (%i5) is (y = z);
    (%o5)                         false
    (%i6) is (equal (y, z));
    (%o6)                         true
    (%i7) y - z;
                               b + a   b   a
    (%o7)                    - ----- + - + -
                                 c     c   c
    (%i8) ratsimp (%);
    (%o8)                           0
    (%i9) {x, y, z};
                              b + a  b   a
    (%o9)                    {-----, - + -}
                                c    c   c

リストの要素から集合を構成するには `setify`を使ってください。

    (%i1) setify ([b, a]);
    (%o1)                        {a, b}

もし `is(x = y)`が `true`に評価されるなら、 集合の要素 `x`と `y`は等しいです。 従って `rat(x)`と `x`は集合の元として等しいです; 結果として

    (%i1) {x, rat(x)};
    (%o1)                          {x}

さらに、 `is((x - 1)*(x + 1) = x^2 - 1)`は `false`に評価されるので、 `(x - 1)*(x + 1)`と `x^2 - 1`は集合の異なる要素です; 従って

    (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                           2
    (%o1)               {(x - 1) (x + 1), x  - 1}

この集合を 1要素集合に縮小するには、 `rat`を集合の元それぞれに適用してください:

    (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                           2
    (%o1)               {(x - 1) (x + 1), x  - 1}
    (%i2) map (rat, %);
                                  2
    (%o2)/R/                    {x  - 1}

他の集合から冗長性を取り除くために他の整理関数を使う必要があるかもしれません。 以下は `trigsimp`を使った例です:

    (%i1) {1, cos(x)^2 + sin(x)^2};
                                2         2
    (%o1)                {1, sin (x) + cos (x)}
    (%i2) map (trigsimp, %);
    (%o2)                          {1}

元が冗長でなく、並べ換えられている時、集合は整理されてます。 集合関数の現在のバージョンは 集合を順に並べるためにMaxima関数 `orderlessp`を使います; しかしながら、 集合関数の将来のバージョンは、違う並び替え関数を使うかもしれません。

代入のような集合に関するいくつかの演算は、再整理を自動的に強制します; 例えば、

    (%i1) s: {a, b, c}$
    (%i2) subst (c=a, s);
    (%o2)                        {a, b}
    (%i3) subst ([a=x, b=x, c=x], s);
    (%o3)                          {x}
    (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
    (%o4)                        {0, 1}

Maximaはリストと集合を異なるオブジェクトとして扱います; `union`や `intersection`のような関数は、 もし引数のいずれかが集合でないなら文句を言います。 もしリストに集合関数を適用する必要があるなら、 集合に変換するために `setify`関数を使ってください。 例えば、

    (%i1) union ([1, 2], {a, b});
    Function union expects a set, instead found [1,2]
     -- an error.  Quitting.  To debug this try debugmode(true);
    (%i2) union (setify ([1, 2]), {a, b});
    (%o2)                     {1, 2, a, b}

集合 `s`の集合要素のうち述語論理 `f`を満たすすべての要素を抽出するためには、 `subset(s, f)`を使ってください。 (述語論理はブーリアン値関数です。) 例えば、 与えられた集合の中で変数 `z`に依存しない等式を見つけるには、 以下を使ってください。

    (%i1) subset ({x + y + z, x - y + 4, x + y - 5},
                                        lambda ([e], freeof (z, e)));
    (%o1)               {- y + x + 4, y + x - 5}

節 Functions and Variables for Setsには Maximaの集合関数すべてがリストされます。

·

Categories: Sets

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 35.1.2 Set Member Iteration

集合の要素上を反復する２つの方法があります。 １つの方法は `map`の使用です; 例えば:

    (%i1) map (f, {a, b, c});
    (%o1)                  {f(a), f(b), f(c)}

他の方法は `for x in s do`を使うことです。

    (%i1) s: {a, b, c};
    (%o1)                       {a, b, c}
    (%i2) for si in s do print (concat (si, 1));
    a1
    b1
    c1
    (%o2)                         done

Maxima関数 `first`と `rest`は集合に対して正しく機能します。 集合に適用されると、 `first`は最初に表示される集合の要素を返します; それは実装依存かもしれません。 もし `s`が集合なら、 `rest(s)`は `disjoin(first(s), s)`と同値です。 今は、集合に対して正しく機能する Maxima関数が他にもあります。 集合関数の将来のバージョンでは、 `first`と `rest`は今と違うように動くかもしれませんし、 全く動かないかもしれません。

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 35.1.3 Bugs

集合関数は集合の要素を並び換えるために Maxima関数 `orderlessp`を使い、 集合の要素の同一性をテストするために (Lispレベルの)関数 `like`を使います。 これらの関数両方に既知のバグがあり、 もし標準有理式 (CRE)形式の式を含むリストや行列を要素に持つ集合を使おうとするなら、 バグが現れるかもしれません。 例は以下の通りです。

    (%i1) {[x], [rat (x)]};
    Maxima encountered a Lisp error:

      The value #:X1440 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.

この式は Maximaがエラーで停止する原因となります。 (エラーメッセージは Maximaが使う Lispのバージョンに依ります。) もう１つの例は以下の通りです。

    (%i1) setify ([[rat(a)], [rat(b)]]);
    Maxima encountered a Lisp error:

      The value #:A1440 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.

これらのバグは `orderlessp`と `like`の中にあるバグに起因します; それらは集合関数の中のバグが原因ではありません。 例証するには以下の式を試してください。

    (%i1) orderlessp ([rat(a)], [rat(b)]);
    Maxima encountered a Lisp error:

      The value #:B1441 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.
    (%i2) is ([rat(a)] = [rat(a)]);
    (%o2)                         false

これらのバグが直されるまで、 CRE形式の式を含むリストや行を要素に持つ集合を構成しないでください; しかしながら、 CRE形式の要素を持つ集合は問題ないはずです:

    (%i1) {x, rat (x)};
    (%o1)                          {x}

Maximaの `orderlessp`には、 集合関数で問題の原因となる可能性がある別のバグがあります。 それは、すなわち、順序付け述語論理 `orderlessp`が推移的でないことです。 これを示す最も簡単な既知の例は以下の通りです。

    (%i1) q: x^2$
    (%i2) r: (x + 1)^2$
    (%i3) s: x*(x + 2)$
    (%i4) orderlessp (q, r);
    (%o4)                         true
    (%i5) orderlessp (r, s);
    (%o5)                         true
    (%i6) orderlessp (q, s);
    (%o6)                         false

このバグは、一般的に Maximaの関数はもちろん、集合関数すべてにおいて問題の原因となる可能性があります。 確実ではありませんが、 もし集合の要素すべてが CRE形式であるか、 `ratsimp`を使って整理されていれるなら、このバグはたぶん避けられます。

Maximaの `orderless`と `ordergreat`メカニズムは集合関数と互換性がありません。 もし `orderless`か `ordergreat`のいずれかを使う必要があるなら、 どんなものでも集合を構成する前にこれらの関数をコールしてください。 そして `unorder`をコールしないでください。

もし集合関数のバグかもしれないと思う何かを見つけたら、 どうか Maximaのバグデータベースに報告してください。 `bug_report`を参照してください。

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 35.1.4 Authors

マサチューセッツ州ケンブリッジ市の Stavros Macrakisと ネブラスカ大学カーニー校(UNK)の Barton Willisが Maximaの集合関数とそれらのドキュメンテーションを書きました。

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 35.2 Functions and Variables for Sets

関数: adjoin (x, a)

  集合 aに要素 `{x}`を加えた集合を返します。

  もし aが集合リテラルでないなら `adjoin`は文句を言います。

  `adjoin(x, a)`と `union(set(x), a)`は同値です; しかし `adjoin`は `union`より幾分早いかもしれません。

  `disjoin`も参照してください。

  例:

      (%i1) adjoin (c, {a, b});
      (%o1)                       {a, b, c}
      (%i2) adjoin (a, {a, b});
      (%o2)                        {a, b}

  ·

  Categories: Sets

関数: belln (n)

  n番目のベル数を返します。 `belln(n)`は n個のメンバーを持つ集合の分割の数です。

  非負整数 nの場合、 `belln(n)`は n番目のベル数に整理されます。 他の引数の場合どんなものでも `belln`は整理されません。

  `belln`は等式、リスト、行列、集合上に分配されます。

  例:

  非負整数に適用された `belln`。

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

  非負整数でない引数に適用された `belln`。

      (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
      (%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]

  ·

  Categories: Sets

関数: cardinality (a)

  集合 aの異なる要素の数を返します。

  整理がディセーブルされた時でも `cardinality`は冗長な要素を無視します。

  例:

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

  ·

  Categories: Sets

関数: cartesian_product (b_1, ... , b_n)

  形式 `[x_1, ..., x_n]`のリストの集合を返します。 ここで x_1, ..., x_nはそれぞれ集合 b_1, ... , b_nの要素です。

  もし任意の引数が集合リテラルでないなら `cartesian_product`は文句を言います。

  例:

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

  ·

  Categories: Sets

関数: disjoin (x, a)

  要素 xを持たない集合 aを返します。 もし xが aのメンバーでないなら aをそのまま返します。

  もし aが集合リテラルでないなら `disjoin`は文句を言います。

  `disjoin(x, a)`, `delete(x, a)`, `setdifference(a, set(x))`はすべて同値です。 これらの中で `disjoin`は一般的に他より速いです。

  例:

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

  ·

  Categories: Sets

関数: disjointp (a, b)

  集合 aと bが交わらないなら `true`を返します。

  もし aか bが集合リテラルでないなら `disjointp`は文句を言います。

  例:

      (%i1) disjointp ({a, b, c}, {1, 2, 3});
      (%o1)                         true
      (%i2) disjointp ({a, b, 3}, {1, 2, 3});
      (%o2)                         false

  ·

  Categories: Sets ·Predicate functions

関数: divisors (n)

  nの約数の集合を表します。

  nがゼロでない整数の時、 `divisors(n)`は整数の集合に整理されます。 約数の集合は要素 1と nを含みます。 負の整数の約数はその絶対値の約数です。

  `divisors`は等式、リスト、行列、集合上に分配されます。

  例:

  28は完全数であることを検証できます: (自身を除いた)約数が 28です。

      (%i1) s: divisors(28);
      (%o1)                 {1, 2, 4, 7, 14, 28}
      (%i2) lreduce ("+", args(s)) - 28;
      (%o2)                          28

  `divisors`は整理関数です。 `divisors(a)`の中で `a`に8を代入することは、 `divisors(8)`を再評価せずに約数をもたらします。

      (%i1) divisors (a);
      (%o1)                      divisors(a)
      (%i2) subst (8, a, %);
      (%o2)                     {1, 2, 4, 8}

  `divisors`は等式、リスト、行列、集合上に分配されます。

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

  ·

  Categories: Integers

関数: elementp (x, a)

  xが集合 aの要素の場合だけ `true`を返します。

  もし aが集合リテラルでないなら `elementp`は文句を言います。

  例:

      (%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
      (%o1)                         true
      (%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
      (%o2)                         false

  ·

  Categories: Sets ·Predicate functions

関数: emptyp (a)

  aが空の集合か空のリストの場合だけ `true`を返します。

  例:

      (%i1) map (emptyp, [{}, []]);
      (%o1)                     [true, true]
      (%i2) map (emptyp, [a + b, {{}}, %pi]);
      (%o2)                 [false, false, false]

  ·

  Categories: Sets ·Predicate functions

関数: equiv_classes (s, F)

  集合 sの同値関係 Fに関する同値クラスの集合を返します。

  Fは sの sとの直積集合上の２変数関数です。 Fの戻り値は `true`か `false`、もしくは `is(expr)`が `true`か `false`のような 式 exprです。

  Fが同値関数でない時、 `equiv_classes`は不平なくそれを受け入れますが、 その場合、結果は一般に正しくありません。

  例:

  同値関係が `true`か `false`を返すラムダ式です。

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

  同値関係が、`is`が `true`か `false`に評価される 関係関数の名前です。

      (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
      (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

  同値クラスが 3の倍数だけ違う数です。

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

  ·

  Categories: Sets

関数: every (f, s)
関数: every (f, L_1, ..., L_n)

  もし述語論理 fが与えられた引数すべてで `true`なら、 `true`を返します。

  ある集合が二番目の引数として与えられたとして、 もし `is(f(a_i))`が sの中の a_iすべてに関して `true`を返すなら、 `every(f, s)`は `true`です。 `every`は sの中の a_iすべてに関して fを評価するかどうかわかりません。 集合は順序付けされていないので、 `every`は任意の順序で `f(a_i)`を評価します。

  引数に１つか複数のリストが与えられたとして、 もし `is(f(x_1, ..., x_n))`が L_1, ..., L_nそれぞれの中の x_1, ..., x_nすべてに対して `true`を返すなら、 `every(f, L_1, ..., L_n)`は `true`を返します。 `every`は、 x_1, ..., x_nのすべての組み合わせに対して fを評価するかどうかわかりません。 `every`はインデックスを増やす順序でリストを評価します。

  空の集合 `{}`または空のリスト `[]`が引数に与えられると、 `every`は `false`を返します。

  グローバルフラグ `maperror`が `true`の時、 リスト L_1, ..., L_nすべては長さが等しくなければいけません。 `maperror`が `false`の時、 リスト引数は最短のリストの長さに効果的に切り詰められます。

  `true`か `false`以外の何かに (`is`を介して)評価される述語論理 fの戻り値は、 `prederror`が決定します。 `prederror`が `true`の時、 そんな値は `false`として扱われ、 `every`の戻り値は `false`です。 `prederror`が `false`の時、 そんな値は `unknown`として扱われ、 `every`の戻り値は `unknown`です。

  例:

  １つの集合に適用された `every`。 述語論理は１引数関数です。

      (%i1) every (integerp, {1, 2, 3, 4, 5, 6});
      (%o1)                         true
      (%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
      (%o2)                         false

  ２つのリストに適用された `every`。 述語論理は２引数関数です。

      (%i1) every ("=", [a, b, c], [a, b, c]);
      (%o1)                         true
      (%i2) every ("#", [a, b, c], [a, b, c]);
      (%o2)                         false

  `true`か `false`以外の何かに評価される 述語論理 fの戻り値はグローバルフラグ `prederror`が決定します。

      (%i1) prederror : false;
      (%o1)                         false
      (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
                         [x^2, y^2, z^2]);
      (%o2)              [unknown, unknown, unknown]
      (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o3)                        unknown
      (%i4) prederror : true;
      (%o4)                         true
      (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o5)                         false

  ·

  Categories: Sets

関数: extremal_subset (s, f, max)
関数: extremal_subset (s, f, min)

  要素に関数 fを適用した結果が最大または最小値になるような sの部分集合を返します。

  `extremal_subset(s, f, max)`は、 実数値関数 fが最大値を取る、 集合またはリスト sの部分集合を返します。

  `extremal_subset(s, f, min)`は、 実数値関数 fが最小値を取る、 集合またはリスト sの部分集合を返します。

  例:

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

  ·

  Categories: Sets

関数: flatten (expr)

  exprと同じ演算子を持つ部分式の引数を集め、これらの集めた引数から式を構成します。

  `expr`の主演算子と違った演算子の部分式は、 たとえそれらが逆に `expr`に関するものと同じ演算子の部分式を含んだとしても、 変更なしにコピーされます。

  引数の数が演算子に関して宣言された引数と違う式を `flatten`が構成する可能性があるかもしれません; これは整理器や評価器からのエラーメッセージを起こさせるかもしれません。 `flatten`はそんな状況を検出しようとしません。

  特別な表現の式、例えば、標準有理式 (CRE)はflattenできません; そんな場合、`flatten`は引数を変更なしに返します。

  例:

  リストに適用すると、 `flatten`はリストの要素すべてを集めます。

      (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
      (%o1)            [a, b, c, d, e, f, g, h, i, j]

  集合に適用すると、 `flatten`は集合の要素すべてを集めます。

      (%i1) flatten ({a, {b}, {{c}}});
      (%o1)                       {a, b, c}
      (%i2) flatten ({a, {[a], {a}}});
      (%o2)                       {a, [a]}

  `flatten`は主演算子を n項に宣言する効果に似ています。 しかしながら、`flatten`は主演算子と違う演算子を持つ部分式上に影響を持ちません。 一方、 n項宣言はそれらに影響します。

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

  `flatten`は他の任意の演算子と同じように添字付き関数を扱います。

      (%i1) flatten (f[5] (f[5] (x, y), z));
      (%o1)                      f (x, y, z)
                                  5

  引数の数が演算子に関して宣言された引数と違う式を `flatten`が構成する可能性があるかもしれません;

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

  ·

  Categories: Sets ·Lists

関数: full_listify (a)

  aの中のすべての集合演算子をリスト演算子で置き換え、結果を返します。 `full_listify`は、たとえ主演算子が `set`でなくても 入れ子の部分式の中の集合演算子を置き換えます。

  `listify`は主演算子だけを置き換えます。

  例:

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

  ·

  Categories: Sets

関数: fullsetify (a)

  aがリストの時、リスト演算子を集合演算子で置き換え、 `fullsetify`を集合であるメンバーそれぞれに適用します。 aがリストでない時、変更なしで返します。

  `setify`は主演算子だけを置き換えます。

  例:

  `f([b])`の主演算子はリストでないので、行 `(%o2)`で `f`の引数は集合に変換されません。

      (%i1) fullsetify ([a, [a]]);
      (%o1)                       {a, {a}}
      (%i2) fullsetify ([a, f([b])]);
      (%o2)                      {a, f([b])}

  ·

  Categories: Lists

関数: identity (x)

  任意の引数 xに対して xを返します。

  例:

  `identity`は、引数が既にブーリアン値の時、述語論理として使うことができます。

      (%i1) every (identity, [true, true]);
      (%o1)                         true

関数: integer_partitions (n)
関数: integer_partitions (n, len)

  nの整数分割を返します。 すなわち、和が nになる整数のリストです。

  `integer_partitions(n)`は整数 nの分割すべての集合を返します。 分割それぞれは大きい順に並べられたリストです。

  `integer_partitions(n, len)`は、長さ len以下の分割すべてを返します; この場合、 lenより少ない項を持つ分割それぞれには、 厳密に len項持つ分割にするようにゼロが足されます。 分割それぞれは大きい順に並べられたリストです。

  リスト [a_1, ..., a_m]は、 (1) a_iそれぞれが非ゼロ整数、かつ、 (2) a_1 + ... + a_m = n. の時、非負整数 nの分割です。 従って 0は分割を持ちません。

  例:

      (%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 ("+", 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]}

  条件を満たす分割すべてを見つけるには、 関数 `subset`を使ってください; 以下は素数から成る 10の分割すべてを見つける例です。

      (%i1) s: integer_partitions (10)$
      (%i2) cardinality (s);
      (%o2)                          42
      (%i3) xprimep(x) := integerp(x) and (x > 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]}

  ·

  Categories: Integers

関数: intersect (a_1, ..., a_n)

  `intersect`は以下に見る `intersection`と同じです。

  ·

  Categories: Sets

関数: intersection (a_1, ..., a_n)

  集合 a_1から a_nまでに共通な要素を含む集合を返します。

  もし引数のいずれかが集合リテラルでないなら `intersection`は文句を言います。

  例:

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

  ·

  Categories: Sets

関数: kron_delta (x, y, …, xp)

  クロネッカーのデルタ関数を表します。

  `kron_delta`は、 xiと yjが引数のすべての対で等しい時 1に整理され、 xiと yjが引数のある対で等しくない時 0に整理されます。 等号は `is(equal(xi,j))`を使って決定され、 不等号は `is(notsqual(xi,xj))`を使って決定されます。 引数が1つの場合、 `kron_delta`はエラーをシグナルします。

  例:

      (%i1) kron_delta(a,a);
      (%o1)                                  1
      (%i2) kron_delta(a,b,a,b);
      (%o2)                          kron_delta(a, b)
      (%i3) kron_delta(a,a,b,a+1);
      (%o3)                                  0
      (%i4) assume(equal(x,y));
      (%o4)                            [equal(x, y)]
      (%i5) kron_delta(x,y);
      (%o5)                                  1

関数: listify (a)

  aが集合の時、aの要素を含むリストを返します。 そうでないなら、 `listify`は aを返します。

  `full_listify`は aの中の集合演算子をリスト演算子に置き換えます。

  例:

      (%i1) listify ({a, b, c, d});
      (%o1)                     [a, b, c, d]
      (%i2) listify (F ({a, b, c, d}));
      (%o2)                    F({a, b, c, d})

  ·

  Categories: Sets

関数: lreduce (F, s)
関数: lreduce (F, s, s_0)

  二項関数 Fを合成によって n項関数に拡張します。 ここで sはリストです。

  `lreduce(F, s)`は `F(... F(F(s_1, s_2), s_3), ... s_n)`を返します。

  オプション引数 s_0が存在する時、 結果は `lreduce(F, cons(s_0, s))`と同値です。

  関数 Fは、最初の leftmostの要素に適用されます。 だから "lreduce"と名付けられています。

  `rreduce`, `xreduce`, `tree_reduce`も参照してください。

  例:

  オプション引数なしの `lreduce`。

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

  オプション引数ありの `lreduce`。

      (%i1) lreduce (f, [1, 2, 3], 4);
      (%o1)                  f(f(f(4, 1), 2), 3)

  組み込み二項演算子に適用された `lreduce`。 `/`は割り算演算子。

      (%i1) lreduce ("^", args ({a, b, c, d}));
                                     b c d
      (%o1)                       ((a ) )
      (%i2) lreduce ("/", args ({a, b, c, d}));
                                      a
      (%o2)                         -----
                                    b c d

  ·

  Categories: Lists

関数: makeset (expr, x, s)

  式 exprから生成された要素を持つ集合を返します。 ここで xは exprの中の変数のリストであり、 sはリストの集合かリストのリストです。 集合の要素それぞれを生成するために、 変数 xを並列に sの要素にバインドして exprを評価します。

  sの要素それぞれは xと同じ長さを持たなければいけません。 変数 xのリストは添字の付かないシンボルのリストでなければいけません。 たとえシンボルが１つしかない場合でも、 xは１要素のリストでなければいけなく、 sの要素それぞれは１要素のリストでなければいけません。

  `makelist`も参照してください。

  例:

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

  ·

  Categories: Sets

関数: moebius (n)

  メビウス関数を表します。

  nが k個の異なる素数の積の時、 `moebius(n)`は (-1)^kに整理されます; n = 1の時 1に整理されます; 他の正の数すべてに対しては 0に整理されます。

  `moebius`は等式、リスト、行列、集合上に分配されます。

  例:

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

  ·

  Categories: Integers

関数: multinomial_coeff (a_1, ..., a_n)
関数: multinomial_coeff ()

  多項係数を返します。

  a_kそれぞれが非負の整数の時、 多項係数は、 `a_1 + ... + a_n`個の別々のオブジェクトを k番目の枠の中に a_kの要素を持つ n個の枠に置く方法の数を与えます。

  一般に、 `multinomial_coeff (a_1, ..., a_n)`は `(a_1 + ... + a_n)!/(a_1! ... a_n!)`と同値です。

  `multinomial_coeff()` (引数なし)は 1に評価されます。

  `minfactorial`は `multinomial_coeff`が返す値を整理することができます。

  例:

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

  ·

  Categories: Integers

関数: num_distinct_partitions (n)
関数: num_distinct_partitions (n, list)

  nが非負の整数の時、 nの異なる整数分割の数を返します。 そうでないなら `num_distinct_partitions`は名詞形を返します。

  `num_distinct_partitions(n, list)`は、 1, 2, 3, ..., nの異なる分割の数のリストを返します。

  nの異なる分割は、 n = k_1 + ... + k_mとなるような 異なる正の整数 k_1, ..., k_mのリストです。

  例:

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

  ·

  Categories: Integers

関数: num_partitions (n)
関数: num_partitions (n, list)

  nが非負の整数の時、 nの整数分割の数を返します。 そうでないなら `num_partitions`は名詞式を返します。

  `num_partitions(n, list)`は、 1, 2, 3, ..., nの整数分割の数のリストを返します。

  非負の整数 nに対して、 `num_partitions(n)`は `cardinality(integer_partitions(n))`と等しいです; しかしながら、 `num_partitions`は 分割の集合を実際には構成しないのではるかに速いです。

  例:

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

  ·

  Categories: Integers

関数: partition_set (a, f)

  集合 aを述語論理 fに従って分割します。

  `partition_set`は２つの集合のリストを返します。 最初の集合は fが `false`に評価される aの要素から成り、 二番目は aの他の要素すべてから成ります。 `partition_set`は `is`を fの戻り値に適用しません。

  もし aが集合リテラルなら `partition_set`は文句を言います。

  `subset`も参照してください。

  例:

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

  ·

  Categories: Sets

関数: permutations (a)

  リストまたは集合 aの要素の異なる順列すべての集合を返します。 順列それぞれは集合でなくリストです。

  aがリストの時、 aの重複した要素が順列の中に含まれます。

  もし aがリストリテラルや集合リテラルでないなら、 `permutations`は文句を言います。

  `random_permutation`も参照してください。

  例:

      (%i1) permutations ([a, a]);
      (%o1)                       {[a, a]}
      (%i2) permutations ([a, a, b]);
      (%o2)           {[a, a, b], [a, b, a], [b, a, a]}

  ·

  Categories: Sets ·Lists

関数: powerset (a)
関数: powerset (a, n)

  aの部分集合すべての集合、またはその集合の部分集合を返します。

  `powerset(a)`は 集合 aの部分集合すべての集合を返します。 `powerset(a)`は`2^cardinality(a)`個の要素を持ちます。

  `powerset(a, n)`は、 濃度 nを持つ aの部分集合すべての集合を返します。

  もし aが集合リテラルでないか nが非負の整数でないなら、 `powerset`は文句を言います。

  例:

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

  ·

  Categories: Sets

関数: random_permutation (a)

  クヌースのシャッフルアルゴリズムで構成されるような、 集合またはリスト aのランダムな順列を返します。

  戻り値は、たとえ要素すべてが偶然同じでも引数とは別の新しいリストです。 しかしながら引数の要素はコピーされません。

  例:

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

  ·

  Categories: Sets ·Lists

関数: rreduce (F, s)
関数: rreduce (F, s, s_{n + 1})

  合成によって二項関数 Fを n項関数に拡張します。 ここで sはリストです。

  `rreduce(F, s)`は `F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n)))`を返します。 オプション引数 s_{n + 1}が存在する時、 結果は `rreduce(F, endcons(s_{n + 1}, s))` と同値です。

  関数 Fは、最初 rightmostのリスト要素に適用されます。 だから名前が "rreduce"です。

  `lreduce`, `tree_reduce`, `xreduce`も参照してください。

  例:

  オプション引数なしの `rreduce`。

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

  オプション引数ありの `rreduce`。

      (%i1) rreduce (f, [1, 2, 3], 4);
      (%o1)                  f(1, f(2, f(3, 4)))

  組み込み二項演算子に適用された `rreduce`。 `/`は割り算演算子。

      (%i1) rreduce ("^", args ({a, b, c, d}));
                                       d
                                      c
                                     b
      (%o1)                         a
      (%i2) rreduce ("/", args ({a, b, c, d}));
                                     a c
      (%o2)                          ---
                                     b d

  ·

  Categories: Lists

関数: setdifference (a, b)

  集合 aの中にあり、集合 bにない要素を含む集合を返します。

  もし aか bが集合リテラルでないなら、 `setdifference`は文句を言います。

  例:

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

  ·

  Categories: Sets

関数: setequalp (a, b)

  集合 aと bが同じ要素数を持ち、 `listify`が決定した順序で考えて aの要素の中の `x`と bの要素の中の `y`に対して `is(x = y)`が`true`なら、 `true`を返します。 そうでないなら `setequalp`は `false`を返します。

  例:

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

  ·

  Categories: Sets ·Predicate functions

関数: setify (a)

  リスト aの要素から集合を構成します。 リスト aの重複した要素は削除され、 要素は述語論理 `orderlessp`に従って並び替えられます。

  もし aが集合リテラルでないなら、 `setify`は文句を言います。

  例:

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

  ·

  Categories: Lists

関数: setp (a)

  aが Maximaの集合の時だけ `true`を返します。

  `setp`は、 整理された集合はもちろん、未整理の集合(すなわち、冗長な元を持つ集合)に対して、 `true`を返します。

  `setp`は Maxima関数 `setp(a) := not atom(a) and op(a) = 'set` と同値です。

  例:

      (%i1) simp : false;
      (%o1)                         false
      (%i2) {a, a, a};
      (%o2)                       {a, a, a}
      (%i3) setp (%);
      (%o3)                         true

  ·

  Categories: Sets ·Predicate functions

関数: set_partitions (a)
関数: set_partitions (a, n)

  aの分割すべての集合、またはその集合の部分集合を返します。

  `set_partitions(a, n)`は n個の空でない交わらない部分集合への aの分解すべての集合を返します。

  `set_partitions(a)`は分割すべての集合を返します。

  `stirling2`は集合の分割の集合の濃度を返します。

  集合の集合Pは

  1. Pの要素それぞれが空でない集合
  2. Pの別の要素が交わらない
  3. Pの要素の和集合が Sに等しい

  時、 集合 Sの分割です。

  例:

  条件 1と 2が空ゆえに真なので、空集合はそれ自身の分割です。

      (%i1) set_partitions ({});
      (%o1)                         {{}}

  集合の分割の集合の濃度は `stirling2`を使って見つけられます。

      (%i1) s: {0, 1, 2, 3, 4, 5}$
      (%i2) p: set_partitions (s, 3)$
      (%i3) cardinality(p) = stirling2 (6, 3);
      (%o3)                        90 = 90

  `p`の要素それぞれは n = 3個の要素を持たなければいけません; チェックしましょう。

      (%i1) s: {0, 1, 2, 3, 4, 5}$
      (%i2) p: set_partitions (s, 3)$
      (%i3) map (cardinality, p);
      (%o3)                          {3}

  最後に、 `p`の要素それぞれに対して、 元の和集合は `s`に等しくなければいけません; チェックしましょう。

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

  ·

  Categories: Sets

関数: some (f, a)
関数: some (f, L_1, ..., L_n)

  もし与えられた引数のうち１つ以上で述語論理 fが `true`なら `true`を返します。

  二番目の引数として集合１つが与えられたとして、 もし sの中の１つ以上の a_iに対して `is(f(a_i))`が `true`を返すなら、 `some(f, s)`は `true`を返します。 `some`は sの中の a_iすべてに対して fを評価するかどうかわかりません。 集合は順序がないので、 `some`は任意の順序で `f(a_i)`評価するかもしれません。

  引数として 1つ以上のリストが与えられたとして、 もし L_1, ..., L_nそれぞれの中の１つ以上の x_1, ..., x_nで `is(f(x_1, ..., x_n))`が `true`を返すなら、 `some(f, L_1, ..., L_n)`は `true`を返します。 `some`はいくつかの組み合わせ x_1, ..., x_nに対して fを評価するかどうかわかりません。 `some`はインデックスを増加する順序でリストを評価します。

  引数として空集合 `{}`か空のリスト `[]`が与えられる場合、 `some`は `false`を返します。

  グローバルフラグ `maperror`が `true`の時、 すべてのリスト L_1, ..., L_nは同じ長さを持たなければいけません。 `maperror`が `false`の時、 リスト引数は最短のリストの長さに効果的に切り詰められます。

  (`is`を介して) `true`か `false`以外の何かに評価される 述語論理 fの戻り値は、 グローバルフラグ `prederror`が決定します。 `prederror`が `true`の時、 そんな値は `false`として扱われます。 `prederror`が `false`の時、 そんな値は `unknown`として扱われます。

  例:

  集合１つに適用された `some`。 述語論理は引数１つの関数です。

      (%i1) some (integerp, {1, 2, 3, 4, 5, 6});
      (%o1)                         true
      (%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
      (%o2)                         true

  ２つのリストに適用された `some`。 述語論理は引数２つの関数です。

      (%i1) some ("=", [a, b, c], [a, b, c]);
      (%o1)                         true
      (%i2) some ("#", [a, b, c], [a, b, c]);
      (%o2)                         false

  `true`か `false`以外の何かに評価される述語論理 fの戻り値は、グローバルフラグ `prederror`が決定します。

      (%i1) prederror : false;
      (%o1)                         false
      (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
                 [x^2, y^2, z^2]);
      (%o2)              [unknown, unknown, unknown]
      (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o3)                        unknown
      (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
      (%o4)                         true
      (%i5) prederror : true;
      (%o5)                         true
      (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o6)                         false
      (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
      (%o7)                         true

  ·

  Categories: Sets ·Lists

関数: stirling1 (n, m)

  第一種のスターリング数を表します。

  nと mが非負の整数の時、 `stirling1 (n, m)`の大きさは m個の巡回置換を持つ n個の元を持つ集合の順列の数です。 詳細は Graham, Knuth and Patashnik Concrete Mathematicsを参照してください。 Maximaは、 0より小さい mに対して `stirling1 (n, m)`を定義するために 再帰関係を使います; 0より小さい nと非整数引数に対して未定義です。

  `stirling1`は整理関数です。 Maximaは以下の恒等式を知っています。

  1. stirling1(0, n) = kron_delta(0, n) (Ref. [1])
  2. stirling1(n, n) = 1 (Ref. [1])
  3. stirling1(n, n - 1) = binomial(n, 2) (Ref. [1])
  4. stirling1(n + 1, 0) = 0 (Ref. [1])
  5. stirling1(n + 1, 1) = n! (Ref. [1])
  6. stirling1(n + 1, 2) = 2^n - 1 (Ref. [1])

  これらの恒等式は 引数が、整数リテラルまたは整数と宣言されたシンボルで、かつ、 最初の引数が非負の時、 適用されます。 `stirling1`は、非整数引数に対して整理しません。

  参考文献:

  [1] Donald Knuth, The Art of Computer Programming, third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.

  例:

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling1 (n, n);
      (%o3)                           1

  `stirling1`は非整数引数に対して整理しません。

      (%i1) stirling1 (sqrt(2), sqrt(2));
      (%o1)              stirling1(sqrt(2), sqrt(2))

  Maximaは `stirling1`に恒等式を適用します。

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling1 (n + 1, n);
                                  n (n + 1)
      (%o3)                       ---------
                                      2
      (%i4) stirling1 (n + 1, 1);
      (%o4)                          n!

  ·

  Categories: Integers

関数: stirling2 (n, m)

  第二種スターリング数を表します。

  nと mが非負の整数の時、 `stirling2 (n, m)`は、 濃度 nの集合が m個のばらばらの部分集合に分割できる方法の数です。 Maximaは、 0より小さい mに対して `stirling2 (n, m)`を定義するために再帰関係を使います; 0より小さい nと非整数の引数に対して未定義です。

  `stirling2`は整理関数です。 Maximaは以下の恒等式を知っています。

  1. stirling2(0, n) = kron_delta(0, n) (Ref. [1])
  2. stirling2(n, n) = 1 (Ref. [1])
  3. stirling2(n, n - 1) = binomial(n, 2) (Ref. [1])
  4. stirling2(n + 1, 1) = 1 (Ref. [1])
  5. stirling2(n + 1, 2) = 2^n - 1 (Ref. [1])
  6. stirling2(n, 0) = kron_delta(n, 0) (Ref. [2])
  7. stirling2(n, m) = 0 when m > n (Ref. [2])
  8. stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m! when m and n are integers, and n is nonnegative. (Ref. [3])

  引数が整数リテラルまたは整数と宣言されたシンボルで、かつ、最初の引数が非負の時、 これらの恒等式が適用されます。 `stirling2`は非整数引数に対して整理されません。

  参考文献:

  [1] Donald Knuth. The Art of Computer Programming, third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.

  [2] Graham, Knuth, and Patashnik. Concrete Mathematics, Table 264.

  [3] Abramowitz and Stegun. Handbook of Mathematical Functions, Section 24.1.4.

  例:

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling2 (n, n);
      (%o3)                           1

  `stirling2`は非整数引数に対して整理されません。

      (%i1) stirling2 (%pi, %pi);
      (%o1)                  stirling2(%pi, %pi)

  Maximaは `stirling2`に恒等式を適用します。

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling2 (n + 9, n + 8);
                               (n + 8) (n + 9)
      (%o3)                    ---------------
                                      2
      (%i4) stirling2 (n + 1, 2);
                                    n
      (%o4)                        2  - 1

  ·

  Categories: Integers

関数: subset (a, f)

  述語論理 fを満たす集合 aの部分集合を返します。

  `subset`は、 aの要素のうち、fが `false`以外の何かを返す要素の集合を返します。 `subset`は `is`を fの戻り値に適用しません。

  もし aが集合リテラルでないなら `subset`は文句を言います。

  `partition_set`も参照してください。

  例:

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

  ·

  Categories: Sets

関数: subsetp (a, b)

  集合 aが bの部分集合の時だけ `true`を返します。

  もし aか bのいずれかが集合リテラルでないなら、 `subsetp`は文句を言います。

  例:

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

  ·

  Categories: Sets ·Predicate functions

関数: symmdifference (a_1, …, a_n)

  集合 a_1, …, a_nの対称差を返します。

  ２つの引数が与えられたとして、 `symmdifference ( a, b)`は `union (setdifference ( a, b), setdifference (b, a))`と同じです。

  もし引数が集合リテラルでないなら、 `symmdifference`は文句を言います。

  例:

      (%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, b, z}
      (%i8) symmdifference ({}, S_1, S_2, S_3);
      (%o8)                        {1,b, z}

  ·

  Categories: Sets

関数: tree_reduce (F, s)
関数: tree_reduce (F, s, s_0)

  合成によって二項関数 Fを n項関数に拡張します。 ここで sは集合かリストです。

  `tree_reduce`は以下と同値です: 新しいリスト `[F(s_1, s_2), F(s_3, s_4), ...]`を形成するために Fを要素の連続する対に適用します。 もし奇数個の要素があるなら、 最後の要素は変化なしに通過させます。 そして、リストが１つの要素になるまで繰り返します。１つの要素になった時、それが戻り値です。

  オプションの引数 s_0がある時， 結果は `tree_reduce(F, cons(s_0, s)`と同値です。

  浮動小数点数の足し算に関して、 `tree_reduce`は `rreduce`や `lreduce`よりも小さな丸め誤差を持つ和を返します。

  sの要素と部分的な結果は 最小深度の二項木の中に配列されます。 だから名前が "tree_reduce"です。

  例:

  偶数個の要素を持つリストに適用された `tree_reduce`。

      (%i1) tree_reduce (f, [a, b, c, d]);
      (%o1)                  f(f(a, b), f(c, d))

  奇数個の要素を持つリストに適用された `tree_reduce`。

      (%i1) tree_reduce (f, [a, b, c, d, e]);
      (%o1)               f(f(f(a, b), f(c, d)), e)

  ·

  Categories: Sets ·Lists

関数: union (a_1, ..., a_n)

  集合 a_1から a_nの和集合を返します。

  `union()` (引数なし)は空集合を返します。

  もし引数が集合リテラルでないなら、`union`は文句を言います。

  例:

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

  ·

  Categories: Sets

関数: xreduce (F, s)
関数: xreduce (F, s, s_0)

  合成によって関数 Fを n項関数に拡張します。 または、もし Fが既に n項関数なら Fを sに適用します。 Fが n項関数でない時、 `xreduce`は `lreduce`と同じです。 引数 sはリストです。

  n項関数として知られている関数は、 足し算 `+`, 掛け算 `*`, `and`, `or`, `max`, `min`, `append`を含みます。 関数は、 `declare(F, nary)`によっても n項と宣言されるかもしれません。 これらの関数に対して、 `xreduce`は `rreduce`や `lreduce`よりも速いことが期待されます。

  オプション引数 s_0がある時、 結果は `xreduce(s, cons(s_0, s))`と同値です。

  浮動小数点の足し算は、厳密には結合的ではありません; そうはそうかもしれませんが、 sが浮動小数点を含む時、 `xreduce`は Maximaの n項足し算を適用します。

  例:

  n項と知られている関数に適用された `xreduce`。 `F`は引数すべてで一度コールされます。

      (%i1) declare (F, nary);
      (%o1)                         done
      (%i2) F ([L]) := L;
      (%o2)                      F([L]) := L
      (%i3) xreduce (F, [a, b, c, d, e]);
      (%o3)         [[[[[("[", simp), a], b], c], d], e]

  n項とわかっていない関数に適用された `xreduce`。 `G`は毎回２つの引数で複数回コールされます。

      (%i1) G ([L]) := L;
      (%o1)                      G([L]) := L
      (%i2) xreduce (G, [a, b, c, d, e]);
      (%o2)         [[[[[("[", simp), a], b], c], d], e]
      (%i3) lreduce (G, [a, b, c, d, e]);
      (%o3)                 [[[[a, b], c], d], e]

  ·

  Categories: Sets ·Lists

[ << ] | [ >> ] |  |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

この文書は市川 雄二によって2012年1月月5日にtexi2html 1.82を用いて生成されました。