include/basix/vector_naive.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : vector_naive.hpp
* DESCRIPTION: header for low level vectorial computations
* COPYRIGHT  : (C) 2003  Joris van der Hoeven
*******************************************************************************
* 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_NAIVE__HPP
#define __MMX__VECTOR_NAIVE__HPP
#include <basix/operators.hpp>


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

/******************************************************************************
* Naive variant for vectors
******************************************************************************/

struct vector_naive {
  typedef vector_naive Naive;      // Naive variant
  typedef vector_naive Aligned;    // Vectors which are assumed to be aligned
  typedef vector_naive No_simd;    // Variant without SIMD instructions
  typedef vector_naive No_thread;  // Variant without threads
};

/* NOTE: defined in basix.hpp
template<typename C>
struct vector_variant_helper {
  typedef vector_naive VV;
};
*/

/******************************************************************************
* Vector defaults
******************************************************************************/

struct vector_defaults {};

template<typename V>
struct implementation<vector_defaults,V,vector_naive> {
  static const nat def_len = 0;
  static const nat init_len= 1;
}; // implementation<vector_defaults,V,vector_naive>

/******************************************************************************
* Memory allocation
******************************************************************************/

struct vector_allocate {};

template<typename V>
struct implementation<vector_allocate,V,vector_naive>:
  public implementation<vector_defaults,V>
{
  TMPL static inline nat
  vec_aligned_size (nat n) {
    return n;
  }
}; // implementation<vector_allocate,V,vector_naive>

template<typename C, typename V> inline nat
aligned_size (nat n) {
  typedef implementation<vector_allocate,V> Vec;
  return Vec::template vec_aligned_size<C> (n);
}

template<typename C> inline nat
default_aligned_size (nat n) {
  typedef typename vector_variant_helper<C>::VV V;
  typedef implementation<vector_allocate,V> Vec;
  return aligned_size<C,V> (n);
}

/******************************************************************************
* Abstract low level vector routines on vectors in memory
******************************************************************************/

struct vector_abstractions {};

template<typename V>
struct implementation<vector_abstractions,V,vector_naive>:
  public implementation<vector_allocate,V>
{

template<typename Op, typename T> static inline void
vec_nullary (T* dest, nat n) {
  for (; n != 0; dest++, n--)
    Op::set_op (*dest);
}

template<typename Op, typename T, typename C> static inline void
vec_unary (T* dest, const C* s, nat n) {
  for (; n != 0; dest++, s++, n--)
    Op::set_op (*dest, *s);
}

template<typename Op, typename T, typename C1, typename C2> static inline void
vec_binary (T* dest, const C1* s1, const C2* s2, nat n) {
  for (; n != 0; dest++, s1++, s2++, n--)
    Op::set_op (*dest, *s1, *s2);
}

template<typename Op, typename T, typename X> static inline void
vec_unary_scalar (T* dest, const X& x, nat n) {
  for (; n != 0; dest++, n--)
    Op::set_op (*dest, x);
}

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) {
  for (; n != 0; dest++, s++, n--)
    Op::set_op (*dest, *s, x);
}

template<typename Op, typename T, typename C1, typename C2, typename X>
static inline void
vec_ternary_scalar (T* dest, const C1* s1, const C1* s2, const X& x, nat n) {
  for (; n != 0; dest++, s1++, s2++, n--)
    Op::set_op (*dest, *s1, *s2, x);
}

template<typename Op, typename C> static inline bool
vec_unary_test (const C* s, nat n) {
  for (; n != 0; s++, n--)
    if (Op::not_op (*s)) return false;
  return true;
}

template<typename Op, typename C1, typename C2> static inline bool
vec_binary_test (const C1* s1, const C2* s2, nat n) {
  for (; n != 0; s1++, s2++, n--)
    if (Op::not_op (*s1, *s2)) return false;
  return true;
}

template<typename Op, typename C, typename X> static inline bool
vec_binary_test_scalar (const C* s, const X& x, nat n) {
  for (; n != 0; s++, n--)
    if (Op::not_op (*s, x)) return false;
  return true;
}

template<typename Op, typename C> static inline Unary_return_type(Op,C)
vec_unary_big (const C* s, nat n) {
  typedef Unary_return_type(Op,C) R;
  R r= Op::template neutral<R> ();
  for (; n != 0; s++, n--)
    Op::set_op (r, *s);
  return r;
}

template<typename Op, typename C> static inline Unary_return_type(Op,C)
vec_unary_big (const C* s, nat n, const format<C>& fm) {
  typedef Unary_return_type(Op,C) R;
  R r= get_sample (unary_map<Op> (fm));
  Op::set_neutral (r);
  for (; n != 0; s++, n--)
    Op::set_op (r, *s);
  return r;
}

