| blob | c3f935b50306685fe07b7e396597c7c49a949abb |
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} @category{Predicate functions}
661 @closecatbox
663 @end deffn
665 @anchor{divisors}
666 @deffn {関数} divisors (@var{n})
668 @var{n}の約数の集合を表します。
670 @var{n}がゼロでない整数の時、
671 @code{divisors(@var{n})}は整数の集合に整理されます。
672 約数の集合は元1と@var{n}を含みます。
673 負の整数の約数は、その絶対値の約数です。
675 @code{divisors}は、等式、リスト、行列、集合上に分配されます。
677 例:
679 28は完全数であることを検証できます:
680 (自身を除いた)約数が28です。
682 @c ===beg===
683 @c s: divisors(28);
684 @c lreduce ("+", args(s)) - 28;
685 @c ===end===
686 @example
687 (%i1) s: divisors(28);
688 (%o1) @{1, 2, 4, 7, 14, 28@}
689 (%i2) lreduce ("+", args(s)) - 28;
690 (%o2) 28
691 @end example
693 @code{divisors}は整理関数です。
694 @code{divisors(a)}の中で@code{a}に8を代入することは、
695 @code{divisors(8)}を再評価せずに約数をもたらします。
697 @c ===beg===
698 @c divisors (a);
699 @c subst (8, a, %);
700 @c ===end===
701 @example
702 (%i1) divisors (a);
703 (%o1) divisors(a)
704 (%i2) subst (8, a, %);
705 (%o2) @{1, 2, 4, 8@}
706 @end example
708 @code{divisors}は、等式、リスト、行列、集合上に分配されます。
710 @c ===beg===
711 @c divisors (a = b);
712 @c divisors ([a, b, c]);
713 @c divisors (matrix ([a, b], [c, d]));
714 @c divisors ({a, b, c});
715 @c ===end===
716 @example
717 (%i1) divisors (a = b);
718 (%o1) divisors(a) = divisors(b)
719 (%i2) divisors ([a, b, c]);
720 (%o2) [divisors(a), divisors(b), divisors(c)]
721 (%i3) divisors (matrix ([a, b], [c, d]));
722 [ divisors(a) divisors(b) ]
723 (%o3) [ ]
724 [ divisors(c) divisors(d) ]
725 (%i4) divisors (@{a, b, c@});
726 (%o4) @{divisors(a), divisors(b), divisors(c)@}
727 @end example
729 @opencatbox
730 @category{Integers}
731 @closecatbox
733 @end deffn
735 @anchor{elementp}
736 @deffn {関数} elementp (@var{x}, @var{a})
737 @var{x}が集合@var{a}の元の時だけ@code{true}を返します。
739 もし@var{a}が集合リテラルでないなら、
740 @code{elementp}は文句を言います。
742 例:
744 @c ===beg===
745 @c elementp (sin(1), {sin(1), sin(2), sin(3)});
746 @c elementp (sin(1), {cos(1), cos(2), cos(3)});
747 @c ===end===
748 @example
749 (%i1) elementp (sin(1), @{sin(1), sin(2), sin(3)@});
750 (%o1) true
751 (%i2) elementp (sin(1), @{cos(1), cos(2), cos(3)@});
752 (%o2) false
753 @end example
755 @opencatbox
756 @category{Sets} @category{Predicate functions}
757 @closecatbox
759 @end deffn
761 @anchor{emptyp}
762 @deffn {関数} emptyp (@var{a})
764 @var{a}が空の集合か空のリストの時だけ、@code{true}を返します。
766 例:
768 @c ===beg===
769 @c map (emptyp, [{}, []]);
770 @c map (emptyp, [a + b, {{}}, %pi]);
771 @c ===end===
772 @example
773 (%i1) map (emptyp, [@{@}, []]);
774 (%o1) [true, true]
775 (%i2) map (emptyp, [a + b, @{@{@}@}, %pi]);
776 (%o2) [false, false, false]
777 @end example
779 @opencatbox
780 @category{Sets} @category{Predicate functions}
781 @closecatbox
783 @end deffn
785 @anchor{equiv_classes}
786 @deffn {関数} equiv_classes (@var{s}, @var{F})
787 集合@var{s}の
788 同値関係@var{F}に関する
789 同値クラスの集合を返します。
791 @var{F}は@var{s}の@var{s}との直積集合上の２変数関数です。
792 The return value of
793 @var{F}の戻り値は、@code{true}か@code{false}、もしくは、
794 @code{is(@var{expr})}が@code{true}か@code{false}のような
795 式@var{expr}です。
797 @var{F}が同値関数でない時、
798 @code{equiv_classes}は不平なくそれを受け入れますが、
799 その場合、結果は、一般に正しくありません。
801 @c EXCESSIVE DETAIL HERE. PROBABLY JUST CUT THIS
802 @c @var{F} may be a relational operator (built-in or user-defined),
803 @c an ordinary Maxima function, a Lisp function, a lambda expression,
804 @c a macro, or a subscripted function.
806 例:
808 同値関係が
809 @code{true}か@code{false}を返すラムダ式です。
811 @c ===beg===
812 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
813 @c lambda ([x, y], is (equal (x, y))));
814 @c ===end===
815 @example
816 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@},
817 lambda ([x, y], is (equal (x, y))));
818 (%o1) @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
819 @end example
821 同値関係が、@code{is}が@code{true}か@code{false}に評価される
822 関係関数の名前です。
824 @c ===beg===
825 @c equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
826 @c ===end===
827 @example
828 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@}, equal);
829 (%o1) @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
830 @end example
832 同値クラスが3の倍数だけ違う数です。
834 @c ===beg===
835 @c equiv_classes ({1, 2, 3, 4, 5, 6, 7},
836 @c lambda ([x, y], remainder (x - y, 3) = 0));
837 @c ===end===
838 @example
839 (%i1) equiv_classes (@{1, 2, 3, 4, 5, 6, 7@},
840 lambda ([x, y], remainder (x - y, 3) = 0));
841 (%o1) @{@{1, 4, 7@}, @{2, 5@}, @{3, 6@}@}
842 @end example
844 @opencatbox
845 @category{Sets}
846 @closecatbox
848 @end deffn
850 @anchor{every}
851 @deffn {関数} every (@var{f}, @var{s})
852 @deffnx {関数} every (@var{f}, @var{L_1}, ..., @var{L_n})
854 もし述語論理@var{f}が与えられた引数すべてで@code{true}なら、
855 @code{true}を返します。
857 ある集合が二番目の引数として与えられたとして、
858 もし@code{is(@var{f}(@var{a_i}))}が
859 @var{s}の中の@var{a_i}すべてに関して
860 @code{true}を返すなら
861 @code{every(@var{f}, @var{s})}は@code{true}です。
862 @code{every}は、
863 @var{s}の中の@var{a_i}すべてに関して@var{f}を評価するかもしれないししないかもしれません。
864 集合は順序付けされていないので、
865 @code{every}は任意の順序で@code{@var{f}(@var{a_i})}を評価します。
867 非キスとして１つか複数のリストが与えられたとして、
868 もし@code{is(@var{f}(@var{x_1}, ..., @var{x_n}))}が
869 @var{L_1}, ..., @var{L_n}それぞれの中の@var{x_1}, ..., @var{x_n}すべてに対して
870 @code{true}を返すなら、
871 @code{every(@var{f}, @var{L_1}, ..., @var{L_n})}は@code{true}を返します。
872 @code{every}は、
873 @var{x_1}, ..., @var{x_n}のすべての組み合わせに対して@var{f}を評価するかもしれないししないかもしれません。
874 @code{every}はインデックスを増やす順序でリストを評価します。
876 空の集合@code{@{@}}または空のリスト@code{[]}が引数として与えられたとして、
877 @code{every}は@code{false}を返します。
879 グローバルフラグ@code{maperror}が@code{true}の時、
880 リスト@var{L_1}, ..., @var{L_n}すべては等しい長さを持たなければいけません。
881 @code{maperror}が@code{false}の時、
882 リスト引数は、最短のリストの長さに効果的に切り詰められます。
884 (@code{is}を介して)
885 @code{true}か@code{false}以外の何かに評価される述語論理@var{f}の戻り値は、
886 @code{prederror}によって決定されます。
887 @code{prederror}が@code{true}の時、
888 そんな値は@code{false}として扱われ、
889 @code{every}の戻り値は@code{false}です。
890 @code{prederror}が@code{false}の時、
891 そんな値は@code{unknown}として扱われ、
892 @code{every}の戻り値は@code{unknown}です。
894 例:
896 １つの集合に適用された@code{every}。
897 述語論理は１引数関数です。
899 @c ===beg===
900 @c every (integerp, {1, 2, 3, 4, 5, 6});
901 @c every (atom, {1, 2, sin(3), 4, 5 + y, 6});
902 @c ===end===
903 @example
904 (%i1) every (integerp, @{1, 2, 3, 4, 5, 6@});
905 (%o1) true
906 (%i2) every (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
907 (%o2) false
908 @end example
910 ２つのリストに適用された@code{every}。
911 述語論理は２引数関数です。
913 @c ===beg===
914 @c every ("=", [a, b, c], [a, b, c]);
915 @c every ("#", [a, b, c], [a, b, c]);
916 @c ===end===
917 @example
918 (%i1) every ("=", [a, b, c], [a, b, c]);
919 (%o1) true
920 (%i2) every ("#", [a, b, c], [a, b, c]);
921 (%o2) false
922 @end example
924 @code{true}か@code{false}以外の何かに評価される
925 述語論理@var{f}の戻り値は、
926 グローバルフラグ@code{prederror}によって決定されます。
928 @c ===beg===
929 @c prederror : false;
930 @c map (lambda ([a, b], is (a < b)), [x, y, z],
931 @c [x^2, y^2, z^2]);
932 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
933 @c prederror : true;
934 @c every ("<", [x, y, z], [x^2, y^2, z^2]);
935 @c ===end===
936 @example
937 (%i1) prederror : false;
938 (%o1) false
939 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
940 [x^2, y^2, z^2]);
941 (%o2) [unknown, unknown, unknown]
942 (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
943 (%o3) unknown
944 (%i4) prederror : true;
945 (%o4) true
946 (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
947 (%o5) false
948 @end example
950 @opencatbox
951 @category{Sets}
952 @closecatbox
954 @end deffn
956 @anchor{extremal_subset}
957 @deffn {関数} extremal_subset (@var{s}, @var{f}, max)
958 @deffnx {関数} extremal_subset (@var{s}, @var{f}, min)
960 関数@var{f}が最大または最小値を取る、
961 @var{s}の部分集合を返します。
963 @code{extremal_subset(@var{s}, @var{f}, max)}は、
964 実数値関数@var{f}が最大値を取る、
965 集合またはリスト@var{s}の部分集合を返します。
967 @code{extremal_subset(@var{s}, @var{f}, min)}は、
968 実数値関数@var{f}が最小値を取る、
969 集合またはリスト@var{s}の部分集合を返します。
971 例:
973 @c ===beg===
974 @c extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
975 @c extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
976 @c ===end===
977 @example
978 (%i1) extremal_subset (@{-2, -1, 0, 1, 2@}, abs, max);
979 (%o1) @{- 2, 2@}
980 (%i2) extremal_subset (@{sqrt(2), 1.57, %pi/2@}, sin, min);
981 (%o2) @{sqrt(2)@}
982 @end example
984 @opencatbox
985 @category{Sets}
986 @closecatbox
988 @end deffn
990 @anchor{flatten}
991 @deffn {関数} flatten (@var{expr})
993 @var{expr}と同じ演算子を持つ部分式の引数を集め、
994 これらの集めた引数から式を構成します。
996 @code{expr}の主演算子と違った演算子の部分式は、
997 たとえそれらが、逆に@code{expr}に関するものと同じ演算子の部分式を含んだとしても、
998 変更なしにコピーされます。
1000 引数の数が演算子に関して宣言された引数と違う
1001 式を@code{flatten}が構成する可能性があるかもしれません;
1002 これは、整理器や評価器からのエラーメッセージを起こさせるかもしれません。
1003 @code{flatten}はそんな状況を検出しようとしません。
1005 特別な表現の式、例えば、標準有理式(CRE)、はflattenできません;
1006 そんな場合、@code{flatten}は引数を変更なしに返します。
1008 例:
1010 リストに適用すると、@code{flatten}はリストの要素すべてを集めます。
1012 @c ===beg===
1013 @c flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
1014 @c ===end===
1015 @example
1016 (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
1017 (%o1) [a, b, c, d, e, f, g, h, i, j]
1018 @end example
1020 集合に適用すると、@code{flatten}は集合の元すべてを集めます。
1022 @c ===beg===
1023 @c flatten ({a, {b}, {{c}}});
1024 @c flatten ({a, {[a], {a}}});
1025 @c ===end===
1026 @example
1027 (%i1) flatten (@{a, @{b@}, @{@{c@}@}@});
1028 (%o1) @{a, b, c@}
1029 (%i2) flatten (@{a, @{[a], @{a@}@}@});
1030 (%o2) @{a, [a]@}
1031 @end example
1033 @code{flatten}は、主演算子をn項に宣言する効果に似ています。
1034 しかしながら、@code{flatten}は、
1035 主演算子と違う演算子を持つ部分式上に影響を持ちません。
1036 一方、n項宣言はそれらに影響します。
1038 @c ===beg===
1039 @c expr: flatten (f (g (f (f (x)))));
1040 @c declare (f, nary);
1041 @c ev (expr);
1042 @c ===end===
1043 @example
1044 (%i1) expr: flatten (f (g (f (f (x)))));
1045 (%o1) f(g(f(f(x))))
1046 (%i2) declare (f, nary);
1047 (%o2) done
1048 (%i3) ev (expr);
1049 (%o3) f(g(f(x)))
1050 @end example
1052 @code{flatten}は、他の任意の演算子と同じように添字付き関数を扱います。
1054 @c ===beg===
1055 @c flatten (f[5] (f[5] (x, y), z));
1056 @c ===end===
1057 @example
1058 (%i1) flatten (f[5] (f[5] (x, y), z));
1059 (%o1) f (x, y, z)
1060 5
1061 @end example
1063 引数の数が演算子に関して宣言された引数と違う
1064 式を@code{flatten}が構成する可能性があるかもしれません;
1066 @c ===beg===
1067 @c 'mod (5, 'mod (7, 4));
1068 @c flatten (%);
1069 @c ''%, nouns;
1070 @c ===end===
1071 @example
1072 (%i1) 'mod (5, 'mod (7, 4));
1073 (%o1) mod(5, mod(7, 4))
1074 (%i2) flatten (%);
1075 (%o2) mod(5, 7, 4)
1076 (%i3) ''%, nouns;
1077 Wrong number of arguments to mod
1078 -- an error. Quitting. To debug this try debugmode(true);
1079 @end example
1081 @opencatbox
1082 @category{Sets} @category{Lists}
1083 @closecatbox
1085 @end deffn
1087 @anchor{full_listify}
1088 @deffn {関数} full_listify (@var{a})
1089 @var{a}の中のすべての集合演算子をリスト演算子で置き換え、
1090 結果を返します。
1091 @code{full_listify}は、
1092 たとえ主演算子が@code{set}でなくても
1093 入れ子の部分式の中の集合演算子を置き換えます。
1095 @code{listify}は主演算子だけを置き換えます。
1097 例:
1099 @c ===beg===
1100 @c full_listify ({a, b, {c, {d, e, f}, g}});
1101 @c full_listify (F (G ({a, b, H({c, d, e})})));
1102 @c ===end===
1103 @example
1104 (%i1) full_listify (@{a, b, @{c, @{d, e, f@}, g@}@});
1105 (%o1) [a, b, [c, [d, e, f], g]]
1106 (%i2) full_listify (F (G (@{a, b, H(@{c, d, e@})@})));
1107 (%o2) F(G([a, b, H([c, d, e])]))
1108 @end example
1110 @opencatbox
1111 @category{Sets}
1112 @closecatbox
1114 @end deffn
1116 @anchor{fullsetify}
1117 @deffn {関数} fullsetify (@var{a})
1118 @var{a}がリストの時、
1119 リスト演算子を集合演算子で置き換え、
1120 @code{fullsetify}を集合であるメンバーそれぞれに適用します。
1121 @var{a}がリストでない時、変更なしで返します。
1123 @code{setify}は主演算子だけを置き換えます。
1125 例:
1128 @code{f([b])}の主演算子はリストでないので、
1129 行@code{(%o2)}で、
1130 @code{f}の引数は集合に変換されません。
1132 @c ===beg===
1133 @c fullsetify ([a, [a]]);
1134 @c fullsetify ([a, f([b])]);
1135 @c ===end===
1136 @example
1137 (%i1) fullsetify ([a, [a]]);
1138 (%o1) @{a, @{a@}@}
1139 (%i2) fullsetify ([a, f([b])]);
1140 (%o2) @{a, f([b])@}
1141 @end example
1143 @opencatbox
1144 @category{Lists}
1145 @closecatbox
1147 @end deffn
1149 @anchor{identity}
1150 @deffn {関数} identity (@var{x})
1152 任意の引数@var{x}に対して@var{x}を返します。
1154 例:
1156 @code{identity}は、
1157 引数が既にブーリアン値の時、
1158 述語論理として使うことができます。
1160 @c ===beg===
1161 @c every (identity, [true, true]);
1162 @c ===end===
1163 @example
1164 (%i1) every (identity, [true, true]);
1165 (%o1) true
1166 @end example
1167 @end deffn
1169 @anchor{integer_partitions}
1170 @deffn {関数} integer_partitions (@var{n})
1171 @deffnx {関数} integer_partitions (@var{n}, @var{len})
1173 @var{n}の整数分割を返します。
1174 すなわち、和が@var{n}になる整数のリストです。
1176 @code{integer_partitions(@var{n})}は、
1177 整数@var{n}の分割すべての集合を返します。
1178 分割それぞれは、大きい順に並べられたリストです。
1180 @code{integer_partitions(@var{n}, @var{len})}は、
1181 長さ@var{len}以下の分割すべてを返します;
1182 この場合、
1183 @var{len}より少ない項を持つ分割それぞれには、
1184 厳密に@var{len}項持つ分割にするように、ゼロが足されます。
1185 分割それぞれは、大きい順に並べられたリストです。
1187 リスト@math{[a_1, ..., a_m]}は、
1188 (1) @math{a_i}それぞれが非ゼロ整数、かつ、
1189 (2) @math{a_1 + ... + a_m = n.}
1190 の時、非負整数@math{n}の分割です。
1191 従って0は分割を持ちません。
1193 例:
1195 @c ===beg===
1196 @c integer_partitions (3);
1197 @c s: integer_partitions (25)$
1198 @c cardinality (s);
1199 @c map (lambda ([x], apply ("+", x)), s);
1200 @c integer_partitions (5, 3);
1201 @c integer_partitions (5, 2);
1202 @c ===end===
1203 @example
1204 (%i1) integer_partitions (3);
1205 (%o1) @{[1, 1, 1], [2, 1], [3]@}
1206 (%i2) s: integer_partitions (25)$
1207 (%i3) cardinality (s);
1208 (%o3) 1958
1209 (%i4) map (lambda ([x], apply ("+", x)), s);
1210 (%o4) @{25@}
1211 (%i5) integer_partitions (5, 3);
1212 (%o5) @{[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]@}
1213 (%i6) integer_partitions (5, 2);
1214 (%o6) @{[3, 2], [4, 1], [5, 0]@}
1215 @end example
1217 条件を満たす分割すべてを見つけるには、
1218 関数@code{subset}を使ってください;
1219 以下は素数から成る10の分割すべてを見つける例です。
1221 @c ===beg===
1222 @c s: integer_partitions (10)$
1223 @c cardinality (s);
1224 @c xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1225 @c subset (s, lambda ([x], every (xprimep, x)));
1226 @c ===end===
1227 @example
1228 (%i1) s: integer_partitions (10)$
1229 (%i2) cardinality (s);
1230 (%o2) 42
1231 (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
1232 (%i4) subset (s, lambda ([x], every (xprimep, x)));
1233 (%o4) @{[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]@}
1234 @end example
1236 @opencatbox
1237 @category{Integers}
1238 @closecatbox
1240 @end deffn
1242 @anchor{intersect}
1243 @deffn {関数} intersect (@var{a_1}, ..., @var{a_n})
1245 @code{intersect}は、以下に見る@code{intersection}と同じです。
1247 @opencatbox
1248 @category{Sets}
1249 @closecatbox
1251 @end deffn
1253 @anchor{intersection}
1254 @deffn {関数} intersection (@var{a_1}, ..., @var{a_n})
1255 集合@var{a_1}から@var{a_n}までに共通な
1256 要素を含む
1257 集合を返します。
1259 もし引数のいずれかが集合リテラルでないなら、
1260 @code{intersection}は文句を言います。
1262 例:
1264 @c ===beg===
1265 @c S_1 : {a, b, c, d};
1266 @c S_2 : {d, e, f, g};
1267 @c S_3 : {c, d, e, f};
1268 @c S_4 : {u, v, w};
1269 @c intersection (S_1, S_2);
1270 @c intersection (S_2, S_3);
1271 @c intersection (S_1, S_2, S_3);
1272 @c intersection (S_1, S_2, S_3, S_4);
1273 @c ===end===
1274 @example
1275 (%i1) S_1 : @{a, b, c, d@};
1276 (%o1) @{a, b, c, d@}
1277 (%i2) S_2 : @{d, e, f, g@};
1278 (%o2) @{d, e, f, g@}
1279 (%i3) S_3 : @{c, d, e, f@};
1280 (%o3) @{c, d, e, f@}
1281 (%i4) S_4 : @{u, v, w@};
1282 (%o4) @{u, v, w@}
1283 (%i5) intersection (S_1, S_2);
1284 (%o5) @{d@}
1285 (%i6) intersection (S_2, S_3);
1286 (%o6) @{d, e, f@}
1287 (%i7) intersection (S_1, S_2, S_3);
1288 (%o7) @{d@}
1289 (%i8) intersection (S_1, S_2, S_3, S_4);
1290 (%o8) @{@}
1291 @end example
1293 @opencatbox
1294 @category{Sets}
1295 @closecatbox
1297 @end deffn
1299 @deffn {関数} kron_delta (@var{x}, @var{y}, @dots{}, @var{xp})
1301 クロネッカーのデルタ関数を表します。
1303 @code{kron_delta}は、
1304 @var{xi}と@var{yj}が引数のすべての対で等しい時
1305 1に整理され、
1306 @var{xi}と@var{yj}が引数のある対で等しくない時
1307 0に整理されます。
1308 等号は@code{is(equal(xi,j))}を使って決定され、
1309 不等号は@code{is(notsqual(xi,xj))}を使って決定されます。
1310 厳密に1つの引数に対して、@code{kron_delta}はエラーをシグナルします。
1312 例:
1314 @c ===beg===
1315 @c kron_delta(a,a);
1316 @c kron_delta(a,b,a,b);
1317 @c kron_delta(a,a,b,a+1);
1318 @c assume(equal(x,y));
1319 @c kron_delta(x,y);
1320 @c ===end===
1321 @example
1322 (%i1) kron_delta(a,a);
1323 (%o1) 1
1324 (%i2) kron_delta(a,b,a,b);
1325 (%o2) kron_delta(a, b)
1326 (%i3) kron_delta(a,a,b,a+1);
1327 (%o3) 0
1328 (%i4) assume(equal(x,y));
1329 (%o4) [equal(x, y)]
1330 (%i5) kron_delta(x,y);
1331 (%o5) 1
1332 @end example
1335 @end deffn
1337 @anchor{listify}
1338 @deffn {関数} listify (@var{a})
1340 @var{a}が集合の時、
1341 @var{a}の元を含む
1342 リストを返します。
1343 そうでなければ、@code{listify}は@var{a}を返します。
1345 @code{full_listify}は
1346 @var{a}の中の集合演算子をリスト演算子に置き換えます。
1348 例:
1350 @c ===beg===
1351 @c listify ({a, b, c, d});
1352 @c listify (F ({a, b, c, d}));
1353 @c ===end===
1354 @example
1355 (%i1) listify (@{a, b, c, d@});
1356 (%o1) [a, b, c, d]
1357 (%i2) listify (F (@{a, b, c, d@}));
1358 (%o2) F(@{a, b, c, d@})
1359 @end example
1361 @opencatbox
1362 @category{Sets}
1363 @closecatbox
1365 @end deffn
1367 @anchor{lreduce}
1368 @deffn {関数} lreduce (@var{F}, @var{s})
1369 @deffnx {関数} lreduce (@var{F}, @var{s}, @var{s_0})
1371 二項関数@var{F}を合成によってn項関数に拡張します。
1372 ここで@var{s}はリストです。
1374 @code{lreduce(@var{F}, @var{s})}は@code{F(... F(F(s_1, s_2), s_3), ... s_n)}を返します。
1376 オプション引数@var{s_0}が存在する時、
1377 結果は@code{lreduce(@var{F}, cons(@var{s_0}, @var{s}))}と同値です。
1379 関数@var{F}は、最初の@i{leftmost}の元に適用されます。
1380 だから、"lreduce"と名付けられています。
1382 @code{rreduce}, @code{xreduce}, @code{tree_reduce}も参照してください。
1384 例:
1386 オプション引数なしの@code{lreduce}。
1388 @c ===beg===
1389 @c lreduce (f, [1, 2, 3]);
1390 @c lreduce (f, [1, 2, 3, 4]);
1391 @c ===end===
1392 @example
1393 (%i1) lreduce (f, [1, 2, 3]);
1394 (%o1) f(f(1, 2), 3)
1395 (%i2) lreduce (f, [1, 2, 3, 4]);
1396 (%o2) f(f(f(1, 2), 3), 4)
1397 @end example
1399 オプション引数ありの@code{lreduce}。
1401 @c ===beg===
1402 @c lreduce (f, [1, 2, 3], 4);
1403 @c ===end===
1404 @example
1405 (%i1) lreduce (f, [1, 2, 3], 4);
1406 (%o1) f(f(f(4, 1), 2), 3)
1407 @end example
1409 組み込み二項演算子に適用された@code{lreduce}。
1410 @code{/}は割り算演算子。
1412 @c ===beg===
1413 @c lreduce ("^", args ({a, b, c, d}));
1414 @c lreduce ("/", args ({a, b, c, d}));
1415 @c ===end===
1416 @example
1417 (%i1) lreduce ("^", args (@{a, b, c, d@}));
1418 b c d
1419 (%o1) ((a ) )
1420 (%i2) lreduce ("/", args (@{a, b, c, d@}));
1421 a
1422 (%o2) -----
1423 b c d
1424 @end example
1426 @opencatbox
1427 @category{Lists}
1428 @closecatbox
1430 @end deffn
1432 @anchor{makeset}
1433 @deffn {関数} makeset (@var{expr}, @var{x}, @var{s})
1435 式@var{expr}から生成された元を持つ集合を返します。
1436 ここで、@var{x}は@var{expr}の中の変数のリストであり、
1437 @var{s}はリストの集合かリストです。
1438 集合の元それぞれを生成するために、
1439 @var{expr}は、
1440 @var{s}の元に並列にバインドされた変数@var{x}で評価されます。
1442 @var{s}の元それぞれは
1443 @var{x}と同じ長さを持たなければいけません。
1444 変数@var{x}のリストは、添字の付かないシンボルのリストでなければいけません。
1445 たとえシンボルが１つしかない場合でも、@var{x}は１要素のリストでなければいけなく、
1446 @var{s}の元それぞれは１要素のリストでなければいけません。
1448 @c FOLLOWING EQUIVALENT EXPRESSION IS REALLY TOO COMPLICATED, JUST SKIP IT FOR NOW
1449 @c @code{makeset(@var{expr}, @var{x}, @var{s})} returns the same result as
1450 @c @code{setify(map(lambda([L], sublis(map("=", ''@var{x}, L), ''@var{expr})), args(@var{s})))}.
1452 @code{makelist}も参照してください。
1454 例:
1456 @c ===beg===
1457 @c makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1458 @c S : {x, y, z}$
1459 @c S3 : cartesian_product (S, S, S);
1460 @c makeset (i + j + k, [i, j, k], S3);
1461 @c makeset (sin(x), [x], {[1], [2], [3]});
1462 @c ===end===
1463 @example
1464 (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1465 1 2 3 4
1466 (%o1) @{-, -, -, -@}
1467 a b c d
1468 (%i2) S : @{x, y, z@}$
1469 (%i3) S3 : cartesian_product (S, S, S);
1470 (%o3) @{[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
1471 [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
1472 [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
1473 [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
1474 [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
1475 [z, z, y], [z, z, z]@}
1476 (%i4) makeset (i + j + k, [i, j, k], S3);
1477 (%o4) @{3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
1478 z + 2 y, 2 z + x, 2 z + y@}
1479 (%i5) makeset (sin(x), [x], @{[1], [2], [3]@});
1480 (%o5) @{sin(1), sin(2), sin(3)@}
1481 @end example
1483 @opencatbox
1484 @category{Sets}
1485 @closecatbox
1487 @end deffn
1489 @anchor{moebius}
1490 @deffn {関数} moebius (@var{n})
1492 メビウス関数を表します。
1494 @var{n}が@math{k}個の異なる素数の積の時、
1495 @code{moebius(@var{n})}は@math{(-1)^k}に整理されます;
1496 @math{@var{n} = 1}の時、1に整理されます;
1497 他の正の数すべてに対して、0に整理されます。
1499 @code{moebius}は等式、リスト、行列、集合上に分配されます。
1501 例:
1503 @c ===beg===
1504 @c moebius (1);
1505 @c moebius (2 * 3 * 5);
1506 @c moebius (11 * 17 * 29 * 31);
1507 @c moebius (2^32);
1508 @c moebius (n);
1509 @c moebius (n = 12);
1510 @c moebius ([11, 11 * 13, 11 * 13 * 15]);
1511 @c moebius (matrix ([11, 12], [13, 14]));
1512 @c moebius ({21, 22, 23, 24});
1513 @c ===end===
1514 @example
1515 (%i1) moebius (1);
1516 (%o1) 1
1517 (%i2) moebius (2 * 3 * 5);
1518 (%o2) - 1
1519 (%i3) moebius (11 * 17 * 29 * 31);
1520 (%o3) 1
1521 (%i4) moebius (2^32);
1522 (%o4) 0
1523 (%i5) moebius (n);
1524 (%o5) moebius(n)
1525 (%i6) moebius (n = 12);
1526 (%o6) moebius(n) = 0
1527 (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
1528 (%o7) [- 1, 1, 1]
1529 (%i8) moebius (matrix ([11, 12], [13, 14]));
1530 [ - 1 0 ]
1531 (%o8) [ ]
1532 [ - 1 1 ]
1533 (%i9) moebius (@{21, 22, 23, 24@});
1534 (%o9) @{- 1, 0, 1@}
1535 @end example
1537 @opencatbox
1538 @category{Integers}
1539 @closecatbox
1541 @end deffn
1543 @anchor{multinomial_coeff}
1544 @deffn {関数} multinomial_coeff (@var{a_1}, ..., @var{a_n})
1545 @deffnx {関数} multinomial_coeff ()
1547 多項係数を返します。
1549 @var{a_k}それぞれが非負の整数の時、
1550 多項係数は、
1551 @code{@var{a_1} + ... + @var{a_n}}個の別々のオブジェクトを
1552 @math{k}番目の枠の中に@var{a_k}の要素を持つ@math{n}個の枠に置く方法の数を与えます。
1554 一般に、@code{multinomial_coeff (@var{a_1}, ..., @var{a_n})}は
1555 @code{(@var{a_1} + ... + @var{a_n})!/(@var{a_1}! ... @var{a_n}!)}と同値です。
1557 @code{multinomial_coeff()} (引数なし)は1に評価されます。
1559 @code{minfactorial}は@code{multinomial_coeff}が返す値を整理することができます。
1561 例:
1563 @c ===beg===
1564 @c multinomial_coeff (1, 2, x);
1565 @c minfactorial (%);
1566 @c multinomial_coeff (-6, 2);
1567 @c minfactorial (%);
1568 @c ===end===
1569 @example
1570 (%i1) multinomial_coeff (1, 2, x);
1571 (x + 3)!
1572 (%o1) --------
1573 2 x!
1574 (%i2) minfactorial (%);
1575 (x + 1) (x + 2) (x + 3)
1576 (%o2) -----------------------
1577 2
1578 (%i3) multinomial_coeff (-6, 2);
1579 (- 4)!
1580 (%o3) --------
1581 2 (- 6)!
1582 (%i4) minfactorial (%);
1583 (%o4) 10
1584 @end example
1586 @opencatbox
1587 @category{Integers}
1588 @closecatbox
1590 @end deffn
1592 @anchor{num_distinct_partitions}
1593 @deffn {関数} num_distinct_partitions (@var{n})
1594 @deffnx {関数} num_distinct_partitions (@var{n}, list)
1596 @var{n}が非負の整数の時、
1597 @var{n}の異なる整数分割の数を返します。
1598 そうでなければ、@code{num_distinct_partitions}は名詞形を返します。
1600 @code{num_distinct_partitions(@var{n}, list)}は、
1601 1, 2, 3, ..., @var{n}の異なる分割の数のリストを返します。
1603 @var{n}の異なる分割は、
1604 @math{@var{n} = k_1 + ... + k_m}となるような
1605 異なる正の整数@math{k_1}, ..., @math{k_m}のリストです。
1607 例:
1609 @c ===beg===
1610 @c num_distinct_partitions (12);
1611 @c num_distinct_partitions (12, list);
1612 @c num_distinct_partitions (n);
1613 @c ===end===
1614 @example
1615 (%i1) num_distinct_partitions (12);
1616 (%o1) 15
1617 (%i2) num_distinct_partitions (12, list);
1618 (%o2) [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
1619 (%i3) num_distinct_partitions (n);
1620 (%o3) num_distinct_partitions(n)
1621 @end example
1623 @opencatbox
1624 @category{Integers}
1625 @closecatbox
1627 @end deffn
1629 @anchor{num_partitions}
1630 @deffn {関数} num_partitions (@var{n})
1631 @deffnx {関数} num_partitions (@var{n}, list)
1633 @var{n}が非負の整数の時、
1634 @var{n}の整数分割の数を返します。
1635 そうでなければ、@code{num_partitions}は名詞式を返します。
1637 @code{num_partitions(@var{n}, list)}は、
1638 1, 2, 3, ..., @var{n}の整数分割の数のリストを返します。
1640 非負の整数@var{n}に対して、
1641 @code{num_partitions(@var{n})}は
1642 @code{cardinality(integer_partitions(@var{n}))}と等しいです;
1643 しかしながら、@code{num_partitions}は、
1644 分割の集合を実際には構成しないので、はるかに速いです。
1646 例:
1648 @c ===beg===
1649 @c num_partitions (5) = cardinality (integer_partitions (5));
1650 @c num_partitions (8, list);
1651 @c num_partitions (n);
1652 @c ===end===
1653 @example
1654 (%i1) num_partitions (5) = cardinality (integer_partitions (5));
1655 (%o1) 7 = 7
1656 (%i2) num_partitions (8, list);
1657 (%o2) [1, 1, 2, 3, 5, 7, 11, 15, 22]
1658 (%i3) num_partitions (n);
1659 (%o3) num_partitions(n)
1660 @end example
1662 @opencatbox
1663 @category{Integers}
1664 @closecatbox
1666 @end deffn
1670 @anchor{partition_set}
1671 @deffn {関数} partition_set (@var{a}, @var{f})
1673 集合@var{a}を述語論理@var{f}に従って分割します。
1675 @code{partition_set}は２つの集合のリストを返します。
1676 最初の集合は
1677 @var{f}が@code{false}に評価される
1678 @var{a}の要素から成り、
1679 二番目は@var{a}の他の要素すべてから成ります。
1680 @code{partition_set}は
1681 @code{is}を@var{f}の戻り値に適用しません。
1683 もし@var{a}が集合リテラルなら
1684 @code{partition_set}は文句を言います。
1686 @code{subset}も参照してください。
1688 例:
1690 @c ===beg===
1691 @c partition_set ({2, 7, 1, 8, 2, 8}, evenp);
1692 @c partition_set ({x, rat(y), rat(y) + z, 1},
1693 @c lambda ([x], ratp(x)));
1694 @c ===end===
1695 @example
1696 (%i1) partition_set (@{2, 7, 1, 8, 2, 8@}, evenp);
1697 (%o1) [@{1, 7@}, @{2, 8@}]
1698 (%i2) partition_set (@{x, rat(y), rat(y) + z, 1@},
1699 lambda ([x], ratp(x)));
1700 (%o2)/R/ [@{1, x@}, @{y, y + z@}]
1701 @end example
1703 @opencatbox
1704 @category{Sets}
1705 @closecatbox
1707 @end deffn
1709 @anchor{permutations}
1710 @deffn {関数} permutations (@var{a})
1712 リストまたは集合@var{a}の元の異なる順列すべての集合を返します。
1713 順列それぞれは、集合でなくリストです。
1715 @var{a}がリストの時、
1716 @var{a}の重複した元が順列の中に含まれます。
1718 もし@var{a}がリストリテラルや集合リテラルでないなら、
1719 @code{permutations}は文句を言います。
1721 @code{random_permutation}も参照してください。
1723 例:
1725 @c ===beg===
1726 @c permutations ([a, a]);
1727 @c permutations ([a, a, b]);
1728 @c ===end===
1729 @example
1730 (%i1) permutations ([a, a]);
1731 (%o1) @{[a, a]@}
1732 (%i2) permutations ([a, a, b]);
1733 (%o2) @{[a, a, b], [a, b, a], [b, a, a]@}
1734 @end example
1736 @opencatbox
1737 @category{Sets} @category{Lists}
1738 @closecatbox
1740 @end deffn
1742 @anchor{powerset}
1743 @deffn {関数} powerset (@var{a})
1744 @deffnx {関数} powerset (@var{a}, @var{n})
1746 @var{a}の部分集合すべての集合、または、その集合の部分集合を返します。
1748 @code{powerset(@var{a})}は
1749 集合@var{a}の部分集合すべての集合を返します。
1750 @code{powerset(@var{a})}は@code{2^cardinality(@var{a})}個の元を持ちます。
1752 @code{powerset(@var{a}, @var{n})}は、
1753 濃度@var{n}を持つ@var{a}の部分集合すべての集合を返します。
1755 もし@var{a}が集合リテラルでないか、
1756 @var{n}が非負の整数でないなら、
1757 @code{powerset}は文句を言います。
1759 例:
1761 @c ===beg===
1762 @c powerset ({a, b, c});
1763 @c powerset ({w, x, y, z}, 4);
1764 @c powerset ({w, x, y, z}, 3);
1765 @c powerset ({w, x, y, z}, 2);
1766 @c powerset ({w, x, y, z}, 1);
1767 @c powerset ({w, x, y, z}, 0);
1768 @c ===end===
1769 @example
1770 (%i1) powerset (@{a, b, c@});
1771 (%o1) @{@{@}, @{a@}, @{a, b@}, @{a, b, c@}, @{a, c@}, @{b@}, @{b, c@}, @{c@}@}
1772 (%i2) powerset (@{w, x, y, z@}, 4);
1773 (%o2) @{@{w, x, y, z@}@}
1774 (%i3) powerset (@{w, x, y, z@}, 3);
1775 (%o3) @{@{w, x, y@}, @{w, x, z@}, @{w, y, z@}, @{x, y, z@}@}
1776 (%i4) powerset (@{w, x, y, z@}, 2);
1777 (%o4) @{@{w, x@}, @{w, y@}, @{w, z@}, @{x, y@}, @{x, z@}, @{y, z@}@}
1778 (%i5) powerset (@{w, x, y, z@}, 1);
1779 (%o5) @{@{w@}, @{x@}, @{y@}, @{z@}@}
1780 (%i6) powerset (@{w, x, y, z@}, 0);
1781 (%o6) @{@{@}@}
1782 @end example
1784 @opencatbox
1785 @category{Sets}
1786 @closecatbox
1788 @end deffn
1790 @deffn {関数} random_permutation (@var{a})
1792 クヌースのシャッフルアルゴリズムで構成されるような、
1793 集合またはリスト@var{a}のランダムな順列を返します。
1795 戻り値は、たとえ要素すべてが偶然同じでも
1796 引数とは別の新しいリストです。
1797 しかしながら、引数の要素はコピーされません。
1799 例:
1801 @c ===beg===
1802 @c random_permutation ([a, b, c, 1, 2, 3]);
1803 @c random_permutation ([a, b, c, 1, 2, 3]);
1804 @c random_permutation ({x + 1, y + 2, z + 3});
1805 @c random_permutation ({x + 1, y + 2, z + 3});
1806 @c ===end===
1807 @example
1808 (%i1) random_permutation ([a, b, c, 1, 2, 3]);
1809 (%o1) [c, 1, 2, 3, a, b]
1810 (%i2) random_permutation ([a, b, c, 1, 2, 3]);
1811 (%o2) [b, 3, 1, c, a, 2]
1812 (%i3) random_permutation (@{x + 1, y + 2, z + 3@});
1813 (%o3) [y + 2, z + 3, x + 1]
1814 (%i4) random_permutation (@{x + 1, y + 2, z + 3@});
1815 (%o4) [x + 1, y + 2, z + 3]
1816 @end example
1818 @opencatbox
1819 @category{Sets} @category{Lists}
1820 @closecatbox
1822 @end deffn
1824 @anchor{rreduce}
1825 @deffn {関数} rreduce (@var{F}, @var{s})
1826 @deffnx {関数} rreduce (@var{F}, @var{s}, @var{s_@{n + 1@}})
1828 合成によって二項関数@var{F}をn項関数に拡張します。
1829 ここで、@var{s}はリストです。
1831 @code{rreduce(@var{F}, @var{s})}は
1832 @code{F(s_1, ... F(s_@{n - 2@}, F(s_@{n - 1@}, s_n)))}を返します。
1833 オプション引数@var{s_@{n + 1@}}が存在する時、
1834 結果は、@code{rreduce(@var{F}, endcons(@var{s_@{n + 1@}}, @var{s}))}
1835 と同値です。
1837 関数@var{F}は、最初@i{rightmost}のリスト要素に適用されます。
1838 だから名前が"rreduce"です。
1840 @code{lreduce}, @code{tree_reduce}, @code{xreduce}も参照してください。
1842 例:
1844 オプション引数なしの@code{rreduce}。
1846 @c ===beg===
1847 @c rreduce (f, [1, 2, 3]);
1848 @c rreduce (f, [1, 2, 3, 4]);
1849 @c ===end===
1850 @example
1851 (%i1) rreduce (f, [1, 2, 3]);
1852 (%o1) f(1, f(2, 3))
1853 (%i2) rreduce (f, [1, 2, 3, 4]);
1854 (%o2) f(1, f(2, f(3, 4)))
1855 @end example
1857 オプション引数ありの@code{rreduce}。
1859 @c ===beg===
1860 @c rreduce (f, [1, 2, 3], 4);
1861 @c ===end===
1862 @example
1863 (%i1) rreduce (f, [1, 2, 3], 4);
1864 (%o1) f(1, f(2, f(3, 4)))
1865 @end example
1867 組み込み二項演算子に適用された@code{rreduce}。
1868 @code{/}は割り算演算子。
1870 @c ===beg===
1871 @c rreduce ("^", args ({a, b, c, d}));
1872 @c rreduce ("/", args ({a, b, c, d}));
1873 @c ===end===
1874 @example
1875 (%i1) rreduce ("^", args (@{a, b, c, d@}));
1876 d
1877 c
1878 b
1879 (%o1) a
1880 (%i2) rreduce ("/", args (@{a, b, c, d@}));
1881 a c
1882 (%o2) ---
1883 b d
1884 @end example
1886 @opencatbox
1887 @category{Lists}
1888 @closecatbox
1890 @end deffn
1892 @anchor{setdifference}
1893 @deffn {関数} setdifference (@var{a}, @var{b})
1895 集合@var{a}の中の、集合@var{b}にない要素を含む集合を返します。
1897 もし@var{a}か@var{b}が集合リテラルでないなら、
1898 @code{setdifference}は文句を言います。
1900 例:
1902 @c ===beg===
1903 @c S_1 : {a, b, c, x, y, z};
1904 @c S_2 : {aa, bb, c, x, y, zz};
1905 @c setdifference (S_1, S_2);
1906 @c setdifference (S_2, S_1);
1907 @c setdifference (S_1, S_1);
1908 @c setdifference (S_1, {});
1909 @c setdifference ({}, S_1);
1910 @c ===end===
1911 @example
1912 (%i1) S_1 : @{a, b, c, x, y, z@};
1913 (%o1) @{a, b, c, x, y, z@}
1914 (%i2) S_2 : @{aa, bb, c, x, y, zz@};
1915 (%o2) @{aa, bb, c, x, y, zz@}
1916 (%i3) setdifference (S_1, S_2);
1917 (%o3) @{a, b, z@}
1918 (%i4) setdifference (S_2, S_1);
1919 (%o4) @{aa, bb, zz@}
1920 (%i5) setdifference (S_1, S_1);
1921 (%o5) @{@}
1922 (%i6) setdifference (S_1, @{@});
1923 (%o6) @{a, b, c, x, y, z@}
1924 (%i7) setdifference (@{@}, S_1);
1925 (%o7) @{@}
1926 @end example
1928 @opencatbox
1929 @category{Sets}
1930 @closecatbox
1932 @end deffn
1934 @anchor{setequalp}
1935 @deffn {関数} setequalp (@var{a}, @var{b})
1937 集合@var{a}と@var{b}が同じ要素数を持ち、
1938 @c $SETEQUALP CALLS THE LISP FUNCTION LIKE,
1939 @c AND SO DOES THE CODE TO EVALUATE IS (X = Y).
1940 @code{listify}が決定した順序で考えて
1941 @var{a}の要素の中の@code{x}と
1942 @var{b}の要素の中の@code{y}に対して
1943 @code{is(@var{x} = @var{y})}が@code{true}なら、
1944 @code{true}を返します。
1945 そうでなければ、@code{setequalp}は@code{false}を返します。
1947 例:
1949 @c ===beg===
1950 @c setequalp ({1, 2, 3}, {1, 2, 3});
1951 @c setequalp ({a, b, c}, {1, 2, 3});
1952 @c setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
1953 @c ===end===
1954 @example
1955 (%i1) setequalp (@{1, 2, 3@}, @{1, 2, 3@});
1956 (%o1) true
1957 (%i2) setequalp (@{a, b, c@}, @{1, 2, 3@});
1958 (%o2) false
1959 (%i3) setequalp (@{x^2 - y^2@}, @{(x + y) * (x - y)@});
1960 (%o3) false
1961 @end example
1963 @opencatbox
1964 @category{Sets} @category{Predicate functions}
1965 @closecatbox
1967 @end deffn
1969 @anchor{setify}
1970 @deffn {関数} setify (@var{a})
1972 リスト@var{a}の要素から集合を構成します。
1973 リスト@var{a}の重複した要素は削除され、
1974 要素は、述語論理@code{orderlessp}に従って並び替えられます。
1976 もし@var{a}が集合リテラルでないなら、
1977 @code{setify}は文句を言います。
1979 例:
1981 @c ===beg===
1982 @c setify ([1, 2, 3, a, b, c]);
1983 @c setify ([a, b, c, a, b, c]);
1984 @c setify ([7, 13, 11, 1, 3, 9, 5]);
1985 @c ===end===
1986 @example
1987 (%i1) setify ([1, 2, 3, a, b, c]);
1988 (%o1) @{1, 2, 3, a, b, c@}
1989 (%i2) setify ([a, b, c, a, b, c]);
1990 (%o2) @{a, b, c@}
1991 (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
1992 (%o3) @{1, 3, 5, 7, 9, 11, 13@}
1993 @end example
1995 @opencatbox
1996 @category{Lists}
1997 @closecatbox
1999 @end deffn
2001 @anchor{setp}
2002 @deffn {関数} setp (@var{a})
2004 @var{a}がMaximaの集合の時だけ、@code{true}を返します。
2006 @code{setp}は、
2007 整理された集合はもちろん、未整理の集合(すなわち、冗長な元を持つ集合)に対して、
2008 @code{true}を返します。
2010 @c NOT SURE WE NEED TO MENTION THIS. OK FOR NOW
2011 @code{setp}はMaxima関数
2012 @code{setp(a) := not atom(a) and op(a) = 'set}
2013 と同値です。
2015 例:
2017 @c ===beg===
2018 @c simp : false;
2019 @c {a, a, a};
2020 @c setp (%);
2021 @c ===end===
2022 @example
2023 (%i1) simp : false;
2024 (%o1) false
2025 (%i2) @{a, a, a@};
2026 (%o2) @{a, a, a@}
2027 (%i3) setp (%);
2028 (%o3) true
2029 @end example
2031 @opencatbox
2032 @category{Sets} @category{Predicate functions}
2033 @closecatbox
2035 @end deffn
2037 @anchor{set_partitions}
2038 @deffn {関数} set_partitions (@var{a})
2039 @deffnx {関数} set_partitions (@var{a}, @var{n})
2041 @var{a}の分割すべての集合、または、その集合の部分集合を返します。
2043 @code{set_partitions(@var{a}, @var{n})}は
2044 @var{n}個の空でないばらばらの部分集合への
2045 @var{a}の分解すべての集合を返します。
2047 @code{set_partitions(@var{a})}は分割すべての集合を返します。
2049 @code{stirling2}は集合の分割の集合の濃度を返します。
2051 集合の集合@math{P}は
2053 @enumerate
2054 @item
2055 @math{P}の元それぞれが空でない集合
2056 @item
2057 @math{P}の別の元はばらばらである。
2058 @item
2059 @math{P}の元の和集合が@math{S}に等しい
2060 @end enumerate
2061 時、
2062 集合@math{S}の分割です。
2064 例:
2066 条件1と2が空ゆえに真なので、空集合はそれ自身の分割です。
2068 @c ===beg===
2069 @c set_partitions ({});
2070 @c ===end===
2071 @example
2072 (%i1) set_partitions (@{@});
2073 (%o1) @{@{@}@}
2074 @end example
2076 集合の分割の集合の濃度は、
2077 @code{stirling2}を使って見つけられます。
2079 @c ===beg===
2080 @c s: {0, 1, 2, 3, 4, 5}$
2081 @c p: set_partitions (s, 3)$
2082 @c cardinality(p) = stirling2 (6, 3);
2083 @c ===end===
2084 @example
2085 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2086 (%i2) p: set_partitions (s, 3)$
2087 (%i3) cardinality(p) = stirling2 (6, 3);
2088 (%o3) 90 = 90
2089 @end example
2091 @code{p}の元それぞれは
2092 @var{n} = 3個の元を持たなければいけません;
2093 チェックしましょう。
2095 @c ===beg===
2096 @c s: {0, 1, 2, 3, 4, 5}$
2097 @c p: set_partitions (s, 3)$
2098 @c map (cardinality, p);
2099 @c ===end===
2100 @example
2101 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2102 (%i2) p: set_partitions (s, 3)$
2103 (%i3) map (cardinality, p);
2104 (%o3) @{3@}
2105 @end example
2107 最後に、
2108 @code{p}の元それぞれに対して、
2109 元の和集合は@code{s}に等しくなければいけません;
2110 チェックしましょう。
2112 @c ===beg===
2113 @c s: {0, 1, 2, 3, 4, 5}$
2114 @c p: set_partitions (s, 3)$
2115 @c map (lambda ([x], apply (union, listify (x))), p);
2116 @c ===end===
2117 @example
2118 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
2119 (%i2) p: set_partitions (s, 3)$
2120 (%i3) map (lambda ([x], apply (union, listify (x))), p);
2121 (%o3) @{@{0, 1, 2, 3, 4, 5@}@}
2122 @end example
2124 @opencatbox
2125 @category{Sets}
2126 @closecatbox
2128 @end deffn
2130 @anchor{some}
2131 @deffn {関数} some (@var{f}, @var{a})
2132 @deffnx {関数} some (@var{f}, @var{L_1}, ..., @var{L_n})
2134 もし与えられた引数のうち１つ以上で述語論理@var{f}が@code{true}なら
2135 @code{true}を返します。
2137 二番目の引数として集合１つが与えられたとして、
2138 もし
2139 @var{s}の中の１つ以上の@var{a_i}に対して
2140 @code{is(@var{f}(@var{a_i}))}が@code{true}を返すなら、
2141 @code{some(@var{f}, @var{s})}は@code{true}を返します。
2142 @code{some}は
2143 @var{s}の中の@var{a_i}すべてに対して
2144 @var{f}を評価するかどうかわかりません。
2145 集合は順序がないので、
2146 @code{some}は任意の順序で@code{@var{f}(@var{a_i})}評価するかもしれません。
2148 引数として２つ以上のリストが与えられたとして、
2149 @code{some(@var{f}, @var{L_1}, ..., @var{L_n})}は@code{true}を返します。
2150 もし
2151 @var{L_1}, ..., @var{L_n}それぞれの中の１つ以上の@var{x_1}, ..., @var{x_n}で
2152 @code{is(@var{f}(@var{x_1}, ..., @var{x_n}))}が@code{true}を返すなら、
2153 @code{some}は
2154 いくつかの組み合わせ@var{x_1}, ..., @var{x_n}に対して
2155 @var{f}を評価するかどうかわかりません。
2156 @code{some}はインデックスを増加する順序でリストを評価します。
2158 引数として空集合@code{@{@}}または空のリスト@code{[]}が与えられたとして、
2159 @code{some}は@code{false}を返します。
2161 グローバルフラグ@code{maperror}が@code{true}の時、
2162 すべてのリスト@var{L_1}, ..., @var{L_n}は同じ長さを持たなければいけません。
2163 @code{maperror}が@code{false}の時、
2164 リスト引数は、最短のリストの長さに効果的に切り詰められます。
2166 (@code{is}を介して)@code{true}か@code{false}以外の何かに評価される
2167 述語論理@var{f}の戻り値は、
2168 グローバルフラグ@code{prederror}によって決定されます。
2169 @code{prederror}が@code{true}の時、
2170 そんな値は@code{false}として扱われます。
2171 @code{prederror}が@code{false}の時、
2172 そんな値は@code{unknown}として扱われます。
2174 例:
2176 集合１つに適用された@code{some}。
2177 述語論理は引数１つの関数です。
2179 @c ===beg===
2180 @c some (integerp, {1, 2, 3, 4, 5, 6});
2181 @c some (atom, {1, 2, sin(3), 4, 5 + y, 6});
2182 @c ===end===
2183 @example
2184 (%i1) some (integerp, @{1, 2, 3, 4, 5, 6@});
2185 (%o1) true
2186 (%i2) some (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
2187 (%o2) true
2188 @end example
2190 ２つのリストに適用された@code{some}。
2191 述語論理は引数２つの関数です。
2193 @c ===beg===
2194 @c some ("=", [a, b, c], [a, b, c]);
2195 @c some ("#", [a, b, c], [a, b, c]);
2196 @c ===end===
2197 @example
2198 (%i1) some ("=", [a, b, c], [a, b, c]);
2199 (%o1) true
2200 (%i2) some ("#", [a, b, c], [a, b, c]);
2201 (%o2) false
2202 @end example
2204 @code{true}か@code{false}以外の何かに評価される述語論理@var{f}の戻り値は、
2205 グローバルフラグ@code{prederror}によって決定されます。
2207 @c ===beg===
2208 @c prederror : false;
2209 @c map (lambda ([a, b], is (a < b)), [x, y, z],
2210 @c [x^2, y^2, z^2]);
2211 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
2212 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
2213 @c prederror : true;
2214 @c some ("<", [x, y, z], [x^2, y^2, z^2]);
2215 @c some ("<", [x, y, z], [x^2, y^2, z + 1]);
2216 @c ===end===
2217 @example
2218 (%i1) prederror : false;
2219 (%o1) false
2220 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
2221 [x^2, y^2, z^2]);
2222 (%o2) [unknown, unknown, unknown]
2223 (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
2224 (%o3) unknown
2225 (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
2226 (%o4) true
2227 (%i5) prederror : true;
2228 (%o5) true
2229 (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
2230 (%o6) false
2231 (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
2232 (%o7) true
2233 @end example
2235 @opencatbox
2236 @category{Sets} @category{Lists}
2237 @closecatbox
2239 @end deffn
2241 @anchor{stirling1}
2242 @deffn {関数} stirling1 (@var{n}, @var{m})
2244 第一種のスターリング数を表します。
2246 @var{n}と@var{m}が非負の整数の時、
2247 @code{stirling1 (@var{n}, @var{m})}の大きさは
2248 @var{m}個の巡回置換を持つ@var{n}個の元を持つ集合の順列の数です。
2249 詳細はGraham, Knuth and Patashnik @i{Concrete Mathematics}を参照してください。
2250 Maximaは、
2251 0より小さい@var{m}に対して
2252 @code{stirling1 (@var{n}, @var{m})}を定義するために
2253 再帰関係を使います;
2254 0より小さい@var{n}と非整数引数に対して未定義です。
2256 @code{stirling1}は整理関数です。
2257 Maximaは以下の恒等式を知っています。
2259 @c COPIED VERBATIM FROM SRC/NSET.LISP
2260 @enumerate
2261 @item
2262 @math{stirling1(0, n) = kron_delta(0, n)} (Ref. [1])
2263 @item
2264 @math{stirling1(n, n) = 1} (Ref. [1])
2265 @item
2266 @math{stirling1(n, n - 1) = binomial(n, 2)} (Ref. [1])
2267 @item
2268 @math{stirling1(n + 1, 0) = 0} (Ref. [1])
2269 @item
2270 @math{stirling1(n + 1, 1) = n!} (Ref. [1])
2271 @item
2272 @math{stirling1(n + 1, 2) = 2^n - 1} (Ref. [1])
2273 @end enumerate
2275 これらの恒等式は
2276 引数が、整数リテラルまたは整数と宣言されたシンボルで、かつ、
2277 最初の引数が非負の時、
2278 適用されます。
2279 @code{stirling1}は、非整数引数に対して整理しません。
2281 参考文献:
2283 [1] Donald Knuth, @i{The Art of Computer Programming,}
2284 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
2286 例:
2288 @c ===beg===
2289 @c declare (n, integer)$
2290 @c assume (n >= 0)$
2291 @c stirling1 (n, n);
2292 @c ===end===
2293 @example
2294 (%i1) declare (n, integer)$
2295 (%i2) assume (n >= 0)$
2296 (%i3) stirling1 (n, n);
2297 (%o3) 1
2298 @end example
2300 @code{stirling1}は非整数引数に対して整理しません。
2302 @c ===beg===
2303 @c stirling1 (sqrt(2), sqrt(2));
2304 @c ===end===
2305 @example
2306 (%i1) stirling1 (sqrt(2), sqrt(2));
2307 (%o1) stirling1(sqrt(2), sqrt(2))
2308 @end example
2310 Maximaは
2311 @code{stirling1}に恒等式を適用します。
2313 @c ===beg===
2314 @c declare (n, integer)$
2315 @c assume (n >= 0)$
2316 @c stirling1 (n + 1, n);
2317 @c stirling1 (n + 1, 1);
2318 @c ===end===
2319 @example
2320 (%i1) declare (n, integer)$
2321 (%i2) assume (n >= 0)$
2322 (%i3) stirling1 (n + 1, n);
2323 n (n + 1)
2324 (%o3) ---------
2325 2
2326 (%i4) stirling1 (n + 1, 1);
2327 (%o4) n!
2328 @end example
2330 @opencatbox
2331 @category{Integers}
2332 @closecatbox
2334 @end deffn
2336 @anchor{stirling2}
2337 @deffn {関数} stirling2 (@var{n}, @var{m})
2339 第二種スターリング数を表します。
2341 @var{n}と@var{m}が非負の整数の時、
2342 @code{stirling2 (@var{n}, @var{m})}は、
2343 濃度@var{n}の集合が@var{m}個のばらばらの部分集合に分割できる方法の数です。
2344 Maximaは、
2345 0より小さい@var{m}に対して
2346 @code{stirling2 (@var{n}, @var{m})}を定義するために
2347 再帰関係を使います;
2348 0より小さい@var{n}と非整数の引数に対して未定義です。
2350 @code{stirling2}は整理関数です。
2351 Maximaは以下の恒等式を知っています。
2353 @c COPIED VERBATIM FROM SRC/NSET.LISP
2354 @enumerate
2355 @item
2356 @math{stirling2(0, n) = kron_delta(0, n)} (Ref. [1])
2357 @item
2358 @math{stirling2(n, n) = 1} (Ref. [1])
2359 @item
2360 @math{stirling2(n, n - 1) = binomial(n, 2)} (Ref. [1])
2361 @item
2362 @math{stirling2(n + 1, 1) = 1} (Ref. [1])
2363 @item
2364 @math{stirling2(n + 1, 2) = 2^n - 1} (Ref. [1])
2365 @item
2366 @math{stirling2(n, 0) = kron_delta(n, 0)} (Ref. [2])
2367 @item
2368 @math{stirling2(n, m) = 0} when @math{m > n} (Ref. [2])
2369 @item
2370 @math{stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m!}
2371 when @math{m} and @math{n} are integers, and @math{n} is nonnegative. (Ref. [3])
2372 @end enumerate
2374 引数が整数リテラルまたは整数と宣言されたシンボルで、かつ、最初の引数が非負の時、
2375 これらの恒等式が適用されます。
2376 @code{stirling2}は非整数引数に対して整理されません。
2378 参考文献:
2380 [1] Donald Knuth. @i{The Art of Computer Programming},
2381 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
2383 [2] Graham, Knuth, and Patashnik. @i{Concrete Mathematics}, Table 264.
2385 [3] Abramowitz and Stegun. @i{Handbook of Mathematical Functions}, Section 24.1.4.
2387 例:
2389 @c ===beg===
2390 @c declare (n, integer)$
2391 @c assume (n >= 0)$
2392 @c stirling2 (n, n);
2393 @c ===end===
2394 @example
2395 (%i1) declare (n, integer)$
2396 (%i2) assume (n >= 0)$
2397 (%i3) stirling2 (n, n);
2398 (%o3) 1
2399 @end example
2401 @code{stirling2}は非整数引数に対して整理されません。
2403 @c ===beg===
2404 @c stirling2 (%pi, %pi);
2405 @c ===end===
2406 @example
2407 (%i1) stirling2 (%pi, %pi);
2408 (%o1) stirling2(%pi, %pi)
2409 @end example
2411 Maximaは
2412 @code{stirling2}に恒等式を適用します。
2414 @c ===beg===
2415 @c declare (n, integer)$
2416 @c assume (n >= 0)$
2417 @c stirling2 (n + 9, n + 8);
2418 @c stirling2 (n + 1, 2);
2419 @c ===end===
2420 @example
2421 (%i1) declare (n, integer)$
2422 (%i2) assume (n >= 0)$
2423 (%i3) stirling2 (n + 9, n + 8);
2424 (n + 8) (n + 9)
2425 (%o3) ---------------
2426 2
2427 (%i4) stirling2 (n + 1, 2);
2428 n
2429 (%o4) 2 - 1
2430 @end example
2432 @opencatbox
2433 @category{Integers}
2434 @closecatbox
2436 @end deffn
2438 @anchor{subset}
2439 @deffn {関数} subset (@var{a}, @var{f})
2441 述語論理@var{f}を満たす
2442 集合@var{a}の部分集合を返します。
2444 @code{subset}は、
2445 @var{f}が@code{false}以外の何かを返す、@var{a}の要素から成る集合を返します。
2446 @code{subset}は
2447 @code{is}を@var{f}の戻り値に適用しません。
2449 もし@var{a}が集合リテラルでないなら
2450 @code{subset}は文句を言います。
2452 @code{partition_set}も参照してください。
2454 例:
2456 @c ===beg===
2457 @c subset ({1, 2, x, x + y, z, x + y + z}, atom);
2458 @c subset ({1, 2, 7, 8, 9, 14}, evenp);
2459 @c ===end===
2460 @example
2461 (%i1) subset (@{1, 2, x, x + y, z, x + y + z@}, atom);
2462 (%o1) @{1, 2, x, z@}
2463 (%i2) subset (@{1, 2, 7, 8, 9, 14@}, evenp);
2464 (%o2) @{2, 8, 14@}
2465 @end example
2467 @opencatbox
2468 @category{Sets}
2469 @closecatbox
2471 @end deffn
2473 @anchor{subsetp}
2474 @deffn {関数} subsetp (@var{a}, @var{b})
2476 集合@var{a}が@var{b}の部分集合の時だけ、
2477 @code{true}を返します。
2479 もし@var{a}か@var{b}のいずれかが集合リテラルでないなら、
2480 @code{subsetp}は文句を言います。
2482 例:
2484 @c ===beg===
2485 @c subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
2486 @c subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
2487 @c ===end===
2488 @example
2489 (%i1) subsetp (@{1, 2, 3@}, @{a, 1, b, 2, c, 3@});
2490 (%o1) true
2491 (%i2) subsetp (@{a, 1, b, 2, c, 3@}, @{1, 2, 3@});
2492 (%o2) false
2493 @end example
2495 @opencatbox
2496 @category{Sets} @category{Predicate functions}
2497 @closecatbox
2499 @end deffn
2501 @anchor{symmdifference}
2502 @deffn {関数} symmdifference (@var{a_1}, @dots{}, @var{a_n})
2504 集合@var{a_1}, @dots{}, @var{a_n}の対称差を返します。
2506 ２つの引数が与えられたとして、
2507 @code{symmdifference ( @var{a}, @var{b})}は
2508 @code{union (setdifference ( @var{a}, @var{b}), setdifference (@var{b}, @var{a}))}と同じです。
2510 もし引数が集合リテラルでないなら、
2511 @code{symmdifference}は文句を言います。
2513 例:
2515 @c ===beg===
2516 @c S_1 : {a, b, c};
2517 @c S_2 : {1, b, c};
2518 @c S_3 : {a, b, z};
2519 @c symmdifference ();
2520 @c symmdifference (S_1);
2521 @c symmdifference (S_1, S_2);
2522 @c symmdifference (S_1, S_2, S_3);
2523 @c symmdifference ({}, S_1, S_2, S_3);
2524 @c ===end===
2525 @example
2526 (%i1) S_1 : @{a, b, c@};
2527 (%o1) @{a, b, c@}
2528 (%i2) S_2 : @{1, b, c@};
2529 (%o2) @{1, b, c@}
2530 (%i3) S_3 : @{a, b, z@};
2531 (%o3) @{a, b, z@}
2532 (%i4) symmdifference ();
2533 (%o4) @{@}
2534 (%i5) symmdifference (S_1);
2535 (%o5) @{a, b, c@}
2536 (%i6) symmdifference (S_1, S_2);
2537 (%o6) @{1, a@}
2538 (%i7) symmdifference (S_1, S_2, S_3);
2539 (%o7) @{1, b, z@}
2540 (%i8) symmdifference (@{@}, S_1, S_2, S_3);
2541 (%o8) @{1,b, z@}
2542 @end example
2544 @opencatbox
2545 @category{Sets}
2546 @closecatbox
2548 @end deffn
2550 @c TREE_REDUCE ACCEPTS A SET OR LIST AS AN ARGUMENT, BUT RREDUCE AND LREDUCE WANT ONLY LISTS; STRANGE
2551 @anchor{tree_reduce}
2552 @deffn {関数} tree_reduce (@var{F}, @var{s})
2553 @deffnx {関数} tree_reduce (@var{F}, @var{s}, @var{s_0})
2555 合成によって二項関数@var{F}をn項関数に拡張します。
2556 ここで@var{s}は集合かリストです。
2558 @code{tree_reduce}は以下と同値です:
2559 新しいリスト@code{[@var{F}(@var{s_1}, @var{s_2}), @var{F}(@var{s_3}, @var{s_4}), ...]}を形成するために
2560 @var{F}を要素の連続する対に適用します。
2561 もし奇数個の要素があるなら、
2562 最後の要素は変化なしに通過させます。
2563 そして、リストが１つの要素になるまで繰り返します。１つの要素になった時、それが戻り値です。
2565 オプションの引数@var{s_0}がある時，
2566 結果は
2567 @code{tree_reduce(@var{F}, cons(@var{s_0}, @var{s})}と同値です。
2569 浮動小数点数の足し算に関して、
2570 @code{tree_reduce}は、
2571 @code{rreduce}や@code{lreduce}よりも小さな丸め誤差を持つ和を返します。
2573 @var{s}の要素と部分的な結果は
2574 最小深度の二項木の中に配列されます。
2575 だから名前が"tree_reduce"です。
2577 例:
2579 偶数個の要素を持つリストに適用された@code{tree_reduce}。
2581 @c ===beg===
2582 @c tree_reduce (f, [a, b, c, d]);
2583 @c ===end===
2584 @example
2585 (%i1) tree_reduce (f, [a, b, c, d]);
2586 (%o1) f(f(a, b), f(c, d))
2587 @end example
2589 奇数個の要素を持つリストに適用された@code{tree_reduce}。
2591 @c ===beg===
2592 @c tree_reduce (f, [a, b, c, d, e]);
2593 @c ===end===
2594 @example
2595 (%i1) tree_reduce (f, [a, b, c, d, e]);
2596 (%o1) f(f(f(a, b), f(c, d)), e)
2597 @end example
2599 @opencatbox
2600 @category{Sets} @category{Lists}
2601 @closecatbox
2603 @end deffn
2605 @anchor{union}
2606 @deffn {関数} union (@var{a_1}, ..., @var{a_n})
2607 集合@var{a_1}から@var{a_n}の和集合を返します。
2609 @code{union()} (引数なし)は空集合を返します。
2611 もし引数が集合リテラルでないなら、
2612 @code{union}は文句を言います。
2614 例:
2616 @c ===beg===
2617 @c S_1 : {a, b, c + d, %e};
2618 @c S_2 : {%pi, %i, %e, c + d};
2619 @c S_3 : {17, 29, 1729, %pi, %i};
2620 @c union ();
2621 @c union (S_1);
2622 @c union (S_1, S_2);
2623 @c union (S_1, S_2, S_3);
2624 @c union ({}, S_1, S_2, S_3);
2625 @c ===end===
2626 @example
2627 (%i1) S_1 : @{a, b, c + d, %e@};
2628 (%o1) @{%e, a, b, d + c@}
2629 (%i2) S_2 : @{%pi, %i, %e, c + d@};
2630 (%o2) @{%e, %i, %pi, d + c@}
2631 (%i3) S_3 : @{17, 29, 1729, %pi, %i@};
2632 (%o3) @{17, 29, 1729, %i, %pi@}
2633 (%i4) union ();
2634 (%o4) @{@}
2635 (%i5) union (S_1);
2636 (%o5) @{%e, a, b, d + c@}
2637 (%i6) union (S_1, S_2);
2638 (%o6) @{%e, %i, %pi, a, b, d + c@}
2639 (%i7) union (S_1, S_2, S_3);
2640 (%o7) @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2641 (%i8) union (@{@}, S_1, S_2, S_3);
2642 (%o8) @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
2643 @end example
2645 @opencatbox
2646 @category{Sets}
2647 @closecatbox
2649 @end deffn
2651 @c XREDUCE ACCEPTS A SET OR LIST AS AN ARGUMENT, BUT RREDUCE AND LREDUCE WANT ONLY LISTS; STRANGE
2652 @anchor{xreduce}
2653 @deffn {関数} xreduce (@var{F}, @var{s})
2654 @deffnx {関数} xreduce (@var{F}, @var{s}, @var{s_0})
2656 合成によって関数@var{F}をn項関数に拡張します。
2657 または、もし@var{F}が既にn項関数なら@var{F}を@var{s}に適用します。
2658 @var{F}がn項関数でない時、
2659 @code{xreduce}は@code{lreduce}と同じです。
2660 引数@var{s}はリストです。
2662 n項関数として知られている関数は、
2663 足し算@code{+}, 掛け算@code{*}, @code{and}, @code{or}, @code{max},
2664 @code{min}, @code{append}を含みます。
2665 関数は、
2666 @code{declare(@var{F}, nary)}によってもn項と宣言されるかもしれません。
2667 これらの関数に対して、
2668 @code{xreduce}は
2669 @code{rreduce}や@code{lreduce}よりも速いことが期待されます。
2671 オプション引数@var{s_0}がある時、
2672 結果は、@code{xreduce(@var{s}, cons(@var{s_0}, @var{s}))}と同値です。
2674 @c NOT SURE WHAT IS THE RELEVANCE OF THE FOLLOWING COMMENT
2675 @c MAXIMA IS NEVER SO CAREFUL ABOUT FLOATING POINT ASSOCIATIVITY SO FAR AS I KNOW
2676 浮動小数点の足し算は、厳密には結合的ではありません;
2677 そうはそうかもしれませんが、
2678 @var{s}が浮動小数点を含む時、
2679 @code{xreduce}はMaximaのn項足し算を適用します。
2681 例:
2683 n項と知られている関数に適用された@code{xreduce}。
2684 @code{F}は引数すべてで、一度コールされます。
2686 @c ===beg===
2687 @c declare (F, nary);
2688 @c F ([L]) := L;
2689 @c xreduce (F, [a, b, c, d, e]);
2690 @c ===end===
2691 @example
2692 (%i1) declare (F, nary);
2693 (%o1) done
2694 (%i2) F ([L]) := L;
2695 (%o2) F([L]) := L
2696 (%i3) xreduce (F, [a, b, c, d, e]);
2697 (%o3) [[[[[("[", simp), a], b], c], d], e]
2698 @end example
2700 n項とわかっていない関数に適用された@code{xreduce}。
2701 @code{G}は、
2702 毎回２つの引数で複数回コールされます。
2704 @c ===beg===
2705 @c G ([L]) := L;
2706 @c xreduce (G, [a, b, c, d, e]);
2707 @c lreduce (G, [a, b, c, d, e]);
2708 @c ===end===
2709 @example
2710 (%i1) G ([L]) := L;
2711 (%o1) G([L]) := L
2712 (%i2) xreduce (G, [a, b, c, d, e]);
2713 (%o2) [[[[[("[", simp), a], b], c], d], e]
2714 (%i3) lreduce (G, [a, b, c, d, e]);
2715 (%o3) [[[[a, b], c], d], e]
2716 @end example
2718 @opencatbox
2719 @category{Sets} @category{Lists}
2720 @closecatbox
2722 @end deffn