mmx Namespace Reference

Classes

Functions

Function Documentation

multivariate< sparse_polynomial<rational> > mmx::as_mv_polynomial_modular ( const multivariate< sparse_polynomial< C > > &  f,
const modulus< C > &  p 
) [inline]

Definition at line 41 of file glue_bad.cpp.

00041                                                                             {
00042     modular<modulus<C>, modular_local>::set_modulus (p);
00043     return as<Polynomial> (f); }

vector< regular_chain< multivariate<sparse_polynomial<rational> > > > mmx::bad_rosenfeld_groebner ( const vector< multivariate< sparse_polynomial< rational > > > &  eqns,
const vector< multivariate_coordinate<> > &  indeps,
const vector< multivariate_coordinate<> > &  deps 
) [inline]

Definition at line 54 of file bad.hpp.

References bad_rosenfeld_groebner().

00056                                                         {
00057   return bad_rosenfeld_groebner (eqns, vec<Polynomial> (), indeps, deps); }

vector< regular_chain< multivariate< sparse_polynomial< rational > > > > bad_rosenfeld_groebner ( const vector< multivariate< sparse_polynomial< rational > > > &  eqns,
const vector< multivariate< sparse_polynomial< rational > > > &  ineqns,
const vector< multivariate_coordinate<> > &  indeps,
const vector< multivariate_coordinate<> > &  deps 
)

Definition at line 29 of file bad.cpp.

References from_bap_polynomial_mpz(), Polynomial_Z, Regular_chain, and to_bap_polynomial_mpq().

Referenced by bad_rosenfeld_groebner(), GLUE_23(), and GLUE_24().

00032                                                         {
00033   blad_session* blad = new blad_session (indeps, deps);
00034   vector<void*> indep_vars= blad -> bav_indeps;
00035   vector<void*> dep_vars= blad -> bav_deps;
00036 
00037   bap_tableof_polynom_mpz* bad_eqns=
00038     (bap_tableof_polynom_mpz*) ba0_new_table ();
00039   bap_tableof_polynom_mpz* bad_ineqns=
00040     (bap_tableof_polynom_mpz*) ba0_new_table ();
00041 
00042   bap_polynom_mpq* pol;
00043   bap_polynom_mpz* pol_mpz;
00044   mpz_t den; mpz_init (den);
00045   for (nat i= 0; i < N(eqns); i++) {
00046     pol= (bap_polynom_mpq*) to_bap_polynomial_mpq (blad, eqns[i]);
00047     pol_mpz= bap_new_polynom_mpz ();
00048     bap_numer_polynom_mpq (pol_mpz, den, pol);
00049     ba0_insert_table ((ba0_table*) bad_eqns, i, (void*) pol_mpz);
00050   }
00051   for (nat i= 0; i < N(ineqns); i++) {
00052     pol= (bap_polynom_mpq*) to_bap_polynomial_mpq (blad, ineqns[i]);
00053     pol_mpz= bap_new_polynom_mpz ();
00054     bap_numer_polynom_mpq (pol_mpz, den, pol);
00055     ba0_insert_table ((ba0_table*) bad_ineqns, i, (void*) pol_mpz);
00056   }
00057 
00058   bad_intersectof_regchain* bad_sol= bad_new_intersectof_regchain ();
00059   ba0_sscanf2 ((char*) "intersectof_regchain ([], \
00060     [differential, squarefree, coherent, primitive, autoreduced])",
00061                (char*) "%intersectof_regchain", bad_sol);
00062   bad_Rosenfeld_Groebner (bad_sol, bad_eqns, bad_ineqns,
00063                           (bad_base_field*) 0, (bad_splitting_control*) 0);
00064   vector<Regular_chain> sol;
00065   for (nat i= 0; i < (bad_sol -> inter).size; i++) {
00066     bad_regchain* bad_chain= (bad_sol -> inter).tab[i];
00067     vector<Polynomial> chain;
00068     for (nat j= 0; j < (bad_chain -> decision_system).size; j++) {
00069       Polynomial_Z p= from_bap_polynomial_mpz
00070         (blad, (bad_chain -> decision_system).tab[j]);
00071       chain << as<Polynomial> (p);
00072     }
00073     bad_attchain* bad_att= &(bad_chain -> attrib);
00074     vector<generic> att;
00075     if (bad_has_structural_property_attchain
00076         (bad_att, bad_differential_structural_property))
00077       att << lit ("differential");
00078     if (bad_has_structural_property_attchain
00079         (bad_att, bad_prime_structural_property))
00080       att << lit ("prime");
00081     if (bad_has_desired_property_attchain
00082         (bad_att, bad_coherence_desired_property))
00083       att << lit ("coherence");
00084     if (bad_has_desired_property_attchain
00085         (bad_att, bad_autoreduced_desired_property))
00086       att << lit ("autoreduced");
00087     if (bad_has_desired_property_attchain
00088         (bad_att, bad_squarefree_desired_property))
00089       att << lit ("squarefree");
00090     if (bad_has_desired_property_attchain
00091         (bad_att, bad_primitive_desired_property))
00092       att << lit ("primitive");
00093     if (bad_has_desired_property_attchain
00094         (bad_att, bad_normalized_desired_property))
00095       att << lit ("normalized");
00096     sol << Regular_chain (chain, att);
00097   }
00098   // delete blad; // FIXME
00099   return sol;
00100 }

