| blob | 9c235c8a284c73f325f1aa2394ba58108e18561d |
1 @menu
2 * Introduction to Sets::
3 * Functions and Variables for Sets::
4 @end menu
6 @node Introduction to Sets, Functions and Variables for Sets, Sets, Sets
7 @section Introduction to Sets
9 Maximaは、
10 陽な列挙によって定義された有限集合のために、
11 積集合や和集合のような、集合関数を提供します。
12 Maximaは、リストと集合を別のオブジェクトとして扱います。
13 この特長は、
14 リストまたは集合であるメンバーがリストであったり集合であったりする集合を扱うことを可能にします。
16 有限集合のための関数に加えて、
17 Maximaは、
18 組み合わせ論に関係したいくつかの関数を提供します;
19 これらは、第一種と第二種スターリング数、ベル数、第一種と第二種の多項係数、
20 非負整数の分割、と2,3の他の関数です。
21 Maximaは、クロネッカーのデルタ関数も定義します。
23 @subsection Usage
25 メンバー@code{a_1, ..., a_n}の集合を構成するには、
26 @code{set(a_1, ..., a_n)}または@code{@{a_1, ..., a_n@}}を書いてください;
27 空集合を構成するには、
28 @code{set()}または@code{@{@}}を書いてください。
29 入力では、
30 @code{set(...)}と@code{@{ ... @}}は同値です。
31 集合は、いつも中括弧で表示されます。
33 もしメンバーが一度以上リストされているなら、
34 整理は、冗長なメンバーを消去します。
36 @c ===beg===
37 @c set();
38 @c set(a, b, a);
39 @c set(a, set(b));
40 @c set(a, [b]);
41 @c {};
42 @c {a, b, a};
43 @c {a, {b}};
44 @c {a, [b]};
45 @c ===end===
46 @example
47 (%i1) set();
48 (%o1) @{@}
49 (%i2) set(a, b, a);
50 (%o2) @{a, b@}
51 (%i3) set(a, set(b));
52 (%o3) @{a, @{b@}@}
53 (%i4) set(a, [b]);
54 (%o4) @{a, [b]@}
55 (%i5) @{@};
56 (%o5) @{@}
57 (%i6) @{a, b, a@};
58 (%o6) @{a, b@}
59 (%i7) @{a, @{b@}@};
60 (%o7) @{a, @{b@}@}
61 (%i8) @{a, [b]@};
62 (%o8) @{a, [b]@}
63 @end example
65 ２つの要素志望@var{x}と@var{y}は、
66 @code{is(@var{x} = @var{y})}が@code{true}をもたらす
67 (すなわち、集合構成の目的で同じと見なされる)
68 時だけ
69 冗長です。
70 @c THAT IS BECAUSE THE SET SIMPLIFICATION CODE CALLS THE LISP FUNCTION LIKE,
71 @c AND SO DOES THE CODE TO EVALUATE IS (X = Y).
72 @code{is(@var{x} = @var{y})}が@code{false}をもたらす一方、
73 @code{is(equal(@var{x}, @var{y}))}は、@code{true}をもたらす可能性があることに
74 注意してください;
75 その場合、要素@var{x}と@var{y}は異なったものと見なされます。
77 @c ===beg===
78 @c x: a/c + b/c;
79 @c y: a/c + b/c;
80 @c z: (a + b)/c;
81 @c is (x = y);
82 @c is (y = z);
83 @c is (equal (y, z));
84 @c y - z;
85 @c ratsimp (%);
86 @c {x, y, z};
87 @c ===end===
88 @example
89 (%i1) x: a/c + b/c;
90 b a
91 (%o1) - + -
92 c c
93 (%i2) y: a/c + b/c;
94 b a
95 (%o2) - + -
96 c c
97 (%i3) z: (a + b)/c;
98 b + a
99 (%o3) -----
100 c
101 (%i4) is (x = y);
102 (%o4) true
103 (%i5) is (y = z);
104 (%o5) false
105 (%i6) is (equal (y, z));
106 (%o6) true
107 (%i7) y - z;
108 b + a b a
109 (%o7) - ----- + - + -
110 c c c
111 (%i8) ratsimp (%);
112 (%o8) 0
113 (%i9) @{x, y, z@};
114 b + a b a
115 (%o9) @{-----, - + -@}
116 c c c
117 @end example
119 リストの要素から集合を構成するには、@code{setify}を使ってください。
121 @c ===beg===
122 @c setify ([b, a]);
123 @c ===end===
124 @example
125 (%i1) setify ([b, a]);
126 (%o1) @{a, b@}
127 @end example
129 もし@code{is(x = y)}が@code{true}に評価されるなら、
130 集合の元@code{x}と@code{y}は等しいです。
131 従って、@code{rat(x)}と@code{x}は集合の元として等しいです;
132 結果として、
134 @c ===beg===
135 @c {x, rat(x)};
136 @c ===end===
137 @example
138 (%i1) @{x, rat(x)@};
139 (%o1) @{x@}
140 @end example
142 さらに、
143 @code{is((x - 1)*(x + 1) = x^2 - 1)}は@code{false}に評価されるので、
144 @code{(x - 1)*(x + 1)}と@code{x^2 - 1}は集合の異なる元です;
145 従って、
147 @c ===beg===
148 @c {(x - 1)*(x + 1), x^2 - 1};
149 @c ===end===
150 @example
151 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
152 2
153 (%o1) @{(x - 1) (x + 1), x - 1@}
154 @end example
156 この集合を1元集合に縮小するには、
157 @code{rat}を集合の元それぞれに適用してください:
159 @c ===beg===
160 @c {(x - 1)*(x + 1), x^2 - 1};
161 @c map (rat, %);
162 @c ===end===
163 @example
164 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
165 2
166 (%o1) @{(x - 1) (x + 1), x - 1@}
167 (%i2) map (rat, %);
168 2
169 (%o2)/R/ @{x - 1@}
170 @end example
172 他の集合から冗長性を取り除くために、
173 他の整理関数を使う必要があるかもしれません。
174 以下は、@code{trigsimp}を使った例です:
176 @c ===beg===
177 @c {1, cos(x)^2 + sin(x)^2};
178 @c map (trigsimp, %);
179 @c ===end===
180 @example
181 (%i1) @{1, cos(x)^2 + sin(x)^2@};
182 2 2
183 (%o1) @{1, sin (x) + cos (x)@}
184 (%i2) map (trigsimp, %);
185 (%o2) @{1@}
186 @end example
188 元が、冗長でなく、並べ換えられている時
189 集合は整理されてます。
190 集合関数の現在のバージョンは、
191 集合を順に並べるためにMaxima関数@code{orderlessp}を使います;
192 しかしながら、
193 @i{集合関数の将来のバージョンは、違う並び替え関数を使うかもしれません。}
195 代入のような、集合に関するいくつかの演算は、
196 再整理を自動的に強制します;
197 例えば、
199 @c ===beg===
200 @c s: {a, b, c}$
201 @c subst (c=a, s);
202 @c subst ([a=x, b=x, c=x], s);
203 @c map (lambda ([x], x^2), set (-1, 0, 1));
204 @c ===end===
205 @example
206 (%i1) s: @{a, b, c@}$
207 (%i2) subst (c=a, s);
208 (%o2) @{a, b@}
209 (%i3) subst ([a=x, b=x, c=x], s);
210 (%o3) @{x@}
211 (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
212 (%o4) @{0, 1@}
213 @end example
215 Maximaは、リストと集合を異なるオブジェクトとして扱います;
216 @code{union}や@code{intersection}のような関数は、
217 もし引数のいずれかがしゅうごうでないなら、文句を言います。
218 もしリストに集合関数を適用する必要があるなら、
219 集合に変換するために、
220 @code{setify}関数を使ってください。
221 例えば、
223 @c ===beg===
224 @c union ([1, 2], {a, b});
225 @c union (setify ([1, 2]), {a, b});
226 @c ===end===
227 @example
228 (%i1) union ([1, 2], @{a, b@});
229 Function union expects a set, instead found [1,2]
230 -- an error. Quitting. To debug this try debugmode(true);
231 (%i2) union (setify ([1, 2]), @{a, b@});
232 (%o2) @{1, 2, a, b@}
233 @end example
235 集合@code{s}の集合要素のうち述語論理@code{f}を満たすすべての要素を抽出するためには、
236 use @code{subset(s, f)}を使ってください。
237 (@i{述語論理}はブーリアン値関数です。)
238 例えば、
239 与えられた集合の中で、変数@code{z}に依存しない等式を見つけるには、
240 以下を使ってください。
242 @c ===beg===
243 @c subset ({x + y + z, x - y + 4, x + y - 5},
244 @c lambda ([e], freeof (z, e)));
245 @c ===end===
246 @example
247 (%i1) subset (@{x + y + z, x - y + 4, x + y - 5@},
248 lambda ([e], freeof (z, e)));
249 (%o1) @{- y + x + 4, y + x - 5@}
250 @end example
252 節@ref{Functions and Variables for Sets}は、
253 Maximaの集合関数の完全なリストを持ちます。
255 @opencatbox
256 @category{Sets}
257 @closecatbox
259 @subsection Set Member Iteration
261 集合の元上を反復する２つの方法があります。
262 １つの方法は@code{map}の使用です;
263 例えば:
265 @c ===beg===
266 @c map (f, {a, b, c});
267 @c ===end===
268 @example
269 (%i1) map (f, @{a, b, c@});
270 (%o1) @{f(a), f(b), f(c)@}
271 @end example
273 他の方法は、
274 @code{for @var{x} in @var{s} do}を使うことです。
276 @c ===beg===
277 @c s: {a, b, c};
278 @c for si in s do print (concat (si, 1));
279 @c ===end===
280 @example
281 (%i1) s: @{a, b, c@};
282 (%o1) @{a, b, c@}
283 (%i2) for si in s do print (concat (si, 1));
284 a1
285 b1
286 c1
287 (%o2) done
288 @end example
290 Maxima関数@code{first}と@code{rest}は、
291 集合に対して正しく機能します。
292 集合に適用されると、
293 @code{first}は、最初に表示される集合の要素を返します;
294 それは、実装依存かもしれません。
295 もし@code{s}が集合なら
296 @code{rest(s)}は、@code{disjoin(first(s), s)}と同値です。
297 現在、
298 集合に対して正しく機能する他のMaxima関数があります。
299 集合関数の将来のバージョンでは、
300 @code{first}と@code{rest}は、違うように機能するかもしれませんし、そうでないかもしれません。
302 @subsection Bugs
304 集合関数は、
305 集合の元を並び換えるために、
306 Maxima関数@code{orderlessp}を使い、
307 集合の元の同一性をテストするために(Lispレベルの)関数@code{like}を使います。
308 これらの関数の両方は、
309 もし標準有理式(CRE)形式の式を含むリストや行列が元の集合を使おうとするなら、現れる既知のバグを持ちます。
310 例は以下の通りです。
312 @c ===beg===
313 @c {[x], [rat (x)]};
314 @c ===end===
315 @example
316 (%i1) @{[x], [rat (x)]@};
317 Maxima encountered a Lisp error:
319 The value #:X1440 is not of type LIST.
321 Automatically continuing.
322 To reenable the Lisp debugger set *debugger-hook* to nil.
323 @end example
325 この式は、Maximaがエラーで停止する原因となります。
326 (エラーメッセージはMaximaが使うLispのバージョンに依ります。)
327 もう１つの例は、以下の通りです。
329 @c ===beg===
330 @c setify ([[rat(a)], [rat(b)]]);
331 @c ===end===
332 @example
333 (%i1) setify ([[rat(a)], [rat(b)]]);
334 Maxima encountered a Lisp error:
336 The value #:A1440 is not of type LIST.
338 Automatically continuing.
339 To reenable the Lisp debugger set *debugger-hook* to nil.
340 @end example
342 これらのバグは、
343 @code{orderlessp}と@code{like}の中にあるバグに原因します;
344 それらは、集合関数の中のバグが原因ではありません。
345 例証するには、以下の式を試してください。
347 @c ===beg===
348 @c orderlessp ([rat(a)], [rat(b)]);
349 @c is ([rat(a)] = [rat(a)]);
350 @c ===end===
351 @example
352 (%i1) orderlessp ([rat(a)], [rat(b)]);
353 Maxima encountered a Lisp error:
355 The value #:B1441 is not of type LIST.
357 Automatically continuing.
358 To reenable the Lisp debugger set *debugger-hook* to nil.
359 (%i2) is ([rat(a)] = [rat(a)]);
360 (%o2) false
361 @end example
363 これらのバグが直されるまで、
364 CRE形式の式を含むリストや行を元に持つ集合を構成しないでください;
365 しかしながら、CRE形式の元を持つ集合は、問題ないはずです:
367 @c ===beg===
368 @c {x, rat (x)};
369 @c ===end===
370 @example
371 (%i1) @{x, rat (x)@};
372 (%o1) @{x@}
373 @end example
375 Maximaの@code{orderlessp}は、
376 集合関数で問題の原因となる可能性がある
377 もう１つのバグを持ちます。
378 それは、すなわち、順序付け述語論理@code{orderlessp}が推移的でないことです。
379 これを示す最も簡単な既知の例は、以下の通りです。
381 @c ===beg===
382 @c q: x^2$
383 @c r: (x + 1)^2$
384 @c s: x*(x + 2)$
385 @c orderlessp (q, r);
386 @c orderlessp (r, s);
387 @c orderlessp (q, s);
388 @c ===end===
389 @example
390 (%i1) q: x^2$
391 (%i2) r: (x + 1)^2$
392 (%i3) s: x*(x + 2)$
393 (%i4) orderlessp (q, r);
394 (%o4) true
395 (%i5) orderlessp (r, s);
396 (%o5) true
397 (%i6) orderlessp (q, s);
398 (%o6) false
399 @end example
401 このバグは、一般的にMaximaの関数はもちろん、集合関数すべてにおいて、
402 問題の原因となる可能性があります。
403 確実ではありませんが、
404 もし集合の元すべてがCRE形式であるか、@code{ratsimp}を使って整理されていれば、
405 このバグはたぶん避けられます。
407 @c WHAT EXACTLY IS THE EFFECT OF ordergreat AND orderless ON THE SET FUNCTIONS ??
408 Maximaの@code{orderless}と@code{ordergreat}メカニズムは、
409 集合関数と互換性がありません。
410 もし、@code{orderless}か@code{ordergreat}のいずれかを使う必要があるなら、
411 いかなる集合を構成する前に、これらの関数をコールしてください。
412 そして、@code{unorder}をコールしないでください。
414 @c APPARENTLY THIS NEXT BIT REFERS TO BUG REPORT 798571
415 @c EXAMPLE WITH kron_delta (1/sqrt(2), sqrt(2)/2); NOW WORKS AS EXPECTED
416 @c COMMENT OUT PENDING CONSTRUCTION OF ANOTHER EXAMPLE WHICH TRIGGERS THE BUG
417 @c
418 @c Maxima's sign function has a bug that may cause the Kronecker
419 @c delta function to misbehave; for example:
420 @c
421 @c @c ===beg===
422 @c @c kron_delta (1/sqrt(2), sqrt(2)/2);
423 @c @c ===end===
424 @c @example
425 @c (%i1) kron_delta (1/sqrt(2), sqrt(2)/2);
426 @c (%o1) 0
427 @c @end example
428 @c
429 @c The correct value is 1; the bug is related to the @code{sign} bug
430 @c
431 @c @c ===beg===
432 @c @c sign (1/sqrt(2) - sqrt(2)/2);
433 @c @c ===end===
434 @c @example
435 @c (%i1) sign (1/sqrt(2) - sqrt(2)/2);
436 @c (%o1) pos
437 @c @end example
439 もし集合関数のバグかもしれないと思う何かを見つけたら、
440 どうかMaximaのバグデータベースに報告してください。
441 @code{bug_report}を参照してください。
443 @subsection Authors
445 マサチューセッツ州ケンブリッジ市のStavros Macrakisと、
446 ネブラスカ大学カーニー校(UNK)のBarton Willisが、
447 Maximaの集合関数とそれらのドキュメンテーションを書きました。
449 @node Functions and Variables for Sets, , Introduction to Sets, Sets
450 @section Functions and Variables for Sets
452 @anchor{adjoin}
453 @deffn {関数} adjoin (@var{x}, @var{a})
455 集合@var{a}に要素@code{@{@var{x}@}}を加えた集合を返します。
457 もし@var{a}が集合リテラルでないなら、
458 @code{adjoin}は文句を言います。
460 @code{adjoin(@var{x}, @var{a})}と@code{union(set(@var{x}), @var{a})}は同値です;
461 しかしながら、@code{adjoin}は@code{union}より幾分早いかもしれません。
463 @code{disjoin}も参照してください。
465 例:
467 @c ===beg===
468 @c adjoin (c, {a, b});
469 @c adjoin (a, {a, b});
470 @c ===end===
471 @example
472 (%i1) adjoin (c, @{a, b@});
473 (%o1) @{a, b, c@}
474 (%i2) adjoin (a, @{a, b@});
475 (%o2) @{a, b@}
476 @end example
478 @opencatbox
479 @category{Sets}
480 @closecatbox
482 @end deffn
484 @anchor{belln}
485 @deffn {関数} belln (@var{n})
487 @math{n}番目のベル数を返します。
488 @code{belln(n)}は@var{n}個のメンバーを持つ集合の分割の数です。
490 非負整数@var{n}に対して、
491 @code{belln(@var{n})}は@math{n}番目のベル数に整理されます。
492 @code{belln}は他のいかなる引数に関して整理されません。
494 @code{belln}は等式、リスト、行列、集合上に分配されます。
496 例:
498 非負整数に適用された@code{belln}。
500 @c ===beg===
501 @c makelist (belln (i), i, 0, 6);
502 @c is (cardinality (set_partitions ({})) = belln (0));
503 @c is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) =
504 @c belln (6));
505 @c ===end===
506 @example
507 (%i1) makelist (belln (i), i, 0, 6);
508 (%o1) [1, 1, 2, 5, 15, 52, 203]
509 (%i2) is (cardinality (set_partitions (@{@})) = belln (0));
510 (%o2) true
511 (%i3) is (cardinality (set_partitions (@{1, 2, 3, 4, 5, 6@})) =
512 belln (6));
513 (%o3) true
514 @end example
516 非負整数でない引数に適用された@code{belln}。
518 @c ===beg===
519 @c [belln (x), belln (sqrt(3)), belln (-9)];
520 @c ===end===
521 @example
522 (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
523 (%o1) [belln(x), belln(sqrt(3)), belln(- 9)]
524 @end example
526 @opencatbox
527 @category{Sets}
528 @closecatbox
530 @end deffn
532 @anchor{cardinality}
533 @deffn {関数} cardinality (@var{a})
535 集合@var{a}の異なる要素の数を返します。
537 整理がディセーブルされた時でも、
538 @code{cardinality}は冗長な要素を無視します。
540 例:
542 @c ===beg===
543 @c cardinality ({});
544 @c cardinality ({a, a, b, c});
545 @c simp : false;
546 @c cardinality ({a, a, b, c});
547 @c ===end===
548 @example
549 (%i1) cardinality (@{@});
550 (%o1) 0
551 (%i2) cardinality (@{a, a, b, c@});
552 (%o2) 3
553 (%i3) simp : false;
554 (%o3) false
555 (%i4) cardinality (@{a, a, b, c@});
556 (%o4) 3
557 @end example
559 @opencatbox
560 @category{Sets}
561 @closecatbox
563 @end deffn
565 @anchor{cartesian_product}
566 @deffn {関数} cartesian_product (@var{b_1}, ... , @var{b_n})
567 Returns a set of lists of the form
568 形式@code{[@var{x_1}, ..., @var{x_n}]}のリストの集合を返します。
569 ここで、@var{x_1}, ..., @var{x_n}はそれぞれ、
570 集合@var{b_1}, ... , @var{b_n}の要素です。
572 もし任意の引数が集合リテラルでないなら、
573 @code{cartesian_product}は文句を言います。
575 例:
577 @c ===beg===
578 @c cartesian_product ({0, 1});
579 @c cartesian_product ({0, 1}, {0, 1});
580 @c cartesian_product ({x}, {y}, {z});
581 @c cartesian_product ({x}, {-1, 0, 1});
582 @c ===end===
583 @example
584 (%i1) cartesian_product (@{0, 1@});
585 (%o1) @{[0], [1]@}
586 (%i2) cartesian_product (@{0, 1@}, @{0, 1@});
587 (%o2) @{[0, 0], [0, 1], [1, 0], [1, 1]@}
588 (%i3) cartesian_product (@{x@}, @{y@}, @{z@});
589 (%o3) @{[x, y, z]@}
590 (%i4) cartesian_product (@{x@}, @{-1, 0, 1@});
591 (%o4) @{[x, - 1], [x, 0], [x, 1]@}
592 @end example
594 @opencatbox
595 @category{Sets}
596 @closecatbox
598 @end deffn
601 @anchor{disjoin}
602 @deffn {関数} disjoin (@var{x}, @var{a})
603 元@var{x}を持たない集合@var{a}を返します。
604 もし@var{x}が@var{a}のメンバーでないなら、
605 変更なしに@var{a}を返します。
607 もし@var{a}が集合リテラルでないなら、
608 @code{disjoin}は文句を言います。
610 @code{disjoin(@var{x}, @var{a})}, @code{delete(@var{x}, @var{a})},
611 @code{setdifference(@var{a}, set(@var{x}))}はすべて同値です。
612 これらの中で、
613 @code{disjoin}は一般的に他より速いです。
615 例:
617 @c ===beg===
618 @c disjoin (a, {a, b, c, d});
619 @c disjoin (a + b, {5, z, a + b, %pi});
620 @c disjoin (a - b, {5, z, a + b, %pi});
621 @c ===end===
622 @example
623 (%i1) disjoin (a, @{a, b, c, d@});
624 (%o1) @{b, c, d@}
625 (%i2) disjoin (a + b, @{5, z, a + b, %pi@});
626 (%o2) @{5, %pi, z@}
627 (%i3) disjoin (a - b, @{5, z, a + b, %pi@});
628 (%o3) @{5, %pi, b + a, z@}
629 @end example
631 @opencatbox
632 @category{Sets}
633 @closecatbox
635 @end deffn
637 @anchor{disjointp}
638 @deffn {関数} disjointp (@var{a}, @var{b})
640 集合@var{a}と@var{b}がばらばらなら、
641 @code{true}を返します。
643 もし@var{a}か@var{b}が集合リテラルでないなら、
644 @code{disjointp}は文句を言います。
646 例:
648 @c ===beg===
649 @c disjointp ({a, b, c}, {1, 2, 3});
650 @c disjointp ({a, b, 3}, {1, 2, 3});
651 @c ===end===
652 @example
653 (%i1) disjointp (@{a, b, c@}, @{1, 2, 3@});
654 (%o1) true
655 (%i2) disjointp (@{a, b, 3@}, @{1, 2, 3@});
656 (%o2) false
657 @end example
659 @opencatbox
660 @category{Sets}
661 @category{Predicate functions}
662 @closecatbox
664 @end deffn
666 @anchor{divisors}
667 @deffn {関数} divisors (@var{n})
669 @var{n}の約数の集合を表します。
671 @var{n}がゼロでない整数の時、
672 @code{divisors(@var{n})}は整数の集合に整理されます。
673 約数の集合は元1と@var{n}を含みます。
674 負の整数の約数は、その絶対値の約数です。
676 @code{divisors}は、等式、リスト、行列、集合上に分配されます。
678 例:
680 28は完全数であることを検証できます:
681 (自身を除いた)約数が28です。
683 @c ===beg===
684 @c s: divisors(28);
685 @c lreduce ("+", args(s)) - 28;
686 @c ===end===
687 @example
688 (%i1) s: divisors(28);
689 (%o1) @{1, 2, 4, 7, 14, 28@}
690 (%i2) lreduce ("+", args(s)) - 28;
691 (%o2) 28
692 @end example
694 @code{divisors}は整理関数です。
695 @code{divisors(a)}の中で@code{a}に8を代入することは、
696 @code{divisors(8)}を再評価せずに約数をもたらします。
698 @c ===beg===
699 @c divisors (a);
700 @c subst (8, a, %);
701 @c ===end===
702 @example
703 (%i1) divisors (a);
704 (%o1) divisors(a)
705 (%i2) subst (8, a, %);
706 (%o2) @{1, 2, 4, 8@}
707 @end example
709 @code{divisors}は、等式、リスト、行列、集合上に分配されます。
711 @c ===beg===
712 @c divisors (a = b);
713 @c divisors ([a, b, c]);
714 @c divisors (matrix ([a, b], [c, d]));
715 @c divisors ({a, b, c});
716 @c ===end===
717 @example
718 (%i1) divisors (a = b);
719 (%o1) divisors(a) = divisors(b)
720 (%i2) divisors ([a, b, c]);
721 (%o2) [divisors(a), divisors(b), divisors(c)]
722 (%i3) divisors (matrix ([a, b], [c, d]));
723 [ divisors(a) divisors(b) ]
724 (%o3) [ ]
725 [ divisors(c) divisors(d) ]
726 (%i4) divisors (@{a, b, c@});
727 (%o4) @{divisors(a), divisors(b), divisors(c)@}
728 @end example
730 @opencatbox
731 @category{Integers}
732 @closecatbox
734 @end deffn
736 @anchor{elementp}
737 @deffn {関数} elementp (@var{x}, @var{a})
738 @var{x}が集合@var{a}の元の時だけ@code{true}を返します。
740 もし@var{a}が集合リテラルでないなら、
741 @code{elementp}は文句を言います。
743 例:
745 @c ===beg===
746 @c elementp (sin(1), {sin(1), sin(2), sin(3)});
747 @c elementp (sin(1), {cos(1), cos(2), cos(3)});
748 @c ===end===
749 @example
750 (%i1) elementp (sin(1), @{sin(1), sin(2), sin(3)@});
751 (%o1) true
752 (%i2) elementp (sin(1), @{cos(1), cos(2), cos(3)@});
753 (%o2) false
754 @end example
756 @opencatbox
757 @category{Sets}
758 @category{Predicate functions}
759 @closecatbox
761 @end deffn
763 @anchor{emptyp}
764 @deffn {関数} emptyp (@var{a})
766 @var{a}が空の集合か空のリストの時だけ、@code{true}を返します。
768 例:
770 @c ===beg===
771 @c map (emptyp, [{}, []]);
772 @c map (emptyp, [a + b, {{}}, %pi]);
773 @c ===end===
774 @example
775 (%i1) map (emptyp, [@{@}, []]);
776 (%o1) [true, true]
777 (%i2) map (emptyp, [a + b, @{@{@}@}, %pi]);
778 (%o2) [false, false, false]
779 @end example
781 @opencatbox
782 @category{Sets}
783 @category{Predicate functions}
784 @closecatbox
786 @end deffn
788 @anchor{equiv_classes}
789 @deffn {関数} equiv_classes (@var{s}, @var{F})
790 集合@var{s}の
791 同値関係@var{F}に関する
792 同値クラスの集合を返します。
794 @var{F}は@var{s}の@var{s}との直積集合上の２変数関数です。
795 The return value of
796 @var{F}の戻り値は、@code{true}か@code{false}、もしくは、
797 @code{is(@var{expr})}が@code{true}か@code{false}のような
798 式@var{expr}です。
800 @var{F}が同値関数でない時、
801 @code{equiv_classes}は不平なくそれを受け入れますが、
802 その場合、結果は、一般に正しくありません。
804 @c EXCESSIVE DETAIL HERE. PROBABLY JUST CUT THIS
805 @c @var{F} may be a relational operator (built-in or user-defined),
806 @c an ordinary Maxima function, a Lisp function, a lambda expression,
807 @c a macro, or a subscripted function.
809 例:
811 同値関係が
812 @code{true}か@code{false}を返すラムダ式です。
814 @c ===beg===
815 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
816 @c lambda ([x, y], is (equal (x, y))));
817 @c ===end===
818 @example
819 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@},
820 lambda ([x, y], is (equal (x, y))));
821 (%o1) @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
822 @end example
824 同値関係が、@code{is}が@code{true}か@code{false}に評価される
825 関係関数の名前です。
827 @c ===beg===
828 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
829 @c ===end===
830 @example
831 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@}, equal);
832 (%o1) @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
833 @end example
835 同値クラスが3の倍数だけ違う数です。
837 @c ===beg===
838 @c equiv_classes ({1, 2, 3, 4, 5, 6, 7},
839 @c lambda ([x, y], remainder (x - y, 3) = 0));
840 @c ===end===
841 @example
842 (%i1) equiv_classes (@{1, 2, 3, 4, 5, 6, 7@},
843 lambda ([x, y], remainder (x - y, 3) = 0));
844 (%o1) @{@{1, 4, 7@}, @{2, 5@}, @{3, 6@}@}
845 @end example
847 @opencatbox
848 @category{Sets}
849 @closecatbox
851 @end deffn
853 @anchor{every}
854 @deffn {関数} every (@var{f}, @var{s})
855 @deffnx {関数} every (@var{f}, @var{L_1}, ..., @var{L_n})
857 もし述語論理@var{f}が与えられた引数すべてで@code{true}なら、
858 @code{true}を返します。
860 ある集合が二番目の引数として与えられたとして、
861 もし@code{is(@var{f}(@var{a_i}))}が
862 @var{s}の中の@var{a_i}すべてに関して
863 @code{true}を返すなら
864 @code{every(@var{f}, @var{s})}は@code{true}です。
865 @code{every}は、
866 @var{s}の中の@var{a_i}すべてに関して@var{f}を評価するかもしれないししないかもしれません。
867 集合は順序付けされていないので、
868 @code{every}は任意の順序で@code{@var{f}(@var{a_i})}を評価します。
870 非キスとして１つか複数のリストが与えられたとして、
871 もし@code{is(@var{f}(@var{x_1}, ..., @var{x_n}))}が
872 @var{L_1}, ..., @var{L_n}それぞれの中の@var{x_1}, ..., @var{x_n}すべてに対して
873 @code{true}を返すなら、
874 @code{every(@var{f}, @var{L_1}, ..., @var{L_n})}は@code{true}を返します。
875 @code{every}は、
876 @var{x_1}, ..., @var{x_n}のすべての組み合わせに対して@var{f}を評価するかもしれないししないかもしれません。
877 @code{every}はインデックスを増やす順序でリストを評価します。
879 空の集合@code{@{@}}または空のリスト@code{[]}が引数として与えられたとして、
880 @code{every}は@code{false}を返します。
882 グローバルフラグ@code{maperror}が@code{true}の時、
883 リスト@var{L_1}, ..., @var{L_n}すべては等しい長さを持たなければいけません。
884 @code{maperror}が@code{false}の時、
885 リスト引数は、最短のリストの長さに効果的に切り詰められます。
887 (@code{is}を介して)
888 @code{true}か@code{false}以外の何かに評価される述語論理@var{f}の戻り値は、
889 @code{prederror}によって決定されます。
890 @code{prederror}が@code{true}の時、
891 そんな値は@code{false}として扱われ、
892 @code{every}の戻り値は@code{false}です。
893 @code{prederror}が@code{false}の時、
894 そんな値は@code{unknown}として扱われ、
895 @code{every}の戻り値は@code{unknown}です。
897 例:
899 １つの集合に適用された@code{every}。
900 述語論理は１引数関数です。
902 @c ===beg===
903 @c every (integerp, {1, 2, 3, 4, 5, 6});
904 @c every (atom, {1, 2, sin(3), 4, 5 + y, 6});
905 @c ===end===
906 @example
907 (%i1) every (integerp, @{1, 2, 3, 4, 5, 6@});
908 (%o1) true
909 (%i2) every (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
910 (%o2) false
911 @end example
913 ２つのリストに適用された@code{every}。
914 述語論理は２引数関数です。
916 @c ===beg===
917 @c every ("=", [a, b, c], [a, b, c]);
918 @c every ("#", [a, b, c], [a, b, c]);
919 @c ===end===
920 @example
921 (%i1) every ("=", [a, b, c], [a, b, c]);
922 (%o1) true
923 (%i2) every ("#", [a, b, c], [a, b, c]);
924 (%o2) false
925 @end example
927 @code{true}か@code{false}以外の何かに評価される
928 述語論理@var{f}の戻り値は、
929 グローバルフラグ@code{prederror}によって決定されます。
931 @c ===beg===
932 @c prederror : false;
933 @c map (lambda ([a, b], is (a < b)), [x, y, z],
934 @c [x^2, y^2, z^2]);
935 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
936 @c prederror : true;
937 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
938 @c ===end===
939 @example
940 (%i1) prederror : false;
941 (%o1) false
942 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
943 [x^2, y^2, z^2]);
944 (%o2) [unknown, unknown, unknown]
945 (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
946 (%o3) unknown
947 (%i4) prederror : true;
948 (%o4) true
949 (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
950 (%o5) false
951 @end example
953 @opencatbox
954 @category{Sets}
955 @closecatbox
957 @end deffn
959 @anchor{extremal_subset}
960 @deffn {関数} extremal_subset (@var{s}, @var{f}, max)
961 @deffnx {関数} extremal_subset (@var{s}, @var{f}, min)
963 関数@var{f}が最大または最小値を取る、
964 @var{s}の部分集合を返します。
966 @code{extremal_subset(@var{s}, @var{f}, max)}は、
967 実数値関数@var{f}が最大値を取る、
968 集合またはリスト@var{s}の部分集合を返します。
970 @code{extremal_subset(@var{s}, @var{f}, min)}は、
971 実数値関数@var{f}が最小値を取る、
972 集合またはリスト@var{s}の部分集合を返します。
974 例:
976 @c ===beg===
977 @c extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
978 @c extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
979 @c ===end===
980 @example
981 (%i1) extremal_subset (@{-2, -1, 0, 1, 2@}, abs, max);
982 (%o1) @{- 2, 2@}
983 (%i2) extremal_subset (@{sqrt(2), 1.57, %pi/2@}, sin, min);
984 (%o2) @{sqrt(2)@}
985 @end example
987 @opencatbox
988 @category{Sets}
989 @closecatbox
991 @end deffn
993 @anchor{flatten}
994 @deffn {関数} flatten (@var{expr})
996 @var{expr}と同じ演算子を持つ部分式の引数を集め、
997 これらの集めた引数から式を構成します。
999 @code{expr}の主演算子と違った演算子の部分式は、
1000 たとえそれらが、逆に@code{expr}に関するものと同じ演算子の部分式を含んだとしても、
1001 変更なしにコピーされます。
1003 引数の数が演算子に関して宣言された引数と違う
1004 式を@code{flatten}が構成する可能性があるかもしれません;
1005 これは、整理器や評価器からのエラーメッセージを起こさせるかもしれません。
1006 @code{flatten}はそんな状況を検出しようとしません。
1008 特別な表現の式、例えば、標準有理式(CRE)、はflattenできません;
1009 そんな場合、@code{flatten}は引数を変更なしに返します。
1011 例:
1013 リストに適用すると、@code{flatten}はリストの要素すべてを集めます。
1015 @c ===beg===
1016 @c flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
1017 @c ===end===
1018 @example
1019 (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
1020 (%o1) [a, b, c, d, e, f, g, h, i, j]
1021 @end example
1023 集合に適用すると、@code{flatten}は集合の元すべてを集めます。
1025 @c ===beg===
1026 @c flatten ({a, {b}, {{c}}});
1027 @c flatten ({a, {[a], {a}}});
1028 @c ===end===
1029 @example
1030 (%i1) flatten (@{a, @{b@}, @{@{c@}@}@});
1031 (%o1) @{a, b, c@}
1032 (%i2) flatten (@{a, @{[a], @{a@}@}@});
1033 (%o2) @{a, [a]@}
1034 @end example
1036 @code{flatten}は、主演算子をn項に宣言する効果に似ています。
1037 しかしながら、@code{flatten}は、
1038 主演算子と違う演算子を持つ部分式上に影響を持ちません。
1039 一方、n項宣言はそれらに影響します。
1041 @c ===beg===
1042 @c expr: flatten (f (g (f (f (x)))));
1043 @c declare (f, nary);
1044 @c ev (expr);
1045 @c ===end===
1046 @example
1047 (%i1) expr: flatten (f (g (f (f (x)))));
1048 (%o1) f(g(f(f(x))))
1049 (%i2) declare (f, nary);
1050 (%o2) done
1051 (%i3) ev (expr);
1052 (%o3) f(g(f(x)))
1053 @end example
1055 @code{flatten}は、他の任意の演算子と同じように添字付き関数を扱います。
1057 @c ===beg===
1058 @c flatten (f[5] (f[5] (x, y), z));
1059 @c ===end===
1060 @example
1061 (%i1) flatten (f[5] (f[5] (x, y), z));
1062 (%o1) f (x, y, z)
1063 5
1064 @end example
1066 引数の数が演算子に関して宣言された引数と違う
1067 式を@code{flatten}が構成する可能性があるかもしれません;
1069 @c ===beg===
1070 @c 'mod (5, 'mod (7, 4));
1071 @c flatten (%);
1072 @c ''%, nouns;
1073 @c ===end===
1074 @example
1075 (%i1) 'mod (5, 'mod (7, 4));
1076 (%o1) mod(5, mod(7, 4))
1077 (%i2) flatten (%);
1078 (%o2) mod(5, 7, 4)
1079 (%i3) ''%, nouns;
1080 Wrong number of arguments to mod
1081 -- an error. Quitting. To debug this try debugmode(true);
1082 @end example
1084 @opencatbox
1085 @category{Sets}
1086 @category{Lists}
1087 @closecatbox
1089 @end deffn
1091 @anchor{full_listify}
1092 @deffn {関数} full_listify (@var{a})
1093 @var{a}の中のすべての集合演算子をリスト演算子で置き換え、
1094 結果を返します。
1095 @code{full_listify}は、
1096 たとえ主演算子が@code{set}でなくても
1097 入れ子の部分式の中の集合演算子を置き換えます。
1099 @code{listify}は主演算子だけを置き換えます。
1101 例:
1103 @c ===beg===
1104 @c full_listify ({a, b, {c, {d, e, f}, g}});
1105 @c full_listify (F (G ({a, b, H({c, d, e})})));
1106 @c ===end===
1107 @example
1108 (%i1) full_listify (@{a, b, @{c, @{d, e, f@}, g@}@});
1109 (%o1) [a, b, [c, [d, e, f], g]]
1110 (%i2) full_listify (F (G (@{a, b, H(@{c, d, e@})@})));
1111 (%o2) F(G([a, b, H([c, d, e])]))
1112 @end example
1114 @opencatbox
1115 @category{Sets}
1116 @closecatbox
1118 @end deffn
1120 @anchor{fullsetify}
1121 @deffn {関数} fullsetify (@var{a})
1122 @var{a}がリストの時、
1123 リスト演算子を集合演算子で置き換え、
1124 @code{fullsetify}を集合であるメンバーそれぞれに適用します。
1125 @var{a}がリストでない時、変更なしで返します。
1127 @code{setify}は主演算子だけを置き換えます。
1129 例:
1132 @code{f([b])}の主演算子はリストでないので、
1133 行@code{(%o2)}で、
1134 @code{f}の引数は集合に変換されません。
1136 @c ===beg===
1137 @c fullsetify ([a, [a]]);
1138 @c fullsetify ([a, f([b])]);
1139 @c ===end===
1140 @example
1141 (%i1) fullsetify ([a, [a]]);
1142 (%o1) @{a, @{a@}@}
1143 (%i2) fullsetify ([a, f([b])]);
1144 (%o2) @{a, f([b])@}
1145 @end example
1147 @opencatbox
1148 @category{Lists}
1149 @closecatbox
1151 @end deffn
1153 @anchor{identity}
1154 @deffn {関数} identity (@var{x})
1156 任意の引数@var{x}に対して@var{x}を返します。
1158 例:
1160 @code{identity}は、
1161 引数が既にブーリアン値の時、
1162 述語論理として使うことができます。
1164 @c ===beg===
1165 @c every (identity, [true, true]);
1166 @c ===end===
1167 @example
1168 (%i1) every (identity, [true, true]);
1169 (%o1) true
1170 @end example
1171 @end deffn
1173 @anchor{integer_partitions}
1174 @deffn {関数} integer_partitions (@var{n})
1175 @deffnx {関数} integer_partitions (@var{n}, @var{len})
1177 @var{n}の整数分割を返します。
1178 すなわち、和が@var{n}になる整数のリストです。
1180 @code{integer_partitions(@var{n})}は、
1181 整数@var{n}の分割すべての集合を返します。
1182 分割それぞれは、大きい順に並べられたリストです。
1184 @code{integer_partitions(@var{n}, @var{len})}は、
1185 長さ@var{len}以下の分割すべてを返します;
1186 この場合、
1187 @var{len}より少ない項を持つ分割それぞれには、
1188 厳密に@var{len}項持つ分割にするように、ゼロが足されます。
1189 分割それぞれは、大きい順に並べられたリストです。
1191 リスト@math{[a_1, ..., a_m]}は、
1192 (1) @math{a_i}それぞれが非ゼロ整数、かつ、
1193 (2) @math{a_1 + ... + a_m = n.}
1194 の時、非負整数@math{n}の分割です。
1195 従って0は分割を持ちません。
1197 例:
1199 @c ===beg===
1200 @c integer_partitions (3);
1201 @c s: integer_partitions (25)$
1202 @c cardinality (s);
1203 @c map (lambda ([x], apply ("+", x)), s);
1204 @c integer_partitions (5, 3);
1205 @c integer_partitions (5, 2);
1206 @c ===end===
1207 @example
1208 (%i1) integer_partitions (3);
1209 (%o1) @{[1, 1, 1], [2, 1], [3]@}
1210 (%i2) s: integer_partitions (25)$
1211 (%i3) cardinality (s);
1212 (%o3) 1958
1213 (%i4) map (lambda ([x], apply ("+", x)), s);
1214 (%o4) @{25@}
1215 (%i5) integer_partitions (5, 3);
1216 (%o5) @{[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]@}
1217 (%i6) integer_partitions (5, 2);
1218 (%o6) @{[3, 2], [4, 1], [5, 0]@}
1219 @end example
1221 条件を満たす分割すべてを見つけるには、
1222 関数@code{subset}を使ってください;
1223 以下は素数から成る10の分割すべてを見つける例です。
1225 @c ===beg===
1226 @c s: integer_partitions (10)$
1227 @c cardinality (s);
1228 @c xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1229 @c subset (s, lambda ([x], every (xprimep, x)));
1230 @c ===end===
1231 @example
1232 (%i1) s: integer_partitions (10)$
1233 (%i2) cardinality (s);
1234 (%o2) 42
1235 (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1236 (%i4) subset (s, lambda ([x], every (xprimep, x)));
1237 (%o4) @{[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]@}
1238 @end example
1240 @opencatbox
1241 @category{Integers}
1242 @closecatbox
1244 @end deffn
1246 @anchor{intersect}
1247 @deffn {関数} intersect (@var{a_1}, ..., @var{a_n})
1249 @code{intersect}は、以下に見る@code{intersection}と同じです。
1251 @opencatbox
1252 @category{Sets}
1253 @closecatbox
1255 @end deffn
1257 @anchor{intersection}
1258 @deffn {関数} intersection (@var{a_1}, ..., @var{a_n})
1259 集合@var{a_1}から@var{a_n}までに共通な
1260 要素を含む
1261 集合を返します。
1263 もし引数のいずれかが集合リテラルでないなら、
1264 @code{intersection}は文句を言います。
1266 例:
1268 @c ===beg===
1269 @c S_1 : {a, b, c, d};
1270 @c S_2 : {d, e, f, g};
1271 @c S_3 : {c, d, e, f};
1272 @c S_4 : {u, v, w};
1273 @c intersection (S_1, S_2);
1274 @c intersection (S_2, S_3);
1275 @c intersection (S_1, S_2, S_3);
1276 @c intersection (S_1, S_2, S_3, S_4);
1277 @c ===end===
1278 @example
1279 (%i1) S_1 : @{a, b, c, d@};
1280 (%o1) @{a, b, c, d@}
1281 (%i2) S_2 : @{d, e, f, g@};
1282 (%o2) @{d, e, f, g@}
1283 (%i3) S_3 : @{c, d, e, f@};
1284 (%o3) @{c, d, e, f@}
1285 (%i4) S_4 : @{u, v, w@};
1286 (%o4) @{u, v, w@}
1287 (%i5) intersection (S_1, S_2);
1288 (%o5) @{d@}
1289 (%i6) intersection (S_2, S_3);
1290 (%o6) @{d, e, f@}
1291 (%i7) intersection (S_1, S_2, S_3);
1292 (%o7) @{d@}
1293 (%i8) intersection (S_1, S_2, S_3, S_4);
1294 (%o8) @{@}
1295 @end example
1297 @opencatbox
1298 @category{Sets}
1299 @closecatbox
1301 @end deffn
1303 @deffn {関数} kron_delta (@var{x}, @var{y}, @dots{}, @var{xp})
1305 クロネッカーのデルタ関数を表します。
1307 @code{kron_delta}は、
1308 @var{xi}と@var{yj}が引数のすべての対で等しい時
1309 1に整理され、
1310 @var{xi}と@var{yj}が引数のある対で等しくない時
1311 0に整理されます。
1312 等号は@code{is(equal(xi,j))}を使って決定され、
1313 不等号は@code{is(notsqual(xi,xj))}を使って決定されます。
1314 厳密に1つの引数に対して、@code{kron_delta}はエラーをシグナルします。
1316 例:
1318 @c ===beg===
1319 @c kron_delta(a,a);
1320 @c kron_delta(a,b,a,b);
1321 @c kron_delta(a,a,b,a+1);
1322 @c assume(equal(x,y));
1323 @c kron_delta(x,y);
1324 @c ===end===
1325 @example
1326 (%i1) kron_delta(a,a);
1327 (%o1) 1
1328 (%i2) kron_delta(a,b,a,b);
1329 (%o2) kron_delta(a, b)
1330 (%i3) kron_delta(a,a,b,a+1);
1331 (%o3) 0
1332 (%i4) assume(equal(x,y));
1333 (%o4) [equal(x, y)]
1334 (%i5) kron_delta(x,y);
1335 (%o5) 1
1336 @end example
1339 @end deffn
1341 @anchor{listify}
1342 @deffn {関数} listify (@var{a})
1344 @var{a}が集合の時、
1345 @var{a}の元を含む
1346 リストを返します。
1347 そうでなければ、@code{listify}は@var{a}を返します。
1349 @code{full_listify}は
1350 @var{a}の中の集合演算子をリスト演算子に置き換えます。
1352 例:
1354 @c ===beg===
1355 @c listify ({a, b, c, d});
1356 @c listify (F ({a, b, c, d}));
1357 @c ===end===
1358 @example
1359 (%i1) listify (@{a, b, c, d@});
1360 (%o1) [a, b, c, d]
1361 (%i2) listify (F (@{a, b, c, d@}));
1362 (%o2) F(@{a, b, c, d@})
1363 @end example
1365 @opencatbox
1366 @category{Sets}
1367 @closecatbox
1369 @end deffn
1371 @anchor{lreduce}
1372 @deffn {関数} lreduce (@var{F}, @var{s})
1373 @deffnx {関数} lreduce (@var{F}, @var{s}, @var{s_0})
1375 二項関数@var{F}を合成によってn項関数に拡張します。
1376 ここで@var{s}はリストです。
1378 @code{lreduce(@var{F}, @var{s})}は@code{F(... F(F(s_1, s_2), s_3), ... s_n)}を返します。
1380 オプション引数@var{s_0}が存在する時、
1381 結果は@code{lreduce(@var{F}, cons(@var{s_0}, @var{s}))}と同値です。
1383 関数@var{F}は、最初の@i{leftmost}の元に適用されます。
1384 だから、"lreduce"と名付けられています。
1386 @code{rreduce}, @code{xreduce}, @code{tree_reduce}も参照してください。
1388 例:
1390 オプション引数なしの@code{lreduce}。
1392 @c ===beg===
1393 @c lreduce (f, [1, 2, 3]);
1394 @c lreduce (f, [1, 2, 3, 4]);
1395 @c ===end===
1396 @example
1397 (%i1) lreduce (f, [1, 2, 3]);
1398 (%o1) f(f(1, 2), 3)
1399 (%i2) lreduce (f, [1, 2, 3, 4]);
1400 (%o2) f(f(f(1, 2), 3), 4)
1401 @end example
1403 オプション引数ありの@code{lreduce}。
1405 @c ===beg===
1406 @c lreduce (f, [1, 2, 3], 4);
1407 @c ===end===
1408 @example
1409 (%i1) lreduce (f, [1, 2, 3], 4);
1410 (%o1) f(f(f(4, 1), 2), 3)
1411 @end example
1413 組み込み二項演算子に適用された@code{lreduce}。
1414 @code{/}は割り算演算子。
1416 @c ===beg===
1417 @c lreduce ("^", args ({a, b, c, d}));
1418 @c lreduce ("/", args ({a, b, c, d}));
1419 @c ===end===
1420 @example
1421 (%i1) lreduce ("^", args (@{a, b, c, d@}));
1422 b c d
1423 (%o1) ((a ) )
1424 (%i2) lreduce ("/", args (@{a, b, c, d@}));
1425 a
1426 (%o2) -----
1427 b c d
1428 @end example
1430 @opencatbox
1431 @category{Lists}
1432 @closecatbox
1434 @end deffn
1436 @anchor{makeset}
1437 @deffn {関数} makeset (@var{expr}, @var{x}, @var{s})
1439 式@var{expr}から生成された元を持つ集合を返します。
1440 ここで、@var{x}は@var{expr}の中の変数のリストであり、
1441 @var{s}はリストの集合かリストです。
1442 集合の元それぞれを生成するために、
1443 @var{expr}は、
1444 @var{s}の元に並列にバインドされた変数@var{x}で評価されます。
1446 @var{s}の元それぞれは
1447 @var{x}と同じ長さを持たなければいけません。
1448 変数@var{x}のリストは、添字の付かないシンボルのリストでなければいけません。
1449 たとえシンボルが１つしかない場合でも、@var{x}は１要素のリストでなければいけなく、
1450 @var{s}の元それぞれは１要素のリストでなければいけません。
1452 @c FOLLOWING EQUIVALENT EXPRESSION IS REALLY TOO COMPLICATED, JUST SKIP IT FOR NOW
1453 @c @code{makeset(@var{expr}, @var{x}, @var{s})} returns the same result as
1454 @c @code{setify(map(lambda([L], sublis(map("=", ''@var{x}, L), ''@var{expr})), args(@var{s})))}.
1456 @code{makelist}も参照してください。
1458 例:
1460 @c ===beg===
1461 @c makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1462 @c S : {x, y, z}$
1463 @c S3 : cartesian_product (S, S, S);
1464 @c makeset (i + j + k, [i, j, k], S3);
1465 @c makeset (sin(x), [x], {[1], [2], [3]});
1466 @c ===end===
1467 @example
1468 (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1469 1 2 3 4
1470 (%o1) @{-, -, -, -@}
1471 a b c d
1472 (%i2) S : @{x, y, z@}$
1473 (%i3) S3 : cartesian_product (S, S, S);
1474 (%o3) @{[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
1475 [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
1476 [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
1477 [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
1478 [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
1479 [z, z, y], [z, z, z]@}
1480 (%i4) makeset (i + j + k, [i, j, k], S3);
1481 (%o4) @{3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
1482 z + 2 y, 2 z + x, 2 z + y@}
1483 (%i5) makeset (sin(x), [x], @{[1], [2], [3]@});
1484 (%o5) @{sin(1), sin(2), sin(3)@}
1485 @end example
1487 @opencatbox
1488 @category{Sets}
1489 @closecatbox
1491 @end deffn
1493 @anchor{moebius}
1494 @deffn {関数} moebius (@var{n})
1496 メビウス関数を表します。
1498 @var{n}が@math{k}個の異なる素数の積の時、
1499 @code{moebius(@var{n})}は@math{(-1)^k}に整理されます;
1500 @math{@var{n} = 1}の時、1に整理されます;
1501 他の正の数すべてに対して、0に整理されます。
1503 @code{moebius}は等式、リスト、行列、集合上に分配されます。
1505 例:
1507 @c ===beg===
1508 @c moebius (1);
1509 @c moebius (2 * 3 * 5);
1510 @c moebius (11 * 17 * 29 * 31);
1511 @c moebius (2^32);
1512 @c moebius (n);
1513 @c moebius (n = 12);
1514 @c moebius ([11, 11 * 13, 11 * 13 * 15]);
1515 @c moebius (matrix ([11, 12], [13, 14]));
1516 @c moebius ({21, 22, 23, 24});
1517 @c ===end===
1518 @example
1519 (%i1) moebius (1);
1520 (%o1) 1
1521 (%i2) moebius (2 * 3 * 5);
1522 (%o2) - 1
1523 (%i3) moebius (11 * 17 * 29 * 31);
1524 (%o3) 1
1525 (%i4) moebius (2^32);
1526 (%o4) 0
1527 (%i5) moebius (n);
1528 (%o5) moebius(n)
1529 (%i6) moebius (n = 12);
1530 (%o6) moebius(n) = 0
1531 (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
1532 (%o7) [- 1, 1, 1]
1533 (%i8) moebius (matrix ([11, 12], [13, 14]));
1534 [ - 1 0 ]
1535 (%o8) [ ]
1536 [ - 1 1 ]
1537 (%i9) moebius (@{21, 22, 23, 24@});
1538 (%o9) @{- 1, 0, 1@}
1539 @end example
1541 @opencatbox
1542 @category{Integers}
1543 @closecatbox
1545 @end deffn
1547 @anchor{multinomial_coeff}
1548 @deffn {関数} multinomial_coeff (@var{a_1}, ..., @var{a_n})
1549 @deffnx {関数} multinomial_coeff ()
1551 多項係数を返します。
1553 @var{a_k}それぞれが非負の整数の時、
1554 多項係数は、
1555 @code{@var{a_1} + ... + @var{a_n}}個の別々のオブジェクトを
1556 @math{k}番目の枠の中に@var{a_k}の要素を持つ@math{n}個の枠に置く方法の数を与えます。
1558 一般に、@code{multinomial_coeff (@var{a_1}, ..., @var{a_n})}は
1559 @code{(@var{a_1} + ... + @var{a_n})!/(@var{a_1}! ... @var{a_n}!)}と同値です。
1561 @code{multinomial_coeff()} (引数なし)は1に評価されます。
1563 @code{minfactorial}は@code{multinomial_coeff}が返す値を整理することができます。
1565 例:
1567 @c ===beg===
1568 @c multinomial_coeff (1, 2, x);
1569 @c minfactorial (%);
1570 @c multinomial_coeff (-6, 2);
1571 @c minfactorial (%);
1572 @c ===end===
1573 @example
1574 (%i1) multinomial_coeff (1, 2, x);
1575 (x + 3)!
1576 (%o1) --------
1577 2 x!
1578 (%i2) minfactorial (%);
1579 (x + 1) (x + 2) (x + 3)
1580 (%o2) -----------------------
1581 2
1582 (%i3) multinomial_coeff (-6, 2);
1583 (- 4)!
1584 (%o3) --------
1585 2 (- 6)!
1586 (%i4) minfactorial (%);
1587 (%o4) 10
1588 @end example
1590 @opencatbox
1591 @category{Integers}
1592 @closecatbox
1594 @end deffn
1596 @anchor{num_distinct_partitions}
1597 @deffn {関数} num_distinct_partitions (@var{n})
1598 @deffnx {関数} num_distinct_partitions (@var{n}, list)
1600 @var{n}が非負の整数の時、
1601 @var{n}の異なる整数分割の数を返します。
1602 そうでなければ、@code{num_distinct_partitions}は名詞形を返します。
1604 @code{num_distinct_partitions(@var{n}, list)}は、
1605 1, 2, 3, ..., @var{n}の異なる分割の数のリストを返します。
1607 @var{n}の異なる分割は、
1608 @math{@var{n} = k_1 + ... + k_m}となるような
1609 異なる正の整数@math{k_1}, ..., @math{k_m}のリストです。
1611 例:
1613 @c ===beg===
1614 @c num_distinct_partitions (12);
1615 @c num_distinct_partitions (12, list);
1616 @c num_distinct_partitions (n);
1617 @c ===end===
1618 @example
1619 (%i1) num_distinct_partitions (12);
1620 (%o1) 15
1621 (%i2) num_distinct_partitions (12, list);
1622 (%o2) [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
1623 (%i3) num_distinct_partitions (n);
1624 (%o3) num_distinct_partitions(n)
1625 @end example
1627 @opencatbox
1628 @category{Integers}
1629 @closecatbox
1631 @end deffn
1633 @anchor{num_partitions}
1634 @deffn {関数} num_partitions (@var{n})
1635 @deffnx {関数} num_partitions (@var{n}, list)
1637 @var{n}が非負の整数の時、
1638 @var{n}の整数分割の数を返します。
1639 そうでなければ、@code{num_partitions}は名詞式を返します。
1641 @code{num_partitions(@var{n}, list)}は、
1642 1, 2, 3, ..., @var{n}の整数分割の数のリストを返します。
1644 非負の整数@var{n}に対して、
1645 @code{num_partitions(@var{n})}は
1646 @code{cardinality(integer_partitions(@var{n}))}と等しいです;
1647 しかしながら、@code{num_partitions}は、
1648 分割の集合を実際には構成しないので、はるかに速いです。
1650 例:
1652 @c ===beg===
1653 @c num_partitions (5) = cardinality (integer_partitions (5));
1654 @c num_partitions (8, list);
1655 @c num_partitions (n);
1656 @c ===end===
1657 @example
1658 (%i1) num_partitions (5) = cardinality (integer_partitions (5));
1659 (%o1) 7 = 7
1660 (%i2) num_partitions (8, list);
1661 (%o2) [1, 1, 2, 3, 5, 7, 11, 15, 22]
1662 (%i3) num_partitions (n);
1663 (%o3) num_partitions(n)
1664 @end example
1666 @opencatbox
1667 @category{Integers}
1668 @closecatbox
1670 @end deffn
1674 @anchor{partition_set}
1675 @deffn {関数} partition_set (@var{a}, @var{f})
1677 集合@var{a}を述語論理@var{f}に従って分割します。
1679 @code{partition_set}は２つの集合のリストを返します。
1680 最初の集合は
1681 @var{f}が@code{false}に評価される
1682 @var{a}の要素から成り、
1683 二番目は@var{a}の他の要素すべてから成ります。
1684 @code{partition_set}は
1685 @code{is}を@var{f}の戻り値に適用しません。
1687 もし@var{a}が集合リテラルなら
1688 @code{partition_set}は文句を言います。
1690 @code{subset}も参照してください。
1692 例:
1694 @c ===beg===
1695 @c partition_set ({2, 7, 1, 8, 2, 8}, evenp);
1696 @c partition_set ({x, rat(y), rat(y) + z, 1},
1697 @c lambda ([x], ratp(x)));
1698 @c ===end===
1699 @example
1700 (%i1) partition_set (@{2, 7, 1, 8, 2, 8@}, evenp);
1701 (%o1) [@{1, 7@}, @{2, 8@}]
1702 (%i2) partition_set (@{x, rat(y), rat(y) + z, 1@},
1703 lambda ([x], ratp(x)));
1704 (%o2)/R/ [@{1, x@}, @{y, y + z@}]
1705 @end example
1707 @opencatbox
1708 @category{Sets}
1709 @closecatbox
1711 @end deffn
1713 @anchor{permutations}
1714 @deffn {関数} permutations (@var{a})
1716 リストまたは集合@var{a}の元の異なる順列すべての集合を返します。
1717 順列それぞれは、集合でなくリストです。
1719 @var{a}がリストの時、
1720 @var{a}の重複した元が順列の中に含まれます。
1722 もし@var{a}がリストリテラルや集合リテラルでないなら、
1723 @code{permutations}は文句を言います。
1725 @code{random_permutation}も参照してください。
1727 例:
1729 @c ===beg===
1730 @c permutations ([a, a]);
1731 @c permutations ([a, a, b]);
1732 @c ===end===
1733 @example
1734 (%i1) permutations ([a, a]);
1735 (%o1) @{[a, a]@}
1736 (%i2) permutations ([a, a, b]);
1737 (%o2) @{[a, a, b], [a, b, a], [b, a, a]@}
1738 @end example
1740 @opencatbox
1741 @category{Sets}
1742 @category{Lists}
1743 @closecatbox
1745 @end deffn
1747 @anchor{powerset}
1748 @deffn {関数} powerset (@var{a})
1749 @deffnx {関数} powerset (@var{a}, @var{n})
1751 @var{a}の部分集合すべての集合、または、その集合の部分集合を返します。
1753 @code{powerset(@var{a})}は
1754 集合@var{a}の部分集合すべての集合を返します。
1755 @code{powerset(@var{a})}は@code{2^cardinality(@var{a})}個の元を持ちます。
1757 @code{powerset(@var{a}, @var{n})}は、
1758 濃度@var{n}を持つ@var{a}の部分集合すべての集合を返します。
1760 もし@var{a}が集合リテラルでないか、
1761 @var{n}が非負の整数でないなら、
1762 @code{powerset}は文句を言います。
1764 例:
1766 @c ===beg===
1767 @c powerset ({a, b, c});
1768 @c powerset ({w, x, y, z}, 4);
1769 @c powerset ({w, x, y, z}, 3);
1770 @c powerset ({w, x, y, z}, 2);
1771 @c powerset ({w, x, y, z}, 1);
1772 @c powerset ({w, x, y, z}, 0);
1773 @c ===end===
1774 @example
1775 (%i1) powerset (@{a, b, c@});
1776 (%o1) @{@{@}, @{a@}, @{a, b@}, @{a, b, c@}, @{a, c@}, @{b@}, @{b, c@}, @{c@}@}
1777 (%i2) powerset (@{w, x, y, z@}, 4);
1778 (%o2) @{@{w, x, y, z@}@}
1779 (%i3) powerset (@{w, x, y, z@}, 3);
1780 (%o3) @{@{w, x, y@}, @{w, x, z@}, @{w, y, z@}, @{x, y, z@}@}
1781 (%i4) powerset (@{w, x, y, z@}, 2);
1782 (%o4) @{@{w, x@}, @{w, y@}, @{w, z@}, @{x, y@}, @{x, z@}, @{y, z@}@}
1783 (%i5) powerset (@{w, x, y, z@}, 1);
1784 (%o5) @{@{w@}, @{x@}, @{y@}, @{z@}@}
1785 (%i6) powerset (@{w, x, y, z@}, 0);
1786 (%o6) @{@{@}@}
1787 @end example
1789 @opencatbox
1790 @category{Sets}
1791 @closecatbox
1793 @end deffn
1795 @deffn {関数} random_permutation (@var{a})
1797 クヌースのシャッフルアルゴリズムで構成されるような、
1798 集合またはリスト@var{a}のランダムな順列を返します。
1800 戻り値は、たとえ要素すべてが偶然同じでも
1801 引数とは別の新しいリストです。
1802 しかしながら、引数の要素はコピーされません。
1804 例:
1806 @c ===beg===
1807 @c random_permutation ([a, b, c, 1, 2, 3]);
1808 @c random_permutation ([a, b, c, 1, 2, 3]);
1809 @c random_permutation ({x + 1, y + 2, z + 3});
1810 @c random_permutation ({x + 1, y + 2, z + 3});
1811 @c ===end===
1812 @example
1813 (%i1) random_permutation ([a, b, c, 1, 2, 3]);
1814 (%o1) [c, 1, 2, 3, a, b]
1815 (%i2) random_permutation ([a, b, c, 1, 2, 3]);
1816 (%o2) [b, 3, 1, c, a, 2]
1817 (%i3) random_permutation (@{x + 1, y + 2, z + 3@});
1818 (%o3) [y + 2, z + 3, x + 1]
1819 (%i4) random_permutation (@{x + 1, y + 2, z + 3@});
1820 (%o4) [x + 1, y + 2, z + 3]
1821 @end example
1823 @opencatbox
1824 @category{Sets}
1825 @category{Lists}
1826 @closecatbox
1828 @end deffn
1830 @anchor{rreduce}
1831 @deffn {関数} rreduce (@var{F}, @var{s})
1832 @deffnx {関数} rreduce (@var{F}, @var{s}, @var{s_@{n + 1@}})
1834 合成によって二項関数@var{F}をn項関数に拡張します。
1835 ここで、@var{s}はリストです。
1837 @code{rreduce(@var{F}, @var{s})}は
1838 @code{F(s_1, ... F(s_@{n - 2@}, F(s_@{n - 1@}, s_n)))}を返します。
1839 オプション引数@var{s_@{n + 1@}}が存在する時、
1840 結果は、@code{rreduce(@var{F}, endcons(@var{s_@{n + 1@}}, @var{s}))}
1841 と同値です。
1843 関数@var{F}は、最初@i{rightmost}のリスト要素に適用されます。
1844 だから名前が"rreduce"です。
1846 @code{lreduce}, @code{tree_reduce}, @code{xreduce}も参照してください。
1848 例:
1850 オプション引数なしの@code{rreduce}。
1852 @c ===beg===
1853 @c rreduce (f, [1, 2, 3]);
1854 @c rreduce (f, [1, 2, 3, 4]);
1855 @c ===end===
1856 @example
1857 (%i1) rreduce (f, [1, 2, 3]);
1858 (%o1) f(1, f(2, 3))
1859 (%i2) rreduce (f, [1, 2, 3, 4]);
1860 (%o2) f(1, f(2, f(3, 4)))
1861 @end example
1863 オプション引数ありの@code{rreduce}。
1865 @c ===beg===
1866 @c rreduce (f, [1, 2, 3], 4);
1867 @c ===end===
1868 @example
1869 (%i1) rreduce (f, [1, 2, 3], 4);
1870 (%o1) f(1, f(2, f(3, 4)))
1871 @end example
1873 組み込み二項演算子に適用された@code{rreduce}。
1874 @code{/}は割り算演算子。
1876 @c ===beg===
1877 @c rreduce ("^", args ({a, b, c, d}));
1878 @c rreduce ("/", args ({a, b, c, d}));
1879 @c ===end===
1880 @example
1881 (%i1) rreduce ("^", args (@{a, b, c, d@}));
1882 d
1883 c
1884 b
1885 (%o1) a
1886 (%i2) rreduce ("/", args (@{a, b, c, d@}));
1887 a c
1888 (%o2) ---
1889 b d
1890 @end example
1892 @opencatbox
1893 @category{Lists}
1894 @closecatbox
1896 @end deffn
1898 @anchor{setdifference}
1899 @deffn {関数} setdifference (@var{a}, @var{b})
1901 集合@var{a}の中の、集合@var{b}にない要素を含む集合を返します。
1903 もし@var{a}か@var{b}が集合リテラルでないなら、
1904 @code{setdifference}は文句を言います。
1906 例:
1908 @c ===beg===
1909 @c S_1 : {a, b, c, x, y, z};
1910 @c S_2 : {aa, bb, c, x, y, zz};
1911 @c setdifference (S_1, S_2);
1912 @c setdifference (S_2, S_1);
1913 @c setdifference (S_1, S_1);
1914 @c setdifference (S_1, {});
1915 @c setdifference ({}, S_1);
1916 @c ===end===
1917 @example
1918 (%i1) S_1 : @{a, b, c, x, y, z@};
1919 (%o1) @{a, b, c, x, y, z@}
1920 (%i2) S_2 : @{aa, bb, c, x, y, zz@};
1921 (%o2) @{aa, bb, c, x, y, zz@}
1922 (%i3) setdifference (S_1, S_2);
1923 (%o3) @{a, b, z@}
1924 (%i4) setdifference (S_2, S_1);
1925 (%o4) @{aa, bb, zz@}
1926 (%i5) setdifference (S_1, S_1);
1927 (%o5) @{@}
1928 (%i6) setdifference (S_1, @{@});
1929 (%o6) @{a, b, c, x, y, z@}
1930 (%i7) setdifference (@{@}, S_1);
1931 (%o7) @{@}
1932 @end example
1934 @opencatbox
1935 @category{Sets}
1936 @closecatbox
1938 @end deffn
1940 @anchor{setequalp}
1941 @deffn {関数} setequalp (@var{a}, @var{b})
1943 集合@var{a}と@var{b}が同じ要素数を持ち、
1944 @c $SETEQUALP CALLS THE LISP FUNCTION LIKE,
1945 @c AND SO DOES THE CODE TO EVALUATE IS (X = Y).
1946 @code{listify}が決定した順序で考えて
1947 @var{a}の要素の中の@code{x}と
1948 @var{b}の要素の中の@code{y}に対して
1949 @code{is(@var{x} = @var{y})}が@code{true}なら、
1950 @code{true}を返します。
1951 そうでなければ、@code{setequalp}は@code{false}を返します。
1953 例:
1955 @c ===beg===
1956 @c setequalp ({1, 2, 3}, {1, 2, 3});
1957 @c setequalp ({a, b, c}, {1, 2, 3});
1958 @c setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
1959 @c ===end===
1960 @example
1961 (%i1) setequalp (@{1, 2, 3@}, @{1, 2, 3@});
1962 (%o1) true
1963 (%i2) setequalp (@{a, b, c@}, @{1, 2, 3@});
1964 (%o2) false
1965 (%i3) setequalp (@{x^2 - y^2@}, @{(x + y) * (x - y)@});
1966 (%o3) false
1967 @end example
1969 @opencatbox
1970 @category{Sets}
1971 @category{Predicate functions}
1972 @closecatbox
1974 @end deffn
1976 @anchor{setify}
1977 @deffn {関数} setify (@var{a})
1979 リスト@var{a}の要素から集合を構成します。
1980 リスト@var{a}の重複した要素は削除され、
1981 要素は、述語論理@code{orderlessp}に従って並び替えられます。
1983 もし@var{a}が集合リテラルでないなら、
1984 @code{setify}は文句を言います。
1986 例:
1988 @c ===beg===
1989 @c setify ([1, 2, 3, a, b, c]);
1990 @c setify ([a, b, c, a, b, c]);
1991 @c setify ([7, 13, 11, 1, 3, 9, 5]);
1992 @c ===end===
1993 @example
1994 (%i1) setify ([1, 2, 3, a, b, c]);
1995 (%o1) @{1, 2, 3, a, b, c@}
1996 (%i2) setify ([a, b, c, a, b, c]);
1997 (%o2) @{a, b, c@}
1998 (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
1999 (%o3) @{1, 3, 5, 7, 9, 11, 13@}
2000 @end example
2002 @opencatbox
2003 @category{Lists}
2004 @closecatbox
2006 @end deffn
2008 @anchor{setp}
2009 @deffn {関数} setp (@var{a})
2011 @var{a}がMaximaの集合の時だけ、@code{true}を返します。
2013 @code{setp}は、
2014 整理された集合はもちろん、未整理の集合(すなわち、冗長な元を持つ集合)に対して、
2015 @code{true}を返します。
2017 @c NOT SURE WE NEED TO MENTION THIS. OK FOR NOW
2018 @code{setp}はMaxima関数
2019 @code{setp(a) := not atom(a) and op(a) = 'set}
2020 と同値です。
2022 例:
2024 @c ===beg===
2025 @c simp : false;
2026 @c {a, a, a};
2027 @c setp (%);
2028 @c ===end===
2029 @example
2030 (%i1) simp : false;
2031 (%o1) false
2032 (%i2) @{a, a, a@};
2033 (%o2) @{a, a, a@}
2034 (%i3) setp (%);
2035 (%o3) true
2036 @end example
2038 @opencatbox
2039 @category{Sets}
2040 @category{Predicate functions}
2041 @closecatbox
2043 @end deffn
2045 @anchor{set_partitions}
2046 @deffn {関数} set_partitions (@var{a})
2047 @deffnx {関数} set_partitions (@var{a}, @var{n})
2049 @var{a}の分割すべての集合、または、その集合の部分集合を返します。
2051 @code{set_partitions(@var{a}, @var{n})}は
2052 @var{n}個の空でないばらばらの部分集合への
2053 @var{a}の分解すべての集合を返します。
2055 @code{set_partitions(@var{a})}は分割すべての集合を返します。
2057 @code{stirling2}は集合の分割の集合の濃度を返します。
2059 集合の集合@math{P}は
2061 @enumerate
2062 @item
2063 @math{P}の元それぞれが空でない集合
2064 @item
2065 @math{P}の別の元はばらばらである。
2066 @item
2067 @math{P}の元の和集合が@math{S}に等しい
2068 @end enumerate
2069 時、
2070 集合@math{S}の分割です。
2072 例:
2074 条件1と2が空ゆえに真なので、空集合はそれ自身の分割です。
2076 @c ===beg===
2077 @c set_partitions ({});
2078 @c ===end===
2079 @example
2080 (%i1) set_partitions (@{@});
2081 (%o1) @{@{@}@}
2082 @end example
2084 集合の分割の集合の濃度は、
2085 @code{stirling2}を使って見つけられます。
2087 @c ===beg===
2088 @c s: {0, 1, 2, 3, 4, 5}$
2089 @c p: set_partitions (s, 3)$
2090 @c cardinality(p) = stirling2 (6, 3);
2091 @c ===end===
2092 @example
2093 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2094 (%i2) p: set_partitions (s, 3)$
2095 (%i3) cardinality(p) = stirling2 (6, 3);
2096 (%o3) 90 = 90
2097 @end example
2099 @code{p}の元それぞれは
2100 @var{n} = 3個の元を持たなければいけません;
2101 チェックしましょう。
2103 @c ===beg===
2104 @c s: {0, 1, 2, 3, 4, 5}$
2105 @c p: set_partitions (s, 3)$
2106 @c map (cardinality, p);
2107 @c ===end===
2108 @example
2109 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2110 (%i2) p: set_partitions (s, 3)$
2111 (%i3) map (cardinality, p);
2112 (%o3) @{3@}
2113 @end example
2115 最後に、
2116 @code{p}の元それぞれに対して、
2117 元の和集合は@code{s}に等しくなければいけません;
2118 チェックしましょう。
2120 @c ===beg===
2121 @c s: {0, 1, 2, 3, 4, 5}$
2122 @c p: set_partitions (s, 3)$
2123 @c map (lambda ([x], apply (union, listify (x))), p);
2124 @c ===end===
2125 @example
2126 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2127 (%i2) p: set_partitions (s, 3)$
2128 (%i3) map (lambda ([x], apply (union, listify (x))), p);
2129 (%o3) @{@{0, 1, 2, 3, 4, 5@}@}
2130 @end example
2132 @opencatbox
2133 @category{Sets}
2134 @closecatbox
2136 @end deffn
2138 @anchor{some}
2139 @deffn {関数} some (@var{f}, @var{a})
2140 @deffnx {関数} some (@var{f}, @var{L_1}, ..., @var{L_n})
2142 もし与えられた引数のうち１つ以上で述語論理@var{f}が@code{true}なら
2143 @code{true}を返します。
2145 二番目の引数として集合１つが与えられたとして、
2146 もし
2147 @var{s}の中の１つ以上の@var{a_i}に対して
2148 @code{is(@var{f}(@var{a_i}))}が@code{true}を返すなら、
2149 @code{some(@var{f}, @var{s})}は@code{true}を返します。
2150 @code{some}は
2151 @var{s}の中の@var{a_i}すべてに対して
2152 @var{f}を評価するかどうかわかりません。
2153 集合は順序がないので、
2154 @code{some}は任意の順序で@code{@var{f}(@var{a_i})}評価するかもしれません。
2156 引数として２つ以上のリストが与えられたとして、
2157 @code{some(@var{f}, @var{L_1}, ..., @var{L_n})}は@code{true}を返します。
2158 もし
2159 @var{L_1}, ..., @var{L_n}それぞれの中の１つ以上の@var{x_1}, ..., @var{x_n}で
2160 @code{is(@var{f}(@var{x_1}, ..., @var{x_n}))}が@code{true}を返すなら、
2161 @code{some}は
2162 いくつかの組み合わせ@var{x_1}, ..., @var{x_n}に対して
2163 @var{f}を評価するかどうかわかりません。
2164 @code{some}はインデックスを増加する順序でリストを評価します。
2166 引数として空集合@code{@{@}}または空のリスト@code{[]}が与えられたとして、
2167 @code{some}は@code{false}を返します。
2169 グローバルフラグ@code{maperror}が@code{true}の時、
2170 すべてのリスト@var{L_1}, ..., @var{L_n}は同じ長さを持たなければいけません。
2171 @code{maperror}が@code{false}の時、
2172 リスト引数は、最短のリストの長さに効果的に切り詰められます。
2174 (@code{is}を介して)@code{true}か@code{false}以外の何かに評価される
2175 述語論理@var{f}の戻り値は、
2176 グローバルフラグ@code{prederror}によって決定されます。
2177 @code{prederror}が@code{true}の時、
2178 そんな値は@code{false}として扱われます。
2179 @code{prederror}が@code{false}の時、
2180 そんな値は@code{unknown}として扱われます。
2182 例:
2184 集合１つに適用された@code{some}。
2185 述語論理は引数１つの関数です。
2187 @c ===beg===
2188 @c some (integerp, {1, 2, 3, 4, 5, 6});
2189 @c some (atom, {1, 2, sin(3), 4, 5 + y, 6});
2190 @c ===end===
2191 @example
2192 (%i1) some (integerp, @{1, 2, 3, 4, 5, 6@});
2193 (%o1) true
2194 (%i2) some (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
2195 (%o2) true
2196 @end example
2198 ２つのリストに適用された@code{some}。
2199 述語論理は引数２つの関数です。
2201 @c ===beg===
2202 @c some ("=", [a, b, c], [a, b, c]);
2203 @c some ("#", [a, b, c], [a, b, c]);
2204 @c ===end===
2205 @example
2206 (%i1) some ("=", [a, b, c], [a, b, c]);
2207 (%o1) true
2208 (%i2) some ("#", [a, b, c], [a, b, c]);
2209 (%o2) false
2210 @end example
2212 @code{true}か@code{false}以外の何かに評価される述語論理@var{f}の戻り値は、
2213 グローバルフラグ@code{prederror}によって決定されます。
2215 @c ===beg===
2216 @c prederror : false;
2217 @c map (lambda ([a, b], is (a < b)), [x, y, z],
2218 @c [x^2, y^2, z^2]);
2219 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
2220 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
2221 @c prederror : true;
2222 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
2223 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
2224 @c ===end===
2225 @example
2226 (%i1) prederror : false;
2227 (%o1) false
2228 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
2229 [x^2, y^2, z^2]);
2230 (%o2) [unknown, unknown, unknown]
2231 (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
2232 (%o3) unknown
2233 (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
2234 (%o4) true
2235 (%i5) prederror : true;
2236 (%o5) true
2237 (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
2238 (%o6) false
2239 (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
2240 (%o7) true
2241 @end example
2243 @opencatbox
2244 @category{Sets}
2245 @category{Lists}
2246 @closecatbox
2248 @end deffn
2250 @anchor{stirling1}
2251 @deffn {関数} stirling1 (@var{n}, @var{m})
2253 第一種のスターリング数を表します。
2255 @var{n}と@var{m}が非負の整数の時、
2256 @code{stirling1 (@var{n}, @var{m})}の大きさは
2257 @var{m}個の巡回置換を持つ@var{n}個の元を持つ集合の順列の数です。
2258 詳細はGraham, Knuth and Patashnik @i{Concrete Mathematics}を参照してください。
2259 Maximaは、
2260 0より小さい@var{m}に対して
2261 @code{stirling1 (@var{n}, @var{m})}を定義するために
2262 再帰関係を使います;
2263 0より小さい@var{n}と非整数引数に対して未定義です。
2265 @code{stirling1}は整理関数です。
2266 Maximaは以下の恒等式を知っています。
2268 @c COPIED VERBATIM FROM SRC/NSET.LISP
2269 @enumerate
2270 @item
2271 @math{stirling1(0, n) = kron_delta(0, n)} (Ref. [1])
2272 @item
2273 @math{stirling1(n, n) = 1} (Ref. [1])
2274 @item
2275 @math{stirling1(n, n - 1) = binomial(n, 2)} (Ref. [1])
2276 @item
2277 @math{stirling1(n + 1, 0) = 0} (Ref. [1])
2278 @item
2279 @math{stirling1(n + 1, 1) = n!} (Ref. [1])
2280 @item
2281 @math{stirling1(n + 1, 2) = 2^n - 1} (Ref. [1])
2282 @end enumerate
2284 これらの恒等式は
2285 引数が、整数リテラルまたは整数と宣言されたシンボルで、かつ、
2286 最初の引数が非負の時、
2287 適用されます。
2288 @code{stirling1}は、非整数引数に対して整理しません。
2290 参考文献:
2292 [1] Donald Knuth, @i{The Art of Computer Programming,}
2293 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
2295 例:
2297 @c ===beg===
2298 @c declare (n, integer)$
2299 @c assume (n >= 0)$
2300 @c stirling1 (n, n);
2301 @c ===end===
2302 @example
2303 (%i1) declare (n, integer)$
2304 (%i2) assume (n >= 0)$
2305 (%i3) stirling1 (n, n);
2306 (%o3) 1
2307 @end example
2309 @code{stirling1}は非整数引数に対して整理しません。
2311 @c ===beg===
2312 @c stirling1 (sqrt(2), sqrt(2));
2313 @c ===end===
2314 @example
2315 (%i1) stirling1 (sqrt(2), sqrt(2));
2316 (%o1) stirling1(sqrt(2), sqrt(2))
2317 @end example
2319 Maximaは
2320 @code{stirling1}に恒等式を適用します。
2322 @c ===beg===
2323 @c declare (n, integer)$
2324 @c assume (n >= 0)$
2325 @c stirling1 (n + 1, n);
2326 @c stirling1 (n + 1, 1);
2327 @c ===end===
2328 @example
2329 (%i1) declare (n, integer)$
2330 (%i2) assume (n >= 0)$
2331 (%i3) stirling1 (n + 1, n);
2332 n (n + 1)
2333 (%o3) ---------
2334 2
2335 (%i4) stirling1 (n + 1, 1);
2336 (%o4) n!
2337 @end example
2339 @opencatbox
2340 @category{Integers}
2341 @closecatbox
2343 @end deffn
2345 @anchor{stirling2}
2346 @deffn {関数} stirling2 (@var{n}, @var{m})
2348 第二種スターリング数を表します。
2350 @var{n}と@var{m}が非負の整数の時、
2351 @code{stirling2 (@var{n}, @var{m})}は、
2352 濃度@var{n}の集合が@var{m}個のばらばらの部分集合に分割できる方法の数です。
2353 Maximaは、
2354 0より小さい@var{m}に対して
2355 @code{stirling2 (@var{n}, @var{m})}を定義するために
2356 再帰関係を使います;
2357 0より小さい@var{n}と非整数の引数に対して未定義です。
2359 @code{stirling2}は整理関数です。
2360 Maximaは以下の恒等式を知っています。
2362 @c COPIED VERBATIM FROM SRC/NSET.LISP
2363 @enumerate
2364 @item
2365 @math{stirling2(0, n) = kron_delta(0, n)} (Ref. [1])
2366 @item
2367 @math{stirling2(n, n) = 1} (Ref. [1])
2368 @item
2369 @math{stirling2(n, n - 1) = binomial(n, 2)} (Ref. [1])
2370 @item
2371 @math{stirling2(n + 1, 1) = 1} (Ref. [1])
2372 @item
2373 @math{stirling2(n + 1, 2) = 2^n - 1} (Ref. [1])
2374 @item
2375 @math{stirling2(n, 0) = kron_delta(n, 0)} (Ref. [2])
2376 @item
2377 @math{stirling2(n, m) = 0} when @math{m > n} (Ref. [2])
2378 @item
2379 @math{stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m!}
2380 when @math{m} and @math{n} are integers, and @math{n} is nonnegative. (Ref. [3])
2381 @end enumerate
2383 引数が整数リテラルまたは整数と宣言されたシンボルで、かつ、最初の引数が非負の時、
2384 これらの恒等式が適用されます。
2385 @code{stirling2}は非整数引数に対して整理されません。
2387 参考文献:
2389 [1] Donald Knuth. @i{The Art of Computer Programming},
2390 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
2392 [2] Graham, Knuth, and Patashnik. @i{Concrete Mathematics}, Table 264.
2394 [3] Abramowitz and Stegun. @i{Handbook of Mathematical Functions}, Section 24.1.4.
2396 例:
2398 @c ===beg===
2399 @c declare (n, integer)$
2400 @c assume (n >= 0)$
2401 @c stirling2 (n, n);
2402 @c ===end===
2403 @example
2404 (%i1) declare (n, integer)$
2405 (%i2) assume (n >= 0)$
2406 (%i3) stirling2 (n, n);
2407 (%o3) 1
2408 @end example
2410 @code{stirling2}は非整数引数に対して整理されません。
2412 @c ===beg===
2413 @c stirling2 (%pi, %pi);
2414 @c ===end===
2415 @example
2416 (%i1) stirling2 (%pi, %pi);
2417 (%o1) stirling2(%pi, %pi)
2418 @end example
2420 Maximaは
2421 @code{stirling2}に恒等式を適用します。
2423 @c ===beg===
2424 @c declare (n, integer)$
2425 @c assume (n >= 0)$
2426 @c stirling2 (n + 9, n + 8);
2427 @c stirling2 (n + 1, 2);
2428 @c ===end===
2429 @example
2430 (%i1) declare (n, integer)$
2431 (%i2) assume (n >= 0)$
2432 (%i3) stirling2 (n + 9, n + 8);
2433 (n + 8) (n + 9)
2434 (%o3) ---------------
2435 2
2436 (%i4) stirling2 (n + 1, 2);
2437 n
2438 (%o4) 2 - 1
2439 @end example
2441 @opencatbox
2442 @category{Integers}
2443 @closecatbox
2445 @end deffn
2447 @anchor{subset}
2448 @deffn {関数} subset (@var{a}, @var{f})
2450 述語論理@var{f}を満たす
2451 集合@var{a}の部分集合を返します。
2453 @code{subset}は、
2454 @var{f}が@code{false}以外の何かを返す、@var{a}の要素から成る集合を返します。
2455 @code{subset}は
2456 @code{is}を@var{f}の戻り値に適用しません。
2458 もし@var{a}が集合リテラルでないなら
2459 @code{subset}は文句を言います。
2461 @code{partition_set}も参照してください。
2463 例:
2465 @c ===beg===
2466 @c subset ({1, 2, x, x + y, z, x + y + z}, atom);
2467 @c subset ({1, 2, 7, 8, 9, 14}, evenp);
2468 @c ===end===
2469 @example
2470 (%i1) subset (@{1, 2, x, x + y, z, x + y + z@}, atom);
2471 (%o1) @{1, 2, x, z@}
2472 (%i2) subset (@{1, 2, 7, 8, 9, 14@}, evenp);
2473 (%o2) @{2, 8, 14@}
2474 @end example
2476 @opencatbox
2477 @category{Sets}
2478 @closecatbox
2480 @end deffn
2482 @anchor{subsetp}
2483 @deffn {関数} subsetp (@var{a}, @var{b})
2485 集合@var{a}が@var{b}の部分集合の時だけ、
2486 @code{true}を返します。
2488 もし@var{a}か@var{b}のいずれかが集合リテラルでないなら、
2489 @code{subsetp}は文句を言います。
2491 例:
2493 @c ===beg===
2494 @c subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
2495 @c subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
2496 @c ===end===
2497 @example
2498 (%i1) subsetp (@{1, 2, 3@}, @{a, 1, b, 2, c, 3@});
2499 (%o1) true
2500 (%i2) subsetp (@{a, 1, b, 2, c, 3@}, @{1, 2, 3@});
2501 (%o2) false
2502 @end example
2504 @opencatbox
2505 @category{Sets}
2506 @category{Predicate functions}
2507 @closecatbox
2509 @end deffn
2511 @anchor{symmdifference}
2512 @deffn {関数} symmdifference (@var{a_1}, @dots{}, @var{a_n})
2514 集合@var{a_1}, @dots{}, @var{a_n}の対称差を返します。
2516 ２つの引数が与えられたとして、
2517 @code{symmdifference ( @var{a}, @var{b})}は
2518 @code{union (setdifference ( @var{a}, @var{b}), setdifference (@var{b}, @var{a}))}と同じです。
2520 もし引数が集合リテラルでないなら、
2521 @code{symmdifference}は文句を言います。
2523 例:
2525 @c ===beg===
2526 @c S_1 : {a, b, c};
2527 @c S_2 : {1, b, c};
2528 @c S_3 : {a, b, z};
2529 @c symmdifference ();
2530 @c symmdifference (S_1);
2531 @c symmdifference (S_1, S_2);
2532 @c symmdifference (S_1, S_2, S_3);
2533 @c symmdifference ({}, S_1, S_2, S_3);
2534 @c ===end===
2535 @example
2536 (%i1) S_1 : @{a, b, c@};
2537 (%o1) @{a, b, c@}
2538 (%i2) S_2 : @{1, b, c@};
2539 (%o2) @{1, b, c@}
2540 (%i3) S_3 : @{a, b, z@};
2541 (%o3) @{a, b, z@}
2542 (%i4) symmdifference ();
2543 (%o4) @{@}
2544 (%i5) symmdifference (S_1);
2545 (%o5) @{a, b, c@}
2546 (%i6) symmdifference (S_1, S_2);
2547 (%o6) @{1, a@}
2548 (%i7) symmdifference (S_1, S_2, S_3);
2549 (%o7) @{1, b, z@}
2550 (%i8) symmdifference (@{@}, S_1, S_2, S_3);
2551 (%o8) @{1,b, z@}
2552 @end example
2554 @opencatbox
2555 @category{Sets}
2556 @closecatbox
2558 @end deffn
2560 @c TREE_REDUCE ACCEPTS A SET OR LIST AS AN ARGUMENT, BUT RREDUCE AND LREDUCE WANT ONLY LISTS; STRANGE
2561 @anchor{tree_reduce}
2562 @deffn {関数} tree_reduce (@var{F}, @var{s})
2563 @deffnx {関数} tree_reduce (@var{F}, @var{s}, @var{s_0})
2565 合成によって二項関数@var{F}をn項関数に拡張します。
2566 ここで@var{s}は集合かリストです。
2568 @code{tree_reduce}は以下と同値です:
2569 新しいリスト@code{[@var{F}(@var{s_1}, @var{s_2}), @var{F}(@var{s_3}, @var{s_4}), ...]}を形成するために
2570 @var{F}を要素の連続する対に適用します。
2571 もし奇数個の要素があるなら、
2572 最後の要素は変化なしに通過させます。
2573 そして、リストが１つの要素になるまで繰り返します。１つの要素になった時、それが戻り値です。
2575 オプションの引数@var{s_0}がある時，
2576 結果は
2577 @code{tree_reduce(@var{F}, cons(@var{s_0}, @var{s})}と同値です。
2579 浮動小数点数の足し算に関して、
2580 @code{tree_reduce}は、
2581 @code{rreduce}や@code{lreduce}よりも小さな丸め誤差を持つ和を返します。
2583 @var{s}の要素と部分的な結果は
2584 最小深度の二項木の中に配列されます。
2585 だから名前が"tree_reduce"です。
2587 例:
2589 偶数個の要素を持つリストに適用された@code{tree_reduce}。
2591 @c ===beg===
2592 @c tree_reduce (f, [a, b, c, d]);
2593 @c ===end===
2594 @example
2595 (%i1) tree_reduce (f, [a, b, c, d]);
2596 (%o1) f(f(a, b), f(c, d))
2597 @end example
2599 奇数個の要素を持つリストに適用された@code{tree_reduce}。
2601 @c ===beg===
2602 @c tree_reduce (f, [a, b, c, d, e]);
2603 @c ===end===
2604 @example
2605 (%i1) tree_reduce (f, [a, b, c, d, e]);
2606 (%o1) f(f(f(a, b), f(c, d)), e)
2607 @end example
2609 @opencatbox
2610 @category{Sets}
2611 @category{Lists}
2612 @closecatbox
2614 @end deffn
2616 @anchor{union}
2617 @deffn {関数} union (@var{a_1}, ..., @var{a_n})
2618 集合@var{a_1}から@var{a_n}の和集合を返します。
2620 @code{union()} (引数なし)は空集合を返します。
2622 もし引数が集合リテラルでないなら、
2623 @code{union}は文句を言います。
2625 例:
2627 @c ===beg===
2628 @c S_1 : {a, b, c + d, %e};
2629 @c S_2 : {%pi, %i, %e, c + d};
2630 @c S_3 : {17, 29, 1729, %pi, %i};
2631 @c union ();
2632 @c union (S_1);
2633 @c union (S_1, S_2);
2634 @c union (S_1, S_2, S_3);
2635 @c union ({}, S_1, S_2, S_3);
2636 @c ===end===
2637 @example
2638 (%i1) S_1 : @{a, b, c + d, %e@};
2639 (%o1) @{%e, a, b, d + c@}
2640 (%i2) S_2 : @{%pi, %i, %e, c + d@};
2641 (%o2) @{%e, %i, %pi, d + c@}
2642 (%i3) S_3 : @{17, 29, 1729, %pi, %i@};
2643 (%o3) @{17, 29, 1729, %i, %pi@}
2644 (%i4) union ();
2645 (%o4) @{@}
2646 (%i5) union (S_1);
2647 (%o5) @{%e, a, b, d + c@}
2648 (%i6) union (S_1, S_2);
2649 (%o6) @{%e, %i, %pi, a, b, d + c@}
2650 (%i7) union (S_1, S_2, S_3);
2651 (%o7) @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2652 (%i8) union (@{@}, S_1, S_2, S_3);
2653 (%o8) @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2654 @end example
2656 @opencatbox
2657 @category{Sets}
2658 @closecatbox
2660 @end deffn
2662 @c XREDUCE ACCEPTS A SET OR LIST AS AN ARGUMENT, BUT RREDUCE AND LREDUCE WANT ONLY LISTS; STRANGE
2663 @anchor{xreduce}
2664 @deffn {関数} xreduce (@var{F}, @var{s})
2665 @deffnx {関数} xreduce (@var{F}, @var{s}, @var{s_0})
2667 合成によって関数@var{F}をn項関数に拡張します。
2668 または、もし@var{F}が既にn項関数なら@var{F}を@var{s}に適用します。
2669 @var{F}がn項関数でない時、
2670 @code{xreduce}は@code{lreduce}と同じです。
2671 引数@var{s}はリストです。
2673 n項関数として知られている関数は、
2674 足し算@code{+}, 掛け算@code{*}, @code{and}, @code{or}, @code{max},
2675 @code{min}, @code{append}を含みます。
2676 関数は、
2677 @code{declare(@var{F}, nary)}によってもn項と宣言されるかもしれません。
2678 これらの関数に対して、
2679 @code{xreduce}は
2680 @code{rreduce}や@code{lreduce}よりも速いことが期待されます。
2682 オプション引数@var{s_0}がある時、
2683 結果は、@code{xreduce(@var{s}, cons(@var{s_0}, @var{s}))}と同値です。
2685 @c NOT SURE WHAT IS THE RELEVANCE OF THE FOLLOWING COMMENT
2686 @c MAXIMA IS NEVER SO CAREFUL ABOUT FLOATING POINT ASSOCIATIVITY SO FAR AS I KNOW
2687 浮動小数点の足し算は、厳密には結合的ではありません;
2688 そうはそうかもしれませんが、
2689 @var{s}が浮動小数点を含む時、
2690 @code{xreduce}はMaximaのn項足し算を適用します。
2692 例:
2694 n項と知られている関数に適用された@code{xreduce}。
2695 @code{F}は引数すべてで、一度コールされます。
2697 @c ===beg===
2698 @c declare (F, nary);
2699 @c F ([L]) := L;
2700 @c xreduce (F, [a, b, c, d, e]);
2701 @c ===end===
2702 @example
2703 (%i1) declare (F, nary);
2704 (%o1) done
2705 (%i2) F ([L]) := L;
2706 (%o2) F([L]) := L
2707 (%i3) xreduce (F, [a, b, c, d, e]);
2708 (%o3) [[[[[("[", simp), a], b], c], d], e]
2709 @end example
2711 n項とわかっていない関数に適用された@code{xreduce}。
2712 @code{G}は、
2713 毎回２つの引数で複数回コールされます。
2715 @c ===beg===
2716 @c G ([L]) := L;
2717 @c xreduce (G, [a, b, c, d, e]);
2718 @c lreduce (G, [a, b, c, d, e]);
2719 @c ===end===
2720 @example
2721 (%i1) G ([L]) := L;
2722 (%o1) G([L]) := L
2723 (%i2) xreduce (G, [a, b, c, d, e]);
2724 (%o2) [[[[[("[", simp), a], b], c], d], e]
2725 (%i3) lreduce (G, [a, b, c, d, e]);
2726 (%o3) [[[[a, b], c], d], e]
2727 @end example
2729 @opencatbox
2730 @category{Sets}
2731 @category{Lists}
2732 @closecatbox
2734 @end deffn