tests/rtest_allnummod.mac

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