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