summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/runmath.cc
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/utils/asymptote/runmath.cc')
-rw-r--r--Build/source/utils/asymptote/runmath.cc782
1 files changed, 782 insertions, 0 deletions
diff --git a/Build/source/utils/asymptote/runmath.cc b/Build/source/utils/asymptote/runmath.cc
new file mode 100644
index 00000000000..776e45c804a
--- /dev/null
+++ b/Build/source/utils/asymptote/runmath.cc
@@ -0,0 +1,782 @@
+/***** Autogenerated from runmath.in; changes will be overwritten *****/
+
+#line 1 "runtimebase.in"
+/*****
+ * runtimebase.in
+ * Andy Hammerlindl 2009/07/28
+ *
+ * Common declarations needed for all code-generating .in files.
+ *
+ *****/
+
+
+#line 1 "runmath.in"
+/*****
+ * runmath.in
+ *
+ * Runtime functions for math operations.
+ *
+ *****/
+
+#line 1 "runtimebase.in"
+#include "stack.h"
+#include "types.h"
+#include "builtin.h"
+#include "entry.h"
+#include "errormsg.h"
+#include "array.h"
+#include "triple.h"
+#include "callable.h"
+#include "opsymbols.h"
+
+using vm::stack;
+using vm::error;
+using vm::array;
+using vm::read;
+using vm::callable;
+using types::formal;
+using types::function;
+using camp::triple;
+
+#define PRIMITIVE(name,Name,asyName) using types::prim##Name;
+#include <primitives.h>
+#undef PRIMITIVE
+
+typedef double real;
+
+void unused(void *);
+
+namespace run {
+array *copyArray(array *a);
+array *copyArray2(array *a);
+array *copyArray3(array *a);
+
+double *copyTripleArray2Components(array *a, size_t &N,
+ GCPlacement placement=NoGC);
+triple *copyTripleArray2C(array *a, size_t &N,
+ GCPlacement placement=NoGC);
+}
+
+function *realRealFunction();
+
+#define CURRENTPEN processData().currentpen
+
+#line 12 "runmath.in"
+#include <inttypes.h>
+
+#include "mathop.h"
+#include "path.h"
+
+#ifdef __CYGWIN__
+ extern "C" double yn(int, double);
+extern "C" double jn(int, double);
+extern "C" int __signgam;
+#define signgam __signgam
+#endif
+
+using namespace camp;
+
+typedef array realarray;
+typedef array pairarray;
+
+using types::realArray;
+using types::pairArray;
+
+using run::integeroverflow;
+using vm::frame;
+
+const char *invalidargument="invalid argument";
+
+extern uint32_t CLZ(uint32_t a);
+
+inline unsigned intbits() {
+ static unsigned count=0;
+ if(count > 0) return count;
+ while((1ULL << count) < Int_MAX)
+ ++count;
+ ++count;
+ return count;
+}
+
+static const unsigned char BitReverseTable8[256]=
+{
+#define R2(n) n, n+2*64, n+1*64, n+3*64
+#define R4(n) R2(n),R2(n+2*16),R2(n+1*16),R2(n+3*16)
+#define R6(n) R4(n),R4(n+2*4 ),R4(n+1*4 ),R4(n+3*4 )
+ R6(0),R6(2),R6(1),R6(3)
+};
+#undef R2
+#undef R4
+#undef R6
+
+unsigned long long bitreverse8(unsigned long long a)
+{
+ return
+ (unsigned long long) BitReverseTable8[a];
+}
+
+unsigned long long bitreverse16(unsigned long long a)
+{
+ return
+ ((unsigned long long) BitReverseTable8[a & 0xff] << 8) |
+ ((unsigned long long) BitReverseTable8[(a >> 8)]);
+}
+
+unsigned long long bitreverse24(unsigned long long a)
+{
+ return
+ ((unsigned long long) BitReverseTable8[a & 0xff] << 16) |
+ ((unsigned long long) BitReverseTable8[(a >> 8) & 0xff] << 8) |
+ ((unsigned long long) BitReverseTable8[(a >> 16)]);
+}
+
+unsigned long long bitreverse32(unsigned long long a)
+{
+ return
+ ((unsigned long long) BitReverseTable8[a & 0xff] << 24) |
+ ((unsigned long long) BitReverseTable8[(a >> 8) & 0xff] << 16) |
+ ((unsigned long long) BitReverseTable8[(a >> 16) & 0xff] << 8) |
+ ((unsigned long long) BitReverseTable8[(a >> 24)]);
+}
+
+unsigned long long bitreverse40(unsigned long long a)
+{
+ return
+ ((unsigned long long) BitReverseTable8[a & 0xff] << 32) |
+ ((unsigned long long) BitReverseTable8[(a >> 8) & 0xff] << 24) |
+ ((unsigned long long) BitReverseTable8[(a >> 16) & 0xff] << 16) |
+ ((unsigned long long) BitReverseTable8[(a >> 24) & 0xff] << 8) |
+ ((unsigned long long) BitReverseTable8[(a >> 32)]);
+}
+
+unsigned long long bitreverse48(unsigned long long a)
+{
+ return
+ ((unsigned long long) BitReverseTable8[a & 0xff] << 40) |
+ ((unsigned long long) BitReverseTable8[(a >> 8) & 0xff] << 32) |
+ ((unsigned long long) BitReverseTable8[(a >> 16) & 0xff] << 24) |
+ ((unsigned long long) BitReverseTable8[(a >> 24) & 0xff] << 16) |
+ ((unsigned long long) BitReverseTable8[(a >> 32) & 0xff] << 8) |
+ ((unsigned long long) BitReverseTable8[(a >> 40)]);
+}
+
+unsigned long long bitreverse56(unsigned long long a)
+{
+ return
+ ((unsigned long long) BitReverseTable8[a & 0xff] << 48) |
+ ((unsigned long long) BitReverseTable8[(a >> 8) & 0xff] << 40) |
+ ((unsigned long long) BitReverseTable8[(a >> 16) & 0xff] << 32) |
+ ((unsigned long long) BitReverseTable8[(a >> 24) & 0xff] << 24) |
+ ((unsigned long long) BitReverseTable8[(a >> 32) & 0xff] << 16) |
+ ((unsigned long long) BitReverseTable8[(a >> 40) & 0xff] << 8) |
+ ((unsigned long long) BitReverseTable8[(a >> 48)]);
+}
+
+unsigned long long bitreverse64(unsigned long long a)
+{
+ return
+ ((unsigned long long) BitReverseTable8[a & 0xff] << 56) |
+ ((unsigned long long) BitReverseTable8[(a >> 8) & 0xff] << 48) |
+ ((unsigned long long) BitReverseTable8[(a >> 16) & 0xff] << 40) |
+ ((unsigned long long) BitReverseTable8[(a >> 24) & 0xff] << 32) |
+ ((unsigned long long) BitReverseTable8[(a >> 32) & 0xff] << 24) |
+ ((unsigned long long) BitReverseTable8[(a >> 40) & 0xff] << 16) |
+ ((unsigned long long) BitReverseTable8[(a >> 48) & 0xff] << 8) |
+ ((unsigned long long) BitReverseTable8[(a >> 56)]);
+}
+
+#ifndef HAVE_POPCOUNT
+// https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+#define T unsignedInt
+Int popcount(T a)
+{
+ a=a-((a >> 1) & (T)~(T)0/3);
+ a=(a & (T)~(T)0/15*3)+((a >> 2) & (T)~(T)0/15*3);
+ a=(a+(a >> 4)) & (T)~(T)0/255*15;
+ return (T)(a*((T)~(T)0/255)) >> (sizeof(T)-1)*CHAR_BIT;
+}
+#undef T
+#endif
+
+// Return the factorial of a non-negative integer using a lookup table.
+Int factorial(Int n)
+{
+ static Int *table;
+ static Int size=0;
+ if(size == 0) {
+ Int f=1;
+ size=2;
+ while(f <= Int_MAX/size)
+ f *= (size++);
+ table=new Int[size];
+ table[0]=f=1;
+ for(Int i=1; i < size; ++i) {
+ f *= i;
+ table[i]=f;
+ }
+ }
+ if(n >= size) integeroverflow(0);
+ return table[n];
+}
+
+static inline Int Round(double x)
+{
+ return Int(x+((x >= 0) ? 0.5 : -0.5));
+}
+
+inline Int sgn(double x)
+{
+ return (x > 0.0 ? 1 : (x < 0.0 ? -1 : 0));
+}
+
+static bool initializeRandom=true;
+
+void Srand(Int seed)
+{
+ initializeRandom=false;
+ const int n=256;
+ static char state[n];
+ initstate(intcast(seed),state,n);
+}
+
+// Autogenerated routines:
+
+
+
+#ifndef NOSYM
+#include "runmath.symbols.h"
+
+#endif
+namespace run {
+#line 192 "runmath.in"
+// real ^(real x, Int y);
+void gen_runmath0(stack *Stack)
+{
+ Int y=vm::pop<Int>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 193 "runmath.in"
+ {Stack->push<real>(pow(x,y)); return;}
+}
+
+#line 197 "runmath.in"
+// pair ^(pair z, Int y);
+void gen_runmath1(stack *Stack)
+{
+ Int y=vm::pop<Int>(Stack);
+ pair z=vm::pop<pair>(Stack);
+#line 198 "runmath.in"
+ {Stack->push<pair>(pow(z,y)); return;}
+}
+
+#line 202 "runmath.in"
+// Int quotient(Int x, Int y);
+void gen_runmath2(stack *Stack)
+{
+ Int y=vm::pop<Int>(Stack);
+ Int x=vm::pop<Int>(Stack);
+#line 203 "runmath.in"
+ {Stack->push<Int>(quotient<Int>()(x,y)); return;}
+}
+
+#line 207 "runmath.in"
+// Int abs(Int x);
+void gen_runmath3(stack *Stack)
+{
+ Int x=vm::pop<Int>(Stack);
+#line 208 "runmath.in"
+ {Stack->push<Int>(Abs(x)); return;}
+}
+
+#line 212 "runmath.in"
+// Int sgn(real x);
+void gen_runmath4(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 213 "runmath.in"
+ {Stack->push<Int>(sgn(x)); return;}
+}
+
+#line 217 "runmath.in"
+// Int rand();
+void gen_runmath5(stack *Stack)
+{
+#line 218 "runmath.in"
+ if(initializeRandom)
+ Srand(1);
+ {Stack->push<Int>(random()); return;}
+}
+
+#line 224 "runmath.in"
+// void srand(Int seed);
+void gen_runmath6(stack *Stack)
+{
+ Int seed=vm::pop<Int>(Stack);
+#line 225 "runmath.in"
+ Srand(seed);
+}
+
+// a random number uniformly distributed in the interval [0,1]
+#line 230 "runmath.in"
+// real unitrand();
+void gen_runmath7(stack *Stack)
+{
+#line 231 "runmath.in"
+ {Stack->push<real>(((real) random())/RANDOM_MAX); return;}
+}
+
+#line 235 "runmath.in"
+// Int ceil(real x);
+void gen_runmath8(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 236 "runmath.in"
+ {Stack->push<Int>(Intcast(ceil(x))); return;}
+}
+
+#line 240 "runmath.in"
+// Int floor(real x);
+void gen_runmath9(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 241 "runmath.in"
+ {Stack->push<Int>(Intcast(floor(x))); return;}
+}
+
+#line 245 "runmath.in"
+// Int round(real x);
+void gen_runmath10(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 246 "runmath.in"
+ if(validInt(x)) {Stack->push<Int>(Round(x)); return;}
+ integeroverflow(0);
+}
+
+#line 251 "runmath.in"
+// Int Ceil(real x);
+void gen_runmath11(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 252 "runmath.in"
+ {Stack->push<Int>(Ceil(x)); return;}
+}
+
+#line 256 "runmath.in"
+// Int Floor(real x);
+void gen_runmath12(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 257 "runmath.in"
+ {Stack->push<Int>(Floor(x)); return;}
+}
+
+#line 261 "runmath.in"
+// Int Round(real x);
+void gen_runmath13(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 262 "runmath.in"
+ {Stack->push<Int>(Round(Intcap(x))); return;}
+}
+
+#line 266 "runmath.in"
+// real fmod(real x, real y);
+void gen_runmath14(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 267 "runmath.in"
+ if (y == 0.0) dividebyzero();
+ {Stack->push<real>(fmod(x,y)); return;}
+}
+
+#line 272 "runmath.in"
+// real atan2(real y, real x);
+void gen_runmath15(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ real y=vm::pop<real>(Stack);
+#line 273 "runmath.in"
+ {Stack->push<real>(atan2(y,x)); return;}
+}
+
+#line 277 "runmath.in"
+// real hypot(real x, real y);
+void gen_runmath16(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 278 "runmath.in"
+ {Stack->push<real>(hypot(x,y)); return;}
+}
+
+#line 282 "runmath.in"
+// real remainder(real x, real y);
+void gen_runmath17(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 283 "runmath.in"
+ {Stack->push<real>(remainder(x,y)); return;}
+}
+
+#line 287 "runmath.in"
+// real Jn(Int n, real x);
+void gen_runmath18(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 288 "runmath.in"
+ {Stack->push<real>(jn(n,x)); return;}
+}
+
+#line 292 "runmath.in"
+// real Yn(Int n, real x);
+void gen_runmath19(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 293 "runmath.in"
+ {Stack->push<real>(yn(n,x)); return;}
+}
+
+#line 297 "runmath.in"
+// real erf(real x);
+void gen_runmath20(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 298 "runmath.in"
+ {Stack->push<real>(erf(x)); return;}
+}
+
+#line 302 "runmath.in"
+// real erfc(real x);
+void gen_runmath21(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 303 "runmath.in"
+ {Stack->push<real>(erfc(x)); return;}
+}
+
+#line 307 "runmath.in"
+// Int factorial(Int n);
+void gen_runmath22(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 308 "runmath.in"
+ if(n < 0) error(invalidargument);
+ {Stack->push<Int>(factorial(n)); return;}
+}
+
+#line 312 "runmath.in"
+// Int choose(Int n, Int k);
+void gen_runmath23(stack *Stack)
+{
+ Int k=vm::pop<Int>(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 313 "runmath.in"
+ if(n < 0 || k < 0 || k > n) error(invalidargument);
+ Int f=1;
+ Int r=n-k;
+ for(Int i=n; i > r; --i) {
+ if(f > Int_MAX/i) integeroverflow(0);
+ f=(f*i)/(n-i+1);
+ }
+ {Stack->push<Int>(f); return;}
+}
+
+#line 323 "runmath.in"
+// real gamma(real x);
+void gen_runmath24(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 324 "runmath.in"
+#ifdef HAVE_TGAMMA
+ {Stack->push<real>(tgamma(x)); return;}
+#else
+ real lg = lgamma(x);
+ {Stack->push<real>(signgam*exp(lg)); return;}
+#endif
+}
+
+#line 333 "runmath.in"
+// realarray* quadraticroots(real a, real b, real c);
+void gen_runmath25(stack *Stack)
+{
+ real c=vm::pop<real>(Stack);
+ real b=vm::pop<real>(Stack);
+ real a=vm::pop<real>(Stack);
+#line 334 "runmath.in"
+ quadraticroots q(a,b,c);
+ array *roots=new array(q.roots);
+ if(q.roots >= 1) (*roots)[0]=q.t1;
+ if(q.roots == 2) (*roots)[1]=q.t2;
+ {Stack->push<realarray*>(roots); return;}
+}
+
+#line 342 "runmath.in"
+// pairarray* quadraticroots(explicit pair a, explicit pair b, explicit pair c);
+void gen_runmath26(stack *Stack)
+{
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 343 "runmath.in"
+ Quadraticroots q(a,b,c);
+ array *roots=new array(q.roots);
+ if(q.roots >= 1) (*roots)[0]=q.z1;
+ if(q.roots == 2) (*roots)[1]=q.z2;
+ {Stack->push<pairarray*>(roots); return;}
+}
+
+#line 351 "runmath.in"
+// realarray* cubicroots(real a, real b, real c, real d);
+void gen_runmath27(stack *Stack)
+{
+ real d=vm::pop<real>(Stack);
+ real c=vm::pop<real>(Stack);
+ real b=vm::pop<real>(Stack);
+ real a=vm::pop<real>(Stack);
+#line 352 "runmath.in"
+ cubicroots q(a,b,c,d);
+ array *roots=new array(q.roots);
+ if(q.roots >= 1) (*roots)[0]=q.t1;
+ if(q.roots >= 2) (*roots)[1]=q.t2;
+ if(q.roots == 3) (*roots)[2]=q.t3;
+ {Stack->push<realarray*>(roots); return;}
+}
+
+
+// Logical operations
+#line 363 "runmath.in"
+// bool !(bool b);
+void gen_runmath28(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack);
+#line 364 "runmath.in"
+ {Stack->push<bool>(!b); return;}
+}
+
+#line 369 "runmath.in"
+void boolMemEq(stack *Stack)
+{
+ frame * b=vm::pop<frame *>(Stack);
+ frame * a=vm::pop<frame *>(Stack);
+#line 370 "runmath.in"
+ {Stack->push<bool>(a == b); return;}
+}
+
+#line 374 "runmath.in"
+void boolMemNeq(stack *Stack)
+{
+ frame * b=vm::pop<frame *>(Stack);
+ frame * a=vm::pop<frame *>(Stack);
+#line 375 "runmath.in"
+ {Stack->push<bool>(a != b); return;}
+}
+
+#line 379 "runmath.in"
+void boolFuncEq(stack *Stack)
+{
+ callable * b=vm::pop<callable *>(Stack);
+ callable * a=vm::pop<callable *>(Stack);
+#line 380 "runmath.in"
+ {Stack->push<bool>(a->compare(b)); return;}
+}
+
+#line 384 "runmath.in"
+void boolFuncNeq(stack *Stack)
+{
+ callable * b=vm::pop<callable *>(Stack);
+ callable * a=vm::pop<callable *>(Stack);
+#line 385 "runmath.in"
+ {Stack->push<bool>(!(a->compare(b))); return;}
+}
+
+
+// Bit operations
+#line 391 "runmath.in"
+// Int AND(Int a, Int b);
+void gen_runmath33(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+#line 392 "runmath.in"
+ {Stack->push<Int>(a & b); return;}
+}
+
+#line 397 "runmath.in"
+// Int OR(Int a, Int b);
+void gen_runmath34(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+#line 398 "runmath.in"
+ {Stack->push<Int>(a | b); return;}
+}
+
+#line 402 "runmath.in"
+// Int XOR(Int a, Int b);
+void gen_runmath35(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+#line 403 "runmath.in"
+ {Stack->push<Int>(a ^ b); return;}
+}
+
+#line 407 "runmath.in"
+// Int NOT(Int a);
+void gen_runmath36(stack *Stack)
+{
+ Int a=vm::pop<Int>(Stack);
+#line 408 "runmath.in"
+ {Stack->push<Int>(~a); return;}
+}
+
+#line 412 "runmath.in"
+// Int CLZ(Int a);
+void gen_runmath37(stack *Stack)
+{
+ Int a=vm::pop<Int>(Stack);
+#line 413 "runmath.in"
+ if((unsigned long long) a > 0xFFFFFFFF)
+ {Stack->push<Int>(CLZ((uint32_t) ((unsigned long long) a >> 32))); return;}
+ else {
+ int bits=intbits();
+ if(a != 0) {Stack->push<Int>(bits-32+CLZ((uint32_t) a)); return;}
+ {Stack->push<Int>(bits); return;}
+ }
+}
+
+#line 423 "runmath.in"
+// Int popcount(Int a);
+void gen_runmath38(stack *Stack)
+{
+ Int a=vm::pop<Int>(Stack);
+#line 424 "runmath.in"
+ {Stack->push<Int>(popcount(a)); return;}
+}
+
+#line 428 "runmath.in"
+// Int CTZ(Int a);
+void gen_runmath39(stack *Stack)
+{
+ Int a=vm::pop<Int>(Stack);
+#line 429 "runmath.in"
+ {Stack->push<Int>(popcount((a&-a)-1)); return;}
+}
+
+// bitreverse a within a word of length bits.
+#line 434 "runmath.in"
+// Int bitreverse(Int a, Int bits);
+void gen_runmath40(stack *Stack)
+{
+ Int bits=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+#line 435 "runmath.in"
+ typedef unsigned long long Bitreverse(unsigned long long a);
+ static Bitreverse *B[]={bitreverse8,bitreverse16,bitreverse24,bitreverse32,
+ bitreverse40,bitreverse48,bitreverse56,bitreverse64};
+ int maxbits=intbits()-1; // Drop sign bit
+#if Int_MAX2 >= 0x7fffffffffffffffLL
+ --maxbits; // Drop extra bit for reserved values
+#endif
+ if(bits <= 0 || bits > maxbits || a < 0 ||
+ (unsigned long long) a >= (1ULL << bits))
+ {Stack->push<Int>(-1); return;}
+ unsigned int bytes=(bits+7)/8;
+ {Stack->push<Int>(B[bytes-1]((unsigned long long) a) >> (8*bytes-bits)); return;}
+}
+
+} // namespace run
+
+namespace trans {
+
+void gen_runmath_venv(venv &ve)
+{
+#line 192 "runmath.in"
+ addFunc(ve, run::gen_runmath0, primReal(), SYM_CARET, formal(primReal(), SYM(x), false, false), formal(primInt(), SYM(y), false, false));
+#line 197 "runmath.in"
+ addFunc(ve, run::gen_runmath1, primPair(), SYM_CARET, formal(primPair(), SYM(z), false, false), formal(primInt(), SYM(y), false, false));
+#line 202 "runmath.in"
+ addFunc(ve, run::gen_runmath2, primInt(), SYM(quotient), formal(primInt(), SYM(x), false, false), formal(primInt(), SYM(y), false, false));
+#line 207 "runmath.in"
+ addFunc(ve, run::gen_runmath3, primInt(), SYM(abs), formal(primInt(), SYM(x), false, false));
+#line 212 "runmath.in"
+ addFunc(ve, run::gen_runmath4, primInt(), SYM(sgn), formal(primReal(), SYM(x), false, false));
+#line 217 "runmath.in"
+ addFunc(ve, run::gen_runmath5, primInt(), SYM(rand));
+#line 224 "runmath.in"
+ addFunc(ve, run::gen_runmath6, primVoid(), SYM(srand), formal(primInt(), SYM(seed), false, false));
+#line 229 "runmath.in"
+ addFunc(ve, run::gen_runmath7, primReal(), SYM(unitrand));
+#line 235 "runmath.in"
+ addFunc(ve, run::gen_runmath8, primInt(), SYM(ceil), formal(primReal(), SYM(x), false, false));
+#line 240 "runmath.in"
+ addFunc(ve, run::gen_runmath9, primInt(), SYM(floor), formal(primReal(), SYM(x), false, false));
+#line 245 "runmath.in"
+ addFunc(ve, run::gen_runmath10, primInt(), SYM(round), formal(primReal(), SYM(x), false, false));
+#line 251 "runmath.in"
+ addFunc(ve, run::gen_runmath11, primInt(), SYM(Ceil), formal(primReal(), SYM(x), false, false));
+#line 256 "runmath.in"
+ addFunc(ve, run::gen_runmath12, primInt(), SYM(Floor), formal(primReal(), SYM(x), false, false));
+#line 261 "runmath.in"
+ addFunc(ve, run::gen_runmath13, primInt(), SYM(Round), formal(primReal(), SYM(x), false, false));
+#line 266 "runmath.in"
+ addFunc(ve, run::gen_runmath14, primReal(), SYM(fmod), formal(primReal(), SYM(x), false, false), formal(primReal(), SYM(y), false, false));
+#line 272 "runmath.in"
+ addFunc(ve, run::gen_runmath15, primReal(), SYM(atan2), formal(primReal(), SYM(y), false, false), formal(primReal(), SYM(x), false, false));
+#line 277 "runmath.in"
+ addFunc(ve, run::gen_runmath16, primReal(), SYM(hypot), formal(primReal(), SYM(x), false, false), formal(primReal(), SYM(y), false, false));
+#line 282 "runmath.in"
+ addFunc(ve, run::gen_runmath17, primReal(), SYM(remainder), formal(primReal(), SYM(x), false, false), formal(primReal(), SYM(y), false, false));
+#line 287 "runmath.in"
+ addFunc(ve, run::gen_runmath18, primReal(), SYM(Jn), formal(primInt(), SYM(n), false, false), formal(primReal(), SYM(x), false, false));
+#line 292 "runmath.in"
+ addFunc(ve, run::gen_runmath19, primReal(), SYM(Yn), formal(primInt(), SYM(n), false, false), formal(primReal(), SYM(x), false, false));
+#line 297 "runmath.in"
+ addFunc(ve, run::gen_runmath20, primReal(), SYM(erf), formal(primReal(), SYM(x), false, false));
+#line 302 "runmath.in"
+ addFunc(ve, run::gen_runmath21, primReal(), SYM(erfc), formal(primReal(), SYM(x), false, false));
+#line 307 "runmath.in"
+ addFunc(ve, run::gen_runmath22, primInt(), SYM(factorial), formal(primInt(), SYM(n), false, false));
+#line 312 "runmath.in"
+ addFunc(ve, run::gen_runmath23, primInt(), SYM(choose), formal(primInt(), SYM(n), false, false), formal(primInt(), SYM(k), false, false));
+#line 323 "runmath.in"
+ addFunc(ve, run::gen_runmath24, primReal(), SYM(gamma), formal(primReal(), SYM(x), false, false));
+#line 333 "runmath.in"
+ addFunc(ve, run::gen_runmath25, realArray(), SYM(quadraticroots), formal(primReal(), SYM(a), false, false), formal(primReal(), SYM(b), false, false), formal(primReal(), SYM(c), false, false));
+#line 342 "runmath.in"
+ addFunc(ve, run::gen_runmath26, pairArray(), SYM(quadraticroots), formal(primPair(), SYM(a), false, true), formal(primPair(), SYM(b), false, true), formal(primPair(), SYM(c), false, true));
+#line 351 "runmath.in"
+ addFunc(ve, run::gen_runmath27, realArray(), SYM(cubicroots), formal(primReal(), SYM(a), false, false), formal(primReal(), SYM(b), false, false), formal(primReal(), SYM(c), false, false), formal(primReal(), SYM(d), false, false));
+#line 361 "runmath.in"
+ addFunc(ve, run::gen_runmath28, primBoolean(), SYM_LOGNOT, formal(primBoolean(), SYM(b), false, false));
+#line 369 "runmath.in"
+ REGISTER_BLTIN(run::boolMemEq,"boolMemEq");
+#line 374 "runmath.in"
+ REGISTER_BLTIN(run::boolMemNeq,"boolMemNeq");
+#line 379 "runmath.in"
+ REGISTER_BLTIN(run::boolFuncEq,"boolFuncEq");
+#line 384 "runmath.in"
+ REGISTER_BLTIN(run::boolFuncNeq,"boolFuncNeq");
+#line 389 "runmath.in"
+ addFunc(ve, run::gen_runmath33, primInt(), SYM(AND), formal(primInt(), SYM(a), false, false), formal(primInt(), SYM(b), false, false));
+#line 397 "runmath.in"
+ addFunc(ve, run::gen_runmath34, primInt(), SYM(OR), formal(primInt(), SYM(a), false, false), formal(primInt(), SYM(b), false, false));
+#line 402 "runmath.in"
+ addFunc(ve, run::gen_runmath35, primInt(), SYM(XOR), formal(primInt(), SYM(a), false, false), formal(primInt(), SYM(b), false, false));
+#line 407 "runmath.in"
+ addFunc(ve, run::gen_runmath36, primInt(), SYM(NOT), formal(primInt(), SYM(a), false, false));
+#line 412 "runmath.in"
+ addFunc(ve, run::gen_runmath37, primInt(), SYM(CLZ), formal(primInt(), SYM(a), false, false));
+#line 423 "runmath.in"
+ addFunc(ve, run::gen_runmath38, primInt(), SYM(popcount), formal(primInt(), SYM(a), false, false));
+#line 428 "runmath.in"
+ addFunc(ve, run::gen_runmath39, primInt(), SYM(CTZ), formal(primInt(), SYM(a), false, false));
+#line 433 "runmath.in"
+ addFunc(ve, run::gen_runmath40, primInt(), SYM(bitreverse), formal(primInt(), SYM(a), false, false), formal(primInt(), SYM(bits), false, false));
+}
+
+} // namespace trans