doc/info/ja/nset.texi

   1 @menu
   2 * Introduction to Sets::
   3 * Functions and Variables for Sets::
   4 @end menu
   5
   6 @node Introduction to Sets, Functions and Variables for Sets, Sets, Sets
   7 @section Introduction to Sets
   8
   9 Maximaは、
  10 陽な列挙によって定義された有限集合のために、
  11 積集合や和集合のような、集合関数を提供します。
  12 Maximaは、リストと集合を別のオブジェクトとして扱います。
  13 この特長は、
  14 リストまたは集合であるメンバーがリストであったり集合であったりする集合を扱うことを可能にします。
  15
  16 有限集合のための関数に加えて、
  17 Maximaは、
  18 組み合わせ論に関係したいくつかの関数を提供します;
  19 これらは、第一種と第二種スターリング数、ベル数、第一種と第二種の多項係数、
  20 非負整数の分割、と2,3の他の関数です。
  21 Maximaは、クロネッカーのデルタ関数も定義します。
  22
  23 @subsection Usage
  24
  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 集合は、いつも中括弧で表示されます。
  32
  33 もしメンバーが一度以上リストされているなら、
  34 整理は、冗長なメンバーを消去します。
  35
  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
  64
  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}は異なったものと見なされます。
  76
  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
 118
 119 リストの要素から集合を構成するには、@code{setify}を使ってください。
 120
 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
 128
 129 もし@code{is(x = y)}が@code{true}に評価されるなら、
 130 集合の元@code{x}と@code{y}は等しいです。
 131 従って、@code{rat(x)}と@code{x}は集合の元として等しいです;
 132 結果として、
 133
 134 @c ===beg===
 135 @c {x, rat(x)};
 136 @c ===end===
 137 @example
 138 (%i1) @{x, rat(x)@};
 139 (%o1)                          @{x@}
 140 @end example
 141
 142 さらに、
 143 @code{is((x - 1)*(x + 1) = x^2 - 1)}は@code{false}に評価されるので、
 144 @code{(x - 1)*(x + 1)}と@code{x^2 - 1}は集合の異なる元です;
 145 従って、
 146
 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
 155
 156 この集合を1元集合に縮小するには、
 157 @code{rat}を集合の元それぞれに適用してください:
 158
 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
 171
 172 他の集合から冗長性を取り除くために、
 173 他の整理関数を使う必要があるかもしれません。
 174 以下は、@code{trigsimp}を使った例です:
 175
 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
 187
 188 元が、冗長でなく、並べ換えられている時
 189 集合は整理されてます。
 190 集合関数の現在のバージョンは、
 191 集合を順に並べるためにMaxima関数@code{orderlessp}を使います;
 192 しかしながら、
 193 @i{集合関数の将来のバージョンは、違う並び替え関数を使うかもしれません。}
 194
 195 代入のような、集合に関するいくつかの演算は、
 196 再整理を自動的に強制します;
 197 例えば、
 198
 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
 214
 215 Maximaは、リストと集合を異なるオブジェクトとして扱います;
 216 @code{union}や@code{intersection}のような関数は、
 217 もし引数のいずれかがしゅうごうでないなら、文句を言います。
 218 もしリストに集合関数を適用する必要があるなら、
 219 集合に変換するために、
 220 @code{setify}関数を使ってください。
 221 例えば、
 222
 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
 234
 235 集合@code{s}の集合要素のうち述語論理@code{f}を満たすすべての要素を抽出するためには、
 236 use @code{subset(s, f)}を使ってください。
 237 (@i{述語論理}はブーリアン値関数です。)
 238 例えば、
 239 与えられた集合の中で、変数@code{z}に依存しない等式を見つけるには、
 240 以下を使ってください。
 241
 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
 251
 252 節@ref{Functions and Variables for Sets}は、
 253 Maximaの集合関数の完全なリストを持ちます。
 254
 255 @opencatbox
 256 @category{Sets}
 257 @closecatbox
 258
 259 @subsection Set Member Iteration
 260
 261 集合の元上を反復する２つの方法があります。
 262 １つの方法は@code{map}の使用です;
 263 例えば:
 264
 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
 272
 273 他の方法は、
 274 @code{for @var{x} in @var{s} do}を使うことです。
 275
 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
 289
 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}は、違うように機能するかもしれませんし、そうでないかもしれません。
 301
 302 @subsection Bugs
 303
 304 集合関数は、
 305 集合の元を並び換えるために、
 306 Maxima関数@code{orderlessp}を使い、
 307 集合の元の同一性をテストするために(Lispレベルの)関数@code{like}を使います。
 308 これらの関数の両方は、
 309 もし標準有理式(CRE)形式の式を含むリストや行列が元の集合を使おうとするなら、現れる既知のバグを持ちます。
 310 例は以下の通りです。
 311
 312 @c ===beg===
 313 @c {[x], [rat (x)]};
 314 @c ===end===
 315 @example
 316 (%i1) @{[x], [rat (x)]@};
 317 Maxima encountered a Lisp error:
 318
 319   The value #:X1440 is not of type LIST.
 320
 321 Automatically continuing.
 322 To reenable the Lisp debugger set *debugger-hook* to nil.
 323 @end example
 324
 325 この式は、Maximaがエラーで停止する原因となります。
 326 (エラーメッセージはMaximaが使うLispのバージョンに依ります。)
 327 もう１つの例は、以下の通りです。
 328
 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:
 335
 336   The value #:A1440 is not of type LIST.
 337
 338 Automatically continuing.
 339 To reenable the Lisp debugger set *debugger-hook* to nil.
 340 @end example
 341
 342 これらのバグは、
 343 @code{orderlessp}と@code{like}の中にあるバグに原因します;
 344 それらは、集合関数の中のバグが原因ではありません。
 345 例証するには、以下の式を試してください。
 346
 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:
 354
 355   The value #:B1441 is not of type LIST.
 356
 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
 362
 363 これらのバグが直されるまで、
 364 CRE形式の式を含むリストや行を元に持つ集合を構成しないでください;
 365 しかしながら、CRE形式の元を持つ集合は、問題ないはずです:
 366
 367 @c ===beg===
 368 @c {x, rat (x)};
 369 @c ===end===
 370 @example
 371 (%i1) @{x, rat (x)@};
 372 (%o1)                          @{x@}
 373 @end example
 374
 375 Maximaの@code{orderlessp}は、
 376 集合関数で問題の原因となる可能性がある
 377 もう１つのバグを持ちます。
 378 それは、すなわち、順序付け述語論理@code{orderlessp}が推移的でないことです。
 379 これを示す最も簡単な既知の例は、以下の通りです。
 380
 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
 400
 401 このバグは、一般的にMaximaの関数はもちろん、集合関数すべてにおいて、
 402 問題の原因となる可能性があります。
 403 確実ではありませんが、
 404 もし集合の元すべてがCRE形式であるか、@code{ratsimp}を使って整理されていれば、
 405 このバグはたぶん避けられます。
 406
 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}をコールしないでください。
 413
 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
 438
 439 もし集合関数のバグかもしれないと思う何かを見つけたら、
 440 どうかMaximaのバグデータベースに報告してください。
 441 @code{bug_report}を参照してください。
 442
 443 @subsection Authors
 444
 445 マサチューセッツ州ケンブリッジ市のStavros Macrakisと、
 446 ネブラスカ大学カーニー校(UNK)のBarton Willisが、
 447 Maximaの集合関数とそれらのドキュメンテーションを書きました。
 448
 449 @node Functions and Variables for Sets,  , Introduction to Sets, Sets
 450 @section Functions and Variables for Sets
 451
 452 @anchor{adjoin}
 453 @deffn {関数} adjoin (@var{x}, @var{a})
 454
 455 集合@var{a}に要素@code{@{@var{x}@}}を加えた集合を返します。
 456
 457 もし@var{a}が集合リテラルでないなら、
 458 @code{adjoin}は文句を言います。
 459
 460 @code{adjoin(@var{x}, @var{a})}と@code{union(set(@var{x}), @var{a})}は同値です;
 461 しかしながら、@code{adjoin}は@code{union}より幾分早いかもしれません。
 462
 463 @code{disjoin}も参照してください。
 464
 465 例:
 466
 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
 477
 478 @opencatbox
 479 @category{Sets}
 480 @closecatbox
 481
 482 @end deffn
 483
 484 @anchor{belln}
 485 @deffn {関数} belln (@var{n})
 486
 487 @math{n}番目のベル数を返します。
 488 @code{belln(n)}は@var{n}個のメンバーを持つ集合の分割の数です。
 489
 490 非負整数@var{n}に対して、
 491 @code{belln(@var{n})}は@math{n}番目のベル数に整理されます。
 492 @code{belln}は他のいかなる引数に関して整理されません。
 493
 494 @code{belln}は等式、リスト、行列、集合上に分配されます。
 495
 496 例:
 497
 498 非負整数に適用された@code{belln}。
 499
 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
 515
 516 非負整数でない引数に適用された@code{belln}。
 517
 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
 525
 526 @opencatbox
 527 @category{Sets}
 528 @closecatbox
 529
 530 @end deffn
 531
 532 @anchor{cardinality}
 533 @deffn {関数} cardinality (@var{a})
 534
 535 集合@var{a}の異なる要素の数を返します。
 536
 537 整理がディセーブルされた時でも、
 538 @code{cardinality}は冗長な要素を無視します。
 539
 540 例:
 541
 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
 558
 559 @opencatbox
 560 @category{Sets}
 561 @closecatbox
 562
 563 @end deffn
 564
 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}の要素です。
 571
 572 もし任意の引数が集合リテラルでないなら、
 573 @code{cartesian_product}は文句を言います。
 574
 575 例:
 576
 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
 593
 594 @opencatbox
 595 @category{Sets}
 596 @closecatbox
 597
 598 @end deffn
 599
 600
 601 @anchor{disjoin}
 602 @deffn {関数} disjoin (@var{x}, @var{a})
 603 元@var{x}を持たない集合@var{a}を返します。
 604 もし@var{x}が@var{a}のメンバーでないなら、
 605 変更なしに@var{a}を返します。
 606
 607 もし@var{a}が集合リテラルでないなら、
 608 @code{disjoin}は文句を言います。
 609
 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}は一般的に他より速いです。
 614
 615 例:
 616
 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
 630
 631 @opencatbox
 632 @category{Sets}
 633 @closecatbox
 634
 635 @end deffn
 636
 637 @anchor{disjointp}
 638 @deffn {関数} disjointp (@var{a}, @var{b})
 639
 640 集合@var{a}と@var{b}がばらばらなら、
 641 @code{true}を返します。
 642
 643 もし@var{a}か@var{b}が集合リテラルでないなら、
 644 @code{disjointp}は文句を言います。
 645
 646 例:
 647
 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
 658
 659 @opencatbox
 660 @category{Sets}
 661 @category{Predicate functions}
 662 @closecatbox
 663
 664 @end deffn
 665
 666 @anchor{divisors}
 667 @deffn {関数} divisors (@var{n})
 668
 669 @var{n}の約数の集合を表します。
 670
 671 @var{n}がゼロでない整数の時、
 672 @code{divisors(@var{n})}は整数の集合に整理されます。
 673 約数の集合は元1と@var{n}を含みます。
 674 負の整数の約数は、その絶対値の約数です。
 675
 676 @code{divisors}は、等式、リスト、行列、集合上に分配されます。
 677
 678 例:
 679
 680 28は完全数であることを検証できます:
 681 (自身を除いた)約数が28です。
 682
 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
 693
 694 @code{divisors}は整理関数です。
 695 @code{divisors(a)}の中で@code{a}に8を代入することは、
 696 @code{divisors(8)}を再評価せずに約数をもたらします。
 697
 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
 708
 709 @code{divisors}は、等式、リスト、行列、集合上に分配されます。
 710
 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
 729
 730 @opencatbox
 731 @category{Integers}
 732 @closecatbox
 733
 734 @end deffn
 735
 736 @anchor{elementp}
 737 @deffn {関数} elementp (@var{x}, @var{a})
 738 @var{x}が集合@var{a}の元の時だけ@code{true}を返します。
 739
 740 もし@var{a}が集合リテラルでないなら、
 741 @code{elementp}は文句を言います。
 742
 743 例:
 744
 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
 755
 756 @opencatbox
 757 @category{Sets}
 758 @category{Predicate functions}
 759 @closecatbox
 760
 761 @end deffn
 762
 763 @anchor{emptyp}
 764 @deffn {関数} emptyp (@var{a})
 765
 766 @var{a}が空の集合か空のリストの時だけ、@code{true}を返します。
 767
 768 例:
 769
 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
 780
 781 @opencatbox
 782 @category{Sets}
 783 @category{Predicate functions}
 784 @closecatbox
 785
 786 @end deffn
 787
 788 @anchor{equiv_classes}
 789 @deffn {関数} equiv_classes (@var{s}, @var{F})
 790 集合@var{s}の
 791 同値関係@var{F}に関する
 792 同値クラスの集合を返します。
 793
 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}です。
 799
 800 @var{F}が同値関数でない時、
 801 @code{equiv_classes}は不平なくそれを受け入れますが、
 802 その場合、結果は、一般に正しくありません。
 803
 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.
 808
 809 例:
 810
 811 同値関係が
 812 @code{true}か@code{false}を返すラムダ式です。
 813
 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
 823
 824 同値関係が、@code{is}が@code{true}か@code{false}に評価される
 825 関係関数の名前です。
 826
 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
 834
 835 同値クラスが3の倍数だけ違う数です。
 836
 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
 846
 847 @opencatbox
 848 @category{Sets}
 849 @closecatbox
 850
 851 @end deffn
 852
 853 @anchor{every}
 854 @deffn {関数} every (@var{f}, @var{s})
 855 @deffnx {関数} every (@var{f}, @var{L_1}, ..., @var{L_n})
 856
 857 もし述語論理@var{f}が与えられた引数すべてで@code{true}なら、
 858 @code{true}を返します。
 859
 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})}を評価します。
 869
 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}はインデックスを増やす順序でリストを評価します。
 878
 879 空の集合@code{@{@}}または空のリスト@code{[]}が引数として与えられたとして、
 880 @code{every}は@code{false}を返します。
 881
 882 グローバルフラグ@code{maperror}が@code{true}の時、
 883 リスト@var{L_1}, ..., @var{L_n}すべては等しい長さを持たなければいけません。
 884 @code{maperror}が@code{false}の時、
 885 リスト引数は、最短のリストの長さに効果的に切り詰められます。
 886
 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}です。
 896
 897 例:
 898
 899 １つの集合に適用された@code{every}。
 900 述語論理は１引数関数です。
 901
 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
 912
 913 ２つのリストに適用された@code{every}。
 914 述語論理は２引数関数です。
 915
 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
 926
 927 @code{true}か@code{false}以外の何かに評価される
 928 述語論理@var{f}の戻り値は、
 929 グローバルフラグ@code{prederror}によって決定されます。
 930
 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
 952
 953 @opencatbox
 954 @category{Sets}
 955 @closecatbox
 956
 957 @end deffn
 958
 959 @anchor{extremal_subset}
 960 @deffn {関数} extremal_subset (@var{s}, @var{f}, max)
 961 @deffnx {関数} extremal_subset (@var{s}, @var{f}, min)
 962
 963 関数@var{f}が最大または最小値を取る、
 964 @var{s}の部分集合を返します。
 965
 966 @code{extremal_subset(@var{s}, @var{f}, max)}は、
 967 実数値関数@var{f}が最大値を取る、
 968 集合またはリスト@var{s}の部分集合を返します。
 969
 970 @code{extremal_subset(@var{s}, @var{f}, min)}は、
 971 実数値関数@var{f}が最小値を取る、
 972 集合またはリスト@var{s}の部分集合を返します。
 973
 974 例:
 975
 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
 986
 987 @opencatbox
 988 @category{Sets}
 989 @closecatbox
 990
 991 @end deffn
 992
 993 @anchor{flatten}
 994 @deffn {関数} flatten (@var{expr})
 995
 996 @var{expr}と同じ演算子を持つ部分式の引数を集め、
 997 これらの集めた引数から式を構成します。
 998
 999 @code{expr}の主演算子と違った演算子の部分式は、
