include/algebramix/vector_fixed.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : vector_fixed.hpp
* DESCRIPTION: inlined low-level vector operations of a fixed size
* 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__VECTOR_FIXED__HPP
#define __MMX__VECTOR_FIXED__HPP
#include <basix/vector_naive.hpp>

namespace mmx {

/******************************************************************************
* Inlined vectorial operations of a fixed size
******************************************************************************/

template<typename Op, typename T, nat n>
struct vec_nullary_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (T* dest) {
    vec_nullary_helper <Op, T, n1>::op (dest);
    vec_nullary_helper <Op, T, n2>::op (dest+n1);
  }
};

template<typename Op, typename T>
struct vec_nullary_helper<Op, T, 1> {
  static inline void op (T* dest) {
    Op::set_op (*dest);
  }
};

template<typename Op, typename T, typename C, nat n>
struct vec_unary_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (T* dest, const C* s) {
    vec_unary_helper <Op, T, C, n1>::op (dest   , s   );
    vec_unary_helper <Op, T, C, n2>::op (dest+n1, s+n1);
  }
};

template<typename Op, typename T, typename C>
struct vec_unary_helper<Op, T, C, 1> {
  static inline void op (T* dest, const C* s) {
    Op::set_op (*dest, *s);
  }
};

template<typename Op, typename T, typename C1, typename C2, nat n>
struct vec_binary_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (T* dest, const C1* s1, const C2* s2) {
    vec_binary_helper <Op, T, C1, C2, n1>::op (dest   , s1   , s2   );
    vec_binary_helper <Op, T, C1, C2, n2>::op (dest+n1, s1+n1, s2+n1);
  }
};

template<typename Op, typename T, typename C1, typename C2>
struct vec_binary_helper<Op, T, C1, C2, 1> {
  static inline void op (T* dest, const C1* s1, const C2* s2) {
    Op::set_op (*dest, *s1, *s2);
  }
};

template<typename Op, typename T, typename X, nat n>
struct vec_unary_scalar_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (T* dest, const X& x) {
    vec_unary_scalar_helper <Op, T, X, n1>::op (dest   , x);
    vec_unary_scalar_helper <Op, T, X, n2>::op (dest+n1, x);
  }
};

template<typename Op, typename T, typename X>
struct vec_unary_scalar_helper<Op, T, X, 1> {
  static inline void op (T* dest, const X& x) {
    Op::set_op (*dest, x);
  }
};

template<typename Op, typename T, typename C, typename X, nat n>
struct vec_binary_scalar_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (T* dest, const C* s, const X& x) {
    vec_binary_scalar_helper <Op, T, C, X, n1>::op (dest   , s   , x);
    vec_binary_scalar_helper <Op, T, C, X, n2>::op (dest+n1, s+n1, x);
  }
};

template<typename Op, typename T, typename C, typename X>
struct vec_binary_scalar_helper<Op, T, C, X, 1> {
  static inline void op (T* dest, const C* s, const X& x) {
    Op::set_op (*dest, *s, x);
  }
};

template<typename Op, typename T, typename C1, typename C2,
         typename X, nat n>
struct vec_ternary_scalar_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (T* dest, const C1* s1, const C2* s2, const X& x) {
    vec_ternary_scalar_helper <Op, T, C1, C2, X, n1>
      ::op (dest, s1, s2, x);
    vec_ternary_scalar_helper <Op, T, C1, C2, X, n2>
      ::op (dest+n1, s1+n1, s2+n1, x);
  }
};

template<typename Op, typename T, typename C1, typename C2, typename X>
struct vec_ternary_scalar_helper<Op, T, C1, C2, X, 1> {
  static inline void op (T* dest, const C1* s1, const C2* s2, const X& x) {
    Op::set_op (*dest, *s1, *s2, x);
  }
};

template<typename Op, typename T, typename C,
         typename X1, typename X2, nat n>
struct vec_ternary_scalar_scalar_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (T* dest, const C* s, const X1& x1, const X2& x2) {
    vec_ternary_scalar_scalar_helper <Op, T, C, X1, X2, n1>
      ::op (dest, s, x1, x2);
    vec_ternary_scalar_scalar_helper <Op, T, C, X1, X2, n2>
      ::op (dest+n1, s+n1, x1, x2);
  }
};

template<typename Op, typename T, typename C, typename X1, typename X2>
struct vec_ternary_scalar_scalar_helper<Op, T, C, X1, X2, 1> {
  static inline void op (T* dest, const C* s, const X1& x1, const X2& x2) {
    Op::set_op (*dest, *s, x1, x2);
  }
};

template<typename Op, typename C, nat n>
struct vec_unary_test_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void op (const C* s) {
    if (!vec_unary_test_helper <Op, C, n1>::op (s)) return false;
    return vec_unary_test_helper <Op, C, n2>::op (s+n1);
  }
};

template<typename Op, typename C>
struct vec_unary_test_helper<Op, C, 1> {
  static inline void op (const C* s) {
    return Op::op (*s);
  }
};

template<typename Op, typename C1, typename C2, nat n>
struct vec_binary_test_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline bool op (const C1* s1, const C2* s2) {
    return vec_binary_test_helper <Op, C1, C2, n1>::op (s1   , s2)
        && vec_binary_test_helper <Op, C1, C2, n2>::op (s1+n1, s2+n1);
  }
};