static bav_symbol* mmx::bav_dependent_symbol ( const string &  s,
nat  i 
) [static]

Definition at line 33 of file blad_session.cpp.

Referenced by bav_dependent_variable().

00033                                               {
00034   bav_symbol* x= ::bav_new_symbol ();
00035   char* c= as_charp (s);
00036   x -> ident= ::ba0_strdup (c); 
00037   free_charp (c);
00038   x -> type= ::bav_dependent_symbol;
00039   x -> index= i;
00040   //x -> derivation_index= -1; // FIXME ???
00041   return x; }

static bav_variable* mmx::bav_dependent_variable ( const string &  s,
nat  i,
nat  r 
) [static]

Definition at line 52 of file blad_session.cpp.

References bav_dependent_symbol().

Referenced by blad_session::blad_session().

00052                                                        {
00053   bav_variable* x= ::bav_new_variable ();
00054   x -> root= bav_dependent_symbol (s, i);
00055   x -> index= i;
00056   ba0_insert_table ((ba0_table*) &(x -> number), 0, (void*) 2);
00057   for (nat k= 0; k < r; k++)
00058     ba0_insert_table ((ba0_table*) &(x -> order), k, (void*) 0);
00059   return x; }

static bav_symbol* mmx::bav_independent_symbol ( const string &  s,
nat  i,
nat  j 
) [static]

Definition at line 22 of file blad_session.cpp.

Referenced by bav_independent_variable().

00022                                                        {
00023   bav_symbol* x= ::bav_new_symbol ();
00024   char* c= as_charp (s);
00025   x -> ident= ::ba0_strdup (c); 
00026   free_charp (c);
00027   x -> type= ::bav_independent_symbol;
00028   x -> index= i;
00029   x -> derivation_index= j;
00030   return x; }

static bav_variable* mmx::bav_independent_variable ( const string &  s,
nat  i,
nat  j 
) [static]

Definition at line 44 of file blad_session.cpp.

References bav_independent_symbol().

Referenced by blad_session::blad_session().

00044                                                          {
00045   bav_variable* x= ::bav_new_variable ();
00046   x -> root= bav_independent_symbol (s, i, j);
00047   x -> index= i;
00048   ba0_insert_table ((ba0_table*) &(x -> number), 0, (void*) 2);
00049   return x; }

string mmx::blad_get_version (  ) 
multivariate_coordinate mmx::derive ( const multivariate_coordinate<> &  u,
const multivariate_coordinate<> &  x,
const multivariate_coordinate<> &  y 
) [inline]

Definition at line 30 of file bav.hpp.

References derive().

00030                                                                        {
00031   return derive (u, vec (x, y)); }

multivariate_coordinate mmx::derive ( const multivariate_coordinate<> &  u,
const multivariate_coordinate<> &  x 
) [inline]

Definition at line 26 of file bav.hpp.

References derive().

00026                                                   {
00027   return derive (u, vec (x)); }

