tests/rtest9a.mac

   1 /*************** -*- Mode: MACSYMA; Package: MAXIMA -*-  ******************/
   2 /***************************************************************************
   3 ***                                                                    *****
   4 ***     Copyright (c) 1984 by William Schelter,University of Texas     *****
   5 ***     All rights reserved                                            *****
   6 ***************************************************************************/
   7
   8
   9 kill(all);
  10 done;
  11 deftaylor(f(x),x^2+sum(x^i/(2^i*i!^2),i,4,inf));
  12 [f]$
  13 taylor(%e^sqrt(f(x)),x,0,4);
  14 1+x+x^2/2+3073*x^3/18432+12817*x^4/307200$
  15
  16 ev(x+sin(3*x)/sin(x),trigexpand,expand);
  17 -sin(x)^2+3*cos(x)^2+x$
  18 trigexpand(sin(10*x+y));
  19 cos(10*x)*sin(y)+sin(10*x)*cos(y)$
  20 -sin(x)^2+3*cos(x)^2+x;
  21 -sin(x)^2+3*cos(x)^2+x$
  22 expand(trigreduce(%));
  23 2*cos(2*x)+x+1$
  24 declare(j,integer,e,even,o,odd);
  25 done$
  26 sin(x+(e+1/2)*%pi),expand;
  27 cos(x)$
  28 sin(x+(o+1/2)*%pi),expand;
  29 -cos(x)$
  30 (linel:500,diff(exp(x^2+y)/(x+y),x,2));
  31 4*x^2*%e^(y+x^2)/(y+x)+2*%e^(y+x^2)/(y+x)-4*x*%e^(y+x^2)/(y+x)^2 +2*%e^(y+x^2)/(y+x)^3$
  32
  33 sconcat(optimize(%));
  34 "block([%1,%2,%3,%4],%1:y+x,%2:x^2,%3:%e^(y+%2),%4:1/%1,4*%2*%4*%3+2*%4*%3-(4*x*%3)/%1^2+(2*%3)/%1^3)"$
  35
  36 linel:79;
  37 79$
  38 laplace(%e^(2*t+a)*sin(t)*t,t,s);
  39 %e^a*(2*s-4)/(s^2-4*s+5)^2$
  40 'integrate(sinh(a*x)*f(t-x),x,0,t)+b*f(t) = t^2;
  41 'integrate(f(t-x)*sinh(a*x),x,0,t)+b*f(t) = t^2$
  42
  43 expand(laplace(%,t,s),0,0);
  44 ''(expand(b*laplace(f(t),t,s)+a*laplace(f(t),t,s)/(s^2-a^2) = 2/s^3,0,0))$
  45
  46 linsolve([%],['laplace(f(t),t,s)]);
  47 ['laplace(f(t),t,s) = (2*s^2-2*a^2)/(b*s^5+(a-a^2*b)*s^3)]$
  48
  49 (exp : %,0);
  50 0$
  51
  52 assume(a>0,b>0,a*b>1);
  53 [a>0,b>0,a*b>1];
  54 ilt(ev(exp[1]),s,t);
  55 f(t)=-2*cosh(sqrt(a*b*(a*b-1))*t/b)/(a^3*b^2-2*a^2*b+a)+a*t^2/(a*b-1)+2/(a^3*b^2-2*a^2*b+a)$
  56 forget(a>0,b>0,a*b>1);
  57 [a>0,b>0,a*b>1];
  58
  59 /* bug reported to mailing list 2015-02-16: expand phenomenon */
  60
  61 block ([f1, f2], f1:y=(x+1)*(x+3), f2:expand(f1), string (expand(f1)=expand(f2)));
  62 "(y = x^2+4*x+3) = (y = x^2+4*x+3)";
  63
  64 string ((a = b) = (c = d));
  65 "(a = b) = (c = d)";
  66
  67 /* following is supposed to test pretty printing code path
  68  * not sure if embedded newline will be recognized appropriately on Windows
  69  */
  70 block ([s, stuff],
  71   with_default_2d_display(
  72     s : make_string_output_stream (),
  73     with_stdout (s, print ((a = b) = (c = d))),
  74     stuff : get_output_stream_string (s),
  75     close (s),
  76     stuff));
  77 "(a = b) = (c = d)
  78 ";
  79
  80 infix ("foo");
  81 "foo";
  82
  83 string ((a foo b) foo (c foo d));
  84 "(a foo b) foo (c foo d)";
  85
  86 /* following is supposed to test pretty printing code path
  87  * not sure if embedded newline will be recognized appropriately on Windows
  88  */
  89 block ([s, stuff],
  90   with_default_2d_display(
  91     s : make_string_output_stream (),
  92     with_stdout (s, print ((a foo b) foo (c foo d))),
  93     stuff : get_output_stream_string (s),
  94     close (s),
  95     stuff));
  96 "(a foo b) foo (c foo d)
  97 ";
  98
  99 kill ("foo");
 100 done;
 101
 102 /* mailing list 2015-09-08 and SF bug #3019: "transfer function" */
 103
 104 (verify_display_2d (expr, expected_output) :=
 105   block ([S, output],
 106     with_default_2d_display
 107      (S : make_string_output_stream (),
 108       with_stdout (S, print (expr)),
 109       output : get_output_stream_string (S),
 110       close (S),
 111       if is (output = expected_output) then true else [expected_output, output])),
 112  verify_display_1d (expr, expected_output) :=
 113    block ([output : string (expr)], if is (output = expected_output) then true else [expected_output, output]),
 114  0);
 115 0;
 116
 117 /* increase linel so next few test cases avoid Lisp error when run_testsuite(display_all = true)
 118  * workaround for SF bug https://sourceforge.net/p/maxima/bugs/4234/
 119  */
 120
 121 linel: 140;
 122 140;
 123
 124 block ([powerdisp : false, display2d_unicode: false],
 125   verify_display_2d ((x+1)/(x+2),
 126 "x + 1
 127 -----
 128 x + 2
 129 "));
 130 true;
 131
 132 block ([powerdisp : true, display2d_unicode: false],
 133   verify_display_2d ((x+1)/(x+2),
 134 "1 + x
 135 -----
 136 2 + x
 137 "));
 138 true;
 139
 140 (reset (linel), 0);
 141 0;
 142
 143 block ([powerdisp : false], verify_display_1d ((x+1)/(x+2), "(x+1)/(x+2)"));
 144 true;
 145
 146 block ([powerdisp : true], verify_display_1d ((x+1)/(x+2), "(1+x)/(2+x)"));
 147 true;
 148
 149 (H : ( n2 * s^2 + n1 * s + n0 ) / ( d2 * s^2 + d1 * s + d0 ), 0);
 150 0;
 151
 152 block ([powerdisp : false, display2d_unicode: false], verify_display_2d (H,
 153 "    2
 154 n2 s  + n1 s + n0
 155 -----------------
 156     2
 157 d2 s  + d1 s + d0
 158 "));
 159 true;
 160
 161 block ([powerdisp : true, display2d_unicode: false], verify_display_2d (H,
 162 "                2
 163 n0 + n1 s + n2 s
 164 -----------------
 165                 2
 166 d0 + d1 s + d2 s
 167 "));
 168 true;
 169
 170 block ([powerdisp : false], verify_display_1d (H, "(n2*s^2+n1*s+n0)/(d2*s^2+d1*s+d0)"));
 171 true;
 172
 173 block ([powerdisp : true], verify_display_1d (H, "(n0+n1*s+n2*s^2)/(d0+d1*s+d2*s^2)"));
 174 true;
 175
 176
 177 /* mailing list 2015-09-08: "Maxima 5.37.1 changes in behaviour when simp:false" */
 178
 179 simp:false;
 180 false;
 181
 182 (p:1+x,
 183  [?second (p), ?third (p)]);
 184 [1, x];
 185
 186 string(p);
 187 "1+x";
 188
 189 tex(p, false);
 190 "$$1+x$$
 191 ";
 192
 193 simp : true;
 194 true;
 195
 196 (p:1+x,
 197  [?second (p), ?third (p)]);
 198 [1, x];
 199
 200 string(p);
 201 "x+1";
 202
 203 tex(p, false);
 204 "$$x+1$$
 205 ";
 206
 207 block ([powerdisp : false], verify_display_2d (diff (x^n, x),
 208 "   n - 1
 209 n x
 210 "));
 211 true;
 212
 213 block ([powerdisp : true], verify_display_2d (diff (x^n, x),
 214 "   - 1 + n
 215 n x
 216 "));
 217 true;
 218
 219 block ([powerdisp : false], verify_display_1d (diff (x^n, x), "n*x^(n-1)"));
 220 true;
 221
 222 block ([powerdisp : true], verify_display_1d (diff (x^n, x), "n*x^(-1+n)"));
 223 true;
 224
 225 /* mailing list 2015-09-04: "Inconsistent ordering: (x+1)^2 becomes (1+x)^2, but x+1 stays x+1" */
 226
 227 block ([powerdisp : false], verify_display_2d ((x+1)^2,
 228 "       2
 229 (x + 1)
 230 "));
 231 true;
 232
 233 block ([powerdisp : true], verify_display_2d ((x+1)^2,
 234 "       2
 235 (1 + x)
 236 "));
 237 true;
 238
 239 block ([powerdisp : false], verify_display_1d ((x+1)^2, "(x+1)^2"));
 240 true;
 241 block ([powerdisp : true], verify_display_1d ((x+1)^2, "(1+x)^2"));
 242 true;
 243
 244 block ([powerdisp : false], verify_display_2d ((x^3+x^2+x+1)^2,
 245 "  3    2         2
 246 (x  + x  + x + 1)
 247 "));
 248 true;
 249
 250 block ([powerdisp : true], verify_display_2d ((x^3+x^2+x+1)^2,
 251 "          2    3 2
 252 (1 + x + x  + x )
 253 "));
 254 true;
 255
 256 block ([powerdisp : false], verify_display_1d ((x^3+x^2+x+1)^2, "(x^3+x^2+x+1)^2"));
 257 true;
 258 block ([powerdisp : true], verify_display_1d ((x^3+x^2+x+1)^2, "(1+x+x^2+x^3)^2"));
 259 true;
 260
 261 block ([powerdisp : false], verify_display_2d (x+1,
 262 "x + 1
 263 "));
 264 true;
 265
 266 block ([powerdisp : true], verify_display_2d (x+1,
 267 "1 + x
 268 "));
 269 true;
 270
 271 block ([powerdisp : false], verify_display_1d (x+1, "x+1"));
 272 true;
 273 block ([powerdisp : true], verify_display_1d (x+1, "1+x"));
 274 true;
 275
 276 block ([powerdisp : false], verify_display_2d (x^3+x^2+x+1,
 277 " 3    2
 278 x  + x  + x + 1
 279 "));
 280 true;
 281
 282 block ([powerdisp : true], verify_display_2d (x^3+x^2+x+1,
 283 "         2    3
 284 1 + x + x  + x
 285 "));
 286 true;
 287
 288 block ([powerdisp : false], verify_display_1d (x^3+x^2+x+1, "x^3+x^2+x+1"));
 289 true;
 290 block ([powerdisp : true], verify_display_1d (x^3+x^2+x+1, "1+x+x^2+x^3"));
 291 true;
 292
 293 block ([powerdisp : false], verify_display_2d (2^(x+1),
 294 " x + 1
 295 2
 296 "));
 297 true;
 298
 299 block ([powerdisp : true], verify_display_2d (2^(x+1),
 300 " 1 + x
 301 2
 302 "));
 303 true;
 304
 305 block ([powerdisp : false], verify_display_1d (2^(x+1), "2^(x+1)"));
 306 true;
 307 block ([powerdisp : true], verify_display_1d (2^(x+1), "2^(1+x)"));
 308 true;
 309
 310 block ([powerdisp : false], verify_display_2d (2^(x^3+x^2+x+1),
 311 "  3    2
 312  x  + x  + x + 1
 313 2
 314 "));
 315 true;
 316
 317 block ([powerdisp : true], verify_display_2d (2^(x^3+x^2+x+1),
 318 "          2    3
 319  1 + x + x  + x
 320 2
 321 "));
 322 true;
 323
 324 block ([powerdisp : false], verify_display_1d (2^(x^3+x^2+x+1), "2^(x^3+x^2+x+1)"));
 325 true;
 326 block ([powerdisp : true], verify_display_1d (2^(x^3+x^2+x+1), "2^(1+x+x^2+x^3)"));
 327 true;
 328
 329 /* SF bug #3046 "Changes of behaviour with simp:false" */
 330
 331 block ([simp:false], string((3/6)*x));
 332 "(3/6)*x";
 333
 334 string (lambda ([], (2/2)*u));
 335 "lambda([],(2/2)*u)";
 336
 337 /* SF bug #4090: "output formatting: -x-1 has redundant parentheses: (-x)-1" */
 338
 339 /* copied print_string_2d from rtest3.mac */
 340 (print_string_2d (e) := with_default_2d_display (printf (false, "~m", e)), 0);
 341 0;
 342
 343 print_string_2d (-b-a);
 344 "- b - a
 345 ";
 346
 347 string (-b-a);
 348 "-b-a";
 349
 350 print_string_2d (-c-a);
 351 "- c - a
 352 ";
 353
 354 string (-c-a);
 355 "-c-a";
 356
 357 print_string_2d (-c-b);
 358 "- c - b
 359 ";
 360
 361 string (-c-b);
 362 "-c-b";
 363
 364 print_string_2d (-c+b+a);
 365 "- c + b + a
 366 ";
 367
 368 string (-c+b+a);
 369 "-c+b+a";
 370
 371 print_string_2d (-c+b-a);
 372 "- c + b - a
 373 ";
 374
 375 string (-c+b-a);
 376 "-c+b-a";
 377
 378 print_string_2d (-c-b+a);
 379 "- c - b + a
 380 ";
 381
 382 string (-c-b+a);
 383 "-c-b+a";
 384
 385 print_string_2d (-c-b-a);
 386 "- c - b - a
 387 ";
 388
 389 string (-c-b-a);
 390 "-c-b-a";
 391
 392 print_string_2d (-a);
 393 "- a
 394 ";
 395
 396 string (-a);
 397 "-a";
 398
 399 print_string_2d (a-b);
 400 "a - b
 401 ";
 402
 403 string (a-b);
 404 "a-b";
 405
 406 print_string_2d (a-c);
 407 "a - c
 408 ";
 409
 410 string (a-c);
 411 "a-c";
 412
 413 print_string_2d (b-a);
 414 "b - a
 415 ";
 416
 417 string (b-a);
 418 "b-a";
 419
 420 print_string_2d (b-c);
 421 "b - c
 422 ";
 423
 424 string (b-c);
 425 "b-c";
 426
 427 print_string_2d (c+b-a);
 428 "c + b - a
 429 ";
 430
 431 string (c+b-a);
 432 "c+b-a";
 433
 434 print_string_2d (c-a);
 435 "c - a
 436 ";
 437
 438 string (c-a);
 439 "c-a";
 440
 441 print_string_2d (c-b);
 442 "c - b
 443 ";
 444
 445 string (c-b);
 446 "c-b";
 447
 448 print_string_2d (c-b+a);
 449 "c - b + a
 450 ";
 451
 452 string (c-b+a);
 453 "c-b+a";
 454
 455 print_string_2d (c-b-a);
 456 "c - b - a
 457 ";
 458
 459 string (c-b-a);
 460 "c-b-a";
 461
 462 /* -a/b, (-a)/b, and -(a/b) all parse to the same thing,
 463  * therefore we should expect all three to be displayed the same.
 464  */
 465
 466 is ((-a)/b = -a/b);
 467 true;
 468
 469 is (-(a/b) = -a/b);
 470 true;
 471
 472 block ([display2d_unicode: false], print_string_2d (-a/b));
 473 "  a
 474 - -
 475   b
 476 ";
 477
 478 string (-a/b);
 479 "-(a/b)";
 480
 481 block ([display2d_unicode: false], print_string_2d (-(a/b)));
 482 "  a
 483 - -
 484   b
 485 ";
 486
 487 string (-(a/b));
 488 "-(a/b)";
 489
 490 block ([display2d_unicode: false], print_string_2d ((-a)/b));
 491 "  a
 492 - -
 493   b
 494 ";
 495
 496 string ((-a)/b);
 497 "-(a/b)";
 498
 499 /* -(a + b)/c and (-(a + b))/c parse to the same thing,
 500  * but -((a + b)/c) parses to something else,
 501  * therefore we should expect the first two are displayed the same,
 502  * and the third is something different.
 503  */
 504
 505 is ((-(a + b))/c = -(a + b)/c);
 506 true;
 507
 508 is (-((a + b)/c) = -(a + b)/c);
 509 false;
 510
 511 block ([display2d_unicode: false], print_string_2d (-(a + b)/c));
 512 "- b - a
 513 -------
 514    c
 515 ";
 516
 517 string (-(a + b)/c);
 518 "(-b-a)/c";
 519
 520 block ([display2d_unicode: false], print_string_2d ((-(a + b))/c));
 521 "- b - a
 522 -------
 523    c
 524 ";
 525
 526 string ((-(a + b))/c);
 527 "(-b-a)/c";
 528
 529 block ([display2d_unicode: false], print_string_2d (-((a + b)/c)));
 530 "  b + a
 531 - -----
 532     c
 533 ";
 534
 535 string (-((a + b)/c));
 536 "-((b+a)/c)";
 537
 538 /* SF bug #4092: "Repeated factorial (n!)! displayed the same as double factorial n!!" */
 539
 540 (kill (n), with_default_2d_display(printf (false, "~m", (n!)!)));
 541 "(n!)!
 542 ";
 543
 544 printf (false, "~a", (n!)!);
 545 "(n!)!";
 546
 547 tex1 ((n!)!);
 548 "\\left(n!\\right)!";
 549
 550 /* verify that "!" continues to interact correctly with other operators */
 551
 552 (kill (m, o), 0);
 553 0;
 554
 555 n! + m! + o!;
 556 (n!) + (m!) + (o!);
 557
 558 (n! * m! * o!);
 559 (n!) * (m!) * (o!);
 560
 561 '(n! := if n = 0 then 1 else n*(n - 1)!);
 562 (n!) := (if (n = 0) then 1 else (n*((n - 1)!)));
 563
 564 '(n! : m!);
 565 (n!) : (m!);
 566
 567 '(n! : m! : o!);
 568 (n!) : ((m!) : (o!));
 569
 570 '(n! := m! : o!);
 571 (n!) := ((m!) : (o!));
 572
 573 /* verify double factorial symbol continues to work the same */
 574
 575 n!!;
 576 genfact(n, n/2, 2);
 577
 578 n!!!;
 579 genfact(n, n/2, 2)!;
 580
 581 n!!!!;
 582 genfact(genfact(n, n/2, 2), genfact(n, n/2, 2)/2, 2);
 583
 584 (n!)!!;
 585 genfact(n!, n!/2, 2);
 586
 587 n!!*m!!;
 588 genfact(m, m/2, 2)*genfact(n, n/2, 2);