mmx Namespace Reference

Namespaces

Classes

Functions

Variables

Function Documentation

V lpolynomial<C,E,V> mmx::__binpow ( const lpolynomial< C, E, V > &  P,
const integer &  n 
)
Type Constraints

Definition at line 393 of file lpolynomial.hpp.

References _binpow(), LPolynomial, and square().

Referenced by _binpow().

00393                                                   {
00394   if (n == 1) return P;
00395   if (n == 2) return square (P);
00396   if (n <= 16) {
00397     LPolynomial Q= P;
00398     for (integer i= 1; i < n; i+= 1) Q = Q * P;
00399     return Q;
00400   }
00401   LPolynomial ret (square (_binpow (P, quo (n, 2))));
00402   if (rem (n, 2) != 0) ret = P * ret;
00403   return ret; }

lpolynomial<C,E,V> mmx::_binpow ( const lpolynomial< C, E, V > &  P,
const integer &  n 
) [inline]

Definition at line 406 of file lpolynomial.hpp.

References __binpow(), and deg().

Referenced by __binpow(), and binpow().

00406                                                  {
00407   integer m= as<integer> (deg (P)) * n;
00408   if (bit_size (m) <= 8*sizeof(unsigned long long int)) {
00409     lpolynomial<C,unsigned long long int> Q=
00410       as<lpolynomial<C,unsigned long long int> > (P);
00411     return as<LPolynomial> (__binpow (Q, n));
00412   }
00413 #if defined(BASIX_HAVE_INT128)
00414   if (bit_size (m) <= 8*sizeof(uint128)) {
00415     lpolynomial<C,uint128> Q= as<lpolynomial<C,uint128> > (P);
00416     return as<LPolynomial> (__binpow (Q, n));
00417   }
00418 #endif
00419   return __binpow (P, n); }

mmx::ARITH_SCALAR_INT_SUGAR ( template< typename C, typename E, typename V >  ,
lpolynomial< C, E, V >   
)
bool mmx::binary_test ( const lpolynomial< C, E, V > &  P1,
const lpolynomial< C, E, V > &  P2 
) [inline]

Definition at line 259 of file lpolynomial.hpp.

References N().

00259                                                            {
00260   vector<E> v (entries (*P1 + *P2));
00261   sort (v);
00262   for (nat i=0; i<N(v); i++)
00263     if (!Op::op (P1[v[i]], P2[v[i]])) return false;
00264   return true; }

lpolynomial<C,E,V> mmx::binpow ( const lpolynomial< C, E, V > &  Q,
const integer &  n 
) [inline]

Definition at line 422 of file lpolynomial.hpp.

References _binpow(), CF(), deg(), LPolynomial, N(), and SE.

Referenced by cyclotomic_factors(), eval(), gap_and_cyclotomic_factors(), GLUE_10(), GLUE_14(), GLUE_33(), GLUE_5(), GLUE_60(), multiplicity(), and special_integer_roots().

00422                                                 {
00423   LPolynomial P= Q; simplify (P.rep);
00424   SE d= deg (P);
00425   if (n == 0) return LPolynomial (promote (1, CF(Q)), 0);
00426   if (d < 0 || n == 1) return P;
00427   if (N(P) == 1) return LPolynomial (P[d], as<E> (d * n));
00428   return _binpow (P, n); }

format<C> mmx::CF ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 95 of file lpolynomial.hpp.

Referenced by mmx::lacunaryx::as_bivariate_polynomial(), mmx::lacunaryx::as_polynomial(), binpow(), coefficients(), eval(), set_as(), mmx::lacunaryx::set_as_bivariate_polynomial(), and mmx::lacunaryx::set_as_polynomial().

00095                                              {
00096   return CF1(*P); }

vector<C> mmx::coefficients ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 154 of file lpolynomial.hpp.

References CF(), and iterate().

Referenced by mmx::lacunaryx::as_sparse_polynomial(), mmx::lacunaryx::homogenize(), mmx::lacunaryx::sparse_derive(), and sparse_derive().

00154                                     {
00155   vector<C> ret (CF(P));
00156   for (iterator<pair<E,C> > it= iterate (*P); busy (it); ++it)
00157     if (cdr (*it) != 0) ret << cdr (*it);
00158   return ret; }

int mmx::compare ( const lpolynomial< C, E, V > &  P1,
const lpolynomial< C, E, V > &  P2 
) [inline]

Definition at line 245 of file lpolynomial.hpp.

References N(), and sign().

00245                                                        {
00246   vector<E> v (entries (*P1 + *P2));
00247   sort (v);
00248   for (nat i=0; i<N(v); i++) {
00249     int s= sign (P1[v[i]] - P2[v[i]]);
00250     if (s != 0) return s;
00251   }
00252   return 0; }

vector< irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > mmx::cyclotomic_factors ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 256 of file linear_factors_univariate.hpp.

References binpow(), deg(), Monomial, N(), sparse_derive(), Sparse_factor, Sparse_factors, and Sparse_polynomial.

00256                                                 {
00257   
00258   Sparse_factors f;
00259   Sparse_polynomial x ((C)1, Monomial (vec(1)));
00260   Sparse_polynomial q= copy(p);
00261   nat mul1=0;
00262   nat mul2=0;
00263   C s;
00264 
00265   for (nat i=0; i<N(p); i++){
00266     
00267     // Factor x-1
00268     if (mul1 == i) {
00269       s=0;
00270       for (nat j=0; j<N(q); j++) s+= get_coefficient (q,j); 
00271       if ( s == 0 ) mul1=i+1;
00272     }
00273 
00274     // Factor x+1
00275     if (mul2 == i) {
00276       s=0;
00277       for (nat j=0; j<N(q); j++) 
00278         s+= get_coefficient (q,j) * binpow(-1, deg (get_monomial (q,j)) % 2);
00279       if ( s == 0 ) mul2=i+1;
00280     }
00281 
00282     if ( mul1 < i+1 && mul2 < i+1 ) break; // Useless to go further
00283 
00284     q= sparse_derive (q);
00285   }
00286 
00287   if (mul1 > 0) f << Sparse_factor (x-1,mul1);
00288   if (mul2 > 0) f << Sparse_factor (x+1,mul2);
00289 
00290   return f;
00291 }

mmx::DEFINE_UNARY_FORMAT_3 ( lpolynomial   ) 
signed_of_helper< E >::type deg ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 128 of file lpolynomial.hpp.

References iterate(), and SE.

Referenced by _binpow(), binpow(), cyclotomic_factors(), degree(), gap_and_cyclotomic_factors(), GLUE_1(), GLUE_23(), GLUE_25(), GLUE_3(), GLUE_53(), GLUE_6(), GLUE_7(), GLUE_8(), mmx::lacunaryx::homogenize(), large_integer_roots(), linear_factors(), multiplicity(), non_cyclotomic_factors(), operator/(), partition(), partition_bivariate_helper(), partition_univariate(), mmx::lacunaryx::set_as_bivariate_polynomial(), mmx::lacunaryx::set_as_polynomial(), mmx::lacunaryx::sort_poly(), mmx::lacunaryx::sparse_derive(), sparse_derive(), special_integer_roots(), and truly_bivariate_linear_factors().

00128                            {
00129   SE ret= -1;
00130   for (iterator<pair<E,C> > it= iterate (*P); busy (it); ++it) {
00131     if (cdr (*it) == 0) continue;
00132     ret= max ((SE) car (*it), ret);
00133   }
00134   return ret; }

signed_of_helper< E >::type degree ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 150 of file lpolynomial.hpp.

References deg().

00150                               {
00151   return deg (P); }

lpolynomial<C,E,V> mmx::derive ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 435 of file lpolynomial.hpp.

References iterate(), and Table.

Referenced by GLUE_115(), GLUE_22(), GLUE_27(), GLUE_46(), GLUE_48(), GLUE_63(), GLUE_74(), and mmx::lacunaryx::multiplicity().

00435                               {
00436   Table ret (0);
00437   for (iterator<pair<E,C> > it= iterate (*P); busy (it); ++it) {
00438     if (car (*it) == 0) continue;
00439     ret[car (*it) - 1] = promote (car (*it), cdr (*it)) * cdr (*it);
00440   }
00441   return ret; }

C mmx::eval ( const lpolynomial< C, E, V > &  P,
const C &  c 
) [inline]

Definition at line 453 of file lpolynomial.hpp.

References binpow(), CF(), and iterate().

Referenced by GLUE_29(), GLUE_53(), GLUE_65(), and GLUE_79().

00453                                         {
00454   C ret= promote (0, CF (P));
00455   for (iterator<pair<E,C> > it= iterate (*P); busy (it); ++it) {
00456     ret += cdr (*it) * binpow (c, car (*it));
00457   }
00458   return ret; }

bool mmx::exact_eq ( const lpolynomial< C, E, V > &  c1,
const lpolynomial< C, E, V > &  c2 
) [inline]

Definition at line 105 of file lpolynomial.hpp.

00105                                                                   {
00106   return exact_eq (*c1, *c2); }

nat mmx::exact_hash ( const lpolynomial< C, E, V > &  c  )  [inline]

Definition at line 99 of file lpolynomial.hpp.

00099 { return exact_hash (*c); }

bool mmx::exact_neq ( const lpolynomial< C, E, V > &  c1,
const lpolynomial< C, E, V > &  c2 
) [inline]

Definition at line 107 of file lpolynomial.hpp.

00107                                                                    {
00108   return exact_neq(*c1,*c2); }

syntactic mmx::flatten ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 227 of file lpolynomial.hpp.

References flatten(), and var().

00227                                {
00228   return flatten (P, as_syntactic (var (P))); }

syntactic mmx::flatten ( const lpolynomial< C, E, V > &  P,
const syntactic &  v 
) [inline]

Definition at line 217 of file lpolynomial.hpp.

References N().

Referenced by flatten().

00217                                                    {
00218   vector<E> w (entries (*P));
00219   sort_leq<gtr_op> (w);
00220   syntactic s= 0;
00221   for (nat i= 0; i < N(w); i++)
00222     if (P[w[i]] != 0)
00223       s= s + flatten (P[w[i]]) * pow (v, flatten (w[i]));
00224   return s; }

pair<C,vector < irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > > mmx::gap_and_cyclotomic_factors ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 295 of file linear_factors_univariate.hpp.

References binpow(), deg(), Monomial, N(), sparse_derive(), Sparse_factor, and Sparse_polynomial.

Referenced by linear_factors_univariate().

00295                                                         {
00296 
00297   Sparse_polynomial q= copy(p);
00298   
00299   // For the factors
00300   vector <Sparse_factor> f;
00301   Sparse_polynomial x ((C)1, Monomial (vec(1)));
00302   nat mul1=0;
00303   nat mul2=0;
00304   C s1, s2;
00305 
00306   // For the gap
00307   C g=0;
00308 
00309   for (nat i=0; i<N(p); i++){
00310     
00311     if (mul1 == i) s1=get_coefficient(q,0); 
00312     if (mul2 == i)
00313       s2=get_coefficient(q,0) * binpow(-1, deg (get_monomial(q,0)) % 2);
00314     C max_coeff= abs (get_coefficient(q,0));
00315 
00316     for (nat j=1; j<N(q); j++) {
00317    
00318       if (mul1 == i) s1+= get_coefficient (q,j); 
00319       if (mul2 == i) 
00320         s2+= get_coefficient (q,j) * binpow(-1, deg (get_monomial(q,j)) % 2);
00321 
00322       C curr_coeff = abs (get_coefficient (q,j));
00323       if (curr_coeff > max_coeff) max_coeff= curr_coeff;
00324     }
00325 
00326     if (mul1 == i && s1 == 0) mul1=i+1;
00327     if (mul2 == i && s2 == 0) mul2=i+1;
00328     
00329     C length= as<C> (N(q)-1);
00330     g= max (g, as<C> (bit_size(length*max_coeff)) );
00331     q= sparse_derive (q);
00332   }
00333 
00334   if (mul1 > 0) f << Sparse_factor (x-1,mul1);
00335   if (mul2 > 0) f << Sparse_factor (x+1,mul2);
00336 
00337   pair<C, vector <Sparse_factor> > result(g,f);
00338 
00339   return result;
00340 }

C mmx::gap_univariate ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 146 of file linear_factors_univariate.hpp.

References N(), sparse_derive(), and Sparse_polynomial.

Referenced by multiplicity().

00146                                               {
00147   C g=0;
00148   Sparse_polynomial q= copy(p);
00149 
00150   for (nat i=0; i<N(p); i++) {
00151     C max_coeff= abs (get_coefficient (q,0));
00152     for (nat j=1; j<N(q); j++) {
00153       C curr_coeff = abs (get_coefficient (q,j));
00154       if (curr_coeff > max_coeff) max_coeff= curr_coeff;
00155     }
00156     C length= as<C> (N(q)-1);
00157     g= max (g, as<C> (bit_size (length*max_coeff)));
00158     q= sparse_derive (q);
00159   }
00160   
00161   return g;
00162 }

static lpolynomial<integer> mmx::GLUE_1 ( const integer &  arg_1  )  [static]

Definition at line 29 of file glue_lpolynomial_integer.cpp.

00029                                 {
00030     return lpolynomial<integer > (arg_1);
00031   }

static integer mmx::GLUE_1 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 28 of file glue_lmvpolynomial_integer.cpp.

References deg().

00028                                      {
00029     return deg (arg_1);
00030   }

static bool mmx::GLUE_1 ( const generic &  arg_1  )  [static]

Definition at line 29 of file glue_lpolynomial_generic.cpp.

References is_generic_compound.

00029                                 {
00030     return is_generic_compound (arg_1);
00031   }

static vector<generic> mmx::GLUE_1 ( const multivariate< sparse_polynomial< integer > > &  arg_1  )  [static]

Definition at line 42 of file glue_linear_factors.cpp.

References linear_factors().

Referenced by glue_linear_factors(), glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00042                                                {
00043     return linear_factors (arg_1);
00044   }

