/Users/mourrain/Devel/mmx/algebramix/include/algebramix/polynomial_carry_naive.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : polynomial_carry_naive.hpp
* DESCRIPTION: naive arithmetic for expansions in base p
* COPYRIGHT  : (C) 2009  Gregoire Lecerf
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX__POLYNOMIAL_CARRY_NAIVE__HPP
#define __MMX__POLYNOMIAL_CARRY_NAIVE__HPP
#include <algebramix/polynomial_naive.hpp>

namespace mmx {
#define TMPL  template <typename C>
#define TMPLK template <typename C, typename K>
#define TMPLX template <typename C, typename X>
#define TMPLP template <typename Polynomial>
#define Vector vector<C>
template <typename C, typename V> struct polynomial;

/******************************************************************************
* Naive variant for polynomials
******************************************************************************/

template<typename V>
struct polynomial_carry_naive: public V {
  typedef typename V::Vec Vec;
  typedef typename V::Naive Naive;
  typedef polynomial_carry_naive<typename V::Positive> Positive;
  typedef polynomial_carry_naive<typename V::No_simd> No_simd;
  typedef polynomial_carry_naive<typename V::No_thread> No_thread;
  typedef polynomial_carry_naive<typename V::No_scaled> No_scaled;
};

template<typename F, typename V, typename W>
struct implementation<F,V,polynomial_carry_naive<W> >:
    public implementation<F,V,W> {};

template<typename C>
struct polynomial_carry_variant_helper {
  typedef polynomial_carry_naive<polynomial_naive> PV;
};

#define Polynomial_carry_variant(C) polynomial_carry_variant_helper<C>::PV

/******************************************************************************
* Variable name storage, default base is written 'p'
******************************************************************************/

template<typename V,typename W>
struct implementation<polynomial_defaults,V,polynomial_carry_naive<W> > {
  template<typename P>
  class global_variables {
    static inline generic& dyn_name () {
      static generic name = "p";
      return name; }
  public:
    static inline void set_variable_name (const generic& x) {
      dyn_name () = x; }
    static inline generic get_variable_name () {
      return dyn_name (); }
  };

}; // implementation<polynomial_defaults,V,polynomial_carry_naive<W> >

/******************************************************************************
* Vectorial operations
******************************************************************************/

template<typename V,typename W>
struct implementation<polynomial_vectorial,V,polynomial_carry_naive<W> >:
  public implementation<polynomial_defaults,V>
{
  typedef implementation<vector_linear,V> Vec;

TMPLX static inline void set (C* dest, const X& c, nat n) {
  Vec::set (dest, c, n); }
TMPL static inline void clear (C* dest, nat n) {
  Vec::clear (dest, n); }
TMPL static inline void copy (C* dest, const C* s, nat n) {
  Vec::copy (dest, s, n); }
TMPLX static inline void cast (C* dest, const X* s, nat n) {
  Vec::cast (dest, s, n); }
TMPL static inline void reverse (C* dest, const C* s, nat n) {
  Vec::vec_reverse (dest, s, n); }

TMPL static inline void add (C* dest, const C* s1, const C* s2, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void add (C* dest, const C* s, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void sub (C* dest, const C* s1, const C* s2, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void sub (C* dest, const C* s, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void mul_add (C* dest, const C* s1, const C* s2, nat n) {
  ERROR ("not implemented"); }

TMPLX static inline void mul_add (C* dest, const C* s, const X& c, nat n) {
  ERROR ("not implemented"); }
TMPLX static inline void mul_add (C* dest, const X& c, const C* s, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void mul_sc (C* dest, const C* s, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void mul_sc (C* dest, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void div_sc (C* dest, const C* s, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void div_sc (C* dest, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void quo_sc (C* dest, const C* s, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void quo_sc (C* dest, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void rem_sc (C* dest, const C* s, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void rem_sc (C* dest, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline bool equal (const C* s1, const C* s2, nat n) {
  ERROR ("not implemented"); }
TMPL static inline bool equal (const C* s, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline bool exact_eq (const C* s1, const C* s2, nat n) {
  ERROR ("not implemented"); }
TMPL static inline bool exact_eq (const C* s, const C& c, nat n) {
  ERROR ("not implemented"); }
TMPL static inline void trim (const C* s, nat& n) {
  ERROR ("not implemented"); }

}; // implementation<polynomial_vectorial,V,polynomial_carry_naive<W> >

/******************************************************************************
* Multiplication
******************************************************************************/

template<typename V,typename W>
struct implementation<polynomial_multiply,V,polynomial_carry_naive<W> >:
  public implementation<polynomial_linear,V>
{
  typedef implementation<polynomial_linear,V> Pol;
  typedef implementation<vector_linear,V> Vec;

TMPLK static void
mul (C* dest, const C* s1, const K* s2, nat n1, nat n2) {
  ERROR ("not implemented"); }

TMPL static void
square (C* dest, const C* s, nat n) {
  ERROR ("not implemented"); }

TMPL static void
tmul (C* dest, const C* s1, const C* s2, nat n1, nat n2) {
  ERROR ("not implemented"); }

}; // implementation<polynomial_multiply,V,polynomial_carry_naive>

/******************************************************************************
* Division
******************************************************************************/

template<typename V, typename W>
struct implementation<polynomial_divide,V,polynomial_carry_naive<W> >:
  public implementation<polynomial_multiply,V>
{
  typedef implementation<polynomial_multiply,V> Pol;
  typedef implementation<vector_linear,V> Vec;

TMPL static void
quo_rem (C* dest, C* s1, const C* s2, nat n1, nat n2) {
  ERROR ("not implemented"); }

TMPL static void
tquo_rem (C* dest, const C* s1, const C* s2, nat n1, nat n2) {
  ERROR ("not implemented"); }

TMPL static void
pquo_rem (C* dest, C* s1, const C* s2, nat n1, nat n2) {
  ERROR ("not implemented"); }

}; // implementation<polynomial_divide,V,polynomial_carry_naive>

/******************************************************************************
* Euclidean sequence
******************************************************************************/

template<typename V,typename W>
struct implementation<polynomial_euclidean,V,polynomial_carry_naive<W> >:
  public implementation<polynomial_divide,V>
{
  typedef implementation<polynomial_divide,V> Pol;
  typedef implementation<vector_linear,V> Vec;

TMPL static void
euclidean_sequence (const C* s1, const C* s2, nat n1, nat n2,
                    C* d1, C* d2, nat& m1 , nat& m2,
                    C* u1, C* u2, nat& nu1, nat& nu2,
                    C* v1, C* v2, nat& nv1, nat& nv2,
                    nat* n, C* rho, C* q, C** r, C** co1, C** co2, nat k= 0) {
  ERROR ("not implemented"); }
  
TMPL static void
gcd (C* g, nat& n, const C* s1, const C* s2, nat n1, nat n2,
     C* u1, C* u2, nat& nu1, nat& nu2) {
  ERROR ("not implemented"); }

TMPL static void
pade (C* r, C* t, const C* s, nat m, nat n, nat k) {
  ERROR ("not implemented"); }

}; // implementation<polynomial_euclidean,V,polynomial_carry_naive>

/******************************************************************************
* Gcd computations
******************************************************************************/

template<typename V,typename W>
struct implementation<polynomial_gcd,V,polynomial_carry_naive<W> >:
  public implementation<polynomial_divide,V>
{
  typedef implementation<polynomial_euclidean,V> Pol;
  typedef implementation<vector_linear,V> Vec;

TMPLP static Polynomial
gcd (const Polynomial& P1, const Polynomial& P2,
     Polynomial& U1, Polynomial& U2) {
  ERROR ("not implemented"); }

TMPLP static Polynomial
gcd (const Polynomial& P1, const Polynomial& P2) {
  ERROR ("not implemented"); }

TMPLP static inline Polynomial
lcm (const Polynomial& P1, const Polynomial& P2) {
  ERROR ("not implemented"); }

TMPLP static Polynomial
invert_mod (const Polynomial& P, const Polynomial& Q) {
  ERROR ("not implemented"); }

TMPLP static void
pade (const Polynomial& P, nat n, nat k,
      Polynomial& Num, Polynomial &Den) {
  ERROR ("not implemented"); }

}; // implementation<polynomial_gcd,V,polynomial_carry_naive>

#undef TMPL
#undef TMPLK
#undef TMPLX
#undef TMPLP
#undef Vector
} // namespace mmx
#endif //__MMX__POLYNOMIAL_CARRY_NAIVE__HPP