1000 たとえそれらが、逆に@code{expr}に関するものと同じ演算子の部分式を含んだとしても、
1001 変更なしにコピーされます。
1002
1003 引数の数が演算子に関して宣言された引数と違う
1004 式を@code{flatten}が構成する可能性があるかもしれません;
1005 これは、整理器や評価器からのエラーメッセージを起こさせるかもしれません。
1006 @code{flatten}はそんな状況を検出しようとしません。
1007
1008 特別な表現の式、例えば、標準有理式(CRE)、はflattenできません;
1009 そんな場合、@code{flatten}は引数を変更なしに返します。
1010
1011 例:
1012
1013 リストに適用すると、@code{flatten}はリストの要素すべてを集めます。
1014
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
1022
1023 集合に適用すると、@code{flatten}は集合の元すべてを集めます。
1024
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
1035
1036 @code{flatten}は、主演算子をn項に宣言する効果に似ています。
1037 しかしながら、@code{flatten}は、
1038 主演算子と違う演算子を持つ部分式上に影響を持ちません。
1039 一方、n項宣言はそれらに影響します。
1040
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
1054
1055 @code{flatten}は、他の任意の演算子と同じように添字付き関数を扱います。
1056
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
1065
1066 引数の数が演算子に関して宣言された引数と違う
1067 式を@code{flatten}が構成する可能性があるかもしれません;
1068
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
1083
1084 @opencatbox
1085 @category{Sets}
1086 @category{Lists}
1087 @closecatbox
1088
1089 @end deffn
1090
1091 @anchor{full_listify}
1092 @deffn {関数} full_listify (@var{a})
1093 @var{a}の中のすべての集合演算子をリスト演算子で置き換え、
1094 結果を返します。
1095 @code{full_listify}は、
1096 たとえ主演算子が@code{set}でなくても
1097 入れ子の部分式の中の集合演算子を置き換えます。
1098
1099 @code{listify}は主演算子だけを置き換えます。
1100
1101 例:
1102
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
1113
1114 @opencatbox
1115 @category{Sets}
1116 @closecatbox
1117
1118 @end deffn
1119
1120 @anchor{fullsetify}
1121 @deffn {関数} fullsetify (@var{a})
1122 @var{a}がリストの時、
1123 リスト演算子を集合演算子で置き換え、
1124 @code{fullsetify}を集合であるメンバーそれぞれに適用します。
1125 @var{a}がリストでない時、変更なしで返します。
1126
1127 @code{setify}は主演算子だけを置き換えます。
1128
1129 例:
1130
1131
1132 @code{f([b])}の主演算子はリストでないので、
1133 行@code{(%o2)}で、
1134 @code{f}の引数は集合に変換されません。
1135
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
1146
1147 @opencatbox
1148 @category{Lists}
1149 @closecatbox
1150
1151 @end deffn
1152
1153 @anchor{identity}
1154 @deffn {関数} identity (@var{x})
1155
1156 任意の引数@var{x}に対して@var{x}を返します。
1157
1158 例:
1159
1160 @code{identity}は、
1161 引数が既にブーリアン値の時、
1162 述語論理として使うことができます。
1163
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
1172
1173 @anchor{integer_partitions}
1174 @deffn {関数} integer_partitions (@var{n})
1175 @deffnx {関数} integer_partitions (@var{n}, @var{len})
1176
1177 @var{n}の整数分割を返します。
1178 すなわち、和が@var{n}になる整数のリストです。
1179
1180 @code{integer_partitions(@var{n})}は、
1181 整数@var{n}の分割すべての集合を返します。
1182 分割それぞれは、大きい順に並べられたリストです。
1183
1184 @code{integer_partitions(@var{n}, @var{len})}は、
1185 長さ@var{len}以下の分割すべてを返します;
1186 この場合、
1187 @var{len}より少ない項を持つ分割それぞれには、
1188 厳密に@var{len}項持つ分割にするように、ゼロが足されます。
1189 分割それぞれは、大きい順に並べられたリストです。
1190
1191 リスト@math{[a_1, ..., a_m]}は、
1192 (1) @math{a_i}それぞれが非ゼロ整数、かつ、
1193 (2) @math{a_1 + ... + a_m = n.}
1194 の時、非負整数@math{n}の分割です。
1195 従って0は分割を持ちません。
1196
1197 例:
1198
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
1220
1221 条件を満たす分割すべてを見つけるには、
1222 関数@code{subset}を使ってください;
1223 以下は素数から成る10の分割すべてを見つける例です。
1224
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
1239
1240 @opencatbox
1241 @category{Integers}
1242 @closecatbox
1243
1244 @end deffn
1245
1246 @anchor{intersect}
1247 @deffn {関数} intersect (@var{a_1}, ..., @var{a_n})
1248
1249 @code{intersect}は、以下に見る@code{intersection}と同じです。
1250
1251 @opencatbox
1252 @category{Sets}
1253 @closecatbox
1254
1255 @end deffn
1256
1257 @anchor{intersection}
1258 @deffn {関数} intersection (@var{a_1}, ..., @var{a_n})
1259 集合@var{a_1}から@var{a_n}までに共通な
1260 要素を含む
1261 集合を返します。
1262
1263 もし引数のいずれかが集合リテラルでないなら、
1264 @code{intersection}は文句を言います。
1265
1266 例:
1267
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
1296
1297 @opencatbox
1298 @category{Sets}
1299 @closecatbox
1300
1301 @end deffn
1302
1303 @deffn {関数} kron_delta (@var{x}, @var{y}, @dots{}, @var{xp})
1304
1305 クロネッカーのデルタ関数を表します。
1306
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}はエラーをシグナルします。
1315
1316 例:
1317
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
1337
1338
1339 @end deffn
1340
1341 @anchor{listify}
1342 @deffn {関数} listify (@var{a})
1343
1344 @var{a}が集合の時、
1345 @var{a}の元を含む
1346 リストを返します。
1347 そうでなければ、@code{listify}は@var{a}を返します。
1348
1349 @code{full_listify}は
1350 @var{a}の中の集合演算子をリスト演算子に置き換えます。
1351
1352 例:
1353
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
1364
1365 @opencatbox
1366 @category{Sets}
1367 @closecatbox
1368
1369 @end deffn
1370
1371 @anchor{lreduce}
1372 @deffn {関数} lreduce (@var{F}, @var{s})
1373 @deffnx {関数} lreduce (@var{F}, @var{s}, @var{s_0})
1374
1375 二項関数@var{F}を合成によってn項関数に拡張します。
1376 ここで@var{s}はリストです。
1377
1378 @code{lreduce(@var{F}, @var{s})}は@code{F(... F(F(s_1, s_2), s_3), ... s_n)}を返します。
1379
1380 オプション引数@var{s_0}が存在する時、
1381 結果は@code{lreduce(@var{F}, cons(@var{s_0}, @var{s}))}と同値です。
1382
1383 関数@var{F}は、最初の@i{leftmost}の元に適用されます。
1384 だから、"lreduce"と名付けられています。
1385
1386 @code{rreduce}, @code{xreduce}, @code{tree_reduce}も参照してください。
1387
1388 例:
1389
1390 オプション引数なしの@code{lreduce}。
1391
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
1402
1403 オプション引数ありの@code{lreduce}。
1404
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
1412
1413 組み込み二項演算子に適用された@code{lreduce}。
1414 @code{/}は割り算演算子。
1415
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
1429
1430 @opencatbox
1431 @category{Lists}
1432 @closecatbox
1433
1434 @end deffn
1435
1436 @anchor{makeset}
1437 @deffn {関数} makeset (@var{expr}, @var{x}, @var{s})
1438
1439 式@var{expr}から生成された元を持つ集合を返します。
1440 ここで、@var{x}は@var{expr}の中の変数のリストであり、
1441 @var{s}はリストの集合かリストです。
1442 集合の元それぞれを生成するために、
1443 @var{expr}は、
1444 @var{s}の元に並列にバインドされた変数@var{x}で評価されます。
1445
1446 @var{s}の元それぞれは
1447 @var{x}と同じ長さを持たなければいけません。
1448 変数@var{x}のリストは、添字の付かないシンボルのリストでなければいけません。
1449 たとえシンボルが１つしかない場合でも、@var{x}は１要素のリストでなければいけなく、
1450 @var{s}の元それぞれは１要素のリストでなければいけません。
1451
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})))}.
1455
1456 @code{makelist}も参照してください。
1457
1458 例:
1459
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
1486
1487 @opencatbox
1488 @category{Sets}
1489 @closecatbox
1490
1491 @end deffn
1492
1493 @anchor{moebius}
1494 @deffn {関数} moebius (@var{n})
1495
1496 メビウス関数を表します。
1497
1498 @var{n}が@math{k}個の異なる素数の積の時、
1499 @code{moebius(@var{n})}は@math{(-1)^k}に整理されます;
1500 @math{@var{n} = 1}の時、1に整理されます;
1501 他の正の数すべてに対して、0に整理されます。
1502
1503 @code{moebius}は等式、リスト、行列、集合上に分配されます。
1504
1505 例:
1506
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
1540
1541 @opencatbox
1542 @category{Integers}
1543 @closecatbox
1544
1545 @end deffn
1546
1547 @anchor{multinomial_coeff}
1548 @deffn {関数} multinomial_coeff (@var{a_1}, ..., @var{a_n})
1549 @deffnx {関数} multinomial_coeff ()
1550
1551 多項係数を返します。
1552
1553 @var{a_k}それぞれが非負の整数の時、
1554 多項係数は、
1555 @code{@var{a_1} + ... + @var{a_n}}個の別々のオブジェクトを
1556 @math{k}番目の枠の中に@var{a_k}の要素を持つ@math{n}個の枠に置く方法の数を与えます。
1557
1558 一般に、@code{multinomial_coeff (@var{a_1}, ..., @var{a_n})}は
1559 @code{(@var{a_1} + ... + @var{a_n})!/(@var{a_1}! ... @var{a_n}!)}と同値です。
1560
1561 @code{multinomial_coeff()} (引数なし)は1に評価されます。
1562
1563 @code{minfactorial}は@code{multinomial_coeff}が返す値を整理することができます。
1564
1565 例:
1566
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
1589
1590 @opencatbox
1591 @category{Integers}
1592 @closecatbox
1593
1594 @end deffn
1595
1596 @anchor{num_distinct_partitions}
1597 @deffn {関数} num_distinct_partitions (@var{n})
1598 @deffnx {関数} num_distinct_partitions (@var{n}, list)
1599
1600 @var{n}が非負の整数の時、
1601 @var{n}の異なる整数分割の数を返します。
1602 そうでなければ、@code{num_distinct_partitions}は名詞形を返します。
1603
1604 @code{num_distinct_partitions(@var{n}, list)}は、
1605 1, 2, 3, ..., @var{n}の異なる分割の数のリストを返します。
1606
1607 @var{n}の異なる分割は、
1608 @math{@var{n} = k_1 + ... + k_m}となるような
1609 異なる正の整数@math{k_1}, ..., @math{k_m}のリストです。
1610
1611 例:
1612
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
1626
1627 @opencatbox
1628 @category{Integers}
1629 @closecatbox
1630
1631 @end deffn
1632
1633 @anchor{num_partitions}
1634 @deffn {関数} num_partitions (@var{n})
1635 @deffnx {関数} num_partitions (@var{n}, list)
1636
1637 @var{n}が非負の整数の時、
1638 @var{n}の整数分割の数を返します。
1639 そうでなければ、@code{num_partitions}は名詞式を返します。
1640
1641 @code{num_partitions(@var{n}, list)}は、
1642 1, 2, 3, ..., @var{n}の整数分割の数のリストを返します。
1643
1644 非負の整数@var{n}に対して、
1645 @code{num_partitions(@var{n})}は
1646 @code{cardinality(integer_partitions(@var{n}))}と等しいです;
1647 しかしながら、@code{num_partitions}は、
1648 分割の集合を実際には構成しないので、はるかに速いです。
1649
1650 例:
1651
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
1665
1666 @opencatbox
1667 @category{Integers}
1668 @closecatbox
1669
1670 @end deffn
1671
1672
1673
1674 @anchor{partition_set}
1675 @deffn {関数} partition_set (@var{a}, @var{f})
1676
1677 集合@var{a}を述語論理@var{f}に従って分割します。
1678
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}の戻り値に適用しません。
1686
1687 もし@var{a}が集合リテラルなら
1688 @code{partition_set}は文句を言います。
1689
1690 @code{subset}も参照してください。
1691
1692 例:
1693
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
1706
1707 @opencatbox
1708 @category{Sets}
1709 @closecatbox
1710
1711 @end deffn
1712
1713 @anchor{permutations}
1714 @deffn {関数} permutations (@var{a})
1715
1716 リストまたは集合@var{a}の元の異なる順列すべての集合を返します。
1717 順列それぞれは、集合でなくリストです。
1718
1719 @var{a}がリストの時、
1720 @var{a}の重複した元が順列の中に含まれます。
1721
1722 もし@var{a}がリストリテラルや集合リテラルでないなら、
1723 @code{permutations}は文句を言います。
1724
1725 @code{random_permutation}も参照してください。
1726
1727 例:
1728
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
1739
1740 @opencatbox
1741 @category{Sets}
1742 @category{Lists}
1743 @closecatbox
1744
1745 @end deffn
1746
1747 @anchor{powerset}
1748 @deffn {関数} powerset (@var{a})
1749 @deffnx {関数} powerset (@var{a}, @var{n})
1750
1751 @var{a}の部分集合すべての集合、または、その集合の部分集合を返します。
1752
1753 @code{powerset(@var{a})}は
1754 集合@var{a}の部分集合すべての集合を返します。
1755 @code{powerset(@var{a})}は@code{2^cardinality(@var{a})}個の元を持ちます。
1756
1757 @code{powerset(@var{a}, @var{n})}は、
1758 濃度@var{n}を持つ@var{a}の部分集合すべての集合を返します。
1759
1760 もし@var{a}が集合リテラルでないか、
1761 @var{n}が非負の整数でないなら、
1762 @code{powerset}は文句を言います。
1763
1764 例:
1765
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
1788
1789 @opencatbox
1790 @category{Sets}
1791 @closecatbox
1792
1793 @end deffn
1794
1795 @deffn {関数} random_permutation (@var{a})
1796
1797 クヌースのシャッフルアルゴリズムで構成されるような、
1798 集合またはリスト@var{a}のランダムな順列を返します。
1799
1800 戻り値は、たとえ要素すべてが偶然同じでも
1801 引数とは別の新しいリストです。
1802 しかしながら、引数の要素はコピーされません。
1803
1804 例:
1805
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
1822
1823 @opencatbox
1824 @category{Sets}
1825 @category{Lists}
1826 @closecatbox
1827
1828 @end deffn
1829
1830 @anchor{rreduce}
1831 @deffn {関数} rreduce (@var{F}, @var{s})
1832 @deffnx {関数} rreduce (@var{F}, @var{s}, @var{s_@{n + 1@}})
1833
1834 合成によって二項関数@var{F}をn項関数に拡張します。
1835 ここで、@var{s}はリストです。
1836
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 と同値です。
1842
1843 関数@var{F}は、最初@i{rightmost}のリスト要素に適用されます。
1844 だから名前が"rreduce"です。
1845
1846 @code{lreduce}, @code{tree_reduce}, @code{xreduce}も参照してください。
1847
1848 例:
1849
1850 オプション引数なしの@code{rreduce}。
1851
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
1862
1863 オプション引数ありの@code{rreduce}。
1864
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
1872
1873 組み込み二項演算子に適用された@code{rreduce}。
1874 @code{/}は割り算演算子。
1875
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
1891
1892 @opencatbox
1893 @category{Lists}
1894 @closecatbox
1895
1896 @end deffn
1897
1898 @anchor{setdifference}
1899 @deffn {関数}  setdifference (@var{a}, @var{b})
1900
1901 集合@var{a}の中の、集合@var{b}にない要素を含む集合を返します。
1902
1903 もし@var{a}か@var{b}が集合リテラルでないなら、
1904 @code{setdifference}は文句を言います。
1905
1906 例:
1907
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
1933
1934 @opencatbox
1935 @category{Sets}
1936 @closecatbox
1937
1938 @end deffn
1939
1940 @anchor{setequalp}
1941 @deffn {関数} setequalp (@var{a}, @var{b})
1942
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}を返します。
1952
1953 例:
1954
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
1968
1969 @opencatbox
1970 @category{Sets}
1971 @category{Predicate functions}
1972 @closecatbox
1973
1974 @end deffn
1975
1976 @anchor{setify}
1977 @deffn {関数} setify (@var{a})
1978
1979 リスト@var{a}の要素から集合を構成します。
1980 リスト@var{a}の重複した要素は削除され、
1981 要素は、述語論理@code{orderlessp}に従って並び替えられます。
1982
1983 もし@var{a}が集合リテラルでないなら、
1984 @code{setify}は文句を言います。
1985
1986 例:
1987
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
2001
2002 @opencatbox
2003 @category{Lists}
2004 @closecatbox
2005
2006 @end deffn
2007
2008 @anchor{setp}
2009 @deffn {関数} setp (@var{a})
2010
2011 @var{a}がMaximaの集合の時だけ、@code{true}を返します。
2012
2013 @code{setp}は、
2014 整理された集合はもちろん、未整理の集合(すなわち、冗長な元を持つ集合)に対して、
2015 @code{true}を返します。
2016
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 と同値です。
2021
2022 例:
2023
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
2037
2038 @opencatbox
2039 @category{Sets}
2040 @category{Predicate functions}
2041 @closecatbox
2042
2043 @end deffn
2044
2045 @anchor{set_partitions}
2046 @deffn {関数} set_partitions (@var{a})
2047 @deffnx {関数} set_partitions (@var{a}, @var{n})
2048
2049 @var{a}の分割すべての集合、または、その集合の部分集合を返します。
2050
2051 @code{set_partitions(@var{a}, @var{n})}は
2052 @var{n}個の空でないばらばらの部分集合への
2053 @var{a}の分解すべての集合を返します。
2054
2055 @code{set_partitions(@var{a})}は分割すべての集合を返します。
2056
2057 @code{stirling2}は集合の分割の集合の濃度を返します。
2058
2059 集合の集合@math{P}は
2060
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}の分割です。
2071
2072 例:
2073
2074 条件1と2が空ゆえに真なので、空集合はそれ自身の分割です。
2075
2076 @c ===beg===
2077 @c set_partitions ({});
2078 @c ===end===
2079 @example
2080 (%i1) set_partitions (@{@});
2081 (%o1)                         @{@{@}@}
2082 @end example
2083
2084 集合の分割の集合の濃度は、
2085 @code{stirling2}を使って見つけられます。
2086
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
2098
2099 @code{p}の元それぞれは
2100 @var{n} = 3個の元を持たなければいけません;
2101 チェックしましょう。
2102
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
2114
2115 最後に、
2116 @code{p}の元それぞれに対して、
2117 元の和集合は@code{s}に等しくなければいけません;
2118 チェックしましょう。
2119
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
2131
2132 @opencatbox
2133 @category{Sets}
2134 @closecatbox
2135
2136 @end deffn
2137
2138 @anchor{some}
2139 @deffn {関数} some (@var{f}, @var{a})
2140 @deffnx {関数} some (@var{f}, @var{L_1}, ..., @var{L_n})
2141
2142 もし与えられた引数のうち１つ以上で述語論理@var{f}が@code{true}なら
2143 @code{true}を返します。
2144
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})}評価するかもしれません。
2155
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}はインデックスを増加する順序でリストを評価します。
2165
2166 引数として空集合@code{@{@}}または空のリスト@code{[]}が与えられたとして、
2167 @code{some}は@code{false}を返します。
2168
2169 グローバルフラグ@code{maperror}が@code{true}の時、
2170 すべてのリスト@var{L_1}, ..., @var{L_n}は同じ長さを持たなければいけません。
2171 @code{maperror}が@code{false}の時、
2172 リスト引数は、最短のリストの長さに効果的に切り詰められます。
2173
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}として扱われます。
2181
2182 例:
2183
2184 集合１つに適用された@code{some}。
2185 述語論理は引数１つの関数です。
2186
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
2197
2198 ２つのリストに適用された@code{some}。
2199 述語論理は引数２つの関数です。
2200
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
2211
2212 @code{true}か@code{false}以外の何かに評価される述語論理@var{f}の戻り値は、
2213 グローバルフラグ@code{prederror}によって決定されます。
2214
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
2242
2243 @opencatbox
2244 @category{Sets}
2245 @category{Lists}
2246 @closecatbox
2247
2248 @end deffn
2249
2250 @anchor{stirling1}
2251 @deffn {関数} stirling1 (@var{n}, @var{m})
2252
2253 第一種のスターリング数を表します。
2254
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}と非整数引数に対して未定義です。
2264
2265 @code{stirling1}は整理関数です。
2266 Maximaは以下の恒等式を知っています。
2267
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
2283
2284 これらの恒等式は
2285 引数が、整数リテラルまたは整数と宣言されたシンボルで、かつ、
2286 最初の引数が非負の時、
2287 適用されます。
2288 @code{stirling1}は、非整数引数に対して整理しません。
2289
2290 参考文献:
2291
2292 [1] Donald Knuth, @i{The Art of Computer Programming,}
2293 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
2294
2295 例:
2296
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
2308
2309 @code{stirling1}は非整数引数に対して整理しません。
2310
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
2318
2319 Maximaは
2320 @code{stirling1}に恒等式を適用します。
2321
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
2338
2339 @opencatbox
2340 @category{Integers}
2341 @closecatbox
2342
2343 @end deffn
2344
2345 @anchor{stirling2}
2346 @deffn {関数} stirling2 (@var{n}, @var{m})
2347
2348 第二種スターリング数を表します。
2349
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}と非整数の引数に対して未定義です。
2358
2359 @code{stirling2}は整理関数です。
2360 Maximaは以下の恒等式を知っています。
2361
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
2382
2383 引数が整数リテラルまたは整数と宣言されたシンボルで、かつ、最初の引数が非負の時、
2384 これらの恒等式が適用されます。
2385 @code{stirling2}は非整数引数に対して整理されません。
2386
2387 参考文献:
2388
2389 [1] Donald Knuth. @i{The Art of Computer Programming},
2390 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
2391
2392 [2] Graham, Knuth, and Patashnik. @i{Concrete Mathematics}, Table 264.
2393
2394 [3] Abramowitz and Stegun. @i{Handbook of Mathematical Functions}, Section 24.1.4.
2395
2396 例:
2397
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
2409
2410 @code{stirling2}は非整数引数に対して整理されません。
2411
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
2419
2420 Maximaは
2421 @code{stirling2}に恒等式を適用します。
2422
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
2440
2441 @opencatbox
2442 @category{Integers}
2443 @closecatbox
2444
2445 @end deffn
2446
2447 @anchor{subset}
2448 @deffn {関数} subset (@var{a}, @var{f})
2449
2450 述語論理@var{f}を満たす
2451 集合@var{a}の部分集合を返します。
2452
2453 @code{subset}は、
2454 @var{f}が@code{false}以外の何かを返す、@var{a}の要素から成る集合を返します。
2455 @code{subset}は
2456 @code{is}を@var{f}の戻り値に適用しません。
2457
2458 もし@var{a}が集合リテラルでないなら
2459 @code{subset}は文句を言います。
2460
2461 @code{partition_set}も参照してください。
2462
2463 例:
2464
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
2475
2476 @opencatbox
2477 @category{Sets}
2478 @closecatbox
2479
2480 @end deffn
2481
2482 @anchor{subsetp}
2483 @deffn {関数} subsetp (@var{a}, @var{b})
2484
2485 集合@var{a}が@var{b}の部分集合の時だけ、
2486 @code{true}を返します。
2487
2488 もし@var{a}か@var{b}のいずれかが集合リテラルでないなら、
2489 @code{subsetp}は文句を言います。
2490
2491 例:
2492
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
2503
2504 @opencatbox
2505 @category{Sets}
2506 @category{Predicate functions}
2507 @closecatbox
2508
2509 @end deffn
2510
2511 @anchor{symmdifference}
2512 @deffn {関数} symmdifference (@var{a_1}, @dots{}, @var{a_n})
2513
2514 集合@var{a_1}, @dots{}, @var{a_n}の対称差を返します。
2515
2516 ２つの引数が与えられたとして、
2517 @code{symmdifference ( @var{a}, @var{b})}は
2518 @code{union (setdifference ( @var{a}, @var{b}), setdifference (@var{b}, @var{a}))}と同じです。
2519
2520 もし引数が集合リテラルでないなら、
2521 @code{symmdifference}は文句を言います。
2522
2523 例:
2524
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
2553
2554 @opencatbox
2555 @category{Sets}
2556 @closecatbox
2557
2558 @end deffn
2559
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})
2564
2565 合成によって二項関数@var{F}をn項関数に拡張します。
2566 ここで@var{s}は集合かリストです。
2567
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 そして、リストが１つの要素になるまで繰り返します。１つの要素になった時、それが戻り値です。
2574
2575 オプションの引数@var{s_0}がある時，
2576 結果は
2577 @code{tree_reduce(@var{F}, cons(@var{s_0}, @var{s})}と同値です。
2578
2579 浮動小数点数の足し算に関して、
2580 @code{tree_reduce}は、
2581 @code{rreduce}や@code{lreduce}よりも小さな丸め誤差を持つ和を返します。
2582
2583 @var{s}の要素と部分的な結果は
2584 最小深度の二項木の中に配列されます。
2585 だから名前が"tree_reduce"です。
2586
2587 例:
2588
2589 偶数個の要素を持つリストに適用された@code{tree_reduce}。
2590
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
2598
2599 奇数個の要素を持つリストに適用された@code{tree_reduce}。
2600
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
2608
2609 @opencatbox
2610 @category{Sets}
2611 @category{Lists}
2612 @closecatbox
2613
2614 @end deffn
2615
2616 @anchor{union}
2617 @deffn {関数} union (@var{a_1}, ..., @var{a_n})
2618 集合@var{a_1}から@var{a_n}の和集合を返します。
2619
2620 @code{union()} (引数なし)は空集合を返します。
2621
2622 もし引数が集合リテラルでないなら、
2623 @code{union}は文句を言います。
2624
2625 例:
2626
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
2655
2656 @opencatbox
2657 @category{Sets}
2658 @closecatbox
2659
2660 @end deffn
2661
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})
2666
2667 合成によって関数@var{F}をn項関数に拡張します。
2668 または、もし@var{F}が既にn項関数なら@var{F}を@var{s}に適用します。
2669 @var{F}がn項関数でない時、
2670 @code{xreduce}は@code{lreduce}と同じです。
2671 引数@var{s}はリストです。
2672
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}よりも速いことが期待されます。
2681
2682 オプション引数@var{s_0}がある時、
2683 結果は、@code{xreduce(@var{s}, cons(@var{s_0}, @var{s}))}と同値です。
2684
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項足し算を適用します。
2691
2692 例:
2693
2694 n項と知られている関数に適用された@code{xreduce}。
2695 @code{F}は引数すべてで、一度コールされます。
2696
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
2710
2711 n項とわかっていない関数に適用された@code{xreduce}。
2712 @code{G}は、
2713 毎回２つの引数で複数回コールされます。
2714
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
2728
2729 @opencatbox
2730 @category{Sets}
2731 @category{Lists}
2732 @closecatbox
2733
2734 @end deffn