template<typename Op, typename C1, typename C2> static inline C1
vec_binary_big (const C1* s1, const C2* s2, nat n) {
  C1 r= Op::template neutral<C1> ();
  for (; n != 0; s1++, s2++, n--)
    Op::set_op (r, *s1, *s2);
  return r;
}

template<typename Op, typename C1, typename C2> static inline C1
vec_binary_big (const C1* s1, const C2* s2, nat n,
                const format<C1>& fm1, const format<C2>& fm2) {
  C1 r= get_sample (binary_map<Op> (fm1, fm2));
  Op::set_neutral (r);
  for (; n != 0; s1++, s2++, n--)
    Op::set_op (r, *s1, *s2);
  return r;
}

template<typename Op, typename C> static C
vec_unary_big_dicho (const C* s, nat n) {
  switch (n) {
  case 0: return Op::template neutral<C> ();
  case 1: return s[0];
  case 2: return Op::op (s[0], s[1]);
  case 3: return Op::op (s[0], Op::op (s[1], s[2]));
  case 4: return Op::op (Op::op (s[0], s[1]), Op::op (s[2], s[3]));
  default: return Op::op (vec_unary_big_dicho<Op> (s, n>>1),
                          vec_unary_big_dicho<Op> (s + (n>>1), n - (n>>1)));
  }
}

template<typename Op, typename C> static inline C
vec_unary_big_dicho (const C* s, nat n, const format<C>& fm) {
  if (n != 0) return vec_unary_big_dicho (s, n);
  else {
    C r= get_sample (unary_map<Op> (fm));
    Op::set_neutral (r);
    return r;
  }
}

}; // implementation<vector_abstractions,V,vector_naive>

/******************************************************************************
* Abstract low level vector routines on vectors with stride
******************************************************************************/

struct vector_abstractions_stride {};

template<typename V>
struct implementation<vector_abstractions_stride,V,vector_naive>:
  public implementation<vector_abstractions,V>
{

template<typename Op, typename T> static inline void
vec_nullary_stride (T* dest, nat dest_stride, nat n) {
  for (; n != 0; dest += dest_stride, n--)
    Op::set_op (*dest);
}

template<typename Op, typename T, typename C> static inline void
vec_unary_stride (T* dest, nat dest_stride, const C* s, nat s_stride, nat n) {
  for (; n != 0; dest += dest_stride, s += s_stride, n--)
    Op::set_op (*dest, *s);
}

template<typename Op, typename T, typename C1, typename C2> static inline void
vec_binary_stride (T* dest, nat dest_stride, const C1* s1, nat s1_stride,
                   const C2* s2, nat s2_stride, nat n) {
  for (; n != 0; dest += dest_stride, s1 += s1_stride, s2 += s2_stride, n--)
    Op::set_op (*dest, *s1, *s2);
}

template<typename Op, typename T, typename X> static inline void
vec_unary_scalar_stride (T* dest, nat dest_stride, const X& x, nat n) {
  for (; n != 0; dest += dest_stride, n--)
    Op::set_op (*dest, x);
}

template<typename Op, typename T, typename C, typename X> static inline void
vec_binary_scalar_stride (T* dest, nat dest_stride, const C* s, nat s_stride,
                          const X& x, nat n) {
  for (; n != 0; dest += dest_stride, s += s_stride, n--)
    Op::set_op (*dest, *s, x);
}

template<typename Op, typename C1, typename C2> static inline void
vec_binary_combine_stride (C1* d1, nat d1_stride,
                           C2* d2, nat d2_stride, nat n) {
  for (; n != 0; d1 += d1_stride, d2 += d2_stride, n--)
    Op::set_op (*d1, *d2);
}

template<typename Op, typename C> static inline bool
vec_unary_test_stride (const C* s, nat s_stride, nat n) {
  for (; n != 0; s += s_stride, n--)
    if (Op::not_op (*s)) return false;
  return true;
}

template<typename Op, typename C1, typename C2> static inline bool
vec_binary_test_stride (const C1* s1, nat s1_stride,
                        const C2* s2, nat s2_stride, nat n) {
  for (; n != 0; s1 += s1_stride, s2 += s2_stride, n--)
    if (Op::not_op (*s1, *s2)) return false;
  return true;
}

template<typename Op, typename C, typename X> static inline bool
vec_binary_test_scalar_stride (const C* s, nat s_stride, const X& x, nat n) {
  for (; n != 0; s += s_stride, n--)
    if (Op::not_op (*s, x)) return false;
  return true;
}

template<typename Op, typename C> static inline C
vec_unary_big_stride (const C* s, nat s_stride, nat n) {
  if (n == 0) return Op::template neutral<C> ();
  C r= *s;
  for (s += s_stride, n--; n != 0; s += s_stride, n--)
    Op::set_op (r, *s);
  return r;
}

template<typename Op, typename C1, typename C2> static inline C1
vec_binary_big_stride (const C1* s1, nat p1, const C2* s2, nat p2, nat n) {
  C1 r; Op::set_neutral (r); //= Op::template neutral<C1> ();
  for (; n != 0; s1 += p1, s2 += p2, n--)
    Op::set_op (r, *s1, *s2);
  return r;
}

template<typename Op, typename C> static C
vec_unary_big_dicho_stride (const C* s, nat p, nat n) {
  switch (n) {
  case 0: return Op::template neutral<C> ();
  case 1: return s[0];
  case 2: return Op::op (s[0], s[p]);
  case 3: return Op::op (s[0], Op::op (s[p], s[p+p]));
  case 4: return Op::op (Op::op (s[0], s[p]), Op::op (s[p+p], s[p+p+p]));
  default:
    return Op::op (vec_unary_big_dicho_stride<Op> (s, p, n>>1),
                   vec_unary_big_dicho_stride<Op> (s + (n>>1), p, n - (n>>1)));
  }
}

}; // implementation<vector_abstractions_stride,V,vector_naive>

