include/lacunaryx/linear_factors.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : linear_factors.hpp
* DESCRIPTION: Linear factors of lacunary polynomials
* COPYRIGHT  : (C) 2014  Bruno Grenet
*******************************************************************************
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
* 
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/

#include <lacunaryx/linear_factors_bivariate.hpp>
#include <multimix/multivariate.hpp>
#include <lacunaryx/lpolynomial.hpp>

namespace mmx {

#define Monomial              monomial< vector<E> >
#define Sparse_polynomial     sparse_polynomial<C, Monomial, V>
#define Sparse_factor         irreducible_factor<Sparse_polynomial>
#define Sparse_factors        vector<Sparse_factor>

template<typename E, typename C, typename V>
Sparse_factors
linear_factors (const Sparse_polynomial &p) {
  nat d= dim(p);
  if (d == 1) return linear_factors_univariate (p);
  if (d == 2) return linear_factors_bivariate (p);
  else return linear_factors_bivariate (p); // TO BE MODIFIED!
}

// Wrapper for multivariate
template<typename E, typename C, typename V>
vector<generic>
linear_factors (const multivariate<Sparse_polynomial> &p) {
  vector<generic> ret;
  Sparse_factors factors= linear_factors (p.rep);
  for (nat i=0; i<N(factors); i++) {
    multivariate<Sparse_polynomial> pol (p.coords, factors[i].f);
    ret << as<generic> (vec (as<generic> (pol), as<generic> (as<integer> (factors[i].m)) ) );
  }
  return ret;
}

// Wrapper for lpolynomial
template<typename E, typename C, typename W>
vector<generic> linear_factors ( const lpolynomial<C,E,W> &lp ){
  typedef typename Sparse_polynomial_variant(C) V;
  // set as Sparse_polynomial
  vector<E> w (entries (*lp));
  vector<C> c;
  vector<Monomial> m;
  for (nat i= 0; i < N(w); i++)
    if (lp[w[i]] != 0) {
      c << lp[w[i]];
      m << Monomial (vec(w[i]));
    }
  Sparse_polynomial p (c, m, 1);

  // Linear factors
  Sparse_factors factors= linear_factors_univariate (p);
  vector<generic> ret;
  for (nat i=0; i<N(factors); i++) {
    table<C,E> tfactor;
    for (nat j=0; j<N(factors[i].f); j++)
      tfactor[ deg( get_monomial(factors[i].f,j) ) ]= get_coefficient(factors[i].f,j);
    lpolynomial<C,E,W> f (tfactor);
    ret << as<generic> (vec (as<generic> (f), as<generic> (as<integer> (factors[i].m))));
  }
  return ret;
}

#undef Monomial
#undef Sparse_polynomial
#undef Sparse_factor
#undef Sparse_factors

} // mmx namespace

---