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