multivariate_coordinate derive ( const multivariate_coordinate<> &  u,
const vector< multivariate_coordinate<> > &  v 
)

Definition at line 22 of file bav.cpp.

References Coordinate.

Referenced by derive(), from_bap_polynomial_mpz(), and GLUE_1().

00022                                                           {
00023   if (N(v) == 0) return u;
00024   generic y= **u;
00025   vector<generic> g;
00026   if (is<compound> (y) && exact_eq (y[0], GEN_CACHED_DERIVE))
00027     g= compound_to_vector (y);
00028   else
00029     g= vec (GEN_CACHED_DERIVE, y);
00030   for (nat i= 0; i < N(v); i++)
00031     g << **v[i];
00032   return Coordinate (vector_to_compound (g)); }

multivariate< sparse_polynomial< integer > > from_bap_polynomial_mpz ( const blad_session *  _blad,
const void *  pol 
)

Definition at line 84 of file bap.cpp.

References Coordinate, derive(), M, Monomial, Polynomial_Z, and Sparse_polynomial_Z.

Referenced by bad_rosenfeld_groebner().

00084                                                                      {
00085   vector<Coordinate> indeps= _blad -> indeps;
00086   vector<Coordinate> deps= _blad -> deps;
00087   nat r= N(indeps), s= N(deps);
00088   bav_tableof_variable* indets= (bav_tableof_variable*) ba0_new_table ();
00089   bav_R_mark_variables (false);
00090   bap_mark_indets_polynom_mpz ((bap_polynom_mpz*) pol);
00091   bav_R_marked_variables (indets, true);
00092   vector<Coordinate> coords;
00093   for (nat i= 0; i < indets -> size; i++) {
00094     bav_variable* aux= indets -> tab[i];
00095     nat k= aux -> root -> index;
00096     VERIFY (k >= r && k < N(deps) + r, "index out of range");
00097     Coordinate coord= deps [k - r];
00098     vector<Coordinate> ders;
00099     for (nat j= 0; j < r; j++)
00100       ders= append (ders, fill (indeps[j], (aux -> order).tab[j]));
00101     coords << derive (coord, ders);
00102   }
00103   struct bap_itermon_mpz iter;;
00104   bap_begin_itermon_mpz (&iter, (bap_polynom_mpz*) pol);
00105   bav_term* term= bav_new_term ();
00106   vector<integer> coeffs;
00107   vector<Monomial> monoms;
00108   while (! bap_outof_itermon_mpz (&iter)) {
00109     integer cf;
00110     mpz_set (*cf, *bap_coeff_itermon_mpz (&iter));
00111     coeffs << cf;
00112     bap_term_itermon_mpz (term, &iter);
00113     M monom;
00114     for (nat k= 0; k < N(coords); k++)
00115       monom << bav_degree_term (term, indets -> tab[k]);
00116     monoms << Monomial (monom);
00117     
00118     bap_next_itermon_mpz (&iter);
00119   }
00120   bap_close_itermon_mpz (&iter);
00121   Sparse_polynomial_Z spol (coeffs, monoms);
00122   return Polynomial_Z (coords, spol); }

static multivariate_coordinate mmx::GLUE_1 ( const multivariate_coordinate<> &  arg_1,
const tuple< multivariate_coordinate<> > &  arg_2 
) [static]

Definition at line 58 of file glue_bad.cpp.

References derive().