/******************************************************************************
* Instantiations
******************************************************************************/

struct vector_linear {};

template<typename V>
struct implementation<vector_linear,V,vector_naive>:
  public implementation<vector_abstractions_stride,V>
{
  typedef implementation<vector_abstractions_stride,V> Vec;

TMPLX static inline void set (C* dest, const X& c, nat n) {
  Vec::template vec_unary_scalar<id_op> (dest, c, n); }
TMPLX static inline void set_as (C* dest, const X& c, nat n) {
  Vec::template vec_unary_scalar<as_op> (dest, c, n); }
TMPL static inline void clear (C* dest, nat n) {
  set_as (dest, (int) 0, n); }
TMPL static inline void copy (C* dest, const C* s, nat n) {
  Vec::template vec_unary<id_op> (dest, s, n); }
TMPLX static inline void cast (C* dest, const X* s, nat n) {
  Vec::template vec_unary<as_op> (dest, s, n); }
TMPL static inline void neg (C* dest, const C* s, nat n) {
  Vec::template vec_unary<neg_op> (dest, s, n); }
TMPL static inline void neg (C* dest, nat n) {
  Vec::template vec_nullary<neg_op> (dest, n); }
TMPL static inline void add (C* dest, const C* s1, const C* s2, nat n) {
  Vec::template vec_binary<add_op> (dest, s1, s2, n); }
TMPL static inline void sub (C* dest, const C* s1, const C* s2, nat n) {
  Vec::template vec_binary<sub_op> (dest, s1, s2, n); }
TMPL static inline void mul (C* dest, const C* s1, const C* s2, nat n) {
  Vec::template vec_binary<mul_op> (dest, s1, s2, n); }
TMPL static inline void div (C* dest, const C* s1, const C* s2, nat n) {
  Vec::template vec_binary<div_op> (dest, s1, s2, n); }
TMPL static inline void mul (C* dest, const C* s, const C& c, nat n) {
  Vec::template vec_binary_scalar<mul_op> (dest, s, c, n); }
TMPL static inline void div (C* dest, const C* s, const C& c, nat n) {
  Vec::template vec_binary_scalar<div_op> (dest, s, c, n); }
TMPL static inline void quo (C* dest, const C* s, const C& c, nat n) {
  Vec::template vec_binary_scalar<quo_op> (dest, s, c, n); }
TMPL static inline void rem (C* dest, const C* s, const C& c, nat n) {
  Vec::template vec_binary_scalar<rem_op> (dest, s, c, n); }
TMPL static inline void add (C* dest, const C* s, nat n) {
  Vec::template vec_unary<add_op> (dest, s, n); }
TMPL static inline void sub (C* dest, const C* s, nat n) {
  Vec::template vec_unary<sub_op> (dest, s, n); }
TMPL static inline void mul (C* dest, const C* s, nat n) {
  Vec::template vec_unary<mul_op> (dest, s, n); }
TMPL static inline void div (C* dest, const C* s, nat n) {
  Vec::template vec_unary<div_op> (dest, s, n); }
TMPL static inline void mul (C* dest, const C& c, nat n) {
  Vec::template vec_unary_scalar<mul_op> (dest, c, n); }
TMPL static inline void div (C* dest, const C& c, nat n) {
  Vec::template vec_unary_scalar<div_op> (dest, c, n); }
TMPL static inline void quo (C* dest, const C& c, nat n) {
  Vec::template vec_unary_scalar<quo_op> (dest, c, n); }
TMPL static inline void rem (C* dest, const C& c, nat n) {
  Vec::template vec_unary_scalar<rem_op> (dest, c, n); }
TMPL static inline void mul_add (C* dest, const C* s1, const C* s2, nat n) {
  Vec::template vec_binary<mul_add_op> (dest, s1, s2, n); }
TMPLX static inline void mul_add (C* dest, const C* s, const X& c, nat n) {
  Vec::template vec_binary_scalar<rmul_add_op> (dest, s, c, n); }
TMPLX static inline void mul_add (C* dest, const X& c, const C* s, nat n) {
  Vec::template vec_binary_scalar<lmul_add_op> (dest, s, c, n); }
TMPL static inline C inn_prod (const C* s1, const C* s2, nat n) {
  return Vec::template vec_binary_big<mul_add_op> (s1, s2, n); }
TMPL static inline C inn_prod (const C* s1, const C* s2, nat n,
                               const format<C>& fm) {
  return Vec::template vec_binary_big<mul_add_op> (s1, s2, n, fm, fm); }
TMPL static inline bool equal (const C* s1, const C* s2, nat n) {
  return Vec::template vec_binary_test<equal_op> (s1, s2, n); }
TMPL static inline bool lesseq (const C* s1, const C* s2, nat n) {
  return Vec::template vec_binary_test<lesseq_op> (s1, s2, n); }
TMPL static inline bool gtreq (const C* s1, const C* s2, nat n) {
  return Vec::template vec_binary_test<gtreq_op> (s1, s2, n); }
TMPL static inline bool equal (const C* s, const C& c, nat n) {
  return Vec::template vec_binary_test_scalar<equal_op> (s, c, n); }
TMPL static inline bool lesseq (const C* s, const C& c, nat n) {
  return Vec::template vec_binary_test_scalar<lesseq_op> (s, c, n); }
TMPL static inline bool gtreq (const C* s, const C& c, nat n) {
  return Vec::template vec_binary_test_scalar<gtreq_op> (s, c, n); }
TMPL static inline bool exact_eq (const C* s1, const C* s2, nat n) {
  return Vec::template vec_binary_test<exact_eq_op> (s1, s2, n); }
TMPL static inline bool exact_eq (const C* s, const C& c, nat n) {
  return Vec::template vec_binary_test_scalar<exact_eq_op> (s, c, n); }

TMPL static inline void half_copy (C* dest, const C* s, nat l) {
  Vec::template vec_unary_stride<id_op> (dest, 1, s, 2, l); }
TMPL static inline void double_copy (C* dest, const C* s, nat l) {
  Vec::template vec_unary_stride<id_op> (dest, 2, s, 1, l); }
TMPL static inline void double_add (C* dest, const C* s, nat l) {
  Vec::template vec_unary_stride<add_op> (dest, 2, s, 1, l); }
TMPL static inline void triple_copy (C* dest, const C* s, nat l) {
  Vec::template vec_unary_stride<id_op> (dest, 3, s, 1, l); }

TMPL static inline void
vec_reverse (C* dest, const C* src, nat n) {
  dest += n-1;
  for (; n != 0; dest--, src++, n--) *dest= *src;
}

TMPL static inline void
vec_reverse (C* dest, nat ds, const C* src, nat ss, nat n) {
  dest += (n-1) * ds;
  for (; n != 0; dest -= ds, src += ss, n--) *dest= *src;
}

TMPL static inline void
vec_reverse (C* dest, nat n) {
  nat h= n >> 1;
  C* rev= dest + n - 1;
  C tmp;
  for (; h != 0; dest++, rev--, h--) {
    tmp  = *dest;
    *dest= *rev;
    *rev = tmp;
  }
}

TMPL static inline void
vec_reverse (C* dest, nat stride, nat n) {
  nat h= n >> 1;
  C* rev= dest + (n - 1) * stride;
  C tmp;
  for (; h != 0; dest += stride, rev -= stride, h--) {
    tmp  = *dest;
    *dest= *rev;
    *rev = tmp;
  }
}

TMPL static inline void
print (const port& out, const C* s, nat n) {
  if (n == 0) out << "[]";
  else {
    out << "[ " << s[0];
    for (nat i=1; i<n; i++)
      out << ", " << s[i];
    out << " ]";
  }
}

}; // implementation<vector_linear,V,vector_naive>

#undef TMPL
#undef TMPLX
} // namespace mmx
#endif //__MMX__VECTOR_NAIVE__HPP

---