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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : vector_scalar.hpp
* DESCRIPTION: support for multiplier within vector variants
* COPYRIGHT  : (C) 2008  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__VECTOR_SCALAR__HPP
#define __MMX__VECTOR_SCALAR__HPP
#include <basix/vector_naive.hpp>
#include <numerix/modular.hpp>
#include <algebramix/multiplier.hpp>
#include <algebramix/vector_unrolled.hpp>

namespace mmx {
#define TMPL  template<typename C>
#define TMPLX template<typename C, typename X>

/******************************************************************************
* Variant for customized scalar multiplications
******************************************************************************/

template<typename V>
struct vector_scalar: public V {
  typedef vector_scalar<typename V::Naive> Naive;
  typedef vector_scalar<typename V::Aligned> Aligned;
  typedef vector_scalar<typename V::No_simd> No_simd;
  typedef vector_scalar<typename V::No_thread> No_thread;
};

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

/******************************************************************************
* Abstract low level vector routines for products
******************************************************************************/

template<typename V, typename W>
struct implementation<vector_abstractions,V,vector_scalar<W> >:
  public implementation<vector_abstractions,V,W>
{
  // V is expected to be a complete vector variant abstraction.
  // Here we simply override routines involving products.
  typedef implementation<vector_abstractions,V,W> Vec;

template<typename Op, typename T, typename X>
struct vec_scalar_unary_scalar_helper {
  static inline void op (T* dest, const X& x, nat n) {
    Vec::template vec_unary_scalar<Op> (dest, x, n); }
};

template<typename T, typename X>
struct vec_scalar_unary_scalar_helper<mul_op, T, X> {
  static inline void op (T* dest, const X& x, nat n) {
    multiplier<X> y (x);
    Vec::template vec_unary_scalar<mul_op> (dest, y, n); }
};

template<typename Op, typename T, typename X> static inline void
vec_unary_scalar (T* dest, const X& x, nat n) {
  vec_scalar_unary_scalar_helper<Op,T,X>::op (dest, x, n);
}

template<typename Op, typename T, typename C, typename X>
struct vec_scalar_binary_scalar_helper {
  static inline void op (T* dest, const C* s, const X& x, nat n) {
    Vec::template vec_binary_scalar<Op> (dest, s, x, n); }
};

template<typename T, typename C, typename X>
struct vec_scalar_binary_scalar_helper<mul_op, T, C, X> {
  static inline void op (T* dest, const C* s, const X& x, nat n) {
    multiplier<X> y (x);
    Vec::template vec_binary_scalar<mul_op> (dest, s, y, n); }
};

template<typename T, typename C, typename X>
struct vec_scalar_binary_scalar_helper<rmul_op, T, C, X> {
  static inline void op (T* dest, const C* s, const X& x, nat n) {
    multiplier<X> y (x);
    Vec::template vec_binary_scalar<rmul_op> (dest, s, y, n); }
};

template<typename T, typename C, typename X>
struct vec_scalar_binary_scalar_helper<lmul_op, T, C, X> {
  static inline void op (T* dest, const C* s, const X& x, nat n) {
    multiplier<X> y (x);
    Vec::template vec_binary_scalar<lmul_op> (dest, s, y, n); }
};

template<typename T, typename C, typename X>
struct vec_scalar_binary_scalar_helper<rmul_add_op, T, C, X> {
  static inline void op (T* dest, const C* s, const X& x, nat n) {
    multiplier<X> y (x);
    Vec::template vec_binary_scalar<rmul_add_op> (dest, s, y, n); }
};

template<typename T, typename C, typename X>
struct vec_scalar_binary_scalar_helper<lmul_add_op, T, C, X> {
  static inline void op (T* dest, const C* s, const X& x, nat n) {
    multiplier<X> y (x);
    Vec::template vec_binary_scalar<lmul_add_op> (dest, s, y, n); }
};

template<typename Op, typename T, typename C, typename X> static inline void
vec_binary_scalar (T* dest, const C* s, const X& x, nat n) {
  vec_scalar_binary_scalar_helper<Op,T,C,X>::op (dest, s, x, n);
}

}; // implementation<vector_abstractions,V,vector_scalar<W> >

/******************************************************************************
* Use vector_scalar operations by default
******************************************************************************/

#define MV(C) modulus<C, modulus_int_preinverse<m> >

template<typename W, nat m>
struct vector_variant_helper<modular<MV (char), W> > {
  typedef vector_scalar<vector_unrolled<16,vector_unrolled<32> > > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (signed char), W> > {
  typedef vector_scalar<vector_unrolled<16,vector_unrolled<32> > > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (unsigned char), W> > {
  typedef vector_scalar<vector_unrolled<16,vector_unrolled<32> > > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (short int), W> > {
  typedef vector_scalar<vector_unrolled<8> > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (short unsigned int), W> > {
  typedef vector_scalar<vector_unrolled<8> > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (int), W> > {
  typedef vector_scalar<vector_unrolled<4> > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (unsigned int), W> > {
  typedef vector_scalar<vector_unrolled<4> > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (long int), W> > {
  typedef vector_scalar<vector_unrolled<4> > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (long unsigned int), W> > {
  typedef vector_scalar<vector_unrolled<4> > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (long long int), W> > {
  typedef vector_scalar<vector_unrolled<2> > VV; };

template<typename W, nat m>
struct vector_variant_helper<modular<MV (long long unsigned int), W> > {
  typedef vector_scalar<vector_unrolled<2> > VV; };

#undef MV
#undef TMPL
#undef TMPLX
} // namespace mmx
#endif //__MMX__VECTOR_SCALAR__HPP