00001
00002 #include <basix/int.hpp>
00003 #include <basix/vector.hpp>
00004 #include <basix/port.hpp>
00005 #include <basix/literal.hpp>
00006 #include <numerix/integer.hpp>
00007 #include <basix/compound.hpp>
00008 #include <basix/mmx_syntax.hpp>
00009 #include <basix/lisp_syntax.hpp>
00010 #include <basix/cpp_syntax.hpp>
00011 #include <basix/syntactic.hpp>
00012 #include <algebramix/vector_unrolled.hpp>
00013 #include <algebramix/vector_simd.hpp>
00014 #include <lacunaryx/lpolynomial.hpp>
00015 #include <basix/tuple.hpp>
00016 #include <basix/alias.hpp>
00017 #include <basix/glue.hpp>
00018
00019 #define int_literal(x) as_int (as_string (x))
00020 #define is_generic_literal is<literal>
00021 #define gen_literal_apply(f,v) gen (as<generic> (f), v)
00022 #define gen_literal_access(f,v) access (as<generic> (f), v)
00023 #define is_generic_compound is<compound>
00024 #define compound_arguments(x) cdr (as_vector (x))
00025 #define gen_compound_apply(f,v) gen (as<generic> (f), v)
00026
00027 namespace mmx {
00028 static bool
00029 GLUE_1 (const generic &arg_1) {
00030 return is_generic_compound (arg_1);
00031 }
00032
00033 static generic
00034 GLUE_2 (const compound &arg_1, const tuple<generic> &arg_2) {
00035 return gen_compound_apply (arg_1, as_vector (arg_2));
00036 }
00037
00038 static compound
00039 GLUE_3 (const tuple<generic> &arg_1) {
00040 return compound (as_vector (arg_1));
00041 }
00042
00043 static compound
00044 GLUE_4 (const vector<generic> &arg_1) {
00045 return compound (arg_1);
00046 }
00047
00048 static vector<generic>
00049 GLUE_5 (const compound &arg_1) {
00050 return as_vector (arg_1);
00051 }
00052
00053 static int
00054 GLUE_6 (const compound &arg_1) {
00055 return N (arg_1);
00056 }
00057
00058 static generic
00059 GLUE_7 (const compound &arg_1, const int &arg_2) {
00060 return arg_1[arg_2];
00061 }
00062
00063 static vector<generic>
00064 GLUE_8 (const compound &arg_1) {
00065 return as_vector (arg_1);
00066 }
00067
00068 static vector<generic>
00069 GLUE_9 (const compound &arg_1) {
00070 return compound_arguments (arg_1);
00071 }
00072
00073 static bool
00074 GLUE_10 (const generic &arg_1) {
00075 return generic_is_boolean (arg_1);
00076 }
00077
00078 static bool
00079 GLUE_11 (const generic &arg_1) {
00080 return generic_is_int (arg_1);
00081 }
00082
00083 static bool
00084 GLUE_12 (const generic &arg_1) {
00085 return generic_is_double (arg_1);
00086 }
00087
00088 static generic
00089 GLUE_13 (const string &arg_1, const bool &arg_2) {
00090 return parse_lisp (arg_1, arg_2);
00091 }
00092
00093 static string
00094 GLUE_14 (const generic &arg_1, const bool &arg_2) {
00095 return as_lisp (arg_1, arg_2);
00096 }
00097
00098 static string
00099 GLUE_15 (const generic &arg_1) {
00100 return flatten_as_mmx (arg_1);
00101 }
00102
00103 static string
00104 GLUE_16 (const generic &arg_1) {
00105 return flatten_as_cpp (arg_1);
00106 }
00107
00108 static bool
00109 GLUE_17 (const bool &arg_1) {
00110 return set_frac_flag (arg_1);
00111 }
00112
00113 static vector<generic>
00114 GLUE_18 (const vector<generic> &arg_1) {
00115 return -arg_1;
00116 }
00117
00118 static vector<generic>
00119 GLUE_19 (const vector<generic> &arg_1) {
00120 return square (arg_1);
00121 }
00122
00123 static vector<generic>
00124 GLUE_20 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00125 return arg_1 + arg_2;
00126 }
00127
00128 static vector<generic>
00129 GLUE_21 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00130 return arg_1 - arg_2;
00131 }
00132
00133 static vector<generic>
00134 GLUE_22 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00135 return arg_1 * arg_2;
00136 }
00137
00138 static generic
00139 GLUE_23 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00140 return dot (arg_1, arg_2);
00141 }
00142
00143 static generic
00144 GLUE_24 (const vector<generic> &arg_1) {
00145 return big_mul (arg_1);
00146 }
00147
00148 static generic
00149 GLUE_25 (const vector<generic> &arg_1) {
00150 return big_add (arg_1);
00151 }
00152
00153 static bool
00154 GLUE_26 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00155 return arg_1 == arg_2;
00156 }
00157
00158 static bool
00159 GLUE_27 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00160 return arg_1 != arg_2;
00161 }
00162
00163 static vector<generic>
00164 GLUE_28 (const vector<generic> &arg_1) {
00165 return invert (arg_1);
00166 }
00167
00168 static vector<generic>
00169 GLUE_29 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00170 return arg_1 / arg_2;
00171 }
00172
00173 static bool
00174 GLUE_30 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00175 return arg_1 <= arg_2;
00176 }
00177
00178 static bool
00179 GLUE_31 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00180 return arg_1 >= arg_2;
00181 }
00182
00183 static bool
00184 GLUE_32 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00185 return arg_1 < arg_2;
00186 }
00187
00188 static bool
00189 GLUE_33 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00190 return arg_1 > arg_2;
00191 }
00192
00193 static vector<generic>
00194 GLUE_34 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00195 return inf (arg_1, arg_2);
00196 }
00197
00198 static vector<generic>
00199 GLUE_35 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00200 return sup (arg_1, arg_2);
00201 }
00202
00203 static vector<generic>
00204 GLUE_36 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
00205 return pow (arg_1, arg_2);
00206 }
00207
00208 static vector<generic>
00209 GLUE_37 (const vector<generic> &arg_1) {
00210 return sqrt (arg_1);
00211 }
00212
00213 static vector<generic>
00214 GLUE_38 (const vector<generic> &arg_1) {
00215 return exp (arg_1);
00216 }
00217
00218 static vector<generic>
00219 GLUE_39 (const vector<generic> &arg_1) {
00220 return log (arg_1);
00221 }
00222
00223 static vector<generic>
00224 GLUE_40 (const vector<generic> &arg_1) {
00225 return cos (arg_1);
00226 }
00227
00228 static vector<generic>
00229 GLUE_41 (const vector<generic> &arg_1) {
00230 return sin (arg_1);
00231 }
00232
00233 static vector<generic>
00234 GLUE_42 (const vector<generic> &arg_1) {
00235 return tan (arg_1);
00236 }
00237
00238 static vector<generic>
00239 GLUE_43 (const vector<generic> &arg_1) {
00240 return acos (arg_1);
00241 }
00242
00243 static vector<generic>
00244 GLUE_44 (const vector<generic> &arg_1) {
00245 return asin (arg_1);
00246 }
00247
00248 static vector<generic>
00249 GLUE_45 (const vector<generic> &arg_1) {
00250 return atan (arg_1);
00251 }
00252
00253 static vector<generic>
00254 GLUE_46 (const vector<generic> &arg_1) {
00255 return derive (arg_1);
00256 }
00257
00258 static vector<generic>
00259 GLUE_47 (const vector<generic> &arg_1) {
00260 return integrate (arg_1);
00261 }
00262
00263 static lpolynomial<generic>
00264 GLUE_48 (const generic &arg_1) {
00265 return lpolynomial<generic > (arg_1);
00266 }
00267
00268 static lpolynomial<generic>
00269 GLUE_49 (const generic &arg_1, const integer &arg_2) {
00270 return lpolynomial<generic > (arg_1, arg_2);
00271 }
00272
00273 static void
00274 GLUE_50 (const lpolynomial<generic> &arg_1, const generic &arg_2) {
00275 set_variable_name (arg_1, arg_2);
00276 }
00277
00278 static int
00279 GLUE_51 (const lpolynomial<generic> &arg_1) {
00280 return N (arg_1);
00281 }
00282
00283 static generic
00284 GLUE_52 (const lpolynomial<generic> &arg_1, const integer &arg_2) {
00285 return arg_1[arg_2];
00286 }
00287
00288 static integer
00289 GLUE_53 (const lpolynomial<generic> &arg_1) {
00290 return deg (arg_1);
00291 }
00292
00293 static integer
00294 GLUE_54 (const lpolynomial<generic> &arg_1) {
00295 return val (arg_1);
00296 }
00297
00298 static lpolynomial<generic>
00299 GLUE_55 (const lpolynomial<generic> &arg_1) {
00300 return -arg_1;
00301 }
00302
00303 static lpolynomial<generic>
00304 GLUE_56 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00305 return arg_1 + arg_2;
00306 }
00307
00308 static lpolynomial<generic>
00309 GLUE_57 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00310 return arg_1 - arg_2;
00311 }
00312
00313 static lpolynomial<generic>
00314 GLUE_58 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00315 return arg_1 * arg_2;
00316 }
00317
00318 static lpolynomial<generic>
00319 GLUE_59 (const lpolynomial<generic> &arg_1) {
00320 return square (arg_1);
00321 }
00322
00323 static lpolynomial<generic>
00324 GLUE_60 (const lpolynomial<generic> &arg_1, const integer &arg_2) {
00325 return binpow (arg_1, arg_2);
00326 }
00327
00328 static bool
00329 GLUE_61 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00330 return arg_1 == arg_2;
00331 }
00332
00333 static bool
00334 GLUE_62 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00335 return arg_1 != arg_2;
00336 }
00337
00338 static lpolynomial<generic>
00339 GLUE_63 (const lpolynomial<generic> &arg_1) {
00340 return derive (arg_1);
00341 }
00342
00343 static lpolynomial<generic>
00344 GLUE_64 (const lpolynomial<generic> &arg_1) {
00345 return xderive (arg_1);
00346 }
00347
00348 static generic
00349 GLUE_65 (const lpolynomial<generic> &arg_1, const generic &arg_2) {
00350 return eval (arg_1, arg_2);
00351 }
00352
00353 static lpolynomial<generic>
00354 GLUE_66 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00355 return arg_1 / arg_2;
00356 }
00357
00358 static int
00359 GLUE_67 (const lpolynomial<generic> &arg_1) {
00360 return pr_hash (arg_1);
00361 }
00362
00363 static bool
00364 GLUE_68 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00365 return pr_eq (arg_1, arg_2);
00366 }
00367
00368 static bool
00369 GLUE_69 (const lpolynomial<generic> &arg_1, const lpolynomial<generic> &arg_2) {
00370 return pr_neq (arg_1, arg_2);
00371 }
00372
00373 static vector<lpolynomial<generic> >
00374 GLUE_70 (const tuple<lpolynomial<generic> > &arg_1) {
00375 return vector<lpolynomial<generic> > (as_vector (arg_1));
00376 }
00377
00378 static vector<lpolynomial<generic> >
00379 GLUE_71 (const tuple<lpolynomial<generic> > &arg_1) {
00380 return vector<lpolynomial<generic> > (as_vector (arg_1));
00381 }
00382
00383 static iterator<generic>
00384 GLUE_72 (const vector<lpolynomial<generic> > &arg_1) {
00385 return as<iterator<generic> > (iterate (arg_1));
00386 }
00387
00388 static int
00389 GLUE_73 (const vector<lpolynomial<generic> > &arg_1) {
00390 return N (arg_1);
00391 }
00392
00393 static lpolynomial<generic>
00394 GLUE_74 (const vector<lpolynomial<generic> > &arg_1, const int &arg_2) {
00395 return arg_1[arg_2];
00396 }
00397
00398 static alias<lpolynomial<generic> >
00399 GLUE_75 (const alias<vector<lpolynomial<generic> > > &arg_1, const int &arg_2) {
00400 return alias_access<lpolynomial<generic> > (arg_1, arg_2);
00401 }
00402
00403 static vector<lpolynomial<generic> >
00404 GLUE_76 (const vector<lpolynomial<generic> > &arg_1, const int &arg_2, const int &arg_3) {
00405 return range (arg_1, arg_2, arg_3);
00406 }
00407
00408 static vector<lpolynomial<generic> >
00409 GLUE_77 (const vector<lpolynomial<generic> > &arg_1) {
00410 return reverse (arg_1);
00411 }
00412
00413 static vector<lpolynomial<generic> >
00414 GLUE_78 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00415 return append (arg_1, arg_2);
00416 }
00417
00418 static alias<vector<lpolynomial<generic> > >
00419 GLUE_79 (const alias<vector<lpolynomial<generic> > > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00420 return alias_write (arg_1, arg_2);
00421 }
00422
00423 static void
00424 GLUE_80 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00425 inside_append (arg_1, arg_2);
00426 }
00427
00428 static vector<lpolynomial<generic> >
00429 GLUE_81 (const lpolynomial<generic> &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00430 return cons (arg_1, arg_2);
00431 }
00432
00433 static lpolynomial<generic>
00434 GLUE_82 (const vector<lpolynomial<generic> > &arg_1) {
00435 return car (arg_1);
00436 }
00437
00438 static vector<lpolynomial<generic> >
00439 GLUE_83 (const vector<lpolynomial<generic> > &arg_1) {
00440 return cdr (arg_1);
00441 }
00442
00443 static bool
00444 GLUE_84 (const vector<lpolynomial<generic> > &arg_1) {
00445 return is_nil (arg_1);
00446 }
00447
00448 static bool
00449 GLUE_85 (const vector<lpolynomial<generic> > &arg_1) {
00450 return is_atom (arg_1);
00451 }
00452
00453 static vector<lpolynomial<generic> >
00454 GLUE_86 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00455 return insert (arg_1, arg_2);
00456 }
00457
00458 static int
00459 GLUE_87 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00460 return find (arg_1, arg_2);
00461 }
00462
00463 static bool
00464 GLUE_88 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00465 return contains (arg_1, arg_2);
00466 }
00467
00468 static vector<lpolynomial<generic> >
00469 GLUE_89 (const vector<generic> &arg_1) {
00470 return as<vector<lpolynomial<generic> > > (arg_1);
00471 }
00472
00473 static vector<generic>
00474 GLUE_90 (const vector<lpolynomial<generic> > &arg_1) {
00475 return as<vector<generic> > (arg_1);
00476 }
00477
00478 static vector<lpolynomial<generic> >
00479 GLUE_91 (const vector<lpolynomial<generic> > &arg_1) {
00480 return -arg_1;
00481 }
00482
00483 static vector<lpolynomial<generic> >
00484 GLUE_92 (const vector<lpolynomial<generic> > &arg_1) {
00485 return square (arg_1);
00486 }
00487
00488 static vector<lpolynomial<generic> >
00489 GLUE_93 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00490 return arg_1 + arg_2;
00491 }
00492
00493 static vector<lpolynomial<generic> >
00494 GLUE_94 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00495 return arg_1 - arg_2;
00496 }
00497
00498 static vector<lpolynomial<generic> >
00499 GLUE_95 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00500 return arg_1 * arg_2;
00501 }
00502
00503 static vector<lpolynomial<generic> >
00504 GLUE_96 (const lpolynomial<generic> &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00505 return arg_1 + arg_2;
00506 }
00507
00508 static vector<lpolynomial<generic> >
00509 GLUE_97 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00510 return arg_1 + arg_2;
00511 }
00512
00513 static vector<lpolynomial<generic> >
00514 GLUE_98 (const lpolynomial<generic> &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00515 return arg_1 - arg_2;
00516 }
00517
00518 static vector<lpolynomial<generic> >
00519 GLUE_99 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00520 return arg_1 - arg_2;
00521 }
00522
00523 static vector<lpolynomial<generic> >
00524 GLUE_100 (const lpolynomial<generic> &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00525 return arg_1 * arg_2;
00526 }
00527
00528 static vector<lpolynomial<generic> >
00529 GLUE_101 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00530 return arg_1 * arg_2;
00531 }
00532
00533 static lpolynomial<generic>
00534 GLUE_102 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00535 return dot (arg_1, arg_2);
00536 }
00537
00538 static lpolynomial<generic>
00539 GLUE_103 (const vector<lpolynomial<generic> > &arg_1) {
00540 return big_mul (arg_1);
00541 }
00542
00543 static lpolynomial<generic>
00544 GLUE_104 (const vector<lpolynomial<generic> > &arg_1) {
00545 return big_add (arg_1);
00546 }
00547
00548 static bool
00549 GLUE_105 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00550 return arg_1 == arg_2;
00551 }
00552
00553 static bool
00554 GLUE_106 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00555 return arg_1 != arg_2;
00556 }
00557
00558 static bool
00559 GLUE_107 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00560 return arg_1 == arg_2;
00561 }
00562
00563 static bool
00564 GLUE_108 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00565 return arg_1 != arg_2;
00566 }
00567
00568 static bool
00569 GLUE_109 (const lpolynomial<generic> &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00570 return arg_1 == arg_2;
00571 }
00572
00573 static bool
00574 GLUE_110 (const lpolynomial<generic> &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00575 return arg_1 != arg_2;
00576 }
00577
00578 static vector<lpolynomial<generic> >
00579 GLUE_111 (const vector<lpolynomial<generic> > &arg_1) {
00580 return invert (arg_1);
00581 }
00582
00583 static vector<lpolynomial<generic> >
00584 GLUE_112 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00585 return arg_1 / arg_2;
00586 }
00587
00588 static vector<lpolynomial<generic> >
00589 GLUE_113 (const lpolynomial<generic> &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00590 return arg_1 / arg_2;
00591 }
00592
00593 static vector<lpolynomial<generic> >
00594 GLUE_114 (const vector<lpolynomial<generic> > &arg_1, const lpolynomial<generic> &arg_2) {
00595 return arg_1 / arg_2;
00596 }
00597
00598 static vector<lpolynomial<generic> >
00599 GLUE_115 (const vector<lpolynomial<generic> > &arg_1) {
00600 return derive (arg_1);
00601 }
00602
00603 static int
00604 GLUE_116 (const vector<lpolynomial<generic> > &arg_1) {
00605 return pr_hash (arg_1);
00606 }
00607
00608 static bool
00609 GLUE_117 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00610 return pr_eq (arg_1, arg_2);
00611 }
00612
00613 static bool
00614 GLUE_118 (const vector<lpolynomial<generic> > &arg_1, const vector<lpolynomial<generic> > &arg_2) {
00615 return pr_neq (arg_1, arg_2);
00616 }
00617
00618 void
00619 glue_lpolynomial_generic () {
00620 static bool done = false;
00621 if (done) return;
00622 done = true;
00623 call_glue (string ("glue_integer"));
00624 call_glue (string ("glue_basix_vector_generic"));
00625 define ("compound?", GLUE_1);
00626 define (".()", GLUE_2);
00627 define ("compound", GLUE_3);
00628 define ("as_compound", GLUE_4);
00629 define ("as_vector", GLUE_5);
00630 define ("#", GLUE_6);
00631 define (".[]", GLUE_7);
00632 define ("components", GLUE_8);
00633 define ("arguments", GLUE_9);
00634 define ("boolean?", GLUE_10);
00635 define ("int?", GLUE_11);
00636 define ("double?", GLUE_12);
00637 define ("parse_lisp", GLUE_13);
00638 define ("as_lisp", GLUE_14);
00639 define ("flatten_as_mmx", GLUE_15);
00640 define ("flatten_as_cpp", GLUE_16);
00641 define ("set_frac_flag", GLUE_17);
00642 define ("-", GLUE_18);
00643 define ("square", GLUE_19);
00644 define ("+", GLUE_20);
00645 define ("-", GLUE_21);
00646 define ("*", GLUE_22);
00647 define ("dot", GLUE_23);
00648 define ("big_mul", GLUE_24);
00649 define ("big_add", GLUE_25);
00650 define ("=", GLUE_26);
00651 define ("!=", GLUE_27);
00652 define ("invert", GLUE_28);
00653 define ("/", GLUE_29);
00654 define ("<=", GLUE_30);
00655 define (">=", GLUE_31);
00656 define ("<", GLUE_32);
00657 define (">", GLUE_33);
00658 define ("inf", GLUE_34);
00659 define ("sup", GLUE_35);
00660 define ("^", GLUE_36);
00661 define ("sqrt", GLUE_37);
00662 define ("exp", GLUE_38);
00663 define ("log", GLUE_39);
00664 define ("cos", GLUE_40);
00665 define ("sin", GLUE_41);
00666 define ("tan", GLUE_42);
00667 define ("arccos", GLUE_43);
00668 define ("arcsin", GLUE_44);
00669 define ("arctan", GLUE_45);
00670 define ("derive", GLUE_46);
00671 define ("integrate", GLUE_47);
00672 define_type<lpolynomial<generic> > (gen (lit ("LPolynomial"), lit ("Generic")));
00673 define ("lpolynomial", GLUE_48);
00674 define ("lpolynomial", GLUE_49);
00675 define ("set_variable_name", GLUE_50);
00676 define ("#", GLUE_51);
00677 define (".[]", GLUE_52);
00678 define ("deg", GLUE_53);
00679 define ("val", GLUE_54);
00680 define ("-", GLUE_55);
00681 define ("+", GLUE_56);
00682 define ("-", GLUE_57);
00683 define ("*", GLUE_58);
00684 define ("square", GLUE_59);
00685 define ("^", GLUE_60);
00686 define ("=", GLUE_61);
00687 define ("!=", GLUE_62);
00688 define ("derive", GLUE_63);
00689 define ("xderive", GLUE_64);
00690 define ("eval", GLUE_65);
00691 define ("/", GLUE_66);
00692 define ("hash%", GLUE_67);
00693 define ("=%", GLUE_68);
00694 define ("!=%", GLUE_69);
00695 define_type<vector<lpolynomial<generic> > > (gen (lit ("Vector"), gen (lit ("LPolynomial"), lit ("Generic"))));
00696 define ("vector", GLUE_70);
00697 define ("[]", GLUE_71);
00698 define_converter (":>", GLUE_72, PENALTY_PROMOTE_GENERIC);
00699 define ("#", GLUE_73);
00700 define (".[]", GLUE_74);
00701 define (".[]", GLUE_75);
00702 define (".[]", GLUE_76);
00703 define ("reverse", GLUE_77);
00704 define ("><", GLUE_78);
00705 define ("<<", GLUE_79);
00706 define ("append", GLUE_80);
00707 define ("cons", GLUE_81);
00708 define ("car", GLUE_82);
00709 define ("cdr", GLUE_83);
00710 define ("nil?", GLUE_84);
00711 define ("atom?", GLUE_85);
00712 define ("insert", GLUE_86);
00713 define ("find", GLUE_87);
00714 define ("contains?", GLUE_88);
00715 define_converter (":>", GLUE_89, PENALTY_PROMOTE_GENERIC);
00716 define_converter (":>", GLUE_90, PENALTY_PROMOTE_GENERIC);
00717 define ("-", GLUE_91);
00718 define ("square", GLUE_92);
00719 define ("+", GLUE_93);
00720 define ("-", GLUE_94);
00721 define ("*", GLUE_95);
00722 define ("+", GLUE_96);
00723 define ("+", GLUE_97);
00724 define ("-", GLUE_98);
00725 define ("-", GLUE_99);
00726 define ("*", GLUE_100);
00727 define ("*", GLUE_101);
00728 define ("dot", GLUE_102);
00729 define ("big_mul", GLUE_103);
00730 define ("big_add", GLUE_104);
00731 define ("=", GLUE_105);
00732 define ("!=", GLUE_106);
00733 define ("=", GLUE_107);
00734 define ("!=", GLUE_108);
00735 define ("=", GLUE_109);
00736 define ("!=", GLUE_110);
00737 define ("invert", GLUE_111);
00738 define ("/", GLUE_112);
00739 define ("/", GLUE_113);
00740 define ("/", GLUE_114);
00741 define ("derive", GLUE_115);
00742 define ("hash%", GLUE_116);
00743 define ("=%", GLUE_117);
00744 define ("!=%", GLUE_118);
00745 }
00746 }
