tests/rtestnset.mac

   1 kill (all)$
   2 done$
   3
   4 /* Test ability of parser to recognize curly braces notation on input.
   5  */
   6
   7 {};
   8 set ();
   9
  10 {a, b, c};
  11 set (a, b, c);
  12
  13 [{b, c}, {a}];
  14 [set (b, c), set (a)];
  15
  16 [{a, b, c}, {}];
  17 [set (a, b, c), set ()];
  18
  19 {{{{a, b, c}}}};
  20 set (set (set (set (a, b, c))));
  21
  22 {a, b, 2^{c, d, e}, mogrify ({x, y, [{}]}, {[]})};
  23 set (a, b, 2^set (c, d, e), mogrify (set (x, y, [set ()]), set ([])));
  24
  25 /* 1-d output should contain curly braces.
  26  */
  27
  28 string (set ());
  29 "{}";
  30
  31 string (set (a, b, set (c, d, set (e))));
  32 "{a,b,{c,d,{e}}}";
  33
  34 /* General tests.
  35  */
  36
  37 emptyp(set());
  38 true$
  39
  40 emptyp([]);
  41 true$
  42
  43 emptyp(set(false));
  44 false$
  45
  46 emptyp([false]);
  47 false$
  48
  49 emptyp(set(true));
  50 false$
  51
  52 emptyp(set(set()));
  53 false$
  54
  55 emptyp(set([]));
  56 false$
  57
  58 emptyp(set(u,n,k));
  59 false$
  60
  61 adjoin(set(),set());
  62 set(set())$
  63
  64 adjoin(set(),set(a));
  65 set(set(),a)$
  66
  67 adjoin(a,set());
  68 set(a)$
  69
  70 adjoin(false,set());
  71 set(false)$
  72
  73 adjoin(false,set(false));
  74 set(false)$
  75
  76 adjoin(false,set(true));
  77 set(true,false)$
  78
  79 adjoin(a, set(set()));
  80 set(set(),a)$
  81
  82 adjoin(a,set(a));
  83 set(a)$
  84
  85 adjoin(set(a),set(a));
  86 set(a,set(a))$
  87
  88 adjoin(a,set(a,b));
  89 set(a,b)$
  90
  91 adjoin(a,set(b,a));
  92 set(a,b)$
  93
  94 adjoin(z,set(a,b));
  95 set(a,b,z)$
  96
  97 errcatch(adjoin(a,b));
  98 []$
  99
 100 disjoin(x,set());
 101 set()$
 102
 103 disjoin(x,set(x));
 104 set()$
 105
 106 disjoin(x,set(y));
 107 set(y)$
 108
 109 disjoin(0,set(0,1,2));
 110 set(1,2)$
 111
 112 disjoin(1,set(0,1,2));
 113 set(0,2)$
 114
 115 disjoin(2,set(0,1,2));
 116 set(0,1)$
 117
 118 set(a,a,c);
 119 set(a,c)$
 120
 121 set(a,c,a);
 122 set(a,c)$
 123
 124 set(a,a,a);
 125 set(a)$
 126
 127 set(set(a,b),set(a,b),z);
 128 set(set(a,b),z)$
 129
 130 union();
 131 set()$
 132
 133 union(set());
 134 set()$
 135
 136 union(set(),set());
 137 set()$
 138
 139 union(set(false),set());
 140 set(false)$
 141
 142 union(set(6));
 143 set(6)$
 144
 145 union(set(8,8,1932));
 146 set(8,1932)$
 147
 148 union(set(a),set(a,b),set(a,b,c));
 149 set(a,b,c)$
 150
 151 union(set(),set(a));
 152 set(a)$
 153
 154 union(set(a),set(b),set(c));
 155 set(a,b,c)$
 156
 157 union(set(set(a)),set(a))$
 158 set(a,set(a))$
 159
 160 errcatch(union(set(a),set(b),x));
 161 []$
 162
 163 union(set(a),set());
 164 set(a)$
 165
 166 union(set(),set(set()));
 167 set(set())$
 168
 169 setdifference(set(a,b),set());
 170 set(a,b)$
 171
 172 setdifference(set(a,b),set(a));
 173 set(b)$
 174
 175 setdifference(set(a,b),set(b));
 176 set(a)$
 177
 178 setdifference(set(a,b),set(x));
 179 set(a,b)$
 180
 181 setdifference(set(a,b),set());
 182 set(a,b)$
 183
 184 setdifference(set(),set(x));
 185 set()$
 186
 187 setdifference(set(a),set(x));
 188 set(a)$
 189
 190 setdifference(set(a,b),set(x));
 191 set(a,b)$
 192
 193 errcatch(setdifference(a,b));
 194 []$
 195
 196 errcatch(setdifference(set(a),b));
 197 []$
 198
 199 errcatch(setdifference(a,set(b)));
 200 []$
 201
 202 errcatch(intersection());
 203 []$
 204
 205 intersection(set(x));
 206 set(x)$
 207
 208 intersection(set(),set());
 209 set()$
 210
 211 intersection(set(set()),set());
 212 set()$
 213
 214 intersection(set(set()),set(set(),set(set())));
 215 set(set())$
 216
 217 intersection(set(a,b),set(a,b,c));
 218 set(a,b)$
 219
 220 intersection(set(a,b),set(x,y,z));
 221 set()$
 222
 223 intersection(set(a,b,c),set(a,y,x),set(z,a),set(p,q,a));
 224 set(a)$
 225
 226 errcatch(intersect());
 227 []$
 228
 229 intersect(set(x));
 230 set(x)$
 231
 232 intersect(set(),set());
 233 set()$
 234
 235 intersect(set(set()),set());
 236 set()$
 237
 238 intersect(set(set()),set(set(),set(set())));
 239 set(set())$
 240
 241 intersect(set(a,b),set(a,b,c));
 242 set(a,b)$
 243
 244 intersect(set(a,b),set(x,y,z));
 245 set()$
 246
 247 intersect(set(a,b,c),set(a,y,x),set(z,a),set(p,q,a));
 248 set(a)$
 249
 250
 251 subsetp(set(),set());
 252 true$
 253
 254 subsetp(set(),set(a));
 255 true$
 256
 257 subsetp(set(a),set())$
 258 false$
 259
 260 subsetp(set(),set(set()));
 261 true$
 262
 263 subsetp(set(set()),set(set()));
 264 true$
 265
 266 subsetp(set(a,b),set(a,b,c));
 267 true$
 268
 269 subsetp(set(a,b,c),set(a,b));
 270 false$
 271
 272 errcatch(subsetp(a,b));
 273 []$
 274
 275 errcatch(subsetp(a,set(b)));
 276 []$
 277
 278 errcatch(subsetp(set(a),b));
 279 []$
 280
 281 disjointp(set(),set());
 282 true$
 283
 284 disjointp(set(set()),set());
 285 true$
 286
 287 errcatch(disjointp(a,a+b));
 288 []$
 289
 290 errcatch(disjointp(set(a),a+b));
 291 []$
 292
 293 errcatch(disjointp(a,set(a+b)));
 294 []$
 295
 296 disjointp(set(a),set(b));
 297 true$
 298
 299 disjointp(set(b,a),set(a));
 300 false$
 301
 302 subset(set(),evenp);
 303 set()$
 304
 305 subset(set(3,5,8),evenp);
 306 set(8)$
 307
 308 errcatch(subset(a,oddp));
 309 []$
 310
 311 subset(set(a,b,4,sin(x)), evenp);
 312 set(4)$
 313
 314 symmdifference();
 315 set()$
 316
 317 symmdifference(set());
 318 set()$
 319
 320 symmdifference(set(1));
 321 set(1)$
 322
 323 symmdifference(set(1,2,3));
 324 set(1,2,3)$
 325
 326 symmdifference(set(a),set(b),set(c));
 327 set(a,b,c)$
 328
 329 symmdifference(set(a),set(a,b),set(a,b,c));
 330 set(a,c)$
 331
 332 symmdifference(set(a,b,c),set(a,b),set(a));
 333 set(a,c)$
 334
 335 symmdifference(set(a,b,c),set(),set(1,2,3));
 336 set(a,b,c,1,2,3)$
 337
 338 symmdifference(set(), set(1,2,3),set(a,b,c));
 339 set(a,b,c,1,2,3)$
 340
 341 symmdifference(set(1,2,3),set(a,b,c),set());
 342 set(a,b,c,1,2,3)$
 343
 344 symmdifference(set(), set(1,2,3),set(a,b,c),set(),set());
 345 set(a,b,c,1,2,3)$
 346
 347 symmdifference(set(),set());
 348 set()$
 349
 350 symmdifference(set(set()),set());
 351 set(set())$
 352
 353 symmdifference(set(i,s,t,j), set(i,n,t,p));
 354 set(s,n,j,p)$
 355
 356 errcatch(symmdifference(a,set(b)));
 357 []$
 358
 359 errcatch(symmdifference(set(a),b));
 360 []$
 361
 362 errcatch(symmdifference(a,set(b)));
 363 []$
 364
 365 symmdifference(set(a,b),set(a));
 366 set(b)$
 367
 368
 369 subsetp(set(),set());
 370 true$
 371
 372 subsetp(set(set()),set());
 373 false$
 374
 375 subsetp(set(),set(set()));
 376 true$
 377
 378 subsetp(set(x),set(set(x)));
 379 false$
 380
 381 subsetp(set(a,b),set(a,y));
 382 false$
 383
 384 subsetp(set(a,b),set(a,b));
 385 true$
 386
 387 subsetp(set(set(a)),set(x,y,set(a)));
 388 true$
 389
 390 subsetp(set(rat(x)),set(x));
 391 true$
 392
 393 subsetp(set(a,a,a,x),set(a,x));
 394 true$
 395
 396 adjoin(x,set());
 397 set(x)$
 398
 399
 400 set(x,rat(x),x,x,x);
 401 set(x)$
 402
 403 union(set(),set());
 404 set()$
 405
 406 union(set(),set(8));
 407 set(8)$
 408
 409 union(set(1932),set());
 410 set(1932)$
 411
 412 union(set(set(8)),set(8));
 413 set(set(8),8)$
 414
 415 is(union(set(a),set(b),set(c))= set(a,b,c));
 416 true$
 417
 418 is(union(set(set()),set(b),set()) = set(b,set()));
 419 true$
 420
 421 is(union(set(x=6),set(y=3),set(z=-8)) = set(z=-8,y=3,x=6));
 422 true$
 423
 424 setify([]);
 425 set()$
 426
 427 setify([a,b]);
 428 set(a,b)$
 429
 430 setify([[a]]);
 431 set([a])$
 432
 433 setify([set(a)]);
 434 set(set(a))$
 435
 436 setify([false]);
 437 set(false)$
 438
 439 setify([false,false]);
 440 set(false)$
 441
 442 setify([false,false,true]);
 443 set(true,false)$
 444
 445 listify(set());
 446 []$
 447
 448 listify(set(a));
 449 [a]$
 450
 451 listify(set(set(a)));
 452 [set(a)]$
 453
 454 listify(set(set()));
 455 [set()]$
 456
 457 full_listify(set());
 458 []$
 459
 460 full_listify(set(false));
 461 [false]$
 462
 463 full_listify(set(set));
 464 [set]$
 465
 466 full_listify(set(x));
 467 [x]$
 468
 469 full_listify(set(set()));
 470 [[]]$
 471
 472 full_listify(set(set(false)));
 473 [[false]]$
 474
 475 full_listify(set(a,set(b),set(set(c))));
 476 [a,[b],[[c]]]$
 477
 478 full_listify(a+b=c);
 479 a+b=c$
 480
 481 full_listify(matrix([1,2],[3,4]));
 482 matrix([1,2],[3,4])$
 483
 484 full_listify(f(set(a)));
 485 f([a])$
 486
 487 full_listify(f(set(set(a))));
 488 f([[a]])$
 489
 490 full_listify(f(a,set(a), [a+b]));
 491 f(a,[a],[a+b])$
 492
 493 full_listify(5);
 494 5$
 495
 496 full_listify(a);
 497 a$
 498
 499 full_listify(a[5]);
 500 a[5]$
 501
 502 full_listify(sin(x+7));
 503 sin(x+7)$
 504
 505 full_listify(7.8e-4);
 506 7.8e-4$
 507
 508 full_listify(5.6b2);
 509 5.6b2$
 510
 511 full_listify(set + 7);
 512 set + 7$
 513
 514 full_listify(a^b + 1/set + set^z);
 515 a^b + 1/set + set^z$
 516
 517 (simp : false,0);
 518 0$
 519
 520 listify(set());
 521 []$
 522
 523 listify(set(a,a,b));
 524 [a,a,b]$
 525
 526 full_listify(set(a,a,b));
 527 [a,a,b]$
 528
 529 full_listify(set(a,a,b,set()));
 530 [a,a,b,[]]$
 531
 532 (simp : true,0);
 533 0$
 534
 535 subst(b=a,set(a,b));
 536 set(a)$
 537
 538 subst(b=a,set());
 539 set()$
 540
 541 subst([a=x,b=x,c=x],set(a,b,c));
 542 set(x)$
 543
 544 union(set(x),set(y));
 545 set(x,y)$
 546
 547 union(set(),set());
 548 set();
 549
 550 errcatch(intersect());
 551 []$
 552
 553 intersect(set(a));
 554 set(a)$
 555
 556 intersect(set(a),set(a,b));
 557 set(a)$
 558
 559 elementp(x,set());
 560 false$
 561
 562 elementp(false, set());
 563 false$
 564
 565 elementp(false, set(false));
 566 true$
 567
 568 elementp(set(),set());
 569 false$
 570
 571 elementp(set(),set(set()));
 572 true$
 573
 574 elementp(x,set(x));
 575 true$
 576
 577 elementp(rat(x),set(x));
 578 true$
 579
 580 elementp(x,set([x]));
 581 false$
 582
 583 union(set(false),set(true));
 584 set(false,true)$
 585
 586 union(setify([true,false]), set(x));
 587 set(x,true,false)$
 588
 589 fullsetify([]);
 590 set()$
 591
 592 fullsetify([false]);
 593 set(false)$
 594
 595 fullsetify([[]]);
 596 set(set())$
 597
 598 fullsetify([a,b,c]);
 599 set(a,b,c)$
 600
 601 fullsetify([a,[b]]);
 602 set(a,set(b))$
 603
 604 fullsetify(f[0,1]);
 605 f[0,1]$
 606
 607 fullsetify(f[5](x));
 608 f[5](x)$
 609
 610 fullsetify(matrix([1,2],[3,4]));
 611 matrix([1,2],[3,4])$
 612
 613 (remfunction(f,g),0);
 614 0$
 615
 616 flatten(3);
 617 3$
 618
 619 flatten(-3);
 620 -3$
 621
 622 flatten(2/3);
 623 2/3$
 624
 625 flatten(-2/3);
 626 -2/3$
 627
 628 flatten(1.4d2);
 629 1.4d2$
 630
 631 flatten(-3.4d0);
 632 -3.4d0$
 633
 634 flatten(x);
 635 x$
 636
 637 flatten(abc);
 638 abc$
 639
 640 flatten(%pi);
 641 %pi$
 642
 643 flatten(rat(x));
 644 ''(rat(x))$
 645
 646 flatten(rat(-x));
 647 ''(rat(-x))$
 648
 649
 650 flatten(x[5]);
 651 x[5]$
 652
 653 flatten(x[8,32]);
 654 x[8,32]$
 655
 656 flatten(-x);
 657 -x$
 658
 659 flatten(rat(-x));
 660 ''(rat(-x))$
 661
 662 flatten(a+b);
 663 a+b$
 664
 665 flatten(rat(a+b));
 666 ''(rat(a+b))$
 667
 668
 669 flatten(a*b);
 670 a*b$
 671
 672 flatten([]);
 673 []$
 674
 675 flatten([[]]);
 676 []$
 677
 678 flatten([x]);
 679 [x]$
 680
 681 flatten([[x]]);
 682 [x]$
 683
 684 flatten(f(g(f(f(x)))));
 685 f(g(f(f(x))))$
 686
 687 flatten(f(f(g(f(x)))));
 688 f(g(f(x)))$
 689
 690 /* Examples from Macsyma 422 */
 691
 692 flatten([a,b,[c,[d]],e,[[f],g,h]]);
 693 [a,b,c,d,e,f,g,h]$
 694
 695 flatten([a,b([c]),[d]]);
 696 [a,b([c]),d]$
 697
 698 flatten(f(f(a,b), f(c,d)));
 699 f(a,b,c,d)$
 700
 701 flatten(f[1](f[1](a,b), f[1](c,d)));
 702 f[1](a,b,c,d)$
 703
 704 elementp(false,set());
 705 false$
 706
 707 elementp(false,set(1));
 708 false$
 709
 710 elementp(false,set(false));
 711 true$
 712
 713 elementp(0,set());
 714 false$
 715
 716 elementp(1,set(1));
 717 true$
 718
 719 elementp(0,set(1));
 720 false$
 721
 722 elementp(2,set(1));
 723 false$
 724
 725 elementp(1,set(0,2));
 726 false$
 727
 728 adjoin(false,set());
 729 set(false)$
 730
 731 adjoin(false,set(1));
 732 set(false,1)$
 733
 734 adjoin(false,set(false));
 735 set(false)$
 736
 737 adjoin(0,set());
 738 set(0)$
 739
 740 adjoin(1,set(1));
 741 set(1)$
 742
 743 adjoin(0,set(1));
 744 set(1,0)$
 745
 746 adjoin(2,set(1));
 747 set(2,1)$
 748
 749 adjoin(1,set(0,2));
 750 set(0,1,2)$
 751
 752 cardinality(set());
 753 0$
 754
 755 cardinality(set([]));
 756 1$
 757
 758 cardinality(set(8,8,1932));
 759 2$
 760
 761 errcatch(cardinality(x+y));
 762 []$
 763
 764 setp([]);
 765 false$
 766
 767 setp(false);
 768 false$
 769
 770 setp(true);
 771 false$
 772
 773 setp(a+b);
 774 false$
 775
 776 setp([x]);
 777 false$
 778
 779 setp(set());
 780 true$
 781
 782 setp(set(set(a+b=c)));
 783 true$
 784
 785 setp(rat(x));
 786 false$
 787
 788 setp(1.5b34);
 789 false$
 790
 791 errcatch(setp());
 792 []$
 793
 794 listify(adjoin(-1,set(2,4,6)));
 795 [-1,2,4,6]$
 796
 797 listify(adjoin(2,set(2,4,6)));
 798 [2,4,6]$
 799
 800 listify(adjoin(3,set(2,4,6)));
 801 [2,3,4,6]$
 802
 803 listify(adjoin(6,set(2,4,6)));
 804 [2,4,6]$
 805
 806 listify(adjoin(7,set(2,4,6)));
 807 [2,4,6,7]$
 808
 809 permutations(set());
 810 set([])$
 811
 812 permutations([]);
 813 set([])$
 814
 815 permutations([a]);
 816 set([a])$
 817
 818 permutations([a,a]);
 819 set([a,a])$
 820
 821 (s : listify(permutations([0,1,2,3,4])),0);
 822 0$
 823
 824 is(s = sort(s));
 825 true$
 826
 827 (s : listify(permutations([a,b,b,a])),0);
 828 0$
 829
 830 is(s = sort(s));
 831 true$
 832
 833 (q : [1,2,3,4,5],0);
 834 0$
 835
 836 (s : permutations(q),0);
 837 0$
 838
 839 is(cardinality(s) = length(q)!);
 840 true$
 841
 842 elementp([5,3,2,1,4],s);
 843 true$
 844
 845 elementp([5,3,2,1,0],s);
 846 false$
 847
 848 (p : map(setify,s),0);
 849 0$
 850
 851 is(p = set(setify(q)));
 852 true$
 853
 854 (remvalue(s,p),0);
 855 0$
 856
 857 powerset(set());
 858 set(set())$
 859
 860 powerset(set(x));
 861 set(set(),set(x))$
 862
 863 powerset(set(x,y));
 864 set(set(),set(x),set(y),set(x,y))$
 865
 866 errcatch(powerset(a+b=c));
 867 []$
 868
 869 errcatch(powerset(rat(a)));
 870 []$
 871
 872 powerset(set(),0);
 873 set(set())$
 874
 875 powerset(set(),1);
 876 set()$
 877
 878 powerset(set(1),2);
 879 set()$
 880
 881 powerset(set(false));
 882 set(set(),set(false))$
 883
 884 powerset(set(a+b=c),1);
 885 set(set(a+b=c))$
 886
 887 powerset(set(1,2,3),2);
 888 set(set(1,2),set(1,3),set(2,3))$
 889
 890 errcatch(powerset(a+b=c));
 891 []$
 892
 893 is(subset(powerset(set(a,b,c,d,e)),lambda([x],is(cardinality(x)=3))) = powerset(set(a,b,c,d,e),3));
 894 true$
 895
 896 is(subset(powerset(set(a,b,c,d,e)),lambda([x],is(cardinality(x)=5))) =
 897         powerset(set(a,b,c,d,e),5));
 898 true$
 899
 900 is(subset(powerset(set(a,b,c,d,e)),lambda([x],is(cardinality(x)=7))) =
 901 powerset(set(a,b,c,d,e),7));
 902 true$
 903
 904 extremal_subset(set(),lambda([x],x^2), max);
 905 set()$
 906
 907 extremal_subset(set(-1,0,1),lambda([x],x^2), max);
 908 set(-1,1)$
 909
 910 extremal_subset(set(1,sqrt(2),3,%pi),log, max);
 911 set(%pi)$
 912
 913 /* quote exp because some other tests assign a value to exp,
 914    and kill refuses to kill the assigned value ... (sigh)
 915  */
 916 extremal_subset(set(sqrt(2),sqrt(3),sqrt(5)), 'exp, max);
 917 set(sqrt(5))$
 918
 919 extremal_subset(set(1+%i,sqrt(2),1-%i),abs, max);
 920 set(1+%i,sqrt(2),1-%i)$
 921
 922 extremal_subset(set(a,a+b,1.4b0,sqrt(28)),lambda([x],if atom(x) then 0 else 1), max);
 923
 924 set(a+b,sqrt(28))$
 925
 926 cartesian_product();
 927 set([])$
 928
 929 cartesian_product(set());
 930 set()$
 931
 932 cartesian_product(set(a));
 933 set([a])$
 934
 935 cartesian_product(set(),set(),set());
 936 set()$
 937
 938 cartesian_product(set(a),set(b));
 939 set([a,b])$
 940
 941 cartesian_product(set(u,n,k),set());
 942 set()$
 943
 944 cartesian_product(set(), set(u,n,k));
 945 set()$
 946
 947 cartesian_product(set(u,n,k),set(1));
 948 set([u,1],[n,1],[k,1])$
 949
 950 cartesian_product(set(a,b),set(1,2));
 951 set([a,1],[a,2],[b,1],[b,2])$
 952
 953 equiv_classes(set(),"=");
 954 set()$
 955
 956 equiv_classes(set(),"#");
 957 set()$
 958
 959 equiv_classes(set(a,b,c),"=");
 960 set(set(a),set(b),set(c))$
 961
 962 equiv_classes(set(a,b,c),"#");
 963 set(set(a,b,c))$
 964
 965 equiv_classes(set(1,2,3,4,5),lambda([x,y],remainder(x-y,2)=0));
 966 set(set(1,3,5),set(2,4))$
 967
 968 partition_set(set(),evenp);
 969 [set(),set()]$
 970
 971 partition_set(set(9),evenp);
 972 [set(9), set()]$
 973
 974 partition_set(set(2,4),evenp);
 975 [set(), set(2,4)]$
 976
 977 partition_set(set(a,b,c),lambda([x],false));
 978 [set(a,b,c), set()]$
 979
 980 partition_set(set(a,b,c),lambda([x],true));
 981 [set(),set(a,b,c)]$
 982
 983 partition_set(set(a,b,c),lambda([x],orderlessp(x,b)));
 984 [set(b,c), set(a)]$
 985
 986 set_partitions(set());
 987 set(set())$
 988
 989 set_partitions(set(),1);
 990 set()$
 991
 992 set_partitions(set(),2);
 993 set()$
 994
 995 set_partitions(set(u,n,k),1);
 996 set(set(set(u,n,k)))$
 997
 998 set_partitions(set(u,n,k),2);
 999 set(set(set(u),set(n,k)),set(set(n),set(u,k)), set(set(k),set(u,n)))$
1000
1001 makelist(stirling1(i,0),i,0,5);
1002 [1,0,0,0,0,0]$
1003
1004 makelist(stirling1(i,i),i,0,5);
1005 [1,1,1,1,1,1]$
1006
1007 factor(sum(stirling1(3,i)*x^i,i,0,3));
1008 x*(x-1)*(x-2)$
1009
1010 makelist(stirling1(i,1) - (-1)^(i-1)*(i-1)!,i,1,5);
1011 [0,0,0,0,0]$
1012
1013 sum(stirling1(8,k),k,1,8);  /* A & S 24.1.3 */
1014 0$
1015
1016 sum(stirling1(3,k),k,1,3);
1017 0$
1018
1019 sum(stirling1(5,k)*(-1)^(5-k),k,0,5);
1020 5!$
1021
1022 sum(stirling1(2,k)*(-1)^(2-k),k,0,2);
1023 2!$
1024
1025 (declare([a,b],integer),0);
1026 0$
1027
1028 (assume(a>0,b>0),0);
1029 0$
1030
1031 stirling1(b,a);
1032 stirling1(b,a)$
1033
1034 stirling2(b,a);
1035 stirling2(b,a)$
1036
1037 (forget(a>0,b>0),0);
1038 0$
1039
1040 (remove(a,integer), remove(b,integer),0);
1041 0$
1042
1043 stirling2(0,0);
1044 1$
1045
1046 stirling2(1,0);
1047 0$
1048
1049 stirling2(0,1);
1050 0$
1051
1052 stirling2(10,10);
1053 1$
1054
1055 stirling2(10,11);
1056 0$
1057
1058 stirling2(10,5) - 5 * stirling2(9,5) - stirling2(9,4);
1059 0$
1060
1061 sum((-1)^(12-m) * m! * stirling2(12,m),m,0,12);
1062 1$
1063
1064 /* test stirling2 simplification rules */
1065
1066 (remvalue(n),0);
1067 0$
1068
1069 (e : stirling2(n,0),0);
1070 0$
1071
1072 makelist(subst(n=i,e) - stirling2(i,0),i,-5,5);
1073 ''(makelist(0,i,-5,5))$
1074
1075 (e : stirling2(n,1),0);
1076 0$
1077
1078 makelist(subst(n=i,e) - stirling2(i,1),i,-5,5);
1079 ''(makelist(0,i,-5,5))$
1080
1081 (e : stirling2(n,2),0);
1082 0$
1083
1084 makelist(subst(n=i,e) - stirling2(i,2),i,-5,5);
1085 ''(makelist(0,i,-5,5))$
1086
1087 (e : stirling2(n,n),0);
1088 0$
1089
1090 makelist(subst(n=i,e) - stirling2(i,i),i,-5,5);
1091 ''(makelist(0,i,-5,5))$
1092
1093 (assume(n >=0), declare(n,integer), declare(k,integer), declare(kk,integer), assume(k >=0),0);
1094 0$
1095
1096 stirling1(n,n);
1097 1$
1098
1099 stirling1(kk,kk);
1100 stirling1(kk,kk)$
1101
1102 stirling1(1,kk);
1103 stirling1(1,kk)$
1104
1105 stirling1(1,k);
1106 kron_delta(1,k)$
1107
1108 stirling1(n,0);
1109 stirling1(n,0)$
1110
1111 stirling1(n+1,0);
1112 0$
1113
1114 stirling1(n,1);
1115 stirling1(n,1)$
1116
1117 stirling1(n+1,1);
1118 (-1)^(n) * (n)!$
1119
1120 stirling1(n,n-1);
1121 stirling1(n,n-1)$
1122
1123 stirling1(n+1,n);
1124 -binomial(n+1,2)$
1125
1126 stirling2(n,n);
1127 1$
1128
1129 stirling2(n,0);
1130 stirling2(n,0)$
1131
1132 stirling2(n+1,0);
1133 0$
1134
1135 stirling2(n,1);
1136 stirling2(n,1)$
1137
1138 stirling2(n+1,1);
1139 1$
1140
1141 stirling2(n,2);
1142 stirling2(n,2)$
1143
1144 stirling2(n+1,2);
1145 2^n -1$
1146
1147 stirling2(n,n-1);
1148 stirling2(n,n-1)$
1149
1150 stirling2(n+1,n);
1151 binomial(n+1,2)$
1152
1153 (forget(n>=0), forget(k >=0), remove(n,integer),remove(k,integer),remove(kk,integer),0);
1154 0$
1155
1156 (remvalue(e),0);
1157 0$
1158
1159 is(cardinality(set_partitions(set())) = belln(0));
1160 true$
1161
1162 is(cardinality(set_partitions(set(1))) = belln(1));
1163 true$
1164
1165 is(cardinality(set_partitions(set(1,2))) = belln(2));
1166 true$
1167
1168 is(cardinality(set_partitions(set(1,2,3))) = belln(3));
1169 true$
1170
1171 belln([5,6]);
1172 [belln(5),belln(6)]$
1173
1174 integer_partitions(0);
1175 set([])$
1176
1177 integer_partitions(1);
1178 set([1])$
1179
1180 integer_partitions(2);
1181 set([1,1],[2])$
1182
1183 is(cardinality(integer_partitions(25)) = 1958)$
1184 true;
1185
1186 map(lambda([x], apply("+",x)), integer_partitions(25));
1187 set(25)$
1188
1189 integer_partitions(2,1);
1190 set([2])$
1191
1192 integer_partitions(2,2);
1193 set([1,1],[2,0])$
1194
1195 integer_partitions(5,3);
1196 set([5,0,0],[4,1,0],[3,1,1],[3,2,0],[2,2,1])$
1197
1198 multinomial_coeff(0);
1199 1$
1200
1201 multinomial_coeff(1);
1202 1$
1203
1204 multinomial_coeff(5);
1205 1$
1206
1207 multinomial_coeff(2,3,4);
1208 (2+3+4)! / (2! * 3! * 4!)$
1209
1210 factor(sum(multinomial_coeff(i,5-i) * x^(5-i) * y^i,i,0,5));
1211 (x+y)^5$
1212
1213 diff((x+y+z)^9,x,3,y,6);
1214 ''(multinomial_coeff(3,6,0) * 3! * 6!)$
1215
1216 kron_delta(false,false);
1217 1$
1218
1219 /* need to have true and false sysconsts (not standard) for this to work
1220 kron_delta(false,true);
1221 0$
1222 */
1223
1224 kron_delta(true,true);
1225 1$
1226
1227 kron_delta(0,0);
1228 1$
1229
1230 kron_delta(a+b,a+b);
1231 1$
1232
1233 kron_delta(rat(x), x);
1234 1$
1235
1236 kron_delta(x,y) - kron_delta(y,x);
1237 0$
1238
1239 kron_delta(x,y) / 42 - kron_delta(y,x) / 42;
1240 0$
1241
1242 kron_delta(%i*x,%i*y) - kron_delta(%i*y,%i*x);
1243 0$
1244
1245 kron_delta(0.42,0.42);
1246 1$
1247
1248 kron_delta(0.42, 42/100);
1249 kron_delta(0.42, 42/100)$
1250
1251 kron_delta(2,3);
1252 0$
1253
1254 kron_delta(x,x);
1255 1$
1256
1257 kron_delta(x,x-1);
1258 0$
1259
1260 kron_delta(%i*x,%i*y);
1261 kron_delta(%i*x,%i*y)$
1262
1263 kron_delta(%i*x,%i*x);
1264 1$
1265
1266 ratsimp(kron_delta(%i*(x+1)^2,%i*(x^2+2*x+1)));
1267 1$
1268
1269 (assume(a > b),0);
1270 0$
1271
1272 kron_delta(a,b);
1273 0$
1274
1275 kron_delta(%i*a,%i*b);
1276 0$
1277
1278 (forget(a > b),0);
1279 0$
1280
1281 (assume(a < 1, b >= 3/2),0);
1282 0$
1283
1284 kron_delta(a,b);
1285 0$
1286
1287 kron_delta(%i,%i);
1288 1$
1289
1290 kron_delta(5+%i,5+%i);
1291 1$
1292
1293 kron_delta(5-%i,5+%i);
1294 0$
1295
1296 kron_delta(3 + %i/7,1 + %i/7);
1297 0$
1298
1299 kron_delta(1 + %i/5,1 + %i/7);
1300 0$
1301
1302 /* new kronecker delta tests for multivariable version */
1303
1304 (map('forget, facts()),0);
1305 0$
1306
1307 errcatch(kron_delta(x));
1308 []$
1309
1310 kron_delta();
1311 1$
1312
1313 kron_delta(sqrt(2), 1/sqrt(2), %pi);
1314 0$
1315
1316 kron_delta(a,b,a);
1317 kron_delta(a,b)$
1318
1319 subst(a=c, kron_delta(a,b,rat(c)));
1320 kron_delta(c,b)$
1321
1322 kron_delta(a,b)-kron_delta(-a,-b);
1323 0$
1324
1325 kron_delta(a,-b)-kron_delta(-a,b);
1326 0$
1327
1328 kron_delta(a,b,-c)-kron_delta(-a,-b,c);
1329 0$
1330
1331 kron_delta(-a,b,-c)-kron_delta(a,-b,c);
1332 0$
1333
1334 conjugate(kron_delta(a+%i,b,c));
1335 kron_delta(a+%i,b,c)$
1336
1337 cabs(kron_delta(a,b,23 +%i));
1338 kron_delta(a,b,23 + %i)$
1339
1340 abs(kron_delta(l,s,s));
1341 kron_delta(l,s)$
1342
1343 sign(kron_delta(u,n,k,1));
1344 pz$
1345
1346 featurep(kron_delta(a+%i, cos(x - %i), 42/19),'integer);
1347 true$
1348
1349 /* end new kronecker delta tests */
1350
1351 every(f,[]);
1352 true$
1353
1354 every(f,set());
1355 true$
1356
1357 every(evenp,set());
1358 true$
1359
1360 every(evenp,set(2));
1361 true$
1362
1363 every(evenp,set(%pi));
1364 false$
1365
1366 every(evenp,set(2,4,6,%pi));
1367 false$
1368
1369 every(evenp,set(1,2,4,6));
1370 false$
1371
1372 every("=",[],[]);
1373 true$
1374
1375 every("=",[1,2],[2,1]);
1376 false$
1377
1378 every("#",[a,b],[b,a]);
1379 true$
1380
1381 some(f,[]);
1382 false$
1383
1384 some(f,set());
1385 false$
1386
1387 some(oddp,set());
1388 false$
1389
1390 some(oddp,set(%i));
1391 false$
1392
1393 some(oddp,set(%i,1));
1394 true$
1395
1396 some(oddp,[1,%i]);
1397 true$
1398
1399 some("<",[a,1],[4,2]);
1400 true$
1401
1402 some("=",[a,4],[a,5]);
1403 true$
1404
1405 some("<=",[5,a],[6,a]);
1406 true$
1407
1408 rreduce("+",[],0);
1409 0$
1410
1411 rreduce("+",[a],0);
1412 a$
1413
1414 rreduce("+",[a,b]);
1415 a+b$
1416
1417 rreduce(adjoin, [1,2,3,4], set());
1418 set(1,2,3,4)$
1419
1420 rreduce(lambda([x,y],x),[a,b,c,d]);
1421 a$
1422
1423 rreduce(lambda([x,y],y),[a,b,c,d]);
1424 d$
1425
1426 rreduce(concat,["a","m","h"],"");
1427 "amh"$
1428
1429 flatten(rreduce(f,[1,2,3,4]));
1430 f(1,2,3,4)$
1431
1432 lreduce("+",[],0);
1433 0$
1434
1435 lreduce("+",[a],0);
1436 a$
1437
1438 lreduce("+",[a,b]);
1439 a+b$
1440
1441 lreduce(lambda([x,y],x),[a,b,c,d]);
1442 a$
1443
1444 lreduce(lambda([x,y],y),[a,b,c,d]);
1445 d$
1446
1447 lreduce(concat,["a","m","h"],"");
1448 "amh"$
1449
1450 flatten(lreduce(f,[1,2,3,4]));
1451 f(1,2,3,4)$
1452
1453 xreduce('max,[]);
1454 minf$
1455
1456 xreduce('min,[]);
1457 inf$
1458
1459 xreduce('max,[0,1]);
1460 1$
1461
1462 xreduce('min,[0,1]);
1463 0$
1464
1465 xreduce('max,[],x);
1466 x$
1467
1468 xreduce('min,[],x);
1469 x$
1470
1471 xreduce("and",[]);
1472 true$
1473
1474 xreduce("or",[]);
1475 false$
1476
1477 xreduce("and",[true]);
1478 true$
1479
1480 xreduce("and",[false]);
1481 false$
1482
1483 xreduce("and",[true,true],false)$
1484 false$
1485
1486 xreduce("or",[true]);
1487 true$
1488
1489 xreduce("or",[false]);
1490 false$
1491
1492 xreduce("or",[true,true],false)$
1493 true$
1494
1495 xreduce("and",[]);
1496 true$
1497
1498 xreduce("or",[]);
1499 false$
1500
1501 xreduce("and",[true]);
1502 true$
1503
1504 xreduce("and",[false]);
1505 false$
1506
1507 xreduce("and",[true,true],false)$
1508 false$
1509
1510 xreduce("or",[true]);
1511 true$
1512
1513 xreduce("or",[false]);
1514 false$
1515
1516 xreduce("or",[true,true],false)$
1517 true$
1518
1519 (nary ("@@@"), declare ("@@@", nary), "@@@" ([L]) := apply (FOO, L), kill (FOO));
1520 done;
1521
1522 xreduce ("@@@", [a, e, c, b, d]);
1523 FOO (a, e, c, b, d);
1524
1525 xreduce ("@@@", {a, e, c, b, d});
1526 FOO (a, b, c, d, e);
1527
1528 (infix ("%%%"), "%%%" (aa, bb) := BAR (aa, bb), kill (BAR));
1529 done;
1530
1531 xreduce ("%%%", [a, e, c, b, d]);
1532 BAR (BAR (BAR (BAR (a, e), c), b), d);
1533
1534 xreduce ("%%%", {a, e, c, b, d});
1535 BAR (BAR (BAR (BAR (a, b), c), d), e);
1536
1537 makeset(i,[i],set());
1538 set()$
1539
1540 makeset(i,[i],[[1]]);
1541 set(1)$
1542
1543 makeset(i,[i],[[true],[false]]);
1544 set(true,false)$
1545
1546 makeset(i/j,[i,j],[[2,6],[6,28]]);
1547 set(2/6,6/28)$
1548
1549 num_partitions(0);
1550 1$
1551
1552 every(is, makelist(num_partitions(i)=cardinality(integer_partitions(i)),i,1,15));
1553 true$
1554
1555 (distinctp(l) := is(cardinality(setify(l)) = length(l)),0);
1556 0$
1557
1558 (chk(n) := cardinality(subset(integer_partitions(n),distinctp)), 0);
1559 0$
1560
1561 every(is, makelist(num_distinct_partitions(i)=chk(i),i,0,10));
1562 true$
1563
1564 (remfunction(chk,distinctp),0);
1565 0$
1566
1567 divisors(1);
1568 set(1)$
1569
1570 divisors(2);
1571 set(1,2)$
1572
1573 divisors(28);
1574 set(1,2,4,7,14,28)$
1575
1576 divisors([28]);
1577 [set(1,2,4,7,14,28)]$
1578
1579 divisors(a=b);
1580 divisors(a) = divisors(b)$
1581
1582 every(is, makelist(divsum(i) = xreduce("+",divisors(i)),i,1,100));
1583 true$
1584
1585 moebius(1);
1586 1$
1587
1588 moebius(2);
1589 -1$
1590
1591 moebius(3);
1592 -1$
1593
1594 moebius([3,4]);
1595 [moebius(3),moebius(4)]$
1596
1597 /* See A & S 24.3.1 */
1598
1599 every(is, makelist(xreduce("+", map(moebius, divisors(i))) = 0,i,2,100));
1600 true$
1601
1602 (rprimep(i,j) := block([ ],
1603   if integerp(i) and integerp(j) then if gcd(i,j) > 1 then 0 else 1
1604   else funmake(rprimep,[i,j])),0);
1605 0$
1606
1607 every(is, makeset(moebius(i*j) = moebius(i) * moebius(j) * rprimep(i,j),[i,j],
1608 cartesian_product(setify(makelist(i,i,1,15)),setify(makelist(j,j,1,15)))));
1609 true$
1610
1611 /* Tests for random_permutation */
1612
1613 (set_random_state (make_random_state (1234)), 0);
1614 0;
1615
1616 (L : '[a + 1, b - 2, c * d, %pi, %e], S : setify (L), 0);
1617 0;
1618
1619 [random_permutation (L), random_permutation (L), random_permutation (L)];
1620 '[[a + 1, %e, c*d, b - 2, %pi], [b - 2, a + 1, c*d, %e, %pi], [a + 1, c*d, b - 2, %e, %pi]];
1621
1622 [random_permutation (S), random_permutation (S), random_permutation (S)];
1623 '[[c*d, b - 2, a + 1, %pi, %e], [%pi, %e, a + 1, b - 2, c*d], [b - 2, %pi, a + 1, %e, c*d]];
1624
1625 apply ("+", makelist (if random_permutation ([1, 2, 3, 4]) = [4,2,1,3] then 1 else 0, i, 1, 1000));
1626 41;
1627
1628 /* Tests for sublist_indices */
1629
1630 sublist_indices ([], lambda([x], x='b));
1631 [];
1632
1633 errcatch (sublist_indices (1, lambda([x], x='b)));
1634 [];
1635
1636 sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b));
1637 [2, 3, 7, 9];
1638
1639 sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], integerp (x)));
1640 [5, 6, 8];
1641
1642 sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
1643 [1, 2, 3, 4, 7, 9];
1644
1645 sublist_indices ([true, false, false, true, true], identity);
1646 [1, 4, 5];
1647
1648 sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity);
1649 [1, 4, 5];
1650
1651 (kill (P), P(x) := ordergreatp (x, 'm), sublist_indices ('[a, %pi, x, z, h, y, %e, 1, s], P));
1652 [3, 4, 6, 9];
1653
1654 sublist_indices ('[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], lambda ([x], evenp(x) and primep(x)));
1655 [3];
1656
1657 /* Tests for sublist (not part of nset but related functionality) */
1658
1659 sublist ([], lambda([x], x='b));
1660 [];
1661
1662 errcatch (sublist (1, lambda([x], x='b)));
1663 [];
1664
1665 sublist ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b));
1666 [b, b, b, b];
1667
1668 sublist ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], integerp (x)));
1669 [1, 2, 3];
1670
1671 sublist ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
1672 [a, b, b, c, b, b];
1673
1674 sublist ([true, false, false, true, true], identity);
1675 [true, true, true];
1676
1677 sublist ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity);
1678 [1 > 0, 2 > 1, 2 > 0];
1679
1680 (kill (P), P(x) := ordergreatp (x, 'm), sublist ('[a, %pi, x, z, h, y, %e, 1, s], P));
1681 [x, z, y, s];
1682
1683 sublist ('[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], lambda ([x], evenp(x) and primep(x)));
1684 [2];
1685
1686 /* from mailing list 2009-08-27 "what happened to 'ev' ?" */
1687
1688 block ([l1: [[2,3], [3,4], [4,5]]], local(s_list),
1689   s_list(list, option) := sublist(list, lambda([x], ev(option))),
1690   s_list(l1, x[2]<4));
1691 [[2, 3]];
1692
1693 block ([l1: [[2,3], [3,4], [4,5]]], local(s_list_indices),
1694   s_list_indices(list, option) := sublist_indices(list, lambda([x], ev(option))),
1695   s_list_indices(l1, x[2]<4));
1696 [1];
1697
1698 /* SF bug 2698078  set_partitions does not produce simplified sets */
1699 (l : set_partitions({1,2,3,4},3),0);
1700 0$
1701
1702 is(l = expand(l));
1703 true$
1704
1705 map(lambda([s], xreduce('union,s)), l);
1706 set(set(1,2,3,4))$
1707
1708 map(lambda([s], xreduce('intersection,s)), l);
1709 set(set())$
1710
1711 (l : set_partitions({1,2,3,4}),0);
1712 0$
1713
1714 is(l = expand(l));
1715 true$
1716
1717 map(lambda([s], xreduce('union,s)), l);
1718 set(set(1,2,3,4))$
1719
1720 map(lambda([s], xreduce('intersection,s)), l);
1721 set(set(), set(1,2,3,4))$
1722
1723 (l : set_partitions(set(a,b, set(c)),2),0);
1724 0$
1725
1726 is(l = expand(l));
1727 true$
1728
1729 map(lambda([s], xreduce('union,s)), l);
1730 set(set(a,b,set(c)))$
1731
1732 map(lambda([s], xreduce('intersection,s)), l);
1733 set(set())$
1734
1735 (l : set_partitions(set(a,b, set(c))),0);
1736 0$
1737
1738 is(l = expand(l));
1739 true$
1740
1741 map(lambda([s], xreduce('union,s)), l);
1742 set(set(a,b,set(c)))$
1743
1744 map(lambda([s], xreduce('intersection,s)), l);
1745 set(set(),set(a,b,set(c)))$
1746
1747 (remvalue(l),0);
1748 0$
1749
1750 in_exactly_one(set());
1751 set()$
1752
1753 in_exactly_one(set(l), set(s), set(s));
1754 set(l)$
1755
1756 in_exactly_one(set(r), set(e), set(n), set(e), set(e));
1757 set(r,n)$
1758
1759 in_exactly_one(set(m), set(a), set(x), set(i,m,a));
1760 set(i,x)$
1761
1762 in_exactly_one(set(x),set(x), set(a,b));
1763 set(a,b)$
1764
1765 /* bug reported to mailing list, is(f("x") > 0) => Lisp error
1766  * following example from Matthew Gwynne 2010-04-29, thanks Matthew!
1767  */
1768
1769 (
1770  /* F as specified in original example
1771  F : {{gv("CSup"),-gv("DiagF"),-gv("DisT"),-gv("ProgF"),-gv("SymA"),-gv("Via")},
1772     {-gv("CSup"),-gv("DiagF"),-gv("DisT"),-gv("ProgF"),-gv("SymA"),-gv("Via")},
1773     {gv("CSup"),-gv("DiagF"),-gv("DisT"),-gv("ProgF"),-gv("SymA"),-gv("Via")},
1774     {-gv("CSup"),-gv("DiagF"),gv("DisT"),-gv("ProgF"),gv("SymA"),-gv("Via")},
1775     {-gv("CSup"),gv("DiagF"),-gv("DisT"),-gv("ProgF"),gv("SymA"),gv("Via")},
1776     {gv("CSup"),gv("DiagF"),-gv("DisT"),-gv("ProgF"),gv("SymA"),gv("Via")},
1777     {gv("CSup"),gv("DiagF"),gv("DisT"),-gv("ProgF"),gv("SymA"),gv("Via")},
1778     {gv("CSup"),gv("DiagF"),gv("DisT"),-gv("ProgF"),gv("SymA"),gv("Via")},
1779     {-gv("CSup"),gv("DiagF"),-gv("DisT"),gv("ProgF"),gv("SymA"),gv("Via")},
1780     {gv("CSup"),gv("DiagF"),gv("DisT"),gv("ProgF"),gv("SymA"),gv("Via")},
1781     {gv("CSup"),gv("DiagF"),gv("DisT"),gv("ProgF"),gv("SymA"),gv("Via")}}, */
1782  /* here is a smaller (fewer variables) example */
1783  F : {{gv("CSup"),-gv("DiagF"),-gv("DisT")},
1784       {gv("CSup"),gv("DiagF"),gv("DisT")},
1785       {gv("CSup"),gv("DiagF"),gv("DisT")}},
1786  var_cs(F) := map(abs,apply(union,listify(F))),
1787  all_tass(V) :=
1788   map(setify,
1789    apply(cartesian_product,
1790      map(lambda([v],{-v,v}),listify(V)))),
1791  fullcnf2fulldnf(F) := setdifference(all_tass(var_cs(F)),F),
1792  fullcnf2fulldnf(F));
1793
1794 {{-abs(gv("CSup")),-abs(gv("DiagF")),-abs(gv("DisT"))},{-abs(gv("CSup")),-abs(gv("DiagF")),abs(gv("DisT"))},
1795  {-abs(gv("CSup")),abs(gv("DiagF")),-abs(gv("DisT"))},{-abs(gv("CSup")),abs(gv("DiagF")),abs(gv("DisT"))},
1796  {abs(gv("CSup")),-abs(gv("DiagF")),-abs(gv("DisT"))},{abs(gv("CSup")),-abs(gv("DiagF")),abs(gv("DisT"))},
1797  {abs(gv("CSup")),abs(gv("DiagF")),-abs(gv("DisT"))},{abs(gv("CSup")),abs(gv("DiagF")),abs(gv("DisT"))}}$
1798
1799 /* full_listify - ID: 3005820 */
1800 full_listify(rat(3/4));
1801 3/4$
1802
1803 /* is union nary? */
1804 xreduce('union,[]);
1805 set()$