| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 35.1 Introduction to Sets | ||
| 35.2 Functions and Variables for Sets |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Maximaは、 明示的な列挙によって定義された有限集合用に、積集合や和集合のような集合関数を提供します。 Maximaはリストと集合を別のオブジェクトとして扱います。 この特長は、要素がリストであったり集合であったりする集合を扱うことを可能にします。
有限集合のための関数に加えて、 Maximaは組み合わせ論に関係したいくつかの関数を提供します; これらは、第一種と第二種スターリング数、ベル数、第一種と第二種の多項係数、 非負整数の分割、と2,3の他の関数を含みます。 Maximaはクロネッカーのデルタ関数も定義します。
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
要素 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
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
集合の要素上を反復する２つの方法があります。
１つの方法は 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の orderlessと
ordergreatメカニズムは集合関数と互換性がありません。
もし orderlessか ordergreatのいずれかを使う必要があるなら、
どんなものでも集合を構成する前にこれらの関数をコールしてください。
そして unorderをコールしないでください。
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
マサチューセッツ州ケンブリッジ市の Stavros Macrakisと ネブラスカ大学カーニー校(UNK)の Barton Willisが Maximaの集合関数とそれらのドキュメンテーションを書きました。
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [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}
|
Categories: Sets
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
集合 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
形式 [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
要素 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
集合 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
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
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
aが空の集合か空のリストの場合だけ trueを返します。
例:
(%i1) map (emptyp, [{}, []]);
(%o1) [true, true]
(%i2) map (emptyp, [a + b, {{}}, %pi]);
(%o2) [false, false, false]
|
Categories: Sets · Predicate functions
集合 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
もし述語論理 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は trueを返します。
グローバルフラグ 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
要素に関数 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
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])]))
|
Categories: Sets
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
任意の引数 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]}
|
Categories: Integers
intersectは以下に見る intersectionと同じです。
Categories: Sets
集合 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は、 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})
|
Categories: Sets
二項関数 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
式 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
メビウス関数を表します。
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
多項係数を返します。
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
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
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
集合 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
リストまたは集合 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) {{}}
|
Categories: Sets
クヌースのシャッフルアルゴリズムで構成されるような、 集合またはリスト 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
|
Categories: Lists
集合 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
集合 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
リスト 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
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
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}}
|
Categories: Sets
もし与えられた引数のうち１つ以上で述語論理 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
|
第一種のスターリング数を表します。
nと mが非負の整数の時、
stirling1 (n, m)の大きさは
m個の巡回置換を持つ n個の元を持つ集合の順列の数です。
stirling1は整理関数です。
Maximaは以下の恒等式を知っています:
これらの恒等式は
引数が、整数リテラルまたは整数と宣言されたシンボルで、かつ、
最初の引数が非負の時、
適用されます。
stirling1は、非整数引数に対して整理しません。
例:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling1 (n, n); (%o3) 1 |
Categories: Integers
第二種スターリング数を表します。
nと mが非負の整数の時、
stirling2 (n, m)は、
濃度 nの集合が m個のばらばらの部分集合に分割できる方法の数です。
stirling2は整理関数です。
Maximaは以下の恒等式を知っています。
引数が整数リテラルまたは整数と宣言されたシンボルで、かつ、最初の引数が非負の時、
これらの恒等式が適用されます。
stirling2は非整数引数に対して整理されません。
例:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling2 (n, n); (%o3) 1 |
stirling2は非整数引数に対して整理されません。
(%i1) stirling2 (%pi, %pi); (%o1) stirling2(%pi, %pi) |
Categories: Integers
述語論理 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
集合 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
集合 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
合成によって二項関数 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}
|
Categories: Sets
合成によって関数 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]
|
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by 市川雄二 on June, 21 2016 using texi2html 1.76.