static lpolynomial<integer> mmx::GLUE_10 ( const lpolynomial< integer > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 74 of file glue_lpolynomial_integer.cpp.

00074                                                                                  {
00075     return arg_1 + arg_2;
00076   }

static bool mmx::GLUE_10 ( const generic &  arg_1  )  [static]

Definition at line 74 of file glue_lpolynomial_generic.cpp.

00074                                  {
00075     return generic_is_boolean (arg_1);
00076   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_10 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 73 of file glue_lmvpolynomial_integer.cpp.

References binpow().

00073                                                                        {
00074     return binpow (arg_1, arg_2);
00075   }

static generic mmx::GLUE_10 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 73 of file glue_lmvpolynomial_generic.cpp.

00073                                                                             {
00074     return arg_1[arg_2];
00075   }

static bool mmx::GLUE_10 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 68 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00068                                                      {
00069     return arg_1 >= arg_2;
00070   }

static vector<lpolynomial<generic> > mmx::GLUE_100 ( const lpolynomial< generic > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 524 of file glue_lpolynomial_generic.cpp.

00524                                                                                            {
00525     return arg_1 * arg_2;
00526   }

static bool mmx::GLUE_100 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const vector< multivariate< monomial< vector< integer > > > > &  arg_2 
) [static]

Definition at line 518 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00518                                                                                   {
00519     return pr_eq (arg_1, arg_2);
00520   }

static vector<lpolynomial<generic> > mmx::GLUE_101 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 529 of file glue_lpolynomial_generic.cpp.

00529                                                                                            {
00530     return arg_1 * arg_2;
00531   }

static bool mmx::GLUE_101 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const vector< multivariate< monomial< vector< integer > > > > &  arg_2 
) [static]

Definition at line 523 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00523                                                                                   {
00524     return pr_neq (arg_1, arg_2);
00525   }

static lpolynomial<generic> mmx::GLUE_102 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 534 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00534                                                                                                     {
00535     return dot (arg_1, arg_2);
00536   }

static lpolynomial<generic> mmx::GLUE_103 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 539 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00539                                                         {
00540     return big_mul (arg_1);
00541   }

static lpolynomial<generic> mmx::GLUE_104 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 544 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00544                                                         {
00545     return big_add (arg_1);
00546   }

static bool mmx::GLUE_105 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 549 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00549                                                                                                     {
00550     return arg_1 == arg_2;
00551   }

static bool mmx::GLUE_106 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 554 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00554                                                                                                     {
00555     return arg_1 != arg_2;
00556   }

static bool mmx::GLUE_107 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 559 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00559                                                                                            {
00560     return arg_1 == arg_2;
00561   }

static bool mmx::GLUE_108 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 564 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00564                                                                                            {
00565     return arg_1 != arg_2;
00566   }

static bool mmx::GLUE_109 ( const lpolynomial< generic > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 569 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00569                                                                                            {
00570     return arg_1 == arg_2;
00571   }

static lpolynomial<integer> mmx::GLUE_11 ( const lpolynomial< integer > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 79 of file glue_lpolynomial_integer.cpp.

00079                                                                                  {
00080     return arg_1 - arg_2;
00081   }

static bool mmx::GLUE_11 ( const generic &  arg_1  )  [static]

Definition at line 79 of file glue_lpolynomial_generic.cpp.

00079                                  {
00080     return generic_is_int (arg_1);
00081   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_11 ( const integer &  arg_1  )  [static]

Definition at line 78 of file glue_lmvpolynomial_integer.cpp.

References lmv_polynomial.

00078                                  {
00079     return (lmv_polynomial(integer ) (arg_1));
00080   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_11 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 78 of file glue_lmvpolynomial_generic.cpp.

00078                                                                    {
00079     return homogeneous_part (arg_1, arg_2);
00080   }

static bool mmx::GLUE_11 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 73 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00073                                                      {
00074     return starts (arg_1, arg_2);
00075   }

static bool mmx::GLUE_110 ( const lpolynomial< generic > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 574 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00574                                                                                            {
00575     return arg_1 != arg_2;
00576   }

static vector<lpolynomial<generic> > mmx::GLUE_111 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 579 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00579                                                         {
00580     return invert (arg_1);
00581   }

static vector<lpolynomial<generic> > mmx::GLUE_112 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 584 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00584                                                                                                     {
00585     return arg_1 / arg_2;
00586   }

static vector<lpolynomial<generic> > mmx::GLUE_113 ( const lpolynomial< generic > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 589 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00589                                                                                            {
00590     return arg_1 / arg_2;
00591   }

static vector<lpolynomial<generic> > mmx::GLUE_114 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 594 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00594                                                                                            {
00595     return arg_1 / arg_2;
00596   }

static vector<lpolynomial<generic> > mmx::GLUE_115 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 599 of file glue_lpolynomial_generic.cpp.

References derive().

Referenced by glue_lpolynomial_generic().

00599                                                         {
00600     return derive (arg_1);
00601   }

static int mmx::GLUE_116 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 604 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00604                                                         {
00605     return pr_hash (arg_1);
00606   }

static bool mmx::GLUE_117 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 609 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00609                                                                                                     {
00610     return pr_eq (arg_1, arg_2);
00611   }

static bool mmx::GLUE_118 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 614 of file glue_lpolynomial_generic.cpp.

Referenced by glue_lpolynomial_generic().

00614                                                                                                     {
00615     return pr_neq (arg_1, arg_2);
00616   }

static lpolynomial<integer> mmx::GLUE_12 ( const lpolynomial< integer > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 84 of file glue_lpolynomial_integer.cpp.

00084                                                                                  {
00085     return arg_1 * arg_2;
00086   }

static bool mmx::GLUE_12 ( const generic &  arg_1  )  [static]

Definition at line 84 of file glue_lpolynomial_generic.cpp.

00084                                  {
00085     return generic_is_double (arg_1);
00086   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_12 ( const integer &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 83 of file glue_lmvpolynomial_integer.cpp.

References lmv_polynomial.

00083                                                             {
00084     return (lmv_polynomial(integer ) (arg_1, arg_2));
00085   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_12 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2,
const int &  arg_3 
) [static]

Definition at line 83 of file glue_lmvpolynomial_generic.cpp.

00083                                                                                                 {
00084     return coefficient (arg_1, arg_2, arg_3);
00085   }

static bool mmx::GLUE_12 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 78 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00078                                                      {
00079     return ends (arg_1, arg_2);
00080   }

static lpolynomial<integer> mmx::GLUE_13 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 89 of file glue_lpolynomial_integer.cpp.

References square().

00089                                               {
00090     return square (arg_1);
00091   }

static generic mmx::GLUE_13 ( const string &  arg_1,
const bool &  arg_2 
) [static]

Definition at line 89 of file glue_lpolynomial_generic.cpp.

00089                                                    {
00090     return parse_lisp (arg_1, arg_2);
00091   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_13 ( const integer &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 88 of file glue_lmvpolynomial_integer.cpp.

References lmv_polynomial.

00088                                                             {
00089     return (lmv_polynomial(integer ) (arg_1, arg_2));
00090   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_13 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 88 of file glue_lmvpolynomial_generic.cpp.

00088                                                  {
00089     return -arg_1;
00090   }

static string mmx::GLUE_13 ( const string &  arg_1,
const string &  arg_2,
const string &  arg_3 
) [static]

Definition at line 83 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00083                                                                           {
00084     return replace (arg_1, arg_2, arg_3);
00085   }

static lpolynomial<integer> mmx::GLUE_14 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 94 of file glue_lpolynomial_integer.cpp.

References binpow().

00094                                                                     {
00095     return binpow (arg_1, arg_2);
00096   }

static string mmx::GLUE_14 ( const generic &  arg_1,
const bool &  arg_2 
) [static]

Definition at line 94 of file glue_lpolynomial_generic.cpp.

00094                                                     {
00095     return as_lisp (arg_1, arg_2);
00096   }

static multivariate_coordinates mmx::GLUE_14 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 93 of file glue_lmvpolynomial_integer.cpp.

00093                                                  {
00094     return arg_1.coords;
00095   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_14 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 93 of file glue_lmvpolynomial_generic.cpp.

00093                                                                                        {
00094     return arg_1 + arg_2;
00095   }

static int mmx::GLUE_14 ( const string &  arg_1,
const string &  arg_2,
const int &  arg_3 
) [static]

Definition at line 88 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00088                                                                        {
00089     return search_forwards (arg_1, arg_2, arg_3);
00090   }

static lpolynomial<integer> mmx::GLUE_15 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 99 of file glue_lpolynomial_integer.cpp.

00099                                                                     {
00100     return arg_1 + arg_2;
00101   }

static string mmx::GLUE_15 ( const generic &  arg_1  )  [static]

Definition at line 99 of file glue_lpolynomial_generic.cpp.

00099                                  {
00100     return flatten_as_mmx (arg_1);
00101   }

static int mmx::GLUE_15 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 98 of file glue_lmvpolynomial_integer.cpp.

00098                                                  {
00099     return dim (arg_1);
00100   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_15 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 98 of file glue_lmvpolynomial_generic.cpp.

00098                                                                                        {
00099     return arg_1 - arg_2;
00100   }

static int mmx::GLUE_15 ( const string &  arg_1,
const string &  arg_2,
const int &  arg_3 
) [static]

Definition at line 93 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00093                                                                        {
00094     return search_backwards (arg_1, arg_2, arg_3);
00095   }

static lpolynomial<integer> mmx::GLUE_16 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 104 of file glue_lpolynomial_integer.cpp.

00104                                                                     {
00105     return arg_1 - arg_2;
00106   }

static string mmx::GLUE_16 ( const generic &  arg_1  )  [static]

Definition at line 104 of file glue_lpolynomial_generic.cpp.

00104                                  {
00105     return flatten_as_cpp (arg_1);
00106   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_16 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 103 of file glue_lmvpolynomial_integer.cpp.

References lmv_polynomial.

00103                                       {
00104     return (lmv_polynomial(integer ) (arg_1));
00105   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_16 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 103 of file glue_lmvpolynomial_generic.cpp.

00103                                                                                        {
00104     return arg_1 * arg_2;
00105   }

static string mmx::GLUE_16 ( const string &  arg_1  )  [static]

Definition at line 98 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00098                                 {
00099     return upcase (arg_1);
00100   }

static lpolynomial<integer> mmx::GLUE_17 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 109 of file glue_lpolynomial_integer.cpp.

00109                                                                     {
00110     return arg_1 * arg_2;
00111   }

static bool mmx::GLUE_17 ( const bool &  arg_1  )  [static]

Definition at line 109 of file glue_lpolynomial_generic.cpp.

00109                               {
00110     return set_frac_flag (arg_1);
00111   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_17 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 108 of file glue_lmvpolynomial_integer.cpp.

References lmv_polynomial.

00108                                       {
00109     return (lmv_polynomial(integer ) (arg_1));
00110   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_17 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 108 of file glue_lmvpolynomial_generic.cpp.

References square().

00108                                                  {
00109     return square (arg_1);
00110   }

static string mmx::GLUE_17 ( const string &  arg_1  )  [static]

Definition at line 103 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00103                                 {
00104     return locase (arg_1);
00105   }

static lpolynomial<integer> mmx::GLUE_18 ( const integer &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 114 of file glue_lpolynomial_integer.cpp.

00114                                                                     {
00115     return arg_1 + arg_2;
00116   }

static vector<generic> mmx::GLUE_18 ( const vector< generic > &  arg_1  )  [static]

Definition at line 114 of file glue_lpolynomial_generic.cpp.

00114                                          {
00115     return -arg_1;
00116   }

static int mmx::GLUE_18 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 113 of file glue_lmvpolynomial_integer.cpp.

References N().

00113                                                  {
00114     return N (arg_1);
00115   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_18 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 113 of file glue_lmvpolynomial_generic.cpp.

00113                                                                             {
00114     return arg_1 * arg_2;
00115   }

static string mmx::GLUE_18 ( const string &  arg_1  )  [static]

Definition at line 108 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00108                                 {
00109     return upcase_first (arg_1);
00110   }

static lpolynomial<integer> mmx::GLUE_19 ( const integer &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 119 of file glue_lpolynomial_integer.cpp.

00119                                                                     {
00120     return arg_1 - arg_2;
00121   }

static vector<generic> mmx::GLUE_19 ( const vector< generic > &  arg_1  )  [static]

Definition at line 119 of file glue_lpolynomial_generic.cpp.

References square().

00119                                          {
00120     return square (arg_1);
00121   }

static integer mmx::GLUE_19 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 118 of file glue_lmvpolynomial_integer.cpp.

00118                                                                    {
00119     return get_coefficient (arg_1, arg_2);
00120   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_19 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 118 of file glue_lmvpolynomial_generic.cpp.

00118                                                                             {
00119     return arg_1 * arg_2;
00120   }

static string mmx::GLUE_19 ( const string &  arg_1  )  [static]

Definition at line 113 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00113                                 {
00114     return locase_first (arg_1);
00115   }

static lpolynomial<integer> mmx::GLUE_2 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 34 of file glue_lpolynomial_integer.cpp.

00034                                                       {
00035     return lpolynomial<integer > (arg_1, arg_2);
00036   }

static generic mmx::GLUE_2 ( const compound &  arg_1,
const tuple< generic > &  arg_2 
) [static]

Definition at line 34 of file glue_lpolynomial_generic.cpp.

References gen_compound_apply.

00034                                                               {
00035     return gen_compound_apply (arg_1, as_vector (arg_2));
00036   }

static integer mmx::GLUE_2 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 33 of file glue_lmvpolynomial_integer.cpp.

References val().

00033                                      {
00034     return val (arg_1);
00035   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_2 ( const generic &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 33 of file glue_lmvpolynomial_generic.cpp.

References lmv_polynomial.

00033                                                            {
00034     return (lmv_polynomial(generic ) (arg_1, arg_2));
00035   }

static int mmx::GLUE_2 ( const string &  arg_1  )  [static]

Definition at line 28 of file glue_lmonomial.cpp.

References N().

00028                                {
00029     return N (arg_1);
00030   }

static vector<generic> mmx::GLUE_2 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 47 of file glue_linear_factors.cpp.

References linear_factors().

Referenced by glue_linear_factors(), glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00047                                                 {
00048     return linear_factors (arg_1);
00049   }

static lpolynomial<integer> mmx::GLUE_20 ( const integer &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 124 of file glue_lpolynomial_integer.cpp.

00124                                                                     {
00125     return arg_1 * arg_2;
00126   }

static vector<generic> mmx::GLUE_20 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 124 of file glue_lpolynomial_generic.cpp.

00124                                                                        {
00125     return arg_1 + arg_2;
00126   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_20 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 123 of file glue_lmvpolynomial_integer.cpp.

00123                                                                    {
00124     return get_monomial (arg_1, arg_2);
00125   }

static bool mmx::GLUE_20 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 123 of file glue_lmvpolynomial_generic.cpp.

00123                                                                                        {
00124     return arg_1 == arg_2;
00125   }

static string mmx::GLUE_20 ( const string &  arg_1  )  [static]

Definition at line 118 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00118                                 {
00119     return quote (arg_1);
00120   }

static bool mmx::GLUE_21 ( const lpolynomial< integer > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 129 of file glue_lpolynomial_integer.cpp.

00129                                                                                  {
00130     return arg_1 == arg_2;
00131   }

static vector<generic> mmx::GLUE_21 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 129 of file glue_lpolynomial_generic.cpp.

00129                                                                        {
00130     return arg_1 - arg_2;
00131   }

static integer mmx::GLUE_21 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 128 of file glue_lmvpolynomial_integer.cpp.

00128                                                                             {
00129     return arg_1[arg_2];
00130   }

static bool mmx::GLUE_21 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 128 of file glue_lmvpolynomial_generic.cpp.

00128                                                                                        {
00129     return arg_1 != arg_2;
00130   }

static string mmx::GLUE_21 ( const string &  arg_1  )  [static]

Definition at line 123 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00123                                 {
00124     return unquote (arg_1);
00125   }

static bool mmx::GLUE_22 ( const lpolynomial< integer > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 134 of file glue_lpolynomial_integer.cpp.

00134                                                                                  {
00135     return arg_1 != arg_2;
00136   }

static vector<generic> mmx::GLUE_22 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 134 of file glue_lpolynomial_generic.cpp.

00134                                                                        {
00135     return arg_1 * arg_2;
00136   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_22 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 133 of file glue_lmvpolynomial_integer.cpp.

00133                                                                    {
00134     return homogeneous_part (arg_1, arg_2);
00135   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_22 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 133 of file glue_lmvpolynomial_generic.cpp.

References derive().

00133                                                                               {
00134     return derive (arg_1, arg_2);
00135   }

static string mmx::GLUE_22 ( const int &  arg_1  )  [static]

Definition at line 128 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00128                              {
00129     return charcode_as_string (arg_1);
00130   }

static bool mmx::GLUE_23 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 139 of file glue_lpolynomial_integer.cpp.

00139                                                                     {
00140     return arg_1 == arg_2;
00141   }

static generic mmx::GLUE_23 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 139 of file glue_lpolynomial_generic.cpp.

00139                                                                        {
00140     return dot (arg_1, arg_2);
00141   }

static integer mmx::GLUE_23 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 138 of file glue_lmvpolynomial_integer.cpp.

References deg().

00138                                                  {
00139     return deg (arg_1);
00140   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_23 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 138 of file glue_lmvpolynomial_generic.cpp.

References xderive().

00138                                                                               {
00139     return xderive (arg_1, arg_2);
00140   }

static int mmx::GLUE_23 ( const string &  arg_1  )  [static]

Definition at line 133 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00133                                 {
00134     return string_as_charcode (arg_1);
00135   }

static bool mmx::GLUE_24 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 144 of file glue_lpolynomial_integer.cpp.

00144                                                                     {
00145     return arg_1 != arg_2;
00146   }

static generic mmx::GLUE_24 ( const vector< generic > &  arg_1  )  [static]

Definition at line 144 of file glue_lpolynomial_generic.cpp.

00144                                          {
00145     return big_mul (arg_1);
00146   }

static integer mmx::GLUE_24 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 143 of file glue_lmvpolynomial_integer.cpp.

References val().

00143                                                  {
00144     return val (arg_1);
00145   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_24 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 143 of file glue_lmvpolynomial_generic.cpp.

00143                                                                                        {
00144     return arg_1 / arg_2;
00145   }

static bool mmx::GLUE_24 ( const string &  arg_1  )  [static]

Definition at line 138 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00138                                 {
00139     return is_integer_string (arg_1);
00140   }

static bool mmx::GLUE_25 ( const integer &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 149 of file glue_lpolynomial_integer.cpp.

00149                                                                     {
00150     return arg_1 == arg_2;
00151   }

static generic mmx::GLUE_25 ( const vector< generic > &  arg_1  )  [static]

Definition at line 149 of file glue_lpolynomial_generic.cpp.

00149                                          {
00150     return big_add (arg_1);
00151   }

static integer mmx::GLUE_25 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 148 of file glue_lmvpolynomial_integer.cpp.

References deg().

00148                                                                               {
00149     return deg (arg_1, arg_2);
00150   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_25 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 148 of file glue_lmvpolynomial_generic.cpp.

00148                                                                             {
00149     return arg_1 / arg_2;
00150   }

static bool mmx::GLUE_25 ( const string &  arg_1  )  [static]

Definition at line 143 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00143                                 {
00144     return is_floating_string (arg_1);
00145   }

static bool mmx::GLUE_26 ( const integer &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 154 of file glue_lpolynomial_integer.cpp.

00154                                                                     {
00155     return arg_1 != arg_2;
00156   }

static bool mmx::GLUE_26 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 154 of file glue_lpolynomial_generic.cpp.

00154                                                                        {
00155     return arg_1 == arg_2;
00156   }

static integer mmx::GLUE_26 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 153 of file glue_lmvpolynomial_integer.cpp.

References val().

00153                                                                               {
00154     return val (arg_1, arg_2);
00155   }

static int mmx::GLUE_26 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 153 of file glue_lmvpolynomial_generic.cpp.

00153                                                  {
00154     return pr_hash (arg_1);
00155   }

static bool mmx::GLUE_26 ( const string &  arg_1  )  [static]

Definition at line 148 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00148                                 {
00149     return is_alpha (arg_1);
00150   }

static lpolynomial<integer> mmx::GLUE_27 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 159 of file glue_lpolynomial_integer.cpp.

References derive().

00159                                               {
00160     return derive (arg_1);
00161   }

static bool mmx::GLUE_27 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 159 of file glue_lpolynomial_generic.cpp.

00159                                                                        {
00160     return arg_1 != arg_2;
00161   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_27 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2,
const int &  arg_3 
) [static]

Definition at line 158 of file glue_lmvpolynomial_integer.cpp.

00158                                                                                                 {
00159     return coefficient (arg_1, arg_2, arg_3);
00160   }

static bool mmx::GLUE_27 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 158 of file glue_lmvpolynomial_generic.cpp.

00158                                                                                        {
00159     return pr_eq (arg_1, arg_2);
00160   }

static bool mmx::GLUE_27 ( const string &  arg_1  )  [static]

Definition at line 153 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00153                                 {
00154     return is_numeric (arg_1);
00155   }

static lpolynomial<integer> mmx::GLUE_28 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 164 of file glue_lpolynomial_integer.cpp.

References xderive().

00164                                               {
00165     return xderive (arg_1);
00166   }

static vector<generic> mmx::GLUE_28 ( const vector< generic > &  arg_1  )  [static]

Definition at line 164 of file glue_lpolynomial_generic.cpp.

00164                                          {
00165     return invert (arg_1);
00166   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_28 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 163 of file glue_lmvpolynomial_integer.cpp.

00163                                                  {
00164     return -arg_1;
00165   }

static bool mmx::GLUE_28 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 163 of file glue_lmvpolynomial_generic.cpp.

00163                                                                                        {
00164     return pr_neq (arg_1, arg_2);
00165   }

static bool mmx::GLUE_28 ( const string &  arg_1  )  [static]

Definition at line 158 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00158                                 {
00159     return is_alpha_numeric (arg_1);
00160   }

static integer mmx::GLUE_29 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 169 of file glue_lpolynomial_integer.cpp.

References eval().

00169                                                                     {
00170     return eval (arg_1, arg_2);
00171   }

static vector<generic> mmx::GLUE_29 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 169 of file glue_lpolynomial_generic.cpp.

00169                                                                        {
00170     return arg_1 / arg_2;
00171   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_29 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 168 of file glue_lmvpolynomial_integer.cpp.

00168                                                                                        {
00169     return arg_1 + arg_2;
00170   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_29 ( const tuple< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 168 of file glue_lmvpolynomial_generic.cpp.

00168                                                          {
00169     return vector<lmv_polynomial(generic) > (as_vector (arg_1));
00170   }

static bool mmx::GLUE_29 ( const string &  arg_1  )  [static]

Definition at line 163 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00163                                 {
00164     return is_mmx_identifier (arg_1);
00165   }

static void mmx::GLUE_3 ( const lpolynomial< integer > &  arg_1,
const generic &  arg_2 
) [static]

Definition at line 39 of file glue_lpolynomial_integer.cpp.

References set_variable_name().

00039                                                                    {
00040     set_variable_name (arg_1, arg_2);
00041   }

static compound mmx::GLUE_3 ( const tuple< generic > &  arg_1  )  [static]

Definition at line 39 of file glue_lpolynomial_generic.cpp.

00039                                        {
00040     return compound (as_vector (arg_1));
00041   }

static integer mmx::GLUE_3 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 38 of file glue_lmvpolynomial_integer.cpp.

References deg().

00038                                                                   {
00039     return deg (arg_1, arg_2);
00040   }

static multivariate_coordinates mmx::GLUE_3 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 38 of file glue_lmvpolynomial_generic.cpp.

00038                                                 {
00039     return arg_1.coords;
00040   }

static string mmx::GLUE_3 ( const string &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 33 of file glue_lmonomial.cpp.

00033                                                                    {
00034     return arg_1 (arg_2, arg_3);
00035   }

static vector<generic> mmx::GLUE_3 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 52 of file glue_linear_factors.cpp.

References linear_factors().

Referenced by glue_linear_factors(), glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00052                                              {
00053     return linear_factors (arg_1);
00054   }

static lpolynomial<generic> mmx::GLUE_30 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 174 of file glue_lpolynomial_integer.cpp.

00174                                               {
00175     return as<lpolynomial<generic> > (arg_1);
00176   }

static bool mmx::GLUE_30 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 174 of file glue_lpolynomial_generic.cpp.

00174                                                                        {
00175     return arg_1 <= arg_2;
00176   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_30 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 173 of file glue_lmvpolynomial_integer.cpp.

00173                                                                                        {
00174     return arg_1 - arg_2;
00175   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_30 ( const tuple< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 173 of file glue_lmvpolynomial_generic.cpp.

00173                                                          {
00174     return vector<lmv_polynomial(generic) > (as_vector (arg_1));
00175   }

static bool mmx::GLUE_30 ( const generic &  arg_1  )  [static]

Definition at line 168 of file glue_lmonomial.cpp.

References is_generic_literal.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00168                                  {
00169     return is_generic_literal (arg_1);
00170   }

static int mmx::GLUE_31 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 179 of file glue_lpolynomial_integer.cpp.

00179                                               {
00180     return pr_hash (arg_1);
00181   }

static bool mmx::GLUE_31 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 179 of file glue_lpolynomial_generic.cpp.

00179                                                                        {
00180     return arg_1 >= arg_2;
00181   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_31 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 178 of file glue_lmvpolynomial_integer.cpp.

00178                                                                                        {
00179     return arg_1 * arg_2;
00180   }

static iterator<generic> mmx::GLUE_31 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 178 of file glue_lmvpolynomial_generic.cpp.

References iterate().

00178                                                           {
00179     return as<iterator<generic> > (iterate (arg_1));
00180   }

static generic mmx::GLUE_31 ( const literal &  arg_1,
const tuple< generic > &  arg_2 
) [static]

Definition at line 173 of file glue_lmonomial.cpp.

References gen_literal_apply.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00173                                                               {
00174     return gen_literal_apply (arg_1, as_vector (arg_2));
00175   }

static bool mmx::GLUE_32 ( const lpolynomial< integer > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 184 of file glue_lpolynomial_integer.cpp.

00184                                                                                  {
00185     return pr_eq (arg_1, arg_2);
00186   }

static bool mmx::GLUE_32 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 184 of file glue_lpolynomial_generic.cpp.

00184                                                                        {
00185     return arg_1 < arg_2;
00186   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_32 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 183 of file glue_lmvpolynomial_integer.cpp.

References square().

00183                                                  {
00184     return square (arg_1);
00185   }

static int mmx::GLUE_32 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 183 of file glue_lmvpolynomial_generic.cpp.

References N().

00183                                                           {
00184     return N (arg_1);
00185   }

static generic mmx::GLUE_32 ( const literal &  arg_1,
const tuple< generic > &  arg_2 
) [static]

Definition at line 178 of file glue_lmonomial.cpp.

References gen_literal_access.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00178                                                               {
00179     return gen_literal_access (arg_1, as_vector (arg_2));
00180   }

static bool mmx::GLUE_33 ( const lpolynomial< integer > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 189 of file glue_lpolynomial_integer.cpp.

00189                                                                                  {
00190     return pr_neq (arg_1, arg_2);
00191   }

static bool mmx::GLUE_33 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 189 of file glue_lpolynomial_generic.cpp.

00189                                                                        {
00190     return arg_1 > arg_2;
00191   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_33 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 188 of file glue_lmvpolynomial_integer.cpp.

References binpow().

00188                                                                        {
00189     return binpow (arg_1, arg_2);
00190   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_33 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 188 of file glue_lmvpolynomial_generic.cpp.

00188                                                                             {
00189     return arg_1[arg_2];
00190   }

static literal mmx::GLUE_33 ( const string &  arg_1  )  [static]

Definition at line 183 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00183                                 {
00184     return literal (arg_1);
00185   }

static vector<lpolynomial<integer> > mmx::GLUE_34 ( const tuple< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 194 of file glue_lpolynomial_integer.cpp.

00194                                                       {
00195     return vector<lpolynomial<integer> > (as_vector (arg_1));
00196   }

static vector<generic> mmx::GLUE_34 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 194 of file glue_lpolynomial_generic.cpp.

00194                                                                        {
00195     return inf (arg_1, arg_2);
00196   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_34 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 193 of file glue_lmvpolynomial_integer.cpp.

00193                                                                        {
00194     return arg_1 + arg_2;
00195   }

static alias<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_34 ( const alias< vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 193 of file glue_lmvpolynomial_generic.cpp.

00193                                                                                     {
00194     return alias_access<lmv_polynomial(generic) > (arg_1, arg_2);
00195   }

static string mmx::GLUE_34 ( const literal &  arg_1  )  [static]

Definition at line 188 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00188                                  {
00189     return *arg_1;
00190   }

static vector<lpolynomial<integer> > mmx::GLUE_35 ( const tuple< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 199 of file glue_lpolynomial_integer.cpp.

00199                                                       {
00200     return vector<lpolynomial<integer> > (as_vector (arg_1));
00201   }

static vector<generic> mmx::GLUE_35 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 199 of file glue_lpolynomial_generic.cpp.

00199                                                                        {
00200     return sup (arg_1, arg_2);
00201   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_35 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 198 of file glue_lmvpolynomial_integer.cpp.

00198                                                                        {
00199     return arg_1 - arg_2;
00200   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_35 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 198 of file glue_lmvpolynomial_generic.cpp.

00198                                                                                               {
00199     return range (arg_1, arg_2, arg_3);
00200   }

static generic mmx::GLUE_35 ( const int &  arg_1  )  [static]

Definition at line 193 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00193                              {
00194     return integer_construct (arg_1);
00195   }

static iterator<generic> mmx::GLUE_36 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 204 of file glue_lpolynomial_integer.cpp.

References iterate().

00204                                                        {
00205     return as<iterator<generic> > (iterate (arg_1));
00206   }

static vector<generic> mmx::GLUE_36 ( const vector< generic > &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 204 of file glue_lpolynomial_generic.cpp.

00204                                                                        {
00205     return pow (arg_1, arg_2);
00206   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_36 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 203 of file glue_lmvpolynomial_integer.cpp.

00203                                                                        {
00204     return arg_1 * arg_2;
00205   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_36 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 203 of file glue_lmvpolynomial_generic.cpp.

00203                                                           {
00204     return reverse (arg_1);
00205   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_36 (  )  [static]

Definition at line 198 of file glue_lmonomial.cpp.

References lmv_monomial.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00198              {
00199     return lmv_monomial ();
00200   }

static int mmx::GLUE_37 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 209 of file glue_lpolynomial_integer.cpp.

References N().

00209                                                        {
00210     return N (arg_1);
00211   }

static vector<generic> mmx::GLUE_37 ( const vector< generic > &  arg_1  )  [static]

Definition at line 209 of file glue_lpolynomial_generic.cpp.

00209                                          {
00210     return sqrt (arg_1);
00211   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_37 ( const integer &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 208 of file glue_lmvpolynomial_integer.cpp.

00208                                                                        {
00209     return arg_1 + arg_2;
00210   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_37 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 208 of file glue_lmvpolynomial_generic.cpp.

00208                                                                                                          {
00209     return append (arg_1, arg_2);
00210   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_37 ( const multivariate_coordinate<> &  arg_1  )  [static]

Definition at line 203 of file glue_lmonomial.cpp.

References lmv_monomial.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00203                                         {
00204     return lmv_monomial (arg_1);
00205   }

static lpolynomial<integer> mmx::GLUE_38 ( const vector< lpolynomial< integer > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 214 of file glue_lpolynomial_integer.cpp.

00214                                                                          {
00215     return arg_1[arg_2];
00216   }

static vector<generic> mmx::GLUE_38 ( const vector< generic > &  arg_1  )  [static]

Definition at line 214 of file glue_lpolynomial_generic.cpp.

00214                                          {
00215     return exp (arg_1);
00216   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_38 ( const integer &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 213 of file glue_lmvpolynomial_integer.cpp.

00213                                                                        {
00214     return arg_1 - arg_2;
00215   }

static alias<vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > > mmx::GLUE_38 ( const alias< vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 213 of file glue_lmvpolynomial_generic.cpp.

00213                                                                                                                  {
00214     return alias_write (arg_1, arg_2);
00215   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_38 ( const multivariate_coordinate<> &  arg_1  )  [static]

Definition at line 208 of file glue_lmonomial.cpp.

References lmv_monomial.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00208                                         {
00209     return lmv_monomial (arg_1);
00210   }

static alias<lpolynomial<integer> > mmx::GLUE_39 ( const alias< vector< lpolynomial< integer > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 219 of file glue_lpolynomial_integer.cpp.

00219                                                                                  {
00220     return alias_access<lpolynomial<integer> > (arg_1, arg_2);
00221   }

static vector<generic> mmx::GLUE_39 ( const vector< generic > &  arg_1  )  [static]

Definition at line 219 of file glue_lpolynomial_generic.cpp.

00219                                          {
00220     return log (arg_1);
00221   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_39 ( const integer &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 218 of file glue_lmvpolynomial_integer.cpp.

00218                                                                        {
00219     return arg_1 * arg_2;
00220   }

static void mmx::GLUE_39 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 218 of file glue_lmvpolynomial_generic.cpp.

00218                                                                                                          {
00219     inside_append (arg_1, arg_2);
00220   }

static multivariate_coordinates mmx::GLUE_39 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 213 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00213                                       {
00214     return arg_1.coords;
00215   }

static lpolynomial<integer> mmx::GLUE_4 ( const integer &  arg_1  )  [static]

Definition at line 44 of file glue_lpolynomial_integer.cpp.

00044                                 {
00045     return lpolynomial<integer > (arg_1);
00046   }

static compound mmx::GLUE_4 ( const vector< generic > &  arg_1  )  [static]

Definition at line 44 of file glue_lpolynomial_generic.cpp.

00044                                         {
00045     return compound (arg_1);
00046   }

static integer mmx::GLUE_4 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 43 of file glue_lmvpolynomial_integer.cpp.

References val().

00043                                                                   {
00044     return val (arg_1, arg_2);
00045   }

static int mmx::GLUE_4 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 43 of file glue_lmvpolynomial_generic.cpp.

00043                                                 {
00044     return dim (arg_1);
00045   }

static string mmx::GLUE_4 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 38 of file glue_lmonomial.cpp.

00038                                                     {
00039     return arg_1 * arg_2;
00040   }

static vector<lpolynomial<integer> > mmx::GLUE_4 ( const vector< integer > &  arg_1  )  [static]

Definition at line 57 of file glue_linear_factors.cpp.

Referenced by glue_linear_factors(), glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00057                                         {
00058     return as<vector<lpolynomial<integer> > > (arg_1);
00059   }

static vector<lpolynomial<integer> > mmx::GLUE_40 ( const vector< lpolynomial< integer > > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 224 of file glue_lpolynomial_integer.cpp.

00224                                                                                            {
00225     return range (arg_1, arg_2, arg_3);
00226   }

static vector<generic> mmx::GLUE_40 ( const vector< generic > &  arg_1  )  [static]

Definition at line 224 of file glue_lpolynomial_generic.cpp.

00224                                          {
00225     return cos (arg_1);
00226   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_40 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 223 of file glue_lmvpolynomial_integer.cpp.

00223                                                                             {
00224     return arg_1 * arg_2;
00225   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_40 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 223 of file glue_lmvpolynomial_generic.cpp.

00223                                                                                                 {
00224     return cons (arg_1, arg_2);
00225   }

static int mmx::GLUE_40 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 218 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00218                                       {
00219     return dim (arg_1);
00220   }

static vector<lpolynomial<integer> > mmx::GLUE_41 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 229 of file glue_lpolynomial_integer.cpp.

00229                                                        {
00230     return reverse (arg_1);
00231   }

static vector<generic> mmx::GLUE_41 ( const vector< generic > &  arg_1  )  [static]

Definition at line 229 of file glue_lpolynomial_generic.cpp.

00229                                          {
00230     return sin (arg_1);
00231   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_41 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 228 of file glue_lmvpolynomial_integer.cpp.

00228                                                                             {
00229     return arg_1 * arg_2;
00230   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_41 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 228 of file glue_lmvpolynomial_generic.cpp.

00228                                                           {
00229     return car (arg_1);
00230   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_41 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 223 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00223                                                                  {
00224     return arg_1 * arg_2;
00225   }

static vector<lpolynomial<integer> > mmx::GLUE_42 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 234 of file glue_lpolynomial_integer.cpp.

00234                                                                                                    {
00235     return append (arg_1, arg_2);
00236   }

static vector<generic> mmx::GLUE_42 ( const vector< generic > &  arg_1  )  [static]

Definition at line 234 of file glue_lpolynomial_generic.cpp.

00234                                          {
00235     return tan (arg_1);
00236   }

static bool mmx::GLUE_42 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 233 of file glue_lmvpolynomial_integer.cpp.

00233                                                                                        {
00234     return arg_1 == arg_2;
00235   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_42 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 233 of file glue_lmvpolynomial_generic.cpp.

00233                                                           {
00234     return cdr (arg_1);
00235   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_42 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 228 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00228                                                                  {
00229     return arg_1 / arg_2;
00230   }

static alias<vector<lpolynomial<integer> > > mmx::GLUE_43 ( const alias< vector< lpolynomial< integer > > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 239 of file glue_lpolynomial_integer.cpp.

00239                                                                                                            {
00240     return alias_write (arg_1, arg_2);
00241   }

static vector<generic> mmx::GLUE_43 ( const vector< generic > &  arg_1  )  [static]

Definition at line 239 of file glue_lpolynomial_generic.cpp.

00239                                          {
00240     return acos (arg_1);
00241   }

static bool mmx::GLUE_43 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 238 of file glue_lmvpolynomial_integer.cpp.

00238                                                                                        {
00239     return arg_1 != arg_2;
00240   }

static bool mmx::GLUE_43 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 238 of file glue_lmvpolynomial_generic.cpp.

00238                                                           {
00239     return is_nil (arg_1);
00240   }

static bool mmx::GLUE_43 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 233 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00233                                                                  {
00234     return arg_1 >>= arg_2;
00235   }

static void mmx::GLUE_44 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 244 of file glue_lpolynomial_integer.cpp.

00244                                                                                                    {
00245     inside_append (arg_1, arg_2);
00246   }

static vector<generic> mmx::GLUE_44 ( const vector< generic > &  arg_1  )  [static]

Definition at line 244 of file glue_lpolynomial_generic.cpp.

00244                                          {
00245     return asin (arg_1);
00246   }

static bool mmx::GLUE_44 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 243 of file glue_lmvpolynomial_integer.cpp.

00243                                                                        {
00244     return eq_scalar (arg_1, arg_2);
00245   }

static bool mmx::GLUE_44 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 243 of file glue_lmvpolynomial_generic.cpp.

00243                                                           {
00244     return is_atom (arg_1);
00245   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_44 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 238 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00238                                                                  {
00239     return gcd (arg_1, arg_2);
00240   }

static vector<lpolynomial<integer> > mmx::GLUE_45 ( const lpolynomial< integer > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 249 of file glue_lpolynomial_integer.cpp.

00249                                                                                           {
00250     return cons (arg_1, arg_2);
00251   }

static vector<generic> mmx::GLUE_45 ( const vector< generic > &  arg_1  )  [static]

Definition at line 249 of file glue_lpolynomial_generic.cpp.

00249                                          {
00250     return atan (arg_1);
00251   }

static bool mmx::GLUE_45 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 248 of file glue_lmvpolynomial_integer.cpp.

00248                                                                        {
00249     return neq_scalar (arg_1, arg_2);
00250   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_45 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 248 of file glue_lmvpolynomial_generic.cpp.

00248                                                                                                 {
00249     return insert (arg_1, arg_2);
00250   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_45 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 243 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00243                                                                  {
00244     return lcm (arg_1, arg_2);
00245   }

static lpolynomial<integer> mmx::GLUE_46 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 254 of file glue_lpolynomial_integer.cpp.

00254                                                        {
00255     return car (arg_1);
00256   }

static vector<generic> mmx::GLUE_46 ( const vector< generic > &  arg_1  )  [static]

Definition at line 254 of file glue_lpolynomial_generic.cpp.

References derive().

00254                                          {
00255     return derive (arg_1);
00256   }

static bool mmx::GLUE_46 ( const integer &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 253 of file glue_lmvpolynomial_integer.cpp.

00253                                                                        {
00254     return scalar_eq (arg_1, arg_2);
00255   }

static int mmx::GLUE_46 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 253 of file glue_lmvpolynomial_generic.cpp.

00253                                                                                                 {
00254     return find (arg_1, arg_2);
00255   }

static bool mmx::GLUE_46 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 248 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00248                                                                  {
00249     return arg_1 << arg_2;
00250   }

static vector<lpolynomial<integer> > mmx::GLUE_47 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 259 of file glue_lpolynomial_integer.cpp.

00259                                                        {
00260     return cdr (arg_1);
00261   }

static vector<generic> mmx::GLUE_47 ( const vector< generic > &  arg_1  )  [static]

Definition at line 259 of file glue_lpolynomial_generic.cpp.

00259                                          {
00260     return integrate (arg_1);
00261   }

static bool mmx::GLUE_47 ( const integer &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 258 of file glue_lmvpolynomial_integer.cpp.

00258                                                                        {
00259     return scalar_neq (arg_1, arg_2);
00260   }

static bool mmx::GLUE_47 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 258 of file glue_lmvpolynomial_generic.cpp.

00258                                                                                                 {
00259     return contains (arg_1, arg_2);
00260   }

static bool mmx::GLUE_47 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 253 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00253                                                                  {
00254     return arg_1 <<= arg_2;
00255   }

static bool mmx::GLUE_48 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 264 of file glue_lpolynomial_integer.cpp.

00264                                                        {
00265     return is_nil (arg_1);
00266   }

static lpolynomial<generic> mmx::GLUE_48 ( const generic &  arg_1  )  [static]

Definition at line 264 of file glue_lpolynomial_generic.cpp.

00264                                  {
00265     return lpolynomial<generic > (arg_1);
00266   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_48 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 263 of file glue_lmvpolynomial_integer.cpp.

References derive().

00263                                                                               {
00264     return derive (arg_1, arg_2);
00265   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_48 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 263 of file glue_lmvpolynomial_generic.cpp.

00263                                                 {
00264     return as<vector<lmv_monomial> > (arg_1);
00265   }

static bool mmx::GLUE_48 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 258 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00258                                                                  {
00259     return arg_1 >> arg_2;
00260   }

static bool mmx::GLUE_49 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 269 of file glue_lpolynomial_integer.cpp.

00269                                                        {
00270     return is_atom (arg_1);
00271   }

static lpolynomial<generic> mmx::GLUE_49 ( const generic &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 269 of file glue_lpolynomial_generic.cpp.

00269                                                        {
00270     return lpolynomial<generic > (arg_1, arg_2);
00271   }

static multivariate<sparse_polynomial< integer ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_49 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 268 of file glue_lmvpolynomial_integer.cpp.

References xderive().

00268                                                                               {
00269     return xderive (arg_1, arg_2);
00270   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_49 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 268 of file glue_lmvpolynomial_generic.cpp.

00268                                                 {
00269     return as<vector<lmv_polynomial(generic) > > (arg_1);
00270   }

static bool mmx::GLUE_49 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 263 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00263                                                                  {
00264     return arg_1 >>= arg_2;
00265   }

static int mmx::GLUE_5 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 49 of file glue_lpolynomial_integer.cpp.

References N().

00049                                              {
00050     return N (arg_1);
00051   }

static vector<generic> mmx::GLUE_5 ( const compound &  arg_1  )  [static]

Definition at line 49 of file glue_lpolynomial_generic.cpp.

00049                                  {
00050     return as_vector (arg_1);
00051   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_5 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 48 of file glue_lmvpolynomial_integer.cpp.

References binpow().

00048                                                            {
00049     return binpow (arg_1, arg_2);
00050   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_5 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 48 of file glue_lmvpolynomial_generic.cpp.

References lmv_polynomial.

00048                                      {
00049     return (lmv_polynomial(generic ) (arg_1));
00050   }

static string mmx::GLUE_5 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 43 of file glue_lmonomial.cpp.

00043                                                     {
00044     return arg_1 * arg_2;
00045   }

static vector<integer> mmx::GLUE_5 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 62 of file glue_linear_factors.cpp.

References supp().

Referenced by glue_linear_factors(), glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00062                                              {
00063     return supp (arg_1);
00064   }

static vector<lpolynomial<integer> > mmx::GLUE_50 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 274 of file glue_lpolynomial_integer.cpp.

00274                                                                                           {
00275     return insert (arg_1, arg_2);
00276   }

static void mmx::GLUE_50 ( const lpolynomial< generic > &  arg_1,
const generic &  arg_2 
) [static]

Definition at line 274 of file glue_lpolynomial_generic.cpp.

References set_variable_name().

00274                                                                     {
00275     set_variable_name (arg_1, arg_2);
00276   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_50 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 273 of file glue_lmvpolynomial_integer.cpp.

00273                                                  {
00274     return as<lmv_polynomial(generic) > (arg_1);
00275   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_50 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 273 of file glue_lmvpolynomial_generic.cpp.

00273                                               {
00274     return as<vector<lmv_polynomial(generic) > > (arg_1);
00275   }

static int mmx::GLUE_50 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 268 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00268                                       {
00269     return pr_hash (arg_1);
00270   }

static int mmx::GLUE_51 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 279 of file glue_lpolynomial_integer.cpp.

00279                                                                                           {
00280     return find (arg_1, arg_2);
00281   }

static int mmx::GLUE_51 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 279 of file glue_lpolynomial_generic.cpp.

References N().

00279                                               {
00280     return N (arg_1);
00281   }

static int mmx::GLUE_51 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 278 of file glue_lmvpolynomial_integer.cpp.

00278                                                  {
00279     return pr_hash (arg_1);
00280   }

static vector<generic> mmx::GLUE_51 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 278 of file glue_lmvpolynomial_generic.cpp.

00278                                                           {
00279     return as<vector<generic> > (arg_1);
00280   }

static bool mmx::GLUE_51 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 273 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00273                                                                  {
00274     return pr_eq (arg_1, arg_2);
00275   }

static bool mmx::GLUE_52 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 284 of file glue_lpolynomial_integer.cpp.

00284                                                                                           {
00285     return contains (arg_1, arg_2);
00286   }

static generic mmx::GLUE_52 ( const lpolynomial< generic > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 284 of file glue_lpolynomial_generic.cpp.

00284                                                                     {
00285     return arg_1[arg_2];
00286   }

static bool mmx::GLUE_52 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 283 of file glue_lmvpolynomial_integer.cpp.

00283                                                                                        {
00284     return pr_eq (arg_1, arg_2);
00285   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_52 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 283 of file glue_lmvpolynomial_generic.cpp.

References supp().

00283                                                  {
00284     return supp (arg_1);
00285   }

static bool mmx::GLUE_52 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 278 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00278                                                                  {
00279     return pr_neq (arg_1, arg_2);
00280   }

static vector<generic> mmx::GLUE_53 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 289 of file glue_lpolynomial_integer.cpp.

00289                                                        {
00290     return as<vector<generic> > (arg_1);
00291   }

static integer mmx::GLUE_53 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 289 of file glue_lpolynomial_generic.cpp.

References deg().

00289                                               {
00290     return deg (arg_1);
00291   }

static bool mmx::GLUE_53 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 288 of file glue_lmvpolynomial_integer.cpp.

00288                                                                                        {
00289     return pr_neq (arg_1, arg_2);
00290   }

static generic mmx::GLUE_53 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< generic > &  arg_3 
) [static]

Definition at line 288 of file glue_lmvpolynomial_generic.cpp.

References eval().

00288                                                                                                                     {
00289     return eval (arg_1, arg_2, arg_3);
00290   }

static vector< multivariate_coordinate<> > mmx::GLUE_53 ( const tuple< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 283 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00283                                                {
00284     return vector<mmx_coordinate > (as_vector (arg_1));
00285   }

static vector<lpolynomial<integer> > mmx::GLUE_54 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 294 of file glue_lpolynomial_integer.cpp.

00294                                                        {
00295     return -arg_1;
00296   }

static integer mmx::GLUE_54 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 294 of file glue_lpolynomial_generic.cpp.

References val().

00294                                               {
00295     return val (arg_1);
00296   }

static int mmx::GLUE_54 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 293 of file glue_lmvpolynomial_integer.cpp.

00293                                                           {
00294     return -arg_1;
00295   }

static vector< multivariate_coordinate<> > mmx::GLUE_54 ( const tuple< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 288 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00288                                                {
00289     return vector<mmx_coordinate > (as_vector (arg_1));
00290   }

static vector<lpolynomial<integer> > mmx::GLUE_55 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 299 of file glue_lpolynomial_integer.cpp.

References square().

00299                                                        {
00300     return square (arg_1);
00301   }

static lpolynomial<generic> mmx::GLUE_55 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 299 of file glue_lpolynomial_generic.cpp.

00299                                               {
00300     return -arg_1;
00301   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_55 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 298 of file glue_lmvpolynomial_integer.cpp.

References square().

00298                                                           {
00299     return square (arg_1);
00300   }

static bool mmx::GLUE_55 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 298 of file glue_lmvpolynomial_generic.cpp.

00298                                                                                                          {
00299     return pr_eq (arg_1, arg_2);
00300   }

static iterator<generic> mmx::GLUE_55 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 293 of file glue_lmonomial.cpp.

References iterate().

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00293                                                 {
00294     return as<iterator<generic> > (iterate (arg_1));
00295   }

static vector<lpolynomial<integer> > mmx::GLUE_56 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 304 of file glue_lpolynomial_integer.cpp.

00304                                                                                                    {
00305     return arg_1 + arg_2;
00306   }

static lpolynomial<generic> mmx::GLUE_56 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 304 of file glue_lpolynomial_generic.cpp.

00304                                                                                  {
00305     return arg_1 + arg_2;
00306   }

static bool mmx::GLUE_56 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 303 of file glue_lmvpolynomial_integer.cpp.

00303                                                                                                          {
00304     return arg_1 + arg_2;
00305   }

static int mmx::GLUE_56 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 298 of file glue_lmonomial.cpp.

References N().

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00298                                                 {
00299     return N (arg_1);
00300   }

static vector<lpolynomial<integer> > mmx::GLUE_57 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 309 of file glue_lpolynomial_integer.cpp.

00309                                                                                                    {
00310     return arg_1 - arg_2;
00311   }

static lpolynomial<generic> mmx::GLUE_57 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 309 of file glue_lpolynomial_generic.cpp.

00309                                                                                  {
00310     return arg_1 - arg_2;
00311   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_57 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 308 of file glue_lmvpolynomial_integer.cpp.

00308                                                                                                          {
00309     return arg_1 - arg_2;
00310   }

static multivariate_coordinate mmx::GLUE_57 ( const vector< multivariate_coordinate<> > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 303 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00303                                                                   {
00304     return arg_1[arg_2];
00305   }

static vector<lpolynomial<integer> > mmx::GLUE_58 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 314 of file glue_lpolynomial_integer.cpp.

00314                                                                                                    {
00315     return arg_1 * arg_2;
00316   }

static lpolynomial<generic> mmx::GLUE_58 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 314 of file glue_lpolynomial_generic.cpp.

00314                                                                                  {
00315     return arg_1 * arg_2;
00316   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_58 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 313 of file glue_lmvpolynomial_integer.cpp.

00313                                                                                                          {
00314     return arg_1 * arg_2;
00315   }

static alias< multivariate_coordinate<> > mmx::GLUE_58 ( const alias< vector< multivariate_coordinate<> > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 308 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00308                                                                           {
00309     return alias_access<mmx_coordinate > (arg_1, arg_2);
00310   }

static vector<lpolynomial<integer> > mmx::GLUE_59 ( const lpolynomial< integer > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 319 of file glue_lpolynomial_integer.cpp.

00319                                                                                           {
00320     return arg_1 + arg_2;
00321   }

static lpolynomial<generic> mmx::GLUE_59 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 319 of file glue_lpolynomial_generic.cpp.

References square().

00319                                               {
00320     return square (arg_1);
00321   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_59 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 318 of file glue_lmvpolynomial_integer.cpp.

00318                                                                                                 {
00319     return arg_1 + arg_2;
00320   }

static vector< multivariate_coordinate<> > mmx::GLUE_59 ( const vector< multivariate_coordinate<> > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 313 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00313                                                                                     {
00314     return range (arg_1, arg_2, arg_3);
00315   }

static integer mmx::GLUE_6 ( const lpolynomial< integer > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 54 of file glue_lpolynomial_integer.cpp.

00054                                                                    {
00055     return arg_1[arg_2];
00056   }

static int mmx::GLUE_6 ( const compound &  arg_1  )  [static]

Definition at line 54 of file glue_lpolynomial_generic.cpp.

References N().

00054                                  {
00055     return N (arg_1);
00056   }

static integer mmx::GLUE_6 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 53 of file glue_lmvpolynomial_integer.cpp.

References deg().

00053                                                 {
00054     return deg (arg_1);
00055   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_6 ( const multivariate< monomial< vector< integer > > > &  arg_1  )  [static]

Definition at line 53 of file glue_lmvpolynomial_generic.cpp.

References lmv_polynomial.

00053                                      {
00054     return (lmv_polynomial(generic ) (arg_1));
00055   }

static alias<string> mmx::GLUE_6 ( const alias< string > &  arg_1,
const string &  arg_2 
) [static]

Definition at line 48 of file glue_lmonomial.cpp.

00048                                                            {
00049     return alias_write (arg_1, arg_2);
00050   }

static vector<integer> mmx::GLUE_6 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 67 of file glue_linear_factors.cpp.

References supp().

Referenced by glue_linear_factors(), glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00067                                              {
00068     return supp (arg_1);
00069   }

static vector<lpolynomial<integer> > mmx::GLUE_60 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 324 of file glue_lpolynomial_integer.cpp.

00324                                                                                           {
00325     return arg_1 + arg_2;
00326   }

static lpolynomial<generic> mmx::GLUE_60 ( const lpolynomial< generic > &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 324 of file glue_lpolynomial_generic.cpp.

References binpow().

00324                                                                     {
00325     return binpow (arg_1, arg_2);
00326   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_60 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 323 of file glue_lmvpolynomial_integer.cpp.

00323                                                                                                 {
00324     return arg_1 + arg_2;
00325   }

static vector< multivariate_coordinate<> > mmx::GLUE_60 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 318 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00318                                                 {
00319     return reverse (arg_1);
00320   }

static vector<lpolynomial<integer> > mmx::GLUE_61 ( const lpolynomial< integer > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 329 of file glue_lpolynomial_integer.cpp.

00329                                                                                           {
00330     return arg_1 - arg_2;
00331   }

static bool mmx::GLUE_61 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 329 of file glue_lpolynomial_generic.cpp.

00329                                                                                  {
00330     return arg_1 == arg_2;
00331   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_61 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 328 of file glue_lmvpolynomial_integer.cpp.

00328                                                                                                 {
00329     return arg_1 - arg_2;
00330   }

static vector< multivariate_coordinate<> > mmx::GLUE_61 ( const vector< multivariate_coordinate<> > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2 
) [static]

Definition at line 323 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00323                                                                                      {
00324     return append (arg_1, arg_2);
00325   }

static vector<lpolynomial<integer> > mmx::GLUE_62 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 334 of file glue_lpolynomial_integer.cpp.

00334                                                                                           {
00335     return arg_1 - arg_2;
00336   }

static bool mmx::GLUE_62 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 334 of file glue_lpolynomial_generic.cpp.

00334                                                                                  {
00335     return arg_1 != arg_2;
00336   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_62 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 333 of file glue_lmvpolynomial_integer.cpp.

00333                                                                                                 {
00334     return arg_1 - arg_2;
00335   }

static alias<vector< multivariate_coordinate<> > > mmx::GLUE_62 ( const alias< vector< multivariate_coordinate<> > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2 
) [static]

Definition at line 328 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00328                                                                                              {
00329     return alias_write (arg_1, arg_2);
00330   }

static vector<lpolynomial<integer> > mmx::GLUE_63 ( const lpolynomial< integer > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 339 of file glue_lpolynomial_integer.cpp.

00339                                                                                           {
00340     return arg_1 * arg_2;
00341   }

static lpolynomial<generic> mmx::GLUE_63 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 339 of file glue_lpolynomial_generic.cpp.

References derive().

00339                                               {
00340     return derive (arg_1);
00341   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_63 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 338 of file glue_lmvpolynomial_integer.cpp.

00338                                                                                                 {
00339     return arg_1 * arg_2;
00340   }

static void mmx::GLUE_63 ( const vector< multivariate_coordinate<> > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2 
) [static]

Definition at line 333 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00333                                                                                      {
00334     inside_append (arg_1, arg_2);
00335   }

static vector<lpolynomial<integer> > mmx::GLUE_64 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 344 of file glue_lpolynomial_integer.cpp.

00344                                                                                           {
00345     return arg_1 * arg_2;
00346   }

static lpolynomial<generic> mmx::GLUE_64 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 344 of file glue_lpolynomial_generic.cpp.

References xderive().

00344                                               {
00345     return xderive (arg_1);
00346   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_64 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 343 of file glue_lmvpolynomial_integer.cpp.

00343                                                                                                 {
00344     return arg_1 * arg_2;
00345   }

static vector< multivariate_coordinate<> > mmx::GLUE_64 ( const multivariate_coordinate<> &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2 
) [static]

Definition at line 338 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00338                                                                              {
00339     return cons (arg_1, arg_2);
00340   }

static lpolynomial<integer> mmx::GLUE_65 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 349 of file glue_lpolynomial_integer.cpp.

00349                                                                                                    {
00350     return dot (arg_1, arg_2);
00351   }

static generic mmx::GLUE_65 ( const lpolynomial< generic > &  arg_1,
const generic &  arg_2 
) [static]

Definition at line 349 of file glue_lpolynomial_generic.cpp.

References eval().

00349                                                                     {
00350     return eval (arg_1, arg_2);
00351   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_65 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 348 of file glue_lmvpolynomial_integer.cpp.

00348                                                                                                          {
00349     return dot (arg_1, arg_2);
00350   }

static multivariate_coordinate mmx::GLUE_65 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 343 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00343                                                 {
00344     return car (arg_1);
00345   }

static lpolynomial<integer> mmx::GLUE_66 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 354 of file glue_lpolynomial_integer.cpp.

00354                                                        {
00355     return big_mul (arg_1);
00356   }

static lpolynomial<generic> mmx::GLUE_66 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 354 of file glue_lpolynomial_generic.cpp.

00354                                                                                  {
00355     return arg_1 / arg_2;
00356   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_66 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 353 of file glue_lmvpolynomial_integer.cpp.

00353                                                           {
00354     return big_mul (arg_1);
00355   }

static vector< multivariate_coordinate<> > mmx::GLUE_66 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 348 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00348                                                 {
00349     return cdr (arg_1);
00350   }

static lpolynomial<integer> mmx::GLUE_67 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 359 of file glue_lpolynomial_integer.cpp.

00359                                                        {
00360     return big_add (arg_1);
00361   }

static int mmx::GLUE_67 ( const lpolynomial< generic > &  arg_1  )  [static]

Definition at line 359 of file glue_lpolynomial_generic.cpp.

00359                                               {
00360     return pr_hash (arg_1);
00361   }

static multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > mmx::GLUE_67 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 358 of file glue_lmvpolynomial_integer.cpp.

00358                                                           {
00359     return big_add (arg_1);
00360   }

static bool mmx::GLUE_67 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 353 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00353                                                 {
00354     return is_nil (arg_1);
00355   }

static bool mmx::GLUE_68 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 364 of file glue_lpolynomial_integer.cpp.

00364                                                                                                    {
00365     return arg_1 == arg_2;
00366   }

static bool mmx::GLUE_68 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 364 of file glue_lpolynomial_generic.cpp.

00364                                                                                  {
00365     return pr_eq (arg_1, arg_2);
00366   }

static bool mmx::GLUE_68 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 363 of file glue_lmvpolynomial_integer.cpp.

00363                                                                                                          {
00364     return arg_1 == arg_2;
00365   }

static bool mmx::GLUE_68 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 358 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00358                                                 {
00359     return is_atom (arg_1);
00360   }

static bool mmx::GLUE_69 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 369 of file glue_lpolynomial_integer.cpp.

00369                                                                                                    {
00370     return arg_1 != arg_2;
00371   }

static bool mmx::GLUE_69 ( const lpolynomial< generic > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 369 of file glue_lpolynomial_generic.cpp.

00369                                                                                  {
00370     return pr_neq (arg_1, arg_2);
00371   }

static bool mmx::GLUE_69 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 368 of file glue_lmvpolynomial_integer.cpp.

00368                                                                                                          {
00369     return arg_1 != arg_2;
00370   }

static vector< multivariate_coordinate<> > mmx::GLUE_69 ( const vector< multivariate_coordinate<> > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 363 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00363                                                                              {
00364     return insert (arg_1, arg_2);
00365   }

static integer mmx::GLUE_7 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 59 of file glue_lpolynomial_integer.cpp.

References deg().

00059                                              {
00060     return deg (arg_1);
00061   }

static generic mmx::GLUE_7 ( const compound &  arg_1,
const int &  arg_2 
) [static]

Definition at line 59 of file glue_lpolynomial_generic.cpp.

00059                                                    {
00060     return arg_1[arg_2];
00061   }

static int mmx::GLUE_7 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 58 of file glue_lmvpolynomial_integer.cpp.

References val().

00058                                                 {
00059     return val (arg_1);
00060   }

static bool mmx::GLUE_7 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 53 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00053                                                     {
00054     return arg_1 < arg_2;
00055   }

static bool mmx::GLUE_70 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 374 of file glue_lpolynomial_integer.cpp.

00374                                                                                           {
00375     return arg_1 == arg_2;
00376   }

static vector<lpolynomial<generic> > mmx::GLUE_70 ( const tuple< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 374 of file glue_lpolynomial_generic.cpp.

00374                                                       {
00375     return vector<lpolynomial<generic> > (as_vector (arg_1));
00376   }

static bool mmx::GLUE_70 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 373 of file glue_lmvpolynomial_integer.cpp.

00373                                                                                                 {
00374     return arg_1 == arg_2;
00375   }

static int mmx::GLUE_70 ( const vector< multivariate_coordinate<> > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 368 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00368                                                                              {
00369     return find (arg_1, arg_2);
00370   }

static bool mmx::GLUE_71 ( const vector< lpolynomial< integer > > &  arg_1,
const lpolynomial< integer > &  arg_2 
) [static]

Definition at line 379 of file glue_lpolynomial_integer.cpp.

00379                                                                                           {
00380     return arg_1 != arg_2;
00381   }

static vector<lpolynomial<generic> > mmx::GLUE_71 ( const tuple< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 379 of file glue_lpolynomial_generic.cpp.

00379                                                       {
00380     return vector<lpolynomial<generic> > (as_vector (arg_1));
00381   }

static bool mmx::GLUE_71 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 378 of file glue_lmvpolynomial_integer.cpp.

00378                                                                                                 {
00379     return arg_1 != arg_2;
00380   }

static bool mmx::GLUE_71 ( const vector< multivariate_coordinate<> > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 373 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00373                                                                              {
00374     return contains (arg_1, arg_2);
00375   }

static bool mmx::GLUE_72 ( const lpolynomial< integer > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 384 of file glue_lpolynomial_integer.cpp.

00384                                                                                           {
00385     return arg_1 == arg_2;
00386   }

static iterator<generic> mmx::GLUE_72 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 384 of file glue_lpolynomial_generic.cpp.

References iterate().

00384                                                        {
00385     return as<iterator<generic> > (iterate (arg_1));
00386   }

static bool mmx::GLUE_72 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 383 of file glue_lmvpolynomial_integer.cpp.

00383                                                                                                 {
00384     return arg_1 == arg_2;
00385   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_72 ( const tuple< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 378 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00378                                              {
00379     return vector<lmv_monomial > (as_vector (arg_1));
00380   }

static bool mmx::GLUE_73 ( const lpolynomial< integer > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 389 of file glue_lpolynomial_integer.cpp.

00389                                                                                           {
00390     return arg_1 != arg_2;
00391   }

static int mmx::GLUE_73 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 389 of file glue_lpolynomial_generic.cpp.

References N().

00389                                                        {
00390     return N (arg_1);
00391   }

static bool mmx::GLUE_73 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 388 of file glue_lmvpolynomial_integer.cpp.

00388                                                                                                 {
00389     return arg_1 != arg_2;
00390   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_73 ( const tuple< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 383 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00383                                              {
00384     return vector<lmv_monomial > (as_vector (arg_1));
00385   }

static vector<lpolynomial<integer> > mmx::GLUE_74 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 394 of file glue_lpolynomial_integer.cpp.

References derive().

00394                                                        {
00395     return derive (arg_1);
00396   }

static lpolynomial<generic> mmx::GLUE_74 ( const vector< lpolynomial< generic > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 394 of file glue_lpolynomial_generic.cpp.

00394                                                                          {
00395     return arg_1[arg_2];
00396   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_74 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1  )  [static]

Definition at line 393 of file glue_lmvpolynomial_integer.cpp.

00393                                                           {
00394     return invert (arg_1);
00395   }

static iterator<generic> mmx::GLUE_74 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 388 of file glue_lmonomial.cpp.

References iterate().

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00388                                               {
00389     return as<iterator<generic> > (iterate (arg_1));
00390   }

static int mmx::GLUE_75 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 399 of file glue_lpolynomial_integer.cpp.

00399                                                        {
00400     return pr_hash (arg_1);
00401   }

static alias<lpolynomial<generic> > mmx::GLUE_75 ( const alias< vector< lpolynomial< generic > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 399 of file glue_lpolynomial_generic.cpp.

00399                                                                                  {
00400     return alias_access<lpolynomial<generic> > (arg_1, arg_2);
00401   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_75 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 398 of file glue_lmvpolynomial_integer.cpp.

00398                                                                                                          {
00399     return arg_1 / arg_2;
00400   }

static int mmx::GLUE_75 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 393 of file glue_lmonomial.cpp.

References N().

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00393                                               {
00394     return N (arg_1);
00395   }

static bool mmx::GLUE_76 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 404 of file glue_lpolynomial_integer.cpp.

00404                                                                                                    {
00405     return pr_eq (arg_1, arg_2);
00406   }

static vector<lpolynomial<generic> > mmx::GLUE_76 ( const vector< lpolynomial< generic > > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 404 of file glue_lpolynomial_generic.cpp.

00404                                                                                            {
00405     return range (arg_1, arg_2, arg_3);
00406   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_76 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_2 
) [static]

Definition at line 403 of file glue_lmvpolynomial_integer.cpp.

00403                                                                                                 {
00404     return arg_1 / arg_2;
00405   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_76 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 398 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00398                                                                 {
00399     return arg_1[arg_2];
00400   }

static bool mmx::GLUE_77 ( const vector< lpolynomial< integer > > &  arg_1,
const vector< lpolynomial< integer > > &  arg_2 
) [static]

Definition at line 409 of file glue_lpolynomial_integer.cpp.

00409                                                                                                    {
00410     return pr_neq (arg_1, arg_2);
00411   }

static vector<lpolynomial<generic> > mmx::GLUE_77 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 409 of file glue_lpolynomial_generic.cpp.

00409                                                        {
00410     return reverse (arg_1);
00411   }

static vector<multivariate<sparse_polynomial< generic ,monomial<vector<integer> >,sparse_polynomial_naive> > > mmx::GLUE_77 ( const vector< multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > > &  arg_1,
const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_2 
) [static]

Definition at line 408 of file glue_lmvpolynomial_integer.cpp.

00408                                                                                                 {
00409     return arg_1 / arg_2;
00410   }

static alias< multivariate<monomial<vector<integer> > > > mmx::GLUE_77 ( const alias< vector< multivariate< monomial< vector< integer > > > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 403 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00403                                                                         {
00404     return alias_access<lmv_monomial > (arg_1, arg_2);
00405   }

static vector<lpolynomial<generic> > mmx::GLUE_78 ( const vector< lpolynomial< integer > > &  arg_1  )  [static]

Definition at line 414 of file glue_lpolynomial_integer.cpp.

00414                                                        {
00415     return as<vector<lpolynomial<generic> > > (arg_1);
00416   }

static vector<lpolynomial<generic> > mmx::GLUE_78 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 414 of file glue_lpolynomial_generic.cpp.

00414                                                                                                    {
00415     return append (arg_1, arg_2);
00416   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_78 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1  )  [static]

Definition at line 413 of file glue_lmvpolynomial_integer.cpp.

References supp().

00413                                                  {
00414     return supp (arg_1);
00415   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_78 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 408 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00408                                                                                   {
00409     return range (arg_1, arg_2, arg_3);
00410   }

static alias<vector<lpolynomial<generic> > > mmx::GLUE_79 ( const alias< vector< lpolynomial< generic > > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 419 of file glue_lpolynomial_generic.cpp.

00419                                                                                                            {
00420     return alias_write (arg_1, arg_2);
00421   }

static integer mmx::GLUE_79 ( const multivariate< sparse_polynomial< integer, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< integer > &  arg_3 
) [static]

Definition at line 418 of file glue_lmvpolynomial_integer.cpp.

References eval().

00418                                                                                                                     {
00419     return eval (arg_1, arg_2, arg_3);
00420   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_79 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 413 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_integer(), and glue_lpolynomial_generic().

00413                                               {
00414     return reverse (arg_1);
00415   }

static integer mmx::GLUE_8 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 64 of file glue_lpolynomial_integer.cpp.

References val().

00064                                              {
00065     return val (arg_1);
00066   }

static vector<generic> mmx::GLUE_8 ( const compound &  arg_1  )  [static]

Definition at line 64 of file glue_lpolynomial_generic.cpp.

00064                                  {
00065     return as_vector (arg_1);
00066   }

static integer mmx::GLUE_8 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 63 of file glue_lmvpolynomial_integer.cpp.

References deg().

00063                                                                              {
00064     return deg (arg_1, arg_2);
00065   }

static generic mmx::GLUE_8 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 63 of file glue_lmvpolynomial_generic.cpp.

00063                                                                   {
00064     return get_coefficient (arg_1, arg_2);
00065   }

static bool mmx::GLUE_8 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 58 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00058                                                     {
00059     return arg_1 <= arg_2;
00060   }

static void mmx::GLUE_80 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 424 of file glue_lpolynomial_generic.cpp.

00424                                                                                                    {
00425     inside_append (arg_1, arg_2);
00426   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_80 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const vector< multivariate< monomial< vector< integer > > > > &  arg_2 
) [static]

Definition at line 418 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00418                                                                                  {
00419     return append (arg_1, arg_2);
00420   }

static vector<lpolynomial<generic> > mmx::GLUE_81 ( const lpolynomial< generic > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 429 of file glue_lpolynomial_generic.cpp.

00429                                                                                           {
00430     return cons (arg_1, arg_2);
00431   }

static alias<vector< multivariate<monomial<vector<integer> > > > > mmx::GLUE_81 ( const alias< vector< multivariate< monomial< vector< integer > > > > > &  arg_1,
const vector< multivariate< monomial< vector< integer > > > > &  arg_2 
) [static]

Definition at line 423 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00423                                                                                          {
00424     return alias_write (arg_1, arg_2);
00425   }

static lpolynomial<generic> mmx::GLUE_82 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 434 of file glue_lpolynomial_generic.cpp.

00434                                                        {
00435     return car (arg_1);
00436   }

static void mmx::GLUE_82 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const vector< multivariate< monomial< vector< integer > > > > &  arg_2 
) [static]

Definition at line 428 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00428                                                                                  {
00429     inside_append (arg_1, arg_2);
00430   }

static vector<lpolynomial<generic> > mmx::GLUE_83 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 439 of file glue_lpolynomial_generic.cpp.

00439                                                        {
00440     return cdr (arg_1);
00441   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_83 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const vector< multivariate< monomial< vector< integer > > > > &  arg_2 
) [static]

Definition at line 433 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00433                                                                          {
00434     return cons (arg_1, arg_2);
00435   }

static bool mmx::GLUE_84 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 444 of file glue_lpolynomial_generic.cpp.

00444                                                        {
00445     return is_nil (arg_1);
00446   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_84 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 438 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00438                                               {
00439     return car (arg_1);
00440   }

static bool mmx::GLUE_85 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 449 of file glue_lpolynomial_generic.cpp.

00449                                                        {
00450     return is_atom (arg_1);
00451   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_85 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 443 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00443                                               {
00444     return cdr (arg_1);
00445   }

static vector<lpolynomial<generic> > mmx::GLUE_86 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 454 of file glue_lpolynomial_generic.cpp.

00454                                                                                           {
00455     return insert (arg_1, arg_2);
00456   }

static bool mmx::GLUE_86 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 448 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00448                                               {
00449     return is_nil (arg_1);
00450   }

static int mmx::GLUE_87 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 459 of file glue_lpolynomial_generic.cpp.

00459                                                                                           {
00460     return find (arg_1, arg_2);
00461   }

static bool mmx::GLUE_87 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 453 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00453                                               {
00454     return is_atom (arg_1);
00455   }

static bool mmx::GLUE_88 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 464 of file glue_lpolynomial_generic.cpp.

00464                                                                                           {
00465     return contains (arg_1, arg_2);
00466   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_88 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 458 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00458                                                                          {
00459     return insert (arg_1, arg_2);
00460   }

static vector<lpolynomial<generic> > mmx::GLUE_89 ( const vector< generic > &  arg_1  )  [static]

Definition at line 469 of file glue_lpolynomial_generic.cpp.

00469                                          {
00470     return as<vector<lpolynomial<generic> > > (arg_1);
00471   }

static int mmx::GLUE_89 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 463 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00463                                                                          {
00464     return find (arg_1, arg_2);
00465   }

static lpolynomial<integer> mmx::GLUE_9 ( const lpolynomial< integer > &  arg_1  )  [static]

Definition at line 69 of file glue_lpolynomial_integer.cpp.

00069                                              {
00070     return -arg_1;
00071   }

static vector<generic> mmx::GLUE_9 ( const compound &  arg_1  )  [static]

Definition at line 69 of file glue_lpolynomial_generic.cpp.

References compound_arguments.

00069                                  {
00070     return compound_arguments (arg_1);
00071   }

static integer mmx::GLUE_9 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const multivariate_coordinate<> &  arg_2 
) [static]

Definition at line 68 of file glue_lmvpolynomial_integer.cpp.

References val().

00068                                                                              {
00069     return val (arg_1, arg_2);
00070   }

static multivariate<monomial<vector<integer> > > mmx::GLUE_9 ( const multivariate< sparse_polynomial< generic, monomial< vector< integer > >, sparse_polynomial_naive > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 68 of file glue_lmvpolynomial_generic.cpp.

00068                                                                   {
00069     return get_monomial (arg_1, arg_2);
00070   }

static bool mmx::GLUE_9 ( const string &  arg_1,
const string &  arg_2 
) [static]

Definition at line 63 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00063                                                     {
00064     return arg_1 > arg_2;
00065   }

static vector<generic> mmx::GLUE_90 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 474 of file glue_lpolynomial_generic.cpp.

00474                                                        {
00475     return as<vector<generic> > (arg_1);
00476   }

static bool mmx::GLUE_90 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1,
const multivariate< monomial< vector< integer > > > &  arg_2 
) [static]

Definition at line 468 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00468                                                                          {
00469     return contains (arg_1, arg_2);
00470   }

static vector<lpolynomial<generic> > mmx::GLUE_91 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 479 of file glue_lpolynomial_generic.cpp.

00479                                                        {
00480     return -arg_1;
00481   }

static vector<generic> mmx::GLUE_91 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 473 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00473                                                 {
00474     return as<vector<generic> > (arg_1);
00475   }

static vector<lpolynomial<generic> > mmx::GLUE_92 ( const vector< lpolynomial< generic > > &  arg_1  )  [static]

Definition at line 484 of file glue_lpolynomial_generic.cpp.

References square().

00484                                                        {
00485     return square (arg_1);
00486   }

static vector<generic> mmx::GLUE_92 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 478 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00478                                               {
00479     return as<vector<generic> > (arg_1);
00480   }

static vector<lpolynomial<generic> > mmx::GLUE_93 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 489 of file glue_lpolynomial_generic.cpp.

00489                                                                                                    {
00490     return arg_1 + arg_2;
00491   }

static vector< multivariate_coordinate<> > mmx::GLUE_93 ( const multivariate_coordinates<> &  arg_1  )  [static]

Definition at line 483 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00483                                          {
00484     return as_vector (arg_1);
00485   }

static vector<lpolynomial<generic> > mmx::GLUE_94 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 494 of file glue_lpolynomial_generic.cpp.

00494                                                                                                    {
00495     return arg_1 - arg_2;
00496   }

static vector< multivariate<monomial<vector<integer> > > > mmx::GLUE_94 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 488 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00488                                               {
00489     return stairs (arg_1);
00490   }

static vector<lpolynomial<generic> > mmx::GLUE_95 ( const vector< lpolynomial< generic > > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 499 of file glue_lpolynomial_generic.cpp.

00499                                                                                                    {
00500     return arg_1 * arg_2;
00501   }

static bool mmx::GLUE_95 ( const multivariate< monomial< vector< integer > > > &  arg_1,
const vector< multivariate< monomial< vector< integer > > > > &  arg_2 
) [static]

Definition at line 493 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00493                                                                          {
00494     return arg_1 <<= arg_2;
00495   }

static vector<lpolynomial<generic> > mmx::GLUE_96 ( const lpolynomial< generic > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 504 of file glue_lpolynomial_generic.cpp.

00504                                                                                           {
00505     return arg_1 + arg_2;
00506   }

static int mmx::GLUE_96 ( const vector< multivariate_coordinate<> > &  arg_1  )  [static]

Definition at line 498 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00498                                                 {
00499     return pr_hash (arg_1);
00500   }

static vector<lpolynomial<generic> > mmx::GLUE_97 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 509 of file glue_lpolynomial_generic.cpp.

00509                                                                                           {
00510     return arg_1 + arg_2;
00511   }

static bool mmx::GLUE_97 ( const vector< multivariate_coordinate<> > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2 
) [static]

Definition at line 503 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00503                                                                                      {
00504     return pr_eq (arg_1, arg_2);
00505   }

static vector<lpolynomial<generic> > mmx::GLUE_98 ( const lpolynomial< generic > &  arg_1,
const vector< lpolynomial< generic > > &  arg_2 
) [static]

Definition at line 514 of file glue_lpolynomial_generic.cpp.

00514                                                                                           {
00515     return arg_1 - arg_2;
00516   }

static bool mmx::GLUE_98 ( const vector< multivariate_coordinate<> > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2 
) [static]

Definition at line 508 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00508                                                                                      {
00509     return pr_neq (arg_1, arg_2);
00510   }

static vector<lpolynomial<generic> > mmx::GLUE_99 ( const vector< lpolynomial< generic > > &  arg_1,
const lpolynomial< generic > &  arg_2 
) [static]

Definition at line 519 of file glue_lpolynomial_generic.cpp.

00519                                                                                           {
00520     return arg_1 - arg_2;
00521   }

static int mmx::GLUE_99 ( const vector< multivariate< monomial< vector< integer > > > > &  arg_1  )  [static]

Definition at line 513 of file glue_lmonomial.cpp.

Referenced by glue_lmonomial(), and glue_lpolynomial_generic().

00513                                               {
00514     return pr_hash (arg_1);
00515   }

void glue_integer_roots (  ) 

Referenced by glue_lacunaryx().

void mmx::glue_lacunaryx (  ) 

Definition at line 15 of file glue_lacunaryx.cpp.

References glue_integer_roots(), glue_linear_factors(), glue_lmonomial(), glue_lmvpolynomial_generic(), glue_lmvpolynomial_integer(), glue_lpolynomial_generic(), and glue_lpolynomial_integer().

00015                     {
00016     static bool done = false;
00017     if (done) return;
00018     done = true;
00019     register_glue (string ("glue_integer_roots"), (& (glue_integer_roots)));
00020     register_glue (string ("glue_linear_factors"), (& (glue_linear_factors)));
00021     register_glue (string ("glue_lmonomial"), (& (glue_lmonomial)));
00022     register_glue (string ("glue_lmvpolynomial_generic"), (& (glue_lmvpolynomial_generic)));
00023     register_glue (string ("glue_lmvpolynomial_integer"), (& (glue_lmvpolynomial_integer)));
00024     register_glue (string ("glue_lpolynomial_generic"), (& (glue_lpolynomial_generic)));
00025     register_glue (string ("glue_lpolynomial_integer"), (& (glue_lpolynomial_integer)));
00026     register_glue (string ("glue_lacunaryx"), (& (glue_lacunaryx)));
00027     dl_link ("factorix");
00028     glue_integer_roots ();
00029     glue_linear_factors ();
00030     glue_lmonomial ();
00031     glue_lmvpolynomial_generic ();
00032     glue_lmvpolynomial_integer ();
00033     glue_lpolynomial_generic ();
00034     glue_lpolynomial_integer ();
00035   }

void glue_linear_factors (  ) 

Definition at line 72 of file glue_linear_factors.cpp.

References GLUE_1(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), and GLUE_6().

Referenced by glue_lacunaryx().

00072                          {
00073     static bool done = false;
00074     if (done) return;
00075     done = true;
00076     call_glue (string ("glue_mvpolynomial_integer"));
00077     call_glue (string ("glue_lmvpolynomial_integer"));
00078     call_glue (string ("glue_lpolynomial_integer"));
00079     call_glue (string ("glue_vector_generic"));
00080     define ("linear_factors", GLUE_1);
00081     define ("linear_factors", GLUE_2);
00082     define ("linear_factors", GLUE_3);
00083     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00084     define ("supp", GLUE_5);
00085     define ("supp", GLUE_6);
00086   }

void glue_lmonomial (  ) 

Definition at line 528 of file glue_lmonomial.cpp.

References GLUE_1(), GLUE_10(), GLUE_100(), GLUE_101(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_57(), GLUE_58(), GLUE_59(), GLUE_6(), GLUE_60(), GLUE_61(), GLUE_62(), GLUE_63(), GLUE_64(), GLUE_65(), GLUE_66(), GLUE_67(), GLUE_68(), GLUE_69(), GLUE_7(), GLUE_70(), GLUE_71(), GLUE_72(), GLUE_73(), GLUE_74(), GLUE_75(), GLUE_76(), GLUE_77(), GLUE_78(), GLUE_79(), GLUE_8(), GLUE_80(), GLUE_81(), GLUE_82(), GLUE_83(), GLUE_84(), GLUE_85(), GLUE_86(), GLUE_87(), GLUE_88(), GLUE_89(), GLUE_9(), GLUE_90(), GLUE_91(), GLUE_92(), GLUE_93(), GLUE_94(), GLUE_95(), GLUE_96(), GLUE_97(), GLUE_98(), and GLUE_99().

Referenced by glue_lacunaryx().

00528                     {
00529     static bool done = false;
00530     if (done) return;
00531     done = true;
00532     call_glue (string ("glue_basix_vector_generic"));
00533     call_glue (string ("glue_coordinates"));
00534     define ("string?", GLUE_1);
00535     define ("#", GLUE_2);
00536     define (".[]", GLUE_3);
00537     define ("*", GLUE_4);
00538     define ("><", GLUE_5);
00539     define ("<<", GLUE_6);
00540     define ("<", GLUE_7);
00541     define ("<=", GLUE_8);
00542     define (">", GLUE_9);
00543     define (">=", GLUE_10);
00544     define ("starts?", GLUE_11);
00545     define ("ends?", GLUE_12);
00546     define ("replace", GLUE_13);
00547     define ("search_forwards", GLUE_14);
00548     define ("search_backwards", GLUE_15);
00549     define ("upcase", GLUE_16);
00550     define ("locase", GLUE_17);
00551     define ("upcase_first", GLUE_18);
00552     define ("locase_first", GLUE_19);
00553     define ("quote", GLUE_20);
00554     define ("unquote", GLUE_21);
00555     define ("ascii", GLUE_22);
00556     define ("ascii_code", GLUE_23);
00557     define ("integer?", GLUE_24);
00558     define ("floating?", GLUE_25);
00559     define ("alpha?", GLUE_26);
00560     define ("numeric?", GLUE_27);
00561     define ("alpha_numeric?", GLUE_28);
00562     define ("mmx_identifier?", GLUE_29);
00563     define ("literal?", GLUE_30);
00564     define (".()", GLUE_31);
00565     define (".[]", GLUE_32);
00566     define ("as_literal", GLUE_33);
00567     define ("as_string", GLUE_34);
00568     define_constructor<int > (GLUE_35);
00569     define_type<lmv_monomial > (lit ("LMonomial"));
00570     define ("lmonomial", GLUE_36);
00571     define ("lmonomial", GLUE_37);
00572     define_converter ("upgrade", GLUE_38, PENALTY_INCLUSION);
00573     define (".coordinates", GLUE_39);
00574     define ("dim", GLUE_40);
00575     define ("*", GLUE_41);
00576     define ("/", GLUE_42);
00577     define ("divides?", GLUE_43);
00578     define ("gcd", GLUE_44);
00579     define ("lcm", GLUE_45);
00580     define ("<<", GLUE_46);
00581     define ("<<=", GLUE_47);
00582     define (">>", GLUE_48);
00583     define (">>=", GLUE_49);
00584     define ("hash%", GLUE_50);
00585     define ("=%", GLUE_51);
00586     define ("!=%", GLUE_52);
00587     define_type<vector<mmx_coordinate> > (gen (lit ("Vector"), lit ("Coordinate")));
00588     define_type<vector<lmv_monomial> > (gen (lit ("Vector"), lit ("LMonomial")));
00589     define ("vector", GLUE_53);
00590     define ("[]", GLUE_54);
00591     define_converter (":>", GLUE_55, PENALTY_CAST);
00592     define ("#", GLUE_56);
00593     define (".[]", GLUE_57);
00594     define (".[]", GLUE_58);
00595     define (".[]", GLUE_59);
00596     define ("reverse", GLUE_60);
00597     define ("><", GLUE_61);
00598     define ("<<", GLUE_62);
00599     define ("append", GLUE_63);
00600     define ("cons", GLUE_64);
00601     define ("car", GLUE_65);
00602     define ("cdr", GLUE_66);
00603     define ("nil?", GLUE_67);
00604     define ("atom?", GLUE_68);
00605     define ("insert", GLUE_69);
00606     define ("find", GLUE_70);
00607     define ("contains?", GLUE_71);
00608     define ("vector", GLUE_72);
00609     define ("[]", GLUE_73);
00610     define_converter (":>", GLUE_74, PENALTY_CAST);
00611     define ("#", GLUE_75);
00612     define (".[]", GLUE_76);
00613     define (".[]", GLUE_77);
00614     define (".[]", GLUE_78);
00615     define ("reverse", GLUE_79);
00616     define ("><", GLUE_80);
00617     define ("<<", GLUE_81);
00618     define ("append", GLUE_82);
00619     define ("cons", GLUE_83);
00620     define ("car", GLUE_84);
00621     define ("cdr", GLUE_85);
00622     define ("nil?", GLUE_86);
00623     define ("atom?", GLUE_87);
00624     define ("insert", GLUE_88);
00625     define ("find", GLUE_89);
00626     define ("contains?", GLUE_90);
00627     define_converter (":>", GLUE_91, PENALTY_PROMOTE_GENERIC);
00628     define_converter (":>", GLUE_92, PENALTY_PROMOTE_GENERIC);
00629     define ("as_vector", GLUE_93);
00630     define ("stairs", GLUE_94);
00631     define ("<<=", GLUE_95);
00632     define ("hash%", GLUE_96);
00633     define ("=%", GLUE_97);
00634     define ("!=%", GLUE_98);
00635     define ("hash%", GLUE_99);
00636     define ("=%", GLUE_100);
00637     define ("!=%", GLUE_101);
00638   }

void glue_lmvpolynomial_generic (  ) 

Definition at line 308 of file glue_lmvpolynomial_generic.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_lacunaryx().

00308                                 {
00309     static bool done = false;
00310     if (done) return;
00311     done = true;
00312     call_glue (string ("glue_lmonomial"));
00313     call_glue (string ("glue_basix_vector_generic"));
00314     define_type<lmv_polynomial(generic) > (gen (lit ("LMVPolynomial"), lit ("Generic")));
00315     define ("lmvpolynomial", GLUE_1);
00316     define ("lmvpolynomial", GLUE_2);
00317     define (".coordinates", GLUE_3);
00318     define ("dim", GLUE_4);
00319     define ("lmvpolynomial", GLUE_5);
00320     define_converter ("upgrade", GLUE_6, PENALTY_PROMOTE_GENERIC);
00321     define ("#", GLUE_7);
00322     define ("coefficient", GLUE_8);
00323     define ("monomial", GLUE_9);
00324     define (".[]", GLUE_10);
00325     define (".[]", GLUE_11);
00326     define ("coefficient", GLUE_12);
00327     define ("-", GLUE_13);
00328     define ("+", GLUE_14);
00329     define ("-", GLUE_15);
00330     define ("*", GLUE_16);
00331     define ("square", GLUE_17);
00332     define ("*", GLUE_18);
00333     define ("*", GLUE_19);
00334     define ("=", GLUE_20);
00335     define ("!=", GLUE_21);
00336     define ("derive", GLUE_22);
00337     define ("xderive", GLUE_23);
00338     define ("/", GLUE_24);
00339     define ("/", GLUE_25);
00340     define ("hash%", GLUE_26);
00341     define ("=%", GLUE_27);
00342     define ("!=%", GLUE_28);
00343     define_type<vector<lmv_polynomial(generic) > > (gen (lit ("Vector"), gen (lit ("LMVPolynomial"), lit ("Generic"))));
00344     define ("vector", GLUE_29);
00345     define ("[]", GLUE_30);
00346     define_converter (":>", GLUE_31, PENALTY_PROMOTE_GENERIC);
00347     define ("#", GLUE_32);
00348     define (".[]", GLUE_33);
00349     define (".[]", GLUE_34);
00350     define (".[]", GLUE_35);
00351     define ("reverse", GLUE_36);
00352     define ("><", GLUE_37);
00353     define ("<<", GLUE_38);
00354     define ("append", GLUE_39);
00355     define ("cons", GLUE_40);
00356     define ("car", GLUE_41);
00357     define ("cdr", GLUE_42);
00358     define ("nil?", GLUE_43);
00359     define ("atom?", GLUE_44);
00360     define ("insert", GLUE_45);
00361     define ("find", GLUE_46);
00362     define ("contains?", GLUE_47);
00363     define_converter (":>", GLUE_48, PENALTY_INCLUSION);
00364     define_converter (":>", GLUE_49, PENALTY_PROMOTE_GENERIC);
00365     define_converter (":>", GLUE_50, PENALTY_PROMOTE_GENERIC);
00366     define_converter (":>", GLUE_51, PENALTY_PROMOTE_GENERIC);
00367     define ("supp", GLUE_52);
00368     define ("eval", GLUE_53);
00369     define ("hash%", GLUE_54);
00370     define ("=%", GLUE_55);
00371     define ("!=%", GLUE_56);
00372   }

void glue_lmvpolynomial_integer (  ) 

Definition at line 423 of file glue_lmvpolynomial_integer.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_57(), GLUE_58(), GLUE_59(), GLUE_6(), GLUE_60(), GLUE_61(), GLUE_62(), GLUE_63(), GLUE_64(), GLUE_65(), GLUE_66(), GLUE_67(), GLUE_68(), GLUE_69(), GLUE_7(), GLUE_70(), GLUE_71(), GLUE_72(), GLUE_73(), GLUE_74(), GLUE_75(), GLUE_76(), GLUE_77(), GLUE_78(), GLUE_79(), GLUE_8(), and GLUE_9().

Referenced by glue_lacunaryx().

00423                                 {
00424     static bool done = false;
00425     if (done) return;
00426     done = true;
00427     call_glue (string ("glue_vector_integer"));
00428     call_glue (string ("glue_lmvpolynomial_generic"));
00429     define ("deg", GLUE_1);
00430     define ("val", GLUE_2);
00431     define ("deg", GLUE_3);
00432     define ("val", GLUE_4);
00433     define ("^", GLUE_5);
00434     define_type<lmv_polynomial(integer) > (gen (lit ("LMVPolynomial"), lit ("Integer")));
00435     define ("deg", GLUE_6);
00436     define ("val", GLUE_7);
00437     define ("deg", GLUE_8);
00438     define ("val", GLUE_9);
00439     define ("^", GLUE_10);
00440     define ("lmvpolynomial", GLUE_11);
00441     define ("lmvpolynomial", GLUE_12);
00442     define ("*", GLUE_13);
00443     define (".coordinates", GLUE_14);
00444     define ("dim", GLUE_15);
00445     define ("lmvpolynomial", GLUE_16);
00446     define_converter ("upgrade", GLUE_17, PENALTY_INCLUSION);
00447     define ("#", GLUE_18);
00448     define ("coefficient", GLUE_19);
00449     define ("monomial", GLUE_20);
00450     define (".[]", GLUE_21);
00451     define (".[]", GLUE_22);
00452     define ("deg", GLUE_23);
00453     define ("val", GLUE_24);
00454     define ("deg", GLUE_25);
00455     define ("val", GLUE_26);
00456     define ("coefficient", GLUE_27);
00457     define ("-", GLUE_28);
00458     define ("+", GLUE_29);
00459     define ("-", GLUE_30);
00460     define ("*", GLUE_31);
00461     define ("square", GLUE_32);
00462     define ("^", GLUE_33);
00463     define ("+", GLUE_34);
00464     define ("-", GLUE_35);
00465     define ("*", GLUE_36);
00466     define ("+", GLUE_37);
00467     define ("-", GLUE_38);
00468     define ("*", GLUE_39);
00469     define ("*", GLUE_40);
00470     define ("*", GLUE_41);
00471     define ("=", GLUE_42);
00472     define ("!=", GLUE_43);
00473     define ("=", GLUE_44);
00474     define ("!=", GLUE_45);
00475     define ("=", GLUE_46);
00476     define ("!=", GLUE_47);
00477     define ("derive", GLUE_48);
00478     define ("xderive", GLUE_49);
00479     define_converter (":>", GLUE_50, PENALTY_PROMOTE_GENERIC);
00480     define ("hash%", GLUE_51);
00481     define ("=%", GLUE_52);
00482     define ("!=%", GLUE_53);
00483     define ("-", GLUE_54);
00484     define ("square", GLUE_55);
00485     define ("+", GLUE_56);
00486     define ("-", GLUE_57);
00487     define ("*", GLUE_58);
00488     define ("+", GLUE_59);
00489     define ("+", GLUE_60);
00490     define ("-", GLUE_61);
00491     define ("-", GLUE_62);
00492     define ("*", GLUE_63);
00493     define ("*", GLUE_64);
00494     define ("dot", GLUE_65);
00495     define ("big_mul", GLUE_66);
00496     define ("big_add", GLUE_67);
00497     define ("=", GLUE_68);
00498     define ("!=", GLUE_69);
00499     define ("=", GLUE_70);
00500     define ("!=", GLUE_71);
00501     define ("=", GLUE_72);
00502     define ("!=", GLUE_73);
00503     define ("invert", GLUE_74);
00504     define ("/", GLUE_75);
00505     define ("/", GLUE_76);
00506     define ("/", GLUE_77);
00507     define ("supp", GLUE_78);
00508     define ("eval", GLUE_79);
00509   }

void glue_lpolynomial_generic (  ) 

Definition at line 619 of file glue_lpolynomial_generic.cpp.

References GLUE_1(), GLUE_10(), GLUE_100(), GLUE_101(), GLUE_102(), GLUE_103(), GLUE_104(), GLUE_105(), GLUE_106(), GLUE_107(), GLUE_108(), GLUE_109(), GLUE_11(), GLUE_110(), GLUE_111(), GLUE_112(), GLUE_113(), GLUE_114(), GLUE_115(), GLUE_116(), GLUE_117(), GLUE_118(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_57(), GLUE_58(), GLUE_59(), GLUE_6(), GLUE_60(), GLUE_61(), GLUE_62(), GLUE_63(), GLUE_64(), GLUE_65(), GLUE_66(), GLUE_67(), GLUE_68(), GLUE_69(), GLUE_7(), GLUE_70(), GLUE_71(), GLUE_72(), GLUE_73(), GLUE_74(), GLUE_75(), GLUE_76(), GLUE_77(), GLUE_78(), GLUE_79(), GLUE_8(), GLUE_80(), GLUE_81(), GLUE_82(), GLUE_83(), GLUE_84(), GLUE_85(), GLUE_86(), GLUE_87(), GLUE_88(), GLUE_89(), GLUE_9(), GLUE_90(), GLUE_91(), GLUE_92(), GLUE_93(), GLUE_94(), GLUE_95(), GLUE_96(), GLUE_97(), GLUE_98(), and GLUE_99().

Referenced by glue_lacunaryx().

00619                               {
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   }

void glue_lpolynomial_integer (  ) 

Definition at line 419 of file glue_lpolynomial_integer.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_57(), GLUE_58(), GLUE_59(), GLUE_6(), GLUE_60(), GLUE_61(), GLUE_62(), GLUE_63(), GLUE_64(), GLUE_65(), GLUE_66(), GLUE_67(), GLUE_68(), GLUE_69(), GLUE_7(), GLUE_70(), GLUE_71(), GLUE_72(), GLUE_73(), GLUE_74(), GLUE_75(), GLUE_76(), GLUE_77(), GLUE_78(), GLUE_8(), and GLUE_9().

Referenced by glue_lacunaryx().

00419                               {
00420     static bool done = false;
00421     if (done) return;
00422     done = true;
00423     call_glue (string ("glue_integer"));
00424     call_glue (string ("glue_basix_vector_generic"));
00425     call_glue (string ("glue_lpolynomial_generic"));
00426     define_type<lpolynomial<integer> > (gen (lit ("LPolynomial"), lit ("Integer")));
00427     define ("lpolynomial", GLUE_1);
00428     define ("lpolynomial", GLUE_2);
00429     define ("set_variable_name", GLUE_3);
00430     define_converter ("upgrade", GLUE_4, PENALTY_INCLUSION);
00431     define ("#", GLUE_5);
00432     define (".[]", GLUE_6);
00433     define ("deg", GLUE_7);
00434     define ("val", GLUE_8);
00435     define ("-", GLUE_9);
00436     define ("+", GLUE_10);
00437     define ("-", GLUE_11);
00438     define ("*", GLUE_12);
00439     define ("square", GLUE_13);
00440     define ("^", GLUE_14);
00441     define ("+", GLUE_15);
00442     define ("-", GLUE_16);
00443     define ("*", GLUE_17);
00444     define ("+", GLUE_18);
00445     define ("-", GLUE_19);
00446     define ("*", GLUE_20);
00447     define ("=", GLUE_21);
00448     define ("!=", GLUE_22);
00449     define ("=", GLUE_23);
00450     define ("!=", GLUE_24);
00451     define ("=", GLUE_25);
00452     define ("!=", GLUE_26);
00453     define ("derive", GLUE_27);
00454     define ("xderive", GLUE_28);
00455     define ("eval", GLUE_29);
00456     define_converter (":>", GLUE_30, PENALTY_PROMOTE_GENERIC);
00457     define ("hash%", GLUE_31);
00458     define ("=%", GLUE_32);
00459     define ("!=%", GLUE_33);
00460     define_type<vector<lpolynomial<integer> > > (gen (lit ("Vector"), gen (lit ("LPolynomial"), lit ("Integer"))));
00461     define ("vector", GLUE_34);
00462     define ("[]", GLUE_35);
00463     define_converter (":>", GLUE_36, PENALTY_CAST);
00464     define ("#", GLUE_37);
00465     define (".[]", GLUE_38);
00466     define (".[]", GLUE_39);
00467     define (".[]", GLUE_40);
00468     define ("reverse", GLUE_41);
00469     define ("><", GLUE_42);
00470     define ("<<", GLUE_43);
00471     define ("append", GLUE_44);
00472     define ("cons", GLUE_45);
00473     define ("car", GLUE_46);
00474     define ("cdr", GLUE_47);
00475     define ("nil?", GLUE_48);
00476     define ("atom?", GLUE_49);
00477     define ("insert", GLUE_50);
00478     define ("find", GLUE_51);
00479     define ("contains?", GLUE_52);
00480     define_converter (":>", GLUE_53, PENALTY_PROMOTE_GENERIC);
00481     define ("-", GLUE_54);
00482     define ("square", GLUE_55);
00483     define ("+", GLUE_56);
00484     define ("-", GLUE_57);
00485     define ("*", GLUE_58);
00486     define ("+", GLUE_59);
00487     define ("+", GLUE_60);
00488     define ("-", GLUE_61);
00489     define ("-", GLUE_62);
00490     define ("*", GLUE_63);
00491     define ("*", GLUE_64);
00492     define ("dot", GLUE_65);
00493     define ("big_mul", GLUE_66);
00494     define ("big_add", GLUE_67);
00495     define ("=", GLUE_68);
00496     define ("!=", GLUE_69);
00497     define ("=", GLUE_70);
00498     define ("!=", GLUE_71);
00499     define ("=", GLUE_72);
00500     define ("!=", GLUE_73);
00501     define ("derive", GLUE_74);
00502     define ("hash%", GLUE_75);
00503     define ("=%", GLUE_76);
00504     define ("!=%", GLUE_77);
00505     define_converter (":>", GLUE_78, PENALTY_PROMOTE_GENERIC);
00506   }

mmx::Ground_type ( C   )  const [inline]
bool mmx::hard_eq ( const lpolynomial< C, E, V > &  c1,
const lpolynomial< C, E, V > &  c2 
) [inline]

Definition at line 109 of file lpolynomial.hpp.

00109                                                                  {
00110   return hard_eq (*c1, *c2); }

nat mmx::hard_hash ( const lpolynomial< C, E, V > &  c  )  [inline]

Definition at line 100 of file lpolynomial.hpp.

00100 { return hard_hash (*c); }

bool mmx::hard_neq ( const lpolynomial< C, E, V > &  c1,
const lpolynomial< C, E, V > &  c2 
) [inline]

Definition at line 111 of file lpolynomial.hpp.

00111                                                                   {
00112  return hard_neq (*c1, *c2); }

nat mmx::hash ( const lpolynomial< C, E, V > &  c  )  [inline]

Definition at line 98 of file lpolynomial.hpp.

00098 { return hash (*c); }

vector<generic> mmx::integer_roots ( const lpolynomial< C, E, W > &  lp  )  [inline]

Definition at line 180 of file integer_roots.hpp.

References integer_roots(), Monomial, N(), Sparse_polynomial, and V.

00180                                                               {
00181   typedef typename Sparse_polynomial_variant(C) V;
00182   // set as Sparse_polynomial
00183   vector<E> w (entries (*lp));
00184   vector<C> c;
00185   vector<Monomial> m;
00186   for (nat i= 0; i < N(w); i++)
00187     if (lp[w[i]] != 0) {
00188       c << lp[w[i]];
00189       m << Monomial (vec(w[i]));
00190     }
00191   Sparse_polynomial p (c, m, 1);
00192 
00193   // Roots
00194   vector<Root> roots= integer_roots (p);
00195   vector<generic> ret;
00196   for (nat i=0; i<N(roots); i++)
00197     ret << as<generic> (vec (car(roots[i]), as<integer> (cdr(roots[i]))));
00198   return ret;
00199 }

vector<generic> mmx::integer_roots ( const multivariate< sparse_polynomial< C, monomial< vector< E > >, V > > &  p  )  [inline]

Definition at line 170 of file integer_roots.hpp.

References integer_roots(), and N().

00170                                                                           {
00171   vector<generic> ret;
00172   vector<Root> roots= integer_roots (p.rep);
00173   for (nat i=0; i<N(roots); i++) 
00174     ret << as<generic> (vec (car(roots[i]), as<integer> (cdr(roots[i]))));
00175   return ret; //integer_roots (p.rep);
00176 }

vector< pair<C,E> > mmx::integer_roots ( const sparse_polynomial< C, monomial< vector< E > >, V > &  q  )  [inline]

Definition at line 162 of file integer_roots.hpp.

References large_integer_roots(), and special_integer_roots().

Referenced by integer_roots().

00162                                                          {
00163   vector<Root> r= large_integer_roots (q);
00164   r << special_integer_roots (q);
00165   return r;
00166 }

iterator<pair<E,C> > mmx::iterate ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 196 of file lpolynomial.hpp.

Referenced by coefficients(), deg(), derive(), eval(), GLUE_31(), GLUE_36(), GLUE_55(), GLUE_72(), GLUE_74(), operator*(), square(), supp(), val(), and xderive().

00196                                {
00197   return iterate (*P); }

vector< pair<C,E> > mmx::large_integer_roots ( const sparse_polynomial< C, monomial< vector< E > >, V > &  q  )  [inline]

Definition at line 88 of file integer_roots.hpp.

References deg(), Dense_polynomial, N(), partition(), and Sparse_polynomial.

Referenced by integer_roots().

00088                                                  {
00089     vector<Sparse_polynomial> polys= partition(q);
00090     vector<Dense_polynomial> vp (as<Dense_polynomial> (0),N(polys));
00091 
00092     for ( nat i=0; i < N( polys ); i++ ) {
00093       Sparse_polynomial p= polys[i];
00094       vector<C> c(0, as<nat> (deg(p)+1));
00095       for ( nat j=0; j < N( p ); j++) 
00096         c[as<nat> (deg(get_monomial(p,j)))]= get_coefficient(p,j);
00097       vp[i]= Dense_polynomial (c);
00098     }
00099 
00100     Dense_polynomial g= primitive_part ( big<gcd_op> ( vp ));
00101     polynomial<rational> g_rat= as< polynomial<rational> > (g);
00102     vector <irreducible_factor <polynomial <rational> > > fact=
00103       bounded_irreducible_factorization (g_rat, 2);
00104       //irreducible_factorization (g_rat);
00105 
00106     vector<Root> r;
00107 
00108     for (nat i=0; i < N(fact); i++)
00109     {
00110       polynomial<rational> f=factor(fact[i]);
00111       if ( deg(f) == 1 && is_integer(f[0]/f[1]) && abs (f[0]/f[1]) != 1 ) 
00112         r << Root (as<C> (numerator (-f[0]/f[1])), fact[i].m);
00113     }
00114 
00115     return r;
00116 }

vector<generic> mmx::linear_factors ( const lpolynomial< C, E, W > &  lp  )  [inline]

Definition at line 56 of file linear_factors.hpp.

References deg(), linear_factors_univariate(), Monomial, N(), Sparse_factors, Sparse_polynomial, and V.

00056                                                                {
00057   typedef typename Sparse_polynomial_variant(C) V;
00058   // set as Sparse_polynomial
00059   vector<E> w (entries (*lp));
00060   vector<C> c;
00061   vector<Monomial> m;
00062   for (nat i= 0; i < N(w); i++)
00063     if (lp[w[i]] != 0) {
00064       c << lp[w[i]];
00065       m << Monomial (vec(w[i]));
00066     }
00067   Sparse_polynomial p (c, m, 1);
00068 
00069   // Linear factors
00070   Sparse_factors factors= linear_factors_univariate (p);
00071   vector<generic> ret;
00072   for (nat i=0; i<N(factors); i++) {
00073     table<C,E> tfactor;
00074     for (nat j=0; j<N(factors[i].f); j++)
00075       tfactor[ deg( get_monomial(factors[i].f,j) ) ]= get_coefficient(factors[i].f,j);
00076     lpolynomial<C,E,W> f (tfactor);
00077     ret << as<generic> (vec (as<generic> (f), as<generic> (as<integer> (factors[i].m))));
00078   }
00079   return ret;
00080 }

vector<generic> mmx::linear_factors ( const multivariate< sparse_polynomial< C, monomial< vector< E > >, V > > &  p  )  [inline]

Definition at line 44 of file linear_factors.hpp.

References linear_factors(), N(), and Sparse_factors.

00044                                                           {
00045   vector<generic> ret;
00046   Sparse_factors factors= linear_factors (p.rep);
00047   for (nat i=0; i<N(factors); i++) {
00048     multivariate<Sparse_polynomial> pol (p.coords, factors[i].f);
00049     ret << as<generic> (vec (as<generic> (pol), as<generic> (as<integer> (factors[i].m)) ) );
00050   }
00051   return ret;
00052 }

vector< irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > mmx::linear_factors ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 34 of file linear_factors.hpp.

References linear_factors_bivariate(), and linear_factors_univariate().

Referenced by GLUE_1(), GLUE_2(), GLUE_3(), and linear_factors().

00034                                             {
00035   nat d= dim(p);
00036   if (d == 1) return linear_factors_univariate (p);
00037   if (d == 2) return linear_factors_bivariate (p);
00038   else return linear_factors_bivariate (p); // TO BE MODIFIED!
00039 }

vector< irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > mmx::linear_factors_bivariate ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 319 of file linear_factors_bivariate.hpp.

References E, mmx::lacunaryx::homogenize(), linear_factors_univariate(), multiplicity(), N(), Sparse_factor, Sparse_factors, truly_bivariate_linear_factors(), val(), and mmx::lacunaryx::w_homogeneous_parts().

Referenced by linear_factors().

00319                                                       {
00320   Sparse_factors factors;
00321   vector<Sparse_polynomial> hom_comp;
00322   Sparse_factors lin_fact;
00323   
00324   // Univariate factors, first variable
00325   hom_comp= w_homogeneous_parts(p, vec((E)0, (E)1));
00326   hom_comp[0]= project (hom_comp[0],vec(0));
00327   nat Nmin= N(hom_comp[0]); 
00328   nat index=0;
00329   for (nat i=1; i<N(hom_comp); i++) {
00330     hom_comp[i]= project (hom_comp[i],vec(0));
00331     if (N(hom_comp[i]) < Nmin) { 
00332       Nmin= N(hom_comp[i]); 
00333       index=i;
00334     }
00335   }
00336   lin_fact= linear_factors_univariate (hom_comp[index]);
00337   for (nat i=0; i<N(hom_comp); i++) {
00338     if (i != index) {
00339       Sparse_factors tmp_fact;
00340       for (nat j=0; j<N(lin_fact); j++) {
00341         nat m= multiplicity (lin_fact[j].f, hom_comp[i]);
00342         if (m > 0) 
00343           tmp_fact << Sparse_factor (lin_fact[j].f, min(lin_fact[j].m,m));
00344       }
00345       lin_fact= tmp_fact;
00346     }
00347   }
00348   for (nat i=0; i<N(lin_fact); i++)
00349     factors << Sparse_factor (inject (lin_fact[i].f, vec(0), 2), lin_fact[i].m);
00350 
00351   // Univariate factors, second variable
00352   hom_comp= w_homogeneous_parts(p,vec((E)1, (E)0));
00353   hom_comp[0]= project (hom_comp[0],vec(1));
00354   Nmin= N(hom_comp[0]); 
00355   index=0;
00356   for (nat i=1; i<N(hom_comp); i++) {
00357     hom_comp[i]= project (hom_comp[i],vec(1));
00358     if (N(hom_comp[i]) < Nmin) { 
00359       Nmin= N(hom_comp[i]); 
00360       index=i;
00361     }
00362   }
00363   lin_fact= linear_factors_univariate (hom_comp[index]);
00364   for (nat i=0; i<N(hom_comp); i++) {
00365     if (i != index) {
00366       Sparse_factors tmp_fact;
00367       for (nat j=0; j<N(lin_fact); j++) {
00368         nat m= multiplicity (lin_fact[j].f,hom_comp[i]);
00369         if (m > 0) 
00370           tmp_fact << Sparse_factor (lin_fact[j].f, min(lin_fact[j].m,m));
00371       }
00372       lin_fact= tmp_fact;
00373     }
00374   }
00375   for (nat i=0; i<N(lin_fact); i++) 
00376     factors << Sparse_factor (inject (lin_fact[i].f, vec(1), 2), lin_fact[i].m);
00377 
00378   // Bivariate factors, binomials
00379   hom_comp= w_homogeneous_parts(p,vec((E)1, (E)1));
00380   hom_comp[0]= project (hom_comp[0],vec(0));
00381   Nmin= N(hom_comp[0]); 
00382   index=0;
00383   for (nat i=1; i<N(hom_comp); i++) {
00384     hom_comp[i]= project (hom_comp[i],vec(0));
00385     if ( N(hom_comp[i]) < Nmin) { 
00386       Nmin= N(hom_comp[i]); 
00387       index=i;
00388     }
00389   }
00390   lin_fact= linear_factors_univariate (hom_comp[index]);
00391   for (nat i=0; i<N(hom_comp); i++) {
00392     if (i != index) {
00393       Sparse_factors tmp_fact;
00394       for (nat j=0; j<N(lin_fact); j++) {
00395         nat m= multiplicity (lin_fact[j].f, hom_comp[i]);
00396         if (m > 0) 
00397           tmp_fact << Sparse_factor (lin_fact[j].f, min(lin_fact[j].m,m));
00398       }
00399       lin_fact= tmp_fact;
00400     }
00401   }
00402   for (nat i=0; i<N(lin_fact); i++)
00403     if (val (lin_fact[i].f) == 0) // remove monomials 
00404       factors << Sparse_factor (homogenize (lin_fact[i].f), lin_fact[i].m);
00405   
00406   // Truly bivariate factors
00407   Sparse_factors tbf= truly_bivariate_linear_factors(p);
00408   for (nat i=0; i<N(tbf); i++) factors << tbf[i];
00409 
00410   return factors;
00411 }

vector< irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > mmx::linear_factors_bivariate_naive ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 271 of file linear_factors_bivariate.hpp.

References E, mmx::lacunaryx::homogenize(), mmx::lacunaryx::intersect_factors(), linear_factors_univariate(), N(), Sparse_factor, Sparse_factors, truly_bivariate_linear_factors(), val(), and mmx::lacunaryx::w_homogeneous_parts().

00271                                                             {
00272   Sparse_factors factors;
00273   vector<Sparse_polynomial> hom_comp;
00274   Sparse_factors lin_fact;
00275   
00276   // Univariate factors, first variable
00277   hom_comp= w_homogeneous_parts(p, vec((E)0, (E)1));
00278   lin_fact= linear_factors_univariate (project (hom_comp[0],vec(0)));
00279   for (nat i=1; i<N(hom_comp); i++) {
00280     Sparse_factors tmp_fact= 
00281       linear_factors_univariate (project (hom_comp[i],vec(0))); 
00282     lin_fact= intersect_factors (tmp_fact, lin_fact);
00283   }
00284   for (nat i=0; i<N(lin_fact); i++)
00285     factors << Sparse_factor (inject (lin_fact[i].f, vec(0), 2), lin_fact[i].m);
00286 
00287   // Univariate factors, second variable
00288   hom_comp= w_homogeneous_parts(p,vec((E)1, (E)0));
00289   lin_fact= linear_factors_univariate (project (hom_comp[0],vec(1)));
00290   for (nat i=1; i<N(hom_comp); i++) {
00291     Sparse_factors tmp_fact= 
00292       linear_factors_univariate (project (hom_comp[i],vec(1)));
00293     lin_fact= intersect_factors (tmp_fact, lin_fact);
00294   }
00295   for (nat i=0; i<N(lin_fact); i++) 
00296     factors << Sparse_factor (inject (lin_fact[i].f, vec(1), 2), lin_fact[i].m);
00297 
00298   // Bivariate factors, binomials
00299   hom_comp= w_homogeneous_parts(p,vec((E)1, (E)1));
00300   lin_fact= linear_factors_univariate (project (hom_comp[0],vec(0)));
00301   for (nat i=1; i<N(hom_comp); i++) {
00302     Sparse_factors tmp_fact= 
00303       linear_factors_univariate (project (hom_comp[i],vec(0)));
00304     lin_fact= intersect_factors (tmp_fact, lin_fact);
00305   }
00306   for (nat i=0; i<N(lin_fact); i++)
00307     if (val (lin_fact[i].f) == 0) // remove monomials 
00308       factors << Sparse_factor (homogenize (lin_fact[i].f), lin_fact[i].m);
00309   
00310   // Truly bivariate factors
00311   Sparse_factors tbf= truly_bivariate_linear_factors(p);
00312   for (nat i=0; i<N(tbf); i++) factors << tbf[i];
00313 
00314   return factors;
00315 }

vector< irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > mmx::linear_factors_univariate ( const sparse_polynomial< C, monomial< vector< E > >, V > &  q  )  [inline]

Definition at line 344 of file linear_factors_univariate.hpp.

References E, gap_and_cyclotomic_factors(), Monomial, non_cyclotomic_factors(), Sparse_factor, Sparse_factors, Sparse_polynomial, and val().

Referenced by linear_factors(), linear_factors_bivariate(), and linear_factors_bivariate_naive().

00344                                                         {
00345   Sparse_polynomial x ((C)1, Monomial (vec(1)));
00346   Sparse_factors f;
00347   nat v= as<nat> (val(q));
00348   
00349   pair<C, vector <Sparse_factor> > gap_cyclo= gap_and_cyclotomic_factors (q);
00350   E gap= as<E> (car (gap_cyclo));
00351 
00352   Sparse_factors cyclotomic_fact= cdr (gap_cyclo);
00353 
00354   if ( v > 0 ) f << Sparse_factor( x , v );
00355   f << cyclotomic_fact; 
00356   f << non_cyclotomic_factors (q,gap);
00357   return f;
00358 }

nat mmx::multiplicity ( const sparse_polynomial< C, monomial< vector< E > >, V > &  f,
const sparse_polynomial< C, monomial< vector< E > >, V > &  p 
) [inline]

Definition at line 194 of file linear_factors_univariate.hpp.

References mmx::lacunaryx::as_polynomial(), binpow(), deg(), E, gap_univariate(), N(), partition_univariate(), sparse_derive(), Sparse_polynomial, and Univariate_polynomial.

Referenced by linear_factors_bivariate().

00194                                                                           {
00195   Univariate_polynomial f_dense= as_polynomial (f);
00196   if (f_dense[0] == 0) return as<nat> (deg (get_monomial (p,0)));
00197   if (f_dense[0] == -f_dense[1]) {
00198     Sparse_polynomial q= copy(p);
00199     for (nat i=0; i<N(p); i++) {
00200       C s=0;
00201       for (nat j=0; j<N(q); j++) s+= get_coefficient (q,j); 
00202       if ( s != 0 ) return i; 
00203       q= sparse_derive (q);
00204     }
00205     return N(p)-1; // should never occur
00206   }
00207   if (f_dense[0] == f_dense[1]) {
00208     Sparse_polynomial q= copy(p);
00209     for (nat i=0; i<N(p); i++) {
00210       C s=0;
00211       for (nat j=0; j<N(q); j++) 
00212         s+= get_coefficient (q,j) * binpow(-1, deg (get_monomial (q,j)) % 2);
00213       if ( s != 0 ) return i; 
00214       q= sparse_derive (q);
00215     }
00216     return N(p)-1; // should never occur
00217   }
00218   E gap= as<E> (gap_univariate (p));
00219   vector<Sparse_polynomial> polys= partition_univariate(p, gap);
00220   nat m= multiplicity (f_dense, as_polynomial (polys[0]));
00221   for ( nat i=0; i < N( polys ); i++ ) {
00222     nat mm= multiplicity (f_dense, as_polynomial (polys[i]));
00223     if (mm == 0) return mm;
00224     if (mm < m) m=mm;
00225   }
00226   return m;
00227 }

nat N ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 92 of file lpolynomial.hpp.

Referenced by mmx::lacunaryx::as_sparse_polynomial(), binary_test(), binpow(), compare(), cyclotomic_factors(), flatten(), gap_and_cyclotomic_factors(), gap_univariate(), GLUE_18(), GLUE_2(), GLUE_32(), GLUE_37(), GLUE_5(), GLUE_51(), GLUE_56(), GLUE_6(), GLUE_73(), GLUE_75(), mmx::lacunaryx::homogenize(), integer_roots(), mmx::lacunaryx::intersect_factors(), large_integer_roots(), linear_factors(), linear_factors_bivariate(), linear_factors_bivariate_naive(), multiplicity(), non_cyclotomic_factors(), partition(), partition_bivariate(), partition_bivariate_helper(), partition_univariate(), mmx::lacunaryx::set_as_bivariate_polynomial(), mmx::lacunaryx::set_as_polynomial(), sign(), mmx::lacunaryx::sort_poly(), mmx::lacunaryx::sparse_derive(), sparse_derive(), special_integer_roots(), truly_bivariate_linear_factors(), val(), and mmx::lacunaryx::w_homogeneous_parts().

00092                                          {
00093   return N(*P); }

vector< irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > mmx::non_cyclotomic_factors ( const sparse_polynomial< C, monomial< vector< E > >, V > &  q,
E  gap 
) [inline]

Definition at line 231 of file linear_factors_univariate.hpp.

References mmx::lacunaryx::as_polynomial(), deg(), N(), partition_univariate(), Sparse_factors, Univariate_factors, and Univariate_polynomial.

Referenced by linear_factors_univariate().

00231                                                            {
00232     vector<Sparse_polynomial> polys= partition_univariate(q, gap);
00233     vector<Univariate_polynomial> vp (as <Univariate_polynomial> (0),N(polys));
00234     
00235     for ( nat i=0; i < N( polys ); i++ ) vp[i]= as_polynomial (polys[i]);
00236 
00237     Univariate_polynomial g= primitive_part ( big<gcd_op> ( vp ));
00238     polynomial<rational> g_rat= as<polynomial <rational> > (g);
00239     Univariate_factors fact= bounded_irreducible_factorization (g_rat, 2);
00240     //Univariate_factors fact= irreducible_factorization (g_rat);
00241 
00242     Sparse_factors sparse_fact;
00243     for (nat i=0; i < N(fact); i++)
00244     {
00245       polynomial<rational> f=factor(fact[i]);
00246       if ( deg(f) == 1 && abs(f[1]*f[0]) != 1 ) {
00247         sparse_fact <<  as_sparse_factor<C,E,V> (fact[i]);
00248       }
00249     }
00250 
00251     return sparse_fact;
00252 }

bool mmx::operator!= ( const lpolynomial< C, E, V > &  c1,
const lpolynomial< C, E, V > &  c2 
) [inline]

Definition at line 103 of file lpolynomial.hpp.

00103                                                                      {
00104   return (*c1) != (*c2); }

lpolynomial<C,E,V> mmx::operator* ( const C &  c,
const lpolynomial< C, E, V > &  P 
) [inline]

Definition at line 350 of file lpolynomial.hpp.

00350                                               {
00351   return c * (*P); }

lpolynomial<C,E,V> mmx::operator* ( const lpolynomial< C, E, V > &  P,
const C &  c 
) [inline]

Definition at line 346 of file lpolynomial.hpp.

00346                                               {
00347   return (*P) * c; }

lpolynomial<C,E,V> mmx::operator* ( const lpolynomial< C, E, V > &  P,
const lpolynomial< C, E, V > &  Q 
) [inline]

Definition at line 336 of file lpolynomial.hpp.

References E, iterate(), and Table.

00336                                                         {
00337   Table ret (0);
00338   for (iterator<pair<E,C> > itP= iterate (*P); busy (itP); ++itP)
00339     for (iterator<pair<E,C> > itQ= iterate (*Q); busy (itQ); ++itQ) {
00340       E i= car(*itP), j= car(*itQ);
00341       ret[i+j] += cdr (*itP) * cdr (*itQ);
00342     }
00343   return ret; }

lpolynomial<C,E,V> mmx::operator+ ( const C &  c,
const lpolynomial< C, E, V > &  P 
) [inline]

Definition at line 314 of file lpolynomial.hpp.

References Table.

00314                                               {
00315   Table ret (*P);
00316   ret[0] = c + ret[0];
00317   return ret; }

lpolynomial<C,E,V> mmx::operator+ ( const lpolynomial< C, E, V > &  P,
const C &  c 
) [inline]

Definition at line 308 of file lpolynomial.hpp.

References Table.

00308                                               {
00309   Table ret (*P);
00310   ret[0] = ret[0] + c;
00311   return ret; }

lpolynomial<C,E,V> mmx::operator+ ( const lpolynomial< C, E, V > &  P,
const lpolynomial< C, E, V > &  Q 
) [inline]

Definition at line 304 of file lpolynomial.hpp.

00304                                                         {
00305   return *P + *Q; }

lpolynomial<C,E,V> mmx::operator- ( const C &  c,
const lpolynomial< C, E, V > &  P 
) [inline]

Definition at line 330 of file lpolynomial.hpp.

References Table.

00330                                               {
00331   Table ret (*P);
00332   ret[0] = c - ret[0];
00333   return ret; }

lpolynomial<C,E,V> mmx::operator- ( const lpolynomial< C, E, V > &  P,
const C &  c 
) [inline]

Definition at line 324 of file lpolynomial.hpp.

References Table.

00324                                               {
00325   Table ret (*P);
00326   ret[0] = ret[0] - c;
00327   return ret; }

lpolynomial<C,E,V> mmx::operator- ( const lpolynomial< C, E, V > &  P,
const lpolynomial< C, E, V > &  Q 
) [inline]

Definition at line 320 of file lpolynomial.hpp.

00320                                                         {
00321   return *P - *Q; }

lpolynomial<C,E,V> mmx::operator- ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 300 of file lpolynomial.hpp.

00300                                   {
00301   return - *P; }

lpolynomial<C,E,V> mmx::operator/ ( const lpolynomial< C, E, V > &  P,
const C &  c 
) [inline]

Definition at line 383 of file lpolynomial.hpp.

00383                                               {
00384   return (*P) / c; }

lpolynomial<C,E,V> mmx::operator/ ( const lpolynomial< C, E, V > &  P,
const lpolynomial< C, E, V > &  Q 
) [inline]

Definition at line 369 of file lpolynomial.hpp.

References deg(), LPolynomial, SE, and Table.

00369                                                         {
00370   ASSERT (deg (Q) != -1, "division by zero");
00371   LPolynomial R= P;
00372   Table ret (0);
00373   SE d, dQ= deg (Q);
00374   C lcQ= Q[dQ];
00375   while ((d= deg (R)) >= dQ) {
00376     C c= R[d] / lcQ;
00377     ret[d - dQ]= c;
00378     R = R - LPolynomial (c, d - dQ) * Q;
00379   }
00380   return ret; }

bool mmx::operator== ( const lpolynomial< C, E, V > &  c1,
const lpolynomial< C, E, V > &  c2 
) [inline]

Definition at line 101 of file lpolynomial.hpp.

00101                                                                      {
00102   return (*c1) == (*c2); }

vector< sparse_polynomial<C, monomial<vector<E> > , V> > mmx::partition ( const sparse_polynomial< C, monomial< vector< E > >, V > &  q  )  [inline]

Definition at line 54 of file integer_roots.hpp.

References deg(), E, Monomial, N(), Sparse_polynomial, and val().

Referenced by large_integer_roots().

00054                                                                  {
00055     C max_coeff= abs(get_coefficient(q,0));
00056     E prev_exponent= deg(get_monomial(q,0));
00057     E curr_exponent;
00058     vector<Sparse_polynomial> polys; 
00059     Sparse_polynomial tmp;
00060     nat index_min=0;
00061 
00062     for (nat i=1; i<N(q); i++) {
00063       
00064       curr_exponent= deg(get_monomial(q,i));
00065 
00066       if ( curr_exponent - prev_exponent > bit_size( max_coeff ) ) {
00067         tmp= range (q,index_min,i);
00068         tmp /= Monomial (vec (val(tmp))); 
00069         polys << tmp; 
00070         prev_exponent = curr_exponent;
00071         max_coeff= abs(get_coefficient(q,i));
00072         index_min= i;
00073       } else {
00074         prev_exponent= curr_exponent;
00075         max_coeff= max(abs(get_coefficient(q,i)),max_coeff);
00076       }
00077     }
00078     tmp= range(q, index_min, N(q));
00079     tmp /= Monomial (vec (val(tmp))); 
00080     polys << tmp; 
00081 
00082     return polys;
00083 }

vector< sparse_polynomial<C, monomial< vector<E> > , V> > mmx::partition_bivariate ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 223 of file linear_factors_bivariate.hpp.

References N(), and partition_bivariate_helper().

Referenced by truly_bivariate_linear_factors().

00223                                                  {
00224 
00225   vector<Sparse_polynomial> current= vec(p);
00226   nat prev_length=0;
00227   nat curr_length= N( current );
00228 
00229   while ( prev_length < curr_length ) {
00230     
00231     prev_length= curr_length;
00232 
00233     // Partition according to both variables
00234     for (nat i=0; i<2; i++) {
00235       vector<Sparse_polynomial> next;
00236       for (nat j=0; j<curr_length; j++) {
00237         next << partition_bivariate_helper( current[j], i );
00238       }
00239       current= next;
00240       curr_length= N(current);
00241     }
00242   }
00243 
00244   return current;
00245 }

vector< sparse_polynomial<C, monomial< vector<E> > , V> > mmx::partition_bivariate_helper ( const sparse_polynomial< C, monomial< vector< E > >, V > &  q,
nat  var 
) [inline]

Definition at line 186 of file linear_factors_bivariate.hpp.

References deg(), E, N(), mmx::lacunaryx::sort_poly(), and Sparse_polynomial.

Referenced by partition_bivariate().

00186                                                                   {
00187 
00188   vector<nat> order= sort_poly( q, var );
00189   
00190   E min_exponent= deg(get_monomial(q,order[0]),var);
00191   E curr_exponent;
00192   E accu=0;
00193   vector<Sparse_polynomial> polys;
00194   Sparse_polynomial tmp;
00195   nat index_min=0;
00196 
00197   for (nat i=1; i<N(q); i++) {
00198     
00199     curr_exponent= deg(get_monomial(q,order[i]),var);
00200   
00201     // The bound is curr_exponent - min_exponent > binom{number_of_terms}{2}
00202     // It is iteratively computed in accu
00203     if ( (curr_exponent - min_exponent) > accu ) {
00204       tmp= range_permute(q,index_min,i,order);
00205       tmp/= gcd_supp (tmp);
00206       polys << tmp;
00207       accu= 0;
00208       min_exponent= curr_exponent;
00209       index_min= i;
00210     } else {
00211       accu+=i;
00212     }
00213   }
00214   tmp= range_permute(q, index_min, N(q), order);
00215   tmp/= gcd_supp (tmp);
00216   polys << tmp;
00217   return polys;
00218 }

vector< sparse_polynomial<C, monomial< vector<E> > , V> > mmx::partition_univariate ( const sparse_polynomial< C, monomial< vector< E > >, V > &  q,
E  g 
) [inline]

Definition at line 166 of file linear_factors_univariate.hpp.

References deg(), E, Monomial, N(), Sparse_polynomial, and val().

Referenced by multiplicity(), and non_cyclotomic_factors().

00166                                                        {
00167     E prev_exponent= deg(get_monomial(q,0));
00168     E curr_exponent;
00169     vector<Sparse_polynomial> polys; 
00170     Sparse_polynomial tmp;
00171     nat index_min=0;
00172 
00173     for (nat i=1; i<N(q); i++) {
00174       
00175       curr_exponent= deg(get_monomial(q,i));
00176 
00177       if ( curr_exponent - prev_exponent > g ) {
00178         tmp= range (q,index_min,i);
00179         tmp /= Monomial (vec (val(tmp))); 
00180         polys << tmp; 
00181         prev_exponent = curr_exponent;
00182         index_min= i;
00183       } 
00184       else prev_exponent= curr_exponent; 
00185     }
00186     tmp= range(q, index_min, N(q));
00187     tmp /= Monomial (vec (val(tmp))); 
00188     polys << tmp; 
00189 
00190     return polys;
00191 }

mmx::PR_IDENTITY_OP_SUGAR ( template< typename C, typename E, typename V >  ,
lpolynomial< C, E, V >   
)
void mmx::set_as ( lpolynomial< C, E, V > &  r,
const T &  x 
) [inline]

Definition at line 174 of file lpolynomial.hpp.

References CF(), set_as(), and Table.

00174                                     {
00175   r.rep= Table (promote (0, CF(r)));
00176   set_as (r.rep[0], x); }

FV void mmx::set_as ( lpolynomial< T, TE, TV > &  r,
const lpolynomial< F, FE, FV > &  p 
) [inline]
Type Constraints

Definition at line 170 of file lpolynomial.hpp.

References lpolynomial< C, E, V >::rep.

Referenced by set_as().

00170                                                                 {
00171   set_as (r.rep, p.rep); }

void mmx::set_variable_name ( const lpolynomial< C, E, V > &  P,
const generic &  x 
) [inline]

Definition at line 213 of file lpolynomial.hpp.

Referenced by GLUE_3(), and GLUE_50().

00213                                                                             {
00214   (void) P; return LPolynomial::set_variable_name (x); }

int mmx::sign ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 235 of file lpolynomial.hpp.

References N().

Referenced by compare().

00235                             {
00236   vector<E> v (entries (*P));
00237   sort (v);
00238   for (nat i=0; i<N(v); i++) {
00239     int s= sign (P[v[i]]);
00240     if (s != 0) return s;
00241   }
00242   return 0; }

sparse_polynomial<C, monomial<vector<E> > , V> mmx::sparse_derive ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 36 of file integer_roots.hpp.

References coefficients(), deg(), E, Monomial, N(), and Sparse_polynomial.

Referenced by cyclotomic_factors(), gap_and_cyclotomic_factors(), gap_univariate(), multiplicity(), and special_integer_roots().

00036                                                              {
00037   E d= deg(get_monomial(p,0));
00038   vector<Monomial> monomials= fill<Monomial> (vec(0),N(p)-1);
00039   vector<C> coefficients= fill<C> (0,N(p)-1);
00040 
00041   for (nat i=1; i<N(p); i++) {
00042     pair<C,Monomial> term= p[i];
00043     monomials[i-1]= cdr(term)/Monomial(vec(d+1));
00044     coefficients[i-1]= car(term)*(as<C> (deg (cdr (term)) - d));
00045   }
00046   
00047   return Sparse_polynomial(coefficients,monomials,1);
00048 }

vector< pair<C,E> > mmx::special_integer_roots ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 119 of file integer_roots.hpp.

References binpow(), deg(), E, N(), Root, sparse_derive(), Sparse_polynomial, and val().

Referenced by integer_roots().

00119                                                                 {
00120   
00121   vector<Root> r;
00122   C s;
00123   
00124   // Root O
00125   E v= val(p);
00126   if ( v > 0 ) r << Root( 0, v );
00127 
00128   // Root 1 & -1
00129   Sparse_polynomial q= copy(p); 
00130   E mul1=0;
00131   E mul2=0;
00132 
00133   for (nat i=0; i<N(p); i++){
00134     
00135     // Root 1
00136     if (mul1 == i) {
00137       s=0;
00138       for (nat j=0; j<N(q); j++) s+=get_coefficient (q,j);
00139       if ( s == 0 ) mul1=i+1;
00140     }
00141 
00142     // Root -1
00143     if (mul2 == i) {
00144       s=0;
00145       for (nat j=0; j<N(q); j++) 
00146         s+= get_coefficient (q,j) * binpow(-1, deg (get_monomial (q,j)) % 2 );
00147       if ( s == 0 ) mul2=i+1;
00148     }
00149 
00150     if ( mul1 < i+1 && mul2 < i+1 ) break; // Useless to go further
00151 
00152     q= sparse_derive(q);
00153   }
00154 
00155   if (mul1 > 0) r << Root (1,mul1);
00156   if (mul2 > 0) r << Root (-1,mul2);
00157 
00158   return r;
00159 }

lpolynomial<C,E,V> mmx::square ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 354 of file lpolynomial.hpp.

References E, iterate(), and Table.

Referenced by __binpow(), GLUE_13(), GLUE_17(), GLUE_19(), GLUE_32(), GLUE_55(), GLUE_59(), and GLUE_92().

00354                               {
00355   Table ret (0);
00356   for (iterator<pair<E,C> > itP= iterate (*P); busy (itP); ++itP)
00357     ret[2*car(*itP)] += square (cdr (*itP));
00358   nat l= 0;
00359   for (iterator<pair<E,C> > itP= iterate (*P); busy (itP); ++itP, l++) {
00360     nat k= 0;
00361     for (iterator<pair<E,C> > itQ= iterate (*P); busy (itQ) && k < l; ++itQ, k++) {
00362       E i= car(*itP), j= car(*itQ);
00363       ret[i+j] += 2 * cdr (*itP) * cdr (*itQ);
00364     }
00365   }
00366   return ret; }

mmx::STYPE_TO_TYPE ( template< typename C, typename E, typename V >  ,
monomial_type  ,
lpolynomial< C, E, V >  ,
E   
)
mmx::STYPE_TO_TYPE ( template< typename C, typename E, typename V >  ,
scalar_type  ,
lpolynomial< C, E, V >  ,
C   
)
vector<E> mmx::supp ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 200 of file lpolynomial.hpp.

References iterate().

Referenced by GLUE_5(), GLUE_52(), GLUE_6(), GLUE_78(), and mmx::lacunaryx::homogenize().

00200                             {
00201   vector<E> ret;
00202   for (iterator<pair<E,C> > it= iterate (*P); busy (it); ++it)
00203     if (cdr (*it) != 0) ret << car (*it);
00204   return ret; }

vector< irreducible_factor< sparse_polynomial<C, monomial< vector<E> > , V> > > mmx::truly_bivariate_linear_factors ( const sparse_polynomial< C, monomial< vector< E > >, V > &  p  )  [inline]

Definition at line 249 of file linear_factors_bivariate.hpp.

References mmx::lacunaryx::as_bivariate_polynomial(), Bivariate_factors, Bivariate_polynomial, deg(), N(), partition_bivariate(), Sparse_factors, and val().

Referenced by linear_factors_bivariate(), and linear_factors_bivariate_naive().

00249                                                               {
00250   vector<Sparse_polynomial> v= partition_bivariate (p);
00251   
00252   Bivariate_polynomial q= as_bivariate_polynomial (v[0]);
00253   for (nat i=1; i<N(v); i++) {
00254     q= gcd (q, as_bivariate_polynomial (v[i]) );
00255   }
00256 
00257   polynomial <polynomial<rational> > q_rat= 
00258     as< polynomial <polynomial<rational> > > (q);
00259   Bivariate_factors f= // irreducible_factorization(q_rat);
00260         bounded_irreducible_factorization(q_rat,2);
00261   Sparse_factors ret;
00262   for (nat i=0; i<N(f); i++) {
00263     if (deg(f[i].f)==1 && deg(f[i].f[0])==1 && val(f[i].f[0])==0)
00264       ret << as_sparse_factor<C,E,V> (f[i]);
00265   }
00266   return ret;
00267 }

bool mmx::unary_hash ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 255 of file lpolynomial.hpp.

00255                                   {
00256   return unary_hash<Op> (*P); }

mmx::UNARY_RETURN_TYPE ( template< typename C, typename E, typename V >  ,
radius_op  ,
lpolynomial< C, E, V >  ,
lpolynomial< Radius_type(C), E >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename E, typename V >  ,
center_op  ,
lpolynomial< C, E, V >  ,
lpolynomial< Center_type(C), E >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename E, typename V >  ,
Re_op  ,
lpolynomial< C, E, V >  ,
lpolynomial< Real_type(C), E >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename E, typename V >  ,
ground_op  ,
lpolynomial< C, E, V >  ,
Ground_type(C)   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename E, typename V >  ,
abs_op  ,
lpolynomial< C, E, V >  ,
lpolynomial< Abs_type(C), E >   
)
signed_of_helper<E>::type mmx::val ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 137 of file lpolynomial.hpp.

References iterate(), N(), and SE.

Referenced by GLUE_2(), GLUE_24(), GLUE_26(), GLUE_4(), GLUE_54(), GLUE_7(), GLUE_8(), GLUE_9(), linear_factors_bivariate(), linear_factors_bivariate_naive(), linear_factors_univariate(), partition(), partition_univariate(), special_integer_roots(), and truly_bivariate_linear_factors().

00137                            {
00138   if (N(P) == 0) return -1;
00139   iterator<pair<E,C> > it= iterate (*P);
00140   while (cdr (*it) == 0 && busy (it)) ++it; 
00141   if (!busy (it)) return -1;
00142   SE ret= car (*it); ++it;
00143   for (; busy (it); ++it) {
00144     if (cdr (*it) == 0) continue;
00145     ret= min ((SE) car (*it), ret);
00146   }
00147   return ret; }

generic mmx::var ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 210 of file lpolynomial.hpp.

Referenced by flatten().

00210                                                {
00211   (void) P; return LPolynomial::get_variable_name (); }

lpolynomial<C,E,V> mmx::xderive ( const lpolynomial< C, E, V > &  P  )  [inline]

Definition at line 444 of file lpolynomial.hpp.

References iterate(), and Table.

Referenced by GLUE_23(), GLUE_28(), GLUE_49(), and GLUE_64().

00444                                {
00445   Table ret (0);
00446   for (iterator<pair<E,C> > it= iterate (*P); busy (it); ++it) {
00447     if (car (*it) == 0) continue;
00448     ret[car (*it)] = promote (car (*it), cdr (*it)) * cdr (*it);
00449   }
00450   return ret; }

Variable Documentation

lpolynomial< C, E, V > C lpolynomial< C, E, V > E

Definition at line 161 of file lpolynomial.hpp.

Referenced by mmx::lacunaryx::homogenize(), linear_factors_bivariate(), linear_factors_bivariate_naive(), linear_factors_univariate(), multiplicity(), operator*(), partition(), partition_bivariate_helper(), partition_univariate(), mmx::lacunaryx::sparse_derive(), sparse_derive(), special_integer_roots(), square(), and mmx::lacunaryx::w_homogeneous_parts().

lpolynomial<C,E,V> C EQUAL_INT_SUGAR(template< typename C, typename E, typename V >, lpolynomial< C, E, V >) COMPARE_INT_SUGAR(template< typename C
lpolynomial<C,E,V> EQUAL_SCALAR_SUGAR(template< typename C, typename E, typename V >, lpolynomial< C, E, V >,C) COMPARE_SCALAR_SUGAR(template< typename C
lpolynomial<C,E,V> C lpolynomial<C,E,V> EQUAL_SCALAR_SUGAR_BIS(template< typename C, typename E, typename V >, lpolynomial< C, E, V >,C) COMPARE_SCALAR_SUGAR_BIS(template< typename C
F

Definition at line 161 of file lpolynomial.hpp.

FE

Definition at line 161 of file lpolynomial.hpp.

lpolynomial< C, E, V > C lpolynomial< C, E, V > lpolynomial< C, E, V >

Definition at line 269 of file lpolynomial.hpp.

TE

Definition at line 161 of file lpolynomial.hpp.

TV

Definition at line 161 of file lpolynomial.hpp.

lpolynomial< C, E, V > C lpolynomial< C, E, V > V

Definition at line 267 of file lpolynomial.hpp.

Referenced by integer_roots(), and linear_factors().

Generated on 18 Jul 2014 for lacunaryx by  doxygen 1.6.1