00058                                                                            {
00059     return derive (arg_1, as_vector (arg_2));
00060   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_10 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 103 of file glue_bad.cpp.

00103                                                                                                               {
00104     return range (arg_1, arg_2, arg_3);
00105   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_11 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 108 of file glue_bad.cpp.

00108                                                                           {
00109     return reverse (arg_1);
00110   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_12 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1,
const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_2 
) [static]

Definition at line 113 of file glue_bad.cpp.

00113                                                                                                                                          {
00114     return append (arg_1, arg_2);
00115   }

static alias<vector<regular_chain<multivariate<sparse_polynomial< rational > > > > > mmx::GLUE_13 ( const alias< vector< regular_chain< multivariate< sparse_polynomial< rational > > > > > &  arg_1,
const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_2 
) [static]

Definition at line 118 of file glue_bad.cpp.

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

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_14 ( const regular_chain< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_2 
) [static]

Definition at line 123 of file glue_bad.cpp.

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

static regular_chain<multivariate<sparse_polynomial< rational > > > mmx::GLUE_15 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 128 of file glue_bad.cpp.

00128                                                                           {
00129     return car (arg_1);
00130   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_16 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 133 of file glue_bad.cpp.

00133                                                                           {
00134     return cdr (arg_1);
00135   }

static bool mmx::GLUE_17 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 138 of file glue_bad.cpp.

00138                                                                           {
00139     return is_nil (arg_1);
00140   }

static bool mmx::GLUE_18 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 143 of file glue_bad.cpp.

00143                                                                           {
00144     return is_atom (arg_1);
00145   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_19 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1,
const regular_chain< multivariate< sparse_polynomial< rational > > > &  arg_2 
) [static]

Definition at line 148 of file glue_bad.cpp.

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

static vector<multivariate<sparse_polynomial< rational > > > mmx::GLUE_2 ( const regular_chain< multivariate< sparse_polynomial< rational > > > &  arg_1  )  [static]

Definition at line 63 of file glue_bad.cpp.

References mmx_regular_chain_decision_system().

00063                                                                 {
00064     return mmx_regular_chain_decision_system (arg_1);
00065   }

static int mmx::GLUE_20 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1,
const regular_chain< multivariate< sparse_polynomial< rational > > > &  arg_2 
) [static]

Definition at line 153 of file glue_bad.cpp.

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

static bool mmx::GLUE_21 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1,
const regular_chain< multivariate< sparse_polynomial< rational > > > &  arg_2 
) [static]

Definition at line 158 of file glue_bad.cpp.

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

static vector<generic> mmx::GLUE_22 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 163 of file glue_bad.cpp.

00163                                                                           {
00164     return as<vector<generic> > (arg_1);
00165   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_23 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate< sparse_polynomial< rational > > > &  arg_2,
const vector< multivariate_coordinate<> > &  arg_3,
const vector< multivariate_coordinate<> > &  arg_4 
) [static]

Definition at line 168 of file glue_bad.cpp.

References bad_rosenfeld_groebner().

00168                                                                                                                                                                                    {
00169     return bad_rosenfeld_groebner (arg_1, arg_2, arg_3, arg_4);
00170   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_24 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< multivariate_coordinate<> > &  arg_3 
) [static]

Definition at line 173 of file glue_bad.cpp.

References bad_rosenfeld_groebner().

00173                                                                                                                                     {
00174     return bad_rosenfeld_groebner (arg_1, arg_2, arg_3);
00175   }

static vector<generic> mmx::GLUE_3 ( const regular_chain< multivariate< sparse_polynomial< rational > > > &  arg_1  )  [static]

Definition at line 68 of file glue_bad.cpp.

References mmx_regular_chain_attrib().

00068                                                                 {
00069     return mmx_regular_chain_attrib (arg_1);
00070   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_4 ( const tuple< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 73 of file glue_bad.cpp.

00073                                                                         {
00074     return vector<regular_chain<mv_polynomial(rational) > > (as_vector (arg_1));
00075   }

static vector<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_5 ( const tuple< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 78 of file glue_bad.cpp.

00078                                                                         {
00079     return vector<regular_chain<mv_polynomial(rational) > > (as_vector (arg_1));
00080   }

static iterator<generic> mmx::GLUE_6 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 83 of file glue_bad.cpp.

00083                                                                          {
00084     return as<iterator<generic> > (iterate (arg_1));
00085   }

static int mmx::GLUE_7 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1  )  [static]

Definition at line 88 of file glue_bad.cpp.

00088                                                                          {
00089     return N (arg_1);
00090   }

static regular_chain<multivariate<sparse_polynomial< rational > > > mmx::GLUE_8 ( const vector< regular_chain< multivariate< sparse_polynomial< rational > > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 93 of file glue_bad.cpp.

00093                                                                                            {
00094     return arg_1[arg_2];
00095   }

static alias<regular_chain<multivariate<sparse_polynomial< rational > > > > mmx::GLUE_9 ( const alias< vector< regular_chain< multivariate< sparse_polynomial< rational > > > > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 98 of file glue_bad.cpp.

00098                                                                                                    {
00099     return alias_access<regular_chain<mv_polynomial(rational) > > (arg_1, arg_2);
00100   }

void glue_bad (  ) 

Referenced by glue_mblad().

void mmx::glue_mblad (  ) 

Definition at line 9 of file glue_mblad.cpp.

References glue_bad().

00009                 {
00010     static bool done = false;
00011     if (done) return;
00012     done = true;
00013     register_glue (string ("glue_bad"), (& (glue_bad)));
00014     register_glue (string ("glue_mblad"), (& (glue_mblad)));
00015     dl_link ("multimix");
00016     glue_bad ();
00017   }

void * to_bap_polynomial_mpq ( const blad_session *  _blad,
const multivariate< sparse_polynomial< rational > > &  eqn 
)

Definition at line 28 of file bap.cpp.

References Coordinate, Coordinates, and M.

Referenced by bad_rosenfeld_groebner().

00028                                                                            {
00029   vector<Coordinate> indeps=  _blad -> indeps;
00030   vector<Coordinate> deps=  _blad -> deps;
00031   vector<void*> bav_indeps= _blad -> bav_indeps;
00032   vector<void*> bav_deps= _blad -> bav_deps;
00033   Coordinates crds= eqn.coords;
00034   nat n= N(crds), j;
00035 
00036   vector<bav_variable*> eqn_vars;
00037   for (nat i= 0; i < n; i++) {
00038     if ((j= find (indeps, crds[i])) < N(indeps))
00039       eqn_vars << (bav_variable*) bav_indeps[j];
00040     else if ((j= find (deps, crds[i])) < N(deps))
00041       eqn_vars << (bav_variable*) bav_deps[j];
00042     else {
00043       ASSERT (is<compound> (**crds[i]), "unexpected variable");
00044       vector<generic> v= compound_to_vector (**crds[i]);
00045       ASSERT (v[0] == GEN_CACHED_DERIVE, "unexpected variable");
00046       j= find (deps, Coordinate (v[1]));
00047       ASSERT (j < N(deps), "unexpected dependent variable");
00048       bav_variable* u= (bav_variable*) bav_deps[j];
00049       for (nat k= 2; k < N(v); k++) {
00050         j= find (indeps, Coordinate (v[k]));
00051         ASSERT (j < N(indeps), "unexpected independent variable");
00052         u= bav_R_derivative (u, ((bav_variable* ) bav_indeps[j]) -> root);
00053       }
00054       eqn_vars << u;
00055     }
00056   }
00057 
00058   bap_polynom_mpq* pol;
00059   bap_polynom_mpq* acc= bap_new_polynom_mpq ();
00060   bap_polynom_mpq* aux= bap_new_polynom_mpq ();
00061   bav_term* term;
00062   bav_term* term_acc= bav_new_term ();
00063   bav_term* term_aux= bav_new_term ();
00064 
00065   pol= bap_new_polynom_mpq ();
00066   for (nat i= 0; i < N(eqn); i++) {
00067     rational c= get_coefficient (eqn, i);
00068     M m= *get_monomial (eqn.rep, i);
00069     term= bav_new_term ();
00070     for (nat j= 0; j < N(m); j++) {
00071       nat e= m[j];
00072       bav_set_term_variable (term_aux, eqn_vars[j], m[j]);
00073       bav_mul_term (term_acc, term, term_aux);
00074       bav_set_term (term, term_acc);
00075     }
00076     mpq_t x; mpq_init (x); mpq_set (x, *c);
00077     bap_set_polynom_monom_mpq (aux, x, term);
00078     bap_add_polynom_mpq (acc, pol, aux);
00079     bap_set_polynom_mpq (pol, acc);
00080   }
00081   return (void*) pol; }

mmx::WRAP_INDIRECT_IMPL ( template< typename R >  inline,
regular_chain< R >   
) const

Definition at line 40 of file bad.hpp.

00043                                         {
00044   return flatten (*chain); }

Generated on 6 Dec 2012 for mblad by  doxygen 1.6.1