template<typename Op, typename C1, typename C2>
struct vec_binary_test_helper<Op, C1, C2, 1> {
  static inline bool op (const C1* s1, const C2* s2) {
    return !Op::not_op (*s1, *s2);
  }
};

template<typename Op, typename C, typename X, nat n>
struct vec_binary_test_scalar_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline bool op (const C* s, const X& x) {
    return vec_binary_test_scalar_helper <Op, C, X, n1>::op (s   , x)
        && vec_binary_test_scalar_helper <Op, C, X, n2>::op (s+n1, x);
  }
};

template<typename Op, typename C, typename X>
struct vec_binary_test_scalar_helper<Op, C, X, 1> {
  static inline bool op (const C* s, const X& x) {
    return !Op::not_op (*s, x);
  }
};

template<typename Op, typename R, typename C, nat n>
struct vec_unary_big_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void set_op (R& r, const C* s) {
    vec_unary_big_helper <Op, R, C, n1>::set_op (r, s);
    vec_unary_big_helper <Op, R, C, n2>::set_op (r, s+n1);
  }
  static inline void set_op (R& r, const C* s, const format<C>& fm) {
    vec_unary_big_helper <Op, R, C, n1>::set_op (r, s, fm);
    vec_unary_big_helper <Op, R, C, n2>::set_op (r, s+n1, fm);
  }
};

template<typename Op, typename R, typename C>
struct vec_unary_big_helper<Op, R, C, 1> {
  static inline void set_op (R& r, const C* s) {
    Op::set_op (r, *s);
  }
  static inline void set_op (R& r, const C* s, const format<C>& fm) {
    (void) fm;
    Op::set_op (r, *s);
  }
};

template<typename Op, typename C1, typename C2, nat n>
struct vec_binary_big_helper {
  static const nat n1= (n>>1), n2= n-n1;
  static inline void _op (C1& r, const C1* s1, const C2* s2) {
    vec_binary_big_helper <Op, C1, C2, n1>::_op (r, s1   , s2);
    vec_binary_big_helper <Op, C1, C2, n2>::_op (r, s1+n1, s2+n1);
  }
  static inline void _op (C1& r, const C1* s1, const C2* s2,
                          const format<C1>& fm1, const format<C2>& fm2) {
    (void) fm1; (void) fm2;
    vec_binary_big_helper <Op, C1, C2, n1>::_op (r, s1   , s2);
    vec_binary_big_helper <Op, C1, C2, n2>::_op (r, s1+n1, s2+n1);
  }
  static inline C1 op (const C1* s1, const C2* s2) {
    C1 r= Op::template neutral<C1> ();
    vec_binary_big_helper <Op, C1, C2, n1>::_op (r, s1   , s2);
    vec_binary_big_helper <Op, C1, C2, n2>::_op (r, s1+n1, s2+n1);
    return r;
  }
  static inline C1 op (const C1* s1, const C2* s2,
                       const format<C1>& fm1, const format<C2>& fm2) {
    C1 r= get_sample (binary_map<Op> (fm1, fm2));
    Op::set_neutral (r);
    vec_binary_big_helper <Op, C1, C2, n1>::_op (r, s1   , s2);
    vec_binary_big_helper <Op, C1, C2, n2>::_op (r, s1+n1, s2+n1);
    return r;
  }
};

template<typename Op, typename C1, typename C2>
struct vec_binary_big_helper<Op, C1, C2, 1> {
  static inline void _op (C1& r, const C1* s1, const C2* s2) {
    Op::set_op (r, *s1, *s2);
  }
  static inline void _op (C1& r, const C1* s1, const C2* s2,
                          const format<C1>& fm1, const format<C2>& fm2) {
    (void) fm1; (void) fm2;
    Op::set_op (r, *s1, *s2);
  }
  static inline C1 op (const C1* s1, const C2* s2) {
    C1 r= Op::template neutral<C1> ();
    Op::set_op (r, *s1, *s2);
    return r;
  }
  static inline C1 op (const C1* s1, const C2* s2,
                       const format<C1>& fm1, const format<C2>& fm2) {
    C1 r= get_sample (binary_map<Op> (fm1, fm2));
    Op::set_neutral (r);
    Op::set_op (r, *s1, *s2);
    return r;
  }
};

// Special speedup for mul_add
template<typename C1, typename C2>
struct vec_binary_big_helper<mul_add_op, C1, C2, 2> {
  static inline void _op (C1& r, const C1* s1, const C2* s2) {
    r += (*s1) * (*s2) + (*(s1+1)) * (*(s2+1));
  }
  static inline void _op (C1& r, const C1* s1, const C2* s2,
                          const format<C1>& fm1, const format<C2>& fm2) {
    (void) fm1; (void) fm2;
    r += (*s1) * (*s2) + (*(s1+1)) * (*(s2+1));
  }
  static inline C1 op (const C1* s1, const C2* s2) {
    return (*s1) * (*s2) + (*(s1+1)) * (*(s2+1));
  }
  static inline C1 op (const C1* s1, const C2* s2,
                       const format<C1>& fm1, const format<C2>& fm2) {
    (void) fm1; (void) fm2;
    return (*s1) * (*s2) + (*(s1+1)) * (*(s2+1));
  }
};

} // namespace mmx
#endif //__MMX__VECTOR_FIXED__HPP

---