Next: Function Definition, Previous: Rules and Patterns [Contents][Index]
Next: Functions and Variables for Sets, Previous: Sets, Up: Sets [Contents][Index]
Maximaは、 陽な列挙によって定義された有限集合のために、 積集合や和集合のような、集合関数を提供します。 Maximaは、リストと集合を別のオブジェクトとして扱います。 この特長は、 リストまたは集合であるメンバーがリストであったり集合であったりする集合を扱うことを可能にします。
有限集合のための関数に加えて、 Maximaは、 組み合わせ論に関係したいくつかの関数を提供します; これらは、第一種と第二種スターリング数、ベル数、第一種と第二種の多項係数、 非負整数の分割、と2,3の他の関数です。 Maximaは、クロネッカーのデルタ関数も定義します。
メンバー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を満たすすべての要素を抽出するためには、
use 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の集合関数の完全なリストを持ちます。
集合の元上を反復する２つの方法があります。
１つの方法は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は、違うように機能するかもしれませんし、そうでないかもしれません。
集合関数は、
集合の元を並び換えるために、
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を参照してください。
マサチューセッツ州ケンブリッジ市のStavros Macrakisと、 ネブラスカ大学カーニー校(UNK)のBarton Willisが、 Maximaの集合関数とそれらのドキュメンテーションを書きました。
Previous: Introduction to Sets, Up: Sets [Contents][Index]
集合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}
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)]
集合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
Returns a set of lists of the form
形式[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]}
元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}
集合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
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)}
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
aが空の集合か空のリストの時だけ、trueを返します。
例:
(%i1) map (emptyp, [{}, []]);
(%o1) [true, true]
(%i2) map (emptyp, [a + b, {{}}, %pi]);
(%o2) [false, false, false]
集合sの 同値関係Fに関する 同値クラスの集合を返します。
Fはsのsとの直積集合上の２変数関数です。
The return value of
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}}
もし述語論理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の時、
リスト引数は、最短のリストの長さに効果的に切り詰められます。
(isを介して)
trueかfalse以外の何かに評価される述語論理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
関数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)}
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);
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])]))
aがリストの時、
リスト演算子を集合演算子で置き換え、
fullsetifyを集合であるメンバーそれぞれに適用します。
aがリストでない時、変更なしで返します。
setifyは主演算子だけを置き換えます。
例:
f([b])の主演算子はリストでないので、
行(%o2)で、
fの引数は集合に変換されません。
(%i1) fullsetify ([a, [a]]);
(%o1) {a, {a}}
(%i2) fullsetify ([a, f([b])]);
(%o2) {a, f([b])}
任意の引数xに対してxを返します。
例:
identityは、
引数が既にブーリアン値の時、
述語論理として使うことができます。
(%i1) every (identity, [true, true]); (%o1) true
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]}
集合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) {}
クロネッカーのデルタ関数を表します。
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
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})
二項関数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
式exprから生成された元を持つ集合を返します。 ここで、xはexprの中の変数のリストであり、 sはリストの集合かリストです。 集合の元それぞれを生成するために、 exprは、 sの元に並列にバインドされた変数xで評価されます。
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)}
メビウス関数を表します。
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}
多項係数を返します。
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
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)
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)
集合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}]
リストまたは集合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]}
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) {{}}
クヌースのシャッフルアルゴリズムで構成されるような、 集合またはリスト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]
合成によって二項関数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
集合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) {}
集合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
リスト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}
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
aの分割すべての集合、または、その集合の部分集合を返します。
set_partitions(a, n)は
n個の空でないばらばらの部分集合への
aの分解すべての集合を返します。
set_partitions(a)は分割すべての集合を返します。
stirling2は集合の分割の集合の濃度を返します。
集合の集合Pは
時、 集合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}}
もし与えられた引数のうち１つ以上で述語論理fがtrueなら
trueを返します。
二番目の引数として集合１つが与えられたとして、
もし
sの中の１つ以上のa_iに対して
is(f(a_i))がtrueを返すなら、
some(f, s)はtrueを返します。
someは
sの中のa_iすべてに対して
fを評価するかどうかわかりません。
集合は順序がないので、
someは任意の順序でf(a_i)評価するかもしれません。
引数として２つ以上のリストが与えられたとして、
some(f, L_1, ..., L_n)はtrueを返します。
もし
L_1, ..., L_nそれぞれの中の１つ以上のx_1, ..., x_nで
is(f(x_1, ..., x_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
第一種のスターリング数を表します。
nとmが非負の整数の時、
stirling1 (n, m)の大きさは
m個の巡回置換を持つn個の元を持つ集合の順列の数です。
詳細はGraham, Knuth and Patashnik Concrete Mathematicsを参照してください。
Maximaは、
0より小さいmに対して
stirling1 (n, m)を定義するために
再帰関係を使います;
0より小さいnと非整数引数に対して未定義です。
stirling1は整理関数です。
Maximaは以下の恒等式を知っています。
これらの恒等式は
引数が、整数リテラルまたは整数と宣言されたシンボルで、かつ、
最初の引数が非負の時、
適用されます。
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!
第二種スターリング数を表します。
nとmが非負の整数の時、
stirling2 (n, m)は、
濃度nの集合がm個のばらばらの部分集合に分割できる方法の数です。
Maximaは、
0より小さいmに対して
stirling2 (n, m)を定義するために
再帰関係を使います;
0より小さいnと非整数の引数に対して未定義です。
stirling2は整理関数です。
Maximaは以下の恒等式を知っています。
引数が整数リテラルまたは整数と宣言されたシンボルで、かつ、最初の引数が非負の時、
これらの恒等式が適用されます。
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
述語論理fを満たす 集合aの部分集合を返します。
subsetは、
fがfalse以外の何かを返す、aの要素から成る集合を返します。
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}
集合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
集合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}
合成によって二項関数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)
集合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}
合成によって関数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]
Next: Function Definition, Previous: Rules and Patterns [Contents][Index]