tests/rtest12.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),matchdeclare(a,true));
  10 done$
  11 (\^rule1_retval : tellsimp(sin(a)^2,1-cos(a)^2), 0);
  12 0;
  13 sin(y)^2;
  14 1-cos(y)^2$
  15 kill(rules);
  16 done$
  17 nonzeroandfreeof(x,e):=is(e # 0 and freeof(x,e));
  18 nonzeroandfreeof(x,e):=is(e # 0 and freeof(x,e))$
  19 matchdeclare(a,nonzeroandfreeof(x),b,freeof(x));
  20 done$
  21 defmatch(linear,a*x+b,x);
  22 linear$
  23 linear(3*z+(y+1)*z+y^2,z);
  24 [b = y^2,a = y+4,x = z]$
  25 matchdeclare([a,f],true);
  26 done$
  27 constinterval(l,h):=constantp(h-l);
  28 constinterval(l,h):=constantp(h-l)$
  29 matchdeclare(b,constinterval(a));
  30 done$
  31 matchdeclare(x,atom);
  32 done$
  33 block(remove(integrate,outative),defmatch(checklimits,'integrate(f,x,a,b)),
  34       declare(integrate,outative));
  35 done$
  36 'integrate(sin(t),t,x+%pi,x+2*%pi);
  37 'integrate(sin(t),t,x+%pi,x+2*%pi)$
  38 checklimits(%);
  39 [b = x+2*%pi,a = x+%pi,x = t,f = sin(t)]$
  40 'integrate(sin(t),t,0,x);
  41 'integrate(sin(t),t,0,t)$
  42 checklimits(%);
  43 false$
  44 (kill(all),matchdeclare(x,freeof(%i)));
  45 done$
  46 %iargs:false;
  47 false$
  48 (sinrule_retval : tellsimp(sin(%i*x),%i*sinh(x)), 0);
  49 0;
  50 trigexpand(sin(x+%i*y));
  51 sin(x)*cos(%i*y)+%i*cos(x)*sinh(y)$
  52 %iargs:true;
  53 true$
  54 errcatch(0^0);
  55 []$
  56 ev((\^rule2_retval : tellsimp(0^0,1), 0),simp:false);
  57 0;
  58 0^0;
  59 1$
  60 remrule ("^", first (\^rule2_retval));
  61 "^"$
  62 (\^rule3_retval : tellsimp(sin(x)^2,1-cos(x)^2), 0);
  63 0;
  64 (sin(x)+1)^2;
  65 (sin(x)+1)^2$
  66 expand(%);
  67 2*sin(x)-cos(x)^2+2$
  68 sin(x)^2;
  69 1-cos(x)^2$
  70 kill(rules);
  71 done$
  72 matchdeclare(a,true);
  73 done$
  74 (\^rule4_retval : tellsimp(sin(a)^2,1-cos(a)^2), 0);
  75 0;
  76 sin(y)^2;
  77 1-cos(y)^2$
  78 kill(rules);
  79 done$
  80 (kill(all),nonzeroandfreeof(x,e):=is(e # 0 and freeof(x,e)));
  81 nonzeroandfreeof(x,e):=is(e # 0 and freeof(x,e))$
  82 matchdeclare(a,nonzeroandfreeof(x),b,freeof(x));
  83 done$
  84 defmatch(linear,a*x+b,x);
  85 linear$
  86 linear(3*z+(y+1)*z+y^2,z);
  87 [b = y^2,a = y+4,x = z]$
  88 matchdeclare([a,f],true);
  89 done$
  90 constinterval(l,h):=constantp(h-l);
  91 constinterval(l,h):=constantp(h-l)$
  92 matchdeclare(b,constinterval(a));
  93 done$
  94 matchdeclare(x,atom);
  95 done$
  96 block(remove(integrate,outative),defmatch(checklimits,'integrate(f,x,a,b)),
  97       declare(integrate,outative));
  98 done$
  99 'integrate(sin(t),t,x+%pi,x+2*%pi);
 100 'integrate(sin(t),t,x+%pi,x+2*%pi)$
 101 checklimits(%);
 102 [b = x+2*%pi,a = x+%pi,x = t,f = sin(t)]$
 103 'integrate(sin(t),t,0,x);
 104 'integrate(sin(t),t,0,t)$
 105 checklimits(%);
 106 false$
 107 remvalue(a,b,f,x);
 108 [a,b,f,x]$
 109
 110 /* test cases extracted from reference manual for 'let' */
 111
 112 (kill(all),matchdeclare([a,a1,a2],true));
 113 done$
 114 oneless(x,y):=is(x = y-1);
 115 oneless(x,y):=is(x = y-1)$
 116 let(a1*a2!,a1!,oneless,a2,a1);
 117 ?mtext(a1*a2!,?\ \-\-\>\ ,a1!,?\ where\ ,oneless(a2,a1))$
 118 ev(let(a1!/a1,(a1-1)!),letrat);
 119 ?mtext(a1!/a1,?\ \-\-\>\ ,(a1-1)!)$
 120 ev(letsimp(n*m!*(n-1)!/m),letrat);
 121 (m-1)!*n!$
 122 let(sin(a)^2,1-cos(a)^2);
 123 ?mtext(sin(a)^2,?\ \-\-\>\ ,1-cos(a)^2)$
 124 sin(x)^4;
 125 sin(x)^4$
 126 letsimp(%);
 127 cos(x)^4-2*cos(x)^2+1$
 128
 129 /* test cases extracted from reference manual for 'letrat' */
 130
 131 (kill (all), matchdeclare (n, true))$
 132 done;
 133
 134 let (n!/n, (n-1)!);
 135 ?mtext (n!/n, ?\ \-\-\>\ , (n - 1)!);
 136
 137 (letrat: false, letsimp (a!/a));
 138 a!/a;
 139
 140 (letrat: true, letsimp (a!/a));
 141 (a - 1)!;
 142
 143 (reset (letrat), 0);
 144 0;
 145
 146 /* test cases extracted from reference manual for 'letsimp' */
 147
 148 (kill (all),
 149  e0: e(k) = -(9*y(k))/(5*z)-u(k-1)/(5*z)+(4*y(k))/(5*z^2) +(3*u(k-1))/(5*z^2)+y(k)-(2*u(k-1))/5,
 150  matchdeclare (h, any),
 151  let (u(h)/z, u(h - 1)));
 152 ?mtext (u(h)/z, ?\ \-\-\>\ , u(h - 1));
 153
 154 let (y(h)/z, y(h - 1));
 155 ?mtext (y(h)/z, ?\ \-\-\>\ , y(h - 1));
 156
 157 /* SF bug #4408: "letsimp doesn't simplify before returning result" */
 158
 159 e1: letsimp (e0);
 160 e(k) = y(k)-(9*y(k-1))/5-(2*u(k-1))/5+(4*y(k-2))/5-u(k-2)/5+(3*u(k-3))/5$
 161
 162 /* SF bug #4407: "letsimp doesn't commute with equation, list, matrix" */
 163
 164 letsimp ([rhs (e0)]);
 165 [''(rhs (e1))];
 166
 167 letsimp (matrix ([rhs (e0)]));
 168 matrix ([''(rhs (e1))]);
 169
 170 letsimp (lhs (e0)) = letsimp (rhs (e0));
 171 ''e1;
 172
 173 [letsimp (rhs (e0))];
 174 [''(rhs (e1))];
 175
 176 matrix ([letsimp (''(rhs (e0)))]);
 177 matrix ([''(rhs (e1))]);
 178
 179 pfeformat:true;
 180 true$
 181 poissimp(sin(x)^2);
 182 1/2-1/2*cos(2*x)$
 183 (2*a^2-b)*cos(x+2*y)-(a*b+5)*sin(u-4*x);
 184 (2*a^2-b)*cos(2*y+x)+(a*b+5)*sin(4*x-u)$
 185 exp1:outofpois(poisexpt(%,2));
 186 1/2*(2*a^2-b)^2*cos(4*y+2*x)-(2*a^2-b)*(-a*b-5)*sin(2*y+5*x-u)
 187                             +(2*a^2-b)*(-a*b-5)*sin(2*y-3*x+u)
 188                             -1/2*(-a*b-5)^2*cos(8*x-2*u)+1/2*(-a*b-5)^2
 189                             +1/2*(2*a^2-b)^2$
 190 printpois(%);
 191 done$
 192
 193 ratsimp(outofpois(poisint(exp1,y)));
 194 ''(ratsimp(((-1)*(2*a^2-b)*(-5-a*b)*cos(u-3*x+2*y))/2+((2*a^2-b)*(-5-a*b)*cos(-u+5*x+2*y))/2+((2*a^2-b)^2*sin(2*x+4*y))/8))$
 195
 196 ratsimp(outofpois(poissimp(%)));
 197 ''(ratsimp(1/8*(2*a^2-b)^2*sin(4*y+2*x)+1/2*(2*a^2-b)*(-a*b-5)*cos(2*y+5*x-u)
 198                             -1/2*(2*a^2-b)*(-a*b-5)*cos(2*y-3*x+u)))$
 199
 200 poissimp(sin(x)^5+cos(x)^5);
 201 1/16*sin(5*x)+1/16*cos(5*x)-5/16*sin(3*x)+5/16*cos(3*x)+5/8*sin(x)+5/8*cos(x)$
 202
 203 pfeformat:false;
 204 false$
 205
 206 /* test for bug #1097: rules and pattern bug */
 207
 208 (kill (foo, bar),
 209  matchdeclare (aa, true, gg, lambda([yy], evenp(yy) and (yy > 1))),
 210  let (foo(aa)^gg, (1 - bar(aa)^2)^(gg/2)),
 211  0);
 212 0;
 213
 214 letsimp (foo(x)^2);
 215 1 - bar(x)^2;
 216
 217 letsimp (foo(x)^3);
 218 foo(x)^3;
 219
 220 letsimp (foo(x)^4);
 221 bar(x)^4 - 2*bar(x)^2 + 1;
 222
 223 /* More tests for bug #1097: pattern variable appears in letsimp result */
 224
 225 (kill (f, g, x, y),
 226  matchdeclare ([arg1, arg2, exp], true),
 227  let (f(arg1, arg2)^exp, g(arg2, arg1)^exp), 0);
 228 0;
 229
 230 letsimp (f(x, y)); /* This used to yield g(arg2,arg1) */
 231 g(y, x);
 232
 233 letsimp (f(x, y)^2); /* This used to yield g(arg2,arg1)^2 */
 234 g(y, x)^2;
 235
 236 letsimp (f(x, y)^q); /* This used to yield g(arg2,arg1)^q */
 237 g(y, x)^q;
 238
 239 (remlet (f(arg1, arg2)^exp),
 240  remove ([arg1, arg2, exp], matchdeclare),
 241  0);
 242 0;
 243
 244 /* letsimp confused by debug stuff in expression car
 245  * mailing list 2012-12-23: "let(simp) behaves different when loaded from batch file"
 246  */
 247 (kill (test),
 248  test() := block([expr],
 249    local (F),
 250    expr : diff(f(x), x),
 251    F(xx) := at(expr, [x = xx]),
 252    let(at(diff(f(x),x),[x=0]),5),
 253    letsimp(F(0))),
 254  test ());
 255 5;
 256
 257 /* Bug #2709: `letsimp' is wrong if `ratexpand' is called */
 258
 259 (let (U, T), 0);
 260 0;
 261
 262 letsimp (U / n);
 263 T / n;
 264
 265 ratexpand (a * b * c);
 266 a * b * c;
 267
 268 letsimp (U / n); /* This used to yield 1 */
 269 T / n;
 270
 271 (remlet (U), 0);
 272 0;
 273
 274 /* Some basic letsimp tests, based on bug #3950 */
 275
 276 (let (f, g), 0);
 277 0;
 278
 279 letsimp (f);
 280 g;
 281
 282 letsimp (f ());
 283 f ();
 284
 285 letsimp (f (1));
 286 f (1);
 287
 288 letsimp (f (1, 2, 3));
 289 f (1, 2, 3);
 290
 291 (remlet (f), 0);
 292 0;
 293
 294 (let (f (1), g (1)), 0);
 295 0;
 296
 297 letsimp (f);
 298 f;
 299
 300 letsimp (f ());
 301 f ();
 302
 303 letsimp (f (1));
 304 g (1);
 305
 306 letsimp (f (1, 2, 3));
 307 f (1, 2, 3);
 308
 309 (remlet (f (1)), 0);
 310 0;
 311
 312 (let (f (1, 2, 3), g (1, 2, 3)), 0);
 313 0;
 314
 315 letsimp (f);
 316 f;
 317
 318 letsimp (f ());
 319 f ();
 320
 321 letsimp (f (1));
 322 f (1);
 323
 324 letsimp (f (1, 2, 3));
 325 g (1, 2, 3);
 326
 327 (remlet (f (1, 2, 3)), 0);
 328 0;
 329
 330 /* Bug #3950: letsimp confuses symbols and nullary applications */
 331
 332 (let (f (), g ()), 0);
 333 0;
 334
 335 /* This used to yield g() */
 336 letsimp (f);
 337 f;
 338
 339 /* This used to yield f() */
 340 letsimp (f ());
 341 g ();
 342
 343 letsimp (f (1));
 344 f (1);
 345
 346 letsimp (f (1, 2, 3));
 347 f (1, 2, 3);
 348
 349 (remlet (f ()), 0);
 350 0;
 351
 352 (matchdeclare (foo, true), 0);
 353 0;
 354
 355 (let (foo (), bar ()), 0);
 356 0;
 357
 358 /* This used to cause a stack overflow */
 359 letsimp (x);
 360 x;
 361
 362 /* This also used to cause a stack overflow */
 363 letsimp (foo ());
 364 bar ();
 365
 366 (remove (foo, matchdeclare),
 367  remlet (foo ()),
 368  0);
 369 0;
 370