include/algebramix/matrix_modular.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : matrix_modular.hpp
* DESCRIPTION: modular matrices
* COPYRIGHT  : (C) 2007  Joris van der Hoeven and 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__MATRIX_MODULAR__HPP
#define __MMX__MATRIX_MODULAR__HPP
#include <numerix/modular.hpp>
#include <algebramix/matrix_int.hpp>
#include <algebramix/matrix_integer.hpp>

namespace mmx {
#define TMPL template<typename C, typename V1, typename V2>
#define Modulus modulus<C,V1>
#define Modular modular<Modulus,V2>

/******************************************************************************
* Variant for modular matrices
******************************************************************************/

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

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

TMPL
struct matrix_variant_helper<Modular > {
  typedef matrix_naive Naive;
  typedef matrix_unrolled<8,Naive> Unrolled;
  typedef matrix_simd<8,8,Unrolled> Simd;
  typedef matrix_modular<Unrolled> MV;
};

/******************************************************************************
* Multiplication of generic modular matrices
******************************************************************************/

template<typename V, typename MV>
struct implementation<matrix_multiply_base,V,matrix_modular<MV> >:
  public implementation<matrix_linear,V>
{
  typedef implementation<matrix_multiply,MV> Mat;

// Fallback
template<typename Op, typename D, typename S1, typename S2>
static inline void
mul (D* d, const S1* s1, const S2* s2,
     nat r, nat rr, nat l, nat ll, nat c, nat cc)
  {
    Mat::template mul<Op> (d, s1, s2, r, rr, l, ll, c, cc);
  }

// Lifting and project is used by default for modulars
template<typename Op, typename C, typename V1, typename V2>
static inline void
mul (Modular* d, const Modular* s1, const Modular* s2,
     nat r, nat rr, nat l, nat ll, nat c, nat cc)
  {
    typedef Lift_type(Modular) D;
    typedef typename Matrix_variant(D) W;
    typedef implementation<matrix_multiply,W> Mat_D;
    nat len_1= aligned_size<D,V> (r * l);
    nat len_2= aligned_size<D,V> (l * c);
    nat len_d= aligned_size<D,V> (r * c);
    nat spc = len_1 + len_2 + len_d;
    D* x1= mmx_new<D> (spc);
    D* x2= x1 + len_1;
    D* xd= x2 + len_2;
    Mat_D::template mat_unary_stride<lift_op, D, Modular>
      (x1, Mat_D::index (1, 0, r, l)  , Mat_D::index (0, 1, r, l),
       s1, Mat  ::index (1, 0, rr, ll), Mat  ::index (0, 1, rr, ll), r, l);
    Mat_D::template mat_unary_stride<lift_op, D, Modular>
      (x2, Mat_D::index (1, 0, l, c)  , Mat_D::index (0, 1, l, c),
       s2, Mat  ::index (1, 0, ll, cc), Mat  ::index (0, 1, ll, cc), l, c);
    Mat_D::template mul<Op> (xd, x1, x2, r, r, l, l, c, c);
    Mat_D::template mat_unary_stride<project_op>
      (d , Mat  ::index (1, 0, rr, cc), Mat  ::index (0, 1, rr, cc),
       xd, Mat_D::index (1, 0, r, c)  , Mat_D::index (0, 1, r, c), r, c);
    mmx_delete<D> (x1, spc);
  }
};

#undef TMPL
#undef Modulus
#undef Modular
} // namespace mmx

#endif //__MMX__MATRIX_MODULAR__HPP

---