tests/rtest6.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 (reset(), kill(all),0);
   9 0;
  10
  11 integrate(x^(5/4)/(x+1)^(5/2),x,0,inf);
  12 beta(9/4,1/4);
  13 gradef(q(x),sin(x^2));
  14 q(x);
  15 diff(log(q(r(x))),x);
  16 'diff(r(x),x,1)*sin(r(x)^2)/q(r(x));
  17 integrate(%,x);
  18 log(q(r(x)));
  19
  20 ?nformat(?complex(1,2));
  21 2*%i + 1;
  22 ?nformat(?/(1,2)); /* ?/(1,2) equivalent to (/ 1 2) in Lisp */
  23 1/2$
  24
  25 /* example for now-disable interval struct in src/nforma.lisp
  26 ?typep(interval(1,2),?ri);
  27 true$
  28  */
  29 is(part(?complex(1,2),0)="+");
  30 true$
  31
  32 /* bug reported to mailing list 2013-05-22 */
  33
  34 block ([a, L],
  35   a : make_array (fixnum, 3),
  36   L : buildq ([a], lambda ([x], a[x])),
  37   print (L, L(0))); /* print(L) --> calls NFORMAT and therefore tickles bug */
  38 0;
  39
  40 /* expressions like f(x)(y) */
  41
  42 (kill (f, x, y), f(x)(y));
  43 f(x)(y);
  44
  45 (f(x)(y), [op (%%), args (%%)]);
  46 [f(x), [y]];
  47
  48 (f(x)(y), [op (op (%%)), args (op (%%))]);
  49 [f, [x]];
  50
  51 apply (f(x), [y]);
  52 f(x)(y);
  53
  54 (kill (z), f(x)(y)(z));
  55 f(x)(y)(z);
  56
  57 (f(x)(y)(z), [op (%%), args (%%), op (op (%%)), args (op (%%)), op (op (op (%%))), args (op (op (%%)))]);
  58 [f(x)(y), [z], f(x), [y], f, [x]];
  59
  60 ev (f(x)(y), f(u) := buildq ([u], lambda ([v], v*u)));
  61 x*y;
  62
  63 apply (f(x)(y), [z]);
  64 f(x)(y)(z);
  65
  66 map (f(x), [1, 2, 3]);
  67 [f(x)(1), f(x)(2), f(x)(3)];
  68
  69 (f(u) := subst (u, 'u, lambda ([v], v^u)),
  70  [f(x), f(x)(y)]);
  71 [lambda ([v], v^x), y^x];
  72
  73 (kill (f),
  74  matchdeclare (xx, integerp),
  75  tellsimp (f(xx), subst ('xx = xx, lambda ([a], a - xx))),
  76  [f(1), f(1)(y)]);
  77 [lambda ([a], a - 1), y - 1];
  78
  79 (remrule (f, all), 0);
  80 0;
  81
  82 (matchdeclare ([xx, yy], integerp),
  83  tellsimp (f(xx)(yy), yy*xx),
  84  [f(2), f(2)(3)]);
  85 [f(2), 6];
  86
  87 kill (rules);
  88 done;
  89
  90 /* verify that subscripted functions are formatted without superfluous parentheses
  91  * see SF bug #2998: "extra () in display2d:false output"
  92  */
  93
  94 (kill (foo, x, y),
  95  string (foo[x](y)));
  96 "foo[x](y)";
  97
  98 [string (li[2](x)), string (psi[3](y))];
  99 ["li[2](x)", "psi[3](y)"];
 100
 101 /* further tests for #2998 combining subscripted functions with various user-defined operators */
 102
 103 block ([opsies : ["infixie", "prefixie", "postfixie", "naryie", "matchfixie", "nofixie"]],
 104   apply (kill, opsies),
 105   map (lambda ([f, a], apply (f, [a])), [infix, prefix, postfix, nary, lambda ([a], matchfix (a, a)), nofix], opsies),
 106   kill (foo, bar, baz, a, b, c, x, y, z),
 107   0);
 108 0;
 109
 110 foo[x, y](a) infixie bar[z](b, c);
 111 (foo[x, y](a)) infixie (bar[z](b, c));
 112
 113 string ((foo[x, y](a)) infixie (bar[z](b, c)));
 114 "foo[x,y](a) infixie bar[z](b,c)";
 115
 116 bar[a, a](x, x) naryie baz[a](x, y) naryie prefixie foo[a, b](x, y);
 117 (bar[a, a](x, x)) naryie (baz[a](x, y)) naryie (prefixie (foo[a, b](x, y)));
 118
 119 string ((bar[a, a](x, x)) naryie (baz[a](x, y)) naryie (prefixie (foo[a, b](x, y))));
 120 "bar[a,a](x,x) naryie baz[a](x,y) naryie prefixie foo[a,b](x,y)";
 121
 122 matchfixie foo[1](z) matchfixie;
 123 matchfixie (foo[1](z)) matchfixie;
 124
 125 string (matchfixie (foo[1](z)) matchfixie);
 126 "matchfixiefoo[1](z)matchfixie";
 127
 128 /* ... and with built-in operators */
 129
 130 foo[x, y](a)^bar[z](b, c);
 131 (foo[x, y](a))^(bar[z](b, c));
 132
 133 string ((foo[x, y](a))^(bar[z](b, c)));
 134 "foo[x,y](a)^bar[z](b,c)";
 135
 136 bar[a, a](x, x) and baz[a](x, y) and not foo[a, b](x, y);
 137 (bar[a, a](x, x)) and (baz[a](x, y)) and (not (foo[a, b](x, y)));
 138
 139 string ((bar[a, a](x, x)) and (baz[a](x, y)) and (not (foo[a, b](x, y))));
 140 "bar[a,a](x,x) and baz[a](x,y) and not foo[a,b](x,y)";
 141
 142 [ foo[1](z) ];
 143 [ (foo[1](z)) ];
 144
 145 string ([ (foo[1](z)) ]);
 146 "[foo[1](z)]";
 147
 148 /* mailing list 2015-10-05: "Wrong result from integrate?" */
 149
 150 (kill(t, R), integrate(sqrt(sin(t)^2*R^2+(1-cos(t))^2*R^2),t,0,2*%pi));
 151 8*R;
 152
 153 /* SF bug #2845: "Avoid initialization-time compile in commac.lisp"
 154  * Ensure that functions to strip trailing zero digits continue to work.
 155  */
 156
 157 string (25.0);
 158 "25.0";
 159
 160 string(1/16.0);
 161 "0.0625";
 162
 163 (string(2e7), %% = "2.0e+7" or %% = "2.0E+7" or %% = "2.0e7" or %% = "2.0E7" or %%);
 164 true;
 165
 166 (string(2e-7), %% = "2.0e-7" or %% = "2.0E-7" or %%);
 167 true;
 168
 169 (string(12345000000.0), %% = "1.2345e+10" or %% = "1.2345E+10" or %% = "1.2345e10" or %% = "1.2345E10" or %%);
 170 true;
 171
 172 (string(1/1024.0), %% = "9.765625e-4" or %% = "9.765625E-4" or %%);
 173 true;
 174
 175 /* SF bug #4107: "least_positive_float doesn't print/read correctly in float/bfloat" */
 176
 177 (reset (fpprintprec), 0);
 178 0;
 179
 180 is (parse_string (string (most_positive_float)) = most_positive_float);
 181 true;
 182
 183 is (parse_string (string (least_positive_float)) = least_positive_float);
 184 true;
 185
 186 is (parse_string (string (least_positive_normalized_float)) = least_positive_normalized_float);
 187 true;
 188
 189 is (parse_string (string (most_negative_float)) = most_negative_float);
 190 true;
 191
 192 is (parse_string (string (least_negative_float)) = least_negative_float);
 193 true;
 194
 195 is (parse_string (string (least_negative_normalized_float)) = least_negative_normalized_float);
 196 true;
 197
 198 is (parse_string (string (float_eps ())) = float_eps ());
 199 true;
 200
 201 /* bug reported to mailing list 2023-09-25: "Casting SPELs" */
 202
 203 (kill (all),
 204 SPEL([rest])::= buildq(
 205   [rest],
 206   buildq(splice(rest)) ),
 207 game_action(command,subj,obj,place,[rest])::= SPEL(
 208   [command,subj,obj,place,rest],
 209   block(
 210      infix(command),
 211      command(subject,object):= block(
 212         if location = place
 213            and subject = subj
 214            and object = obj
 215            and have(subj) then apply(sconcat,rest)
 216         else sconcat("you cannot ",command," like that. ") ))),
 217 game_action("weld",chain,bucket,attic,
 218   if have(bucket)
 219   and not chain_welded then (
 220      chain_welded: true,
 221      "the chain is now securely welded to the bucket. " )
 222   else "you do not have a bucket. "),
 223 0);
 224 0;
 225
 226 chain weld bucket;
 227 "you cannot weld like that. ";
 228
 229 subst (f = "foo", f(x));
 230 foo(x);