PSEUDO_F32vec4.h

Go to the documentation of this file.

#ifndef L1Algo_PSEUDO_F32vec4_H
#define L1Algo_PSEUDO_F32vec4_H
 
#include "vec_arithmetic.h"
#include <cmath>
#include <iostream>
 
/**********************************
 *
 *   Vector of four floats
 *
 **********************************/
 
 
float min(float x, float y);
float max(float x, float y);
float asgnb(float x, float y);
float rsqrt(float x);
float rcp(float x);
float sgn(float x);
 
class F32vec4 {
 
 
public:
  float v[4];
 
  float& operator[](int i) { return ((float*) &v)[i]; }
  float operator[](int i) const { return ((float*) &v)[i]; }
 
  F32vec4() {}
  F32vec4(const F32vec4& a) {
    v[0] = a.v[0];
    v[1] = a.v[1];
    v[2] = a.v[2];
    v[3] = a.v[3];
  }
  F32vec4(const float& a) {
    v[0] = a;
    v[1] = a;
    v[2] = a;
    v[3] = a;
  }
 
  F32vec4(const float& f0, const float& f1, const float& f2, const float& f3) {
    v[0] = f0;
    v[1] = f1;
    v[2] = f2;
    v[3] = f3;
  }
 
 
#define _f2(A, B, F)                                                           \
  F32vec4 z;                                                                   \
  z.v[0] = F(A.v[0], B.v[0]);                                                  \
  z.v[1] = F(A.v[1], B.v[1]);                                                  \
  z.v[2] = F(A.v[2], B.v[2]);                                                  \
  z.v[3] = F(A.v[3], B.v[3]);                                                  \
  return z;
#define _f1(A, F)                                                              \
  F32vec4 z;                                                                   \
  z.v[0] = F(A.v[0]);                                                          \
  z.v[1] = F(A.v[1]);                                                          \
  z.v[2] = F(A.v[2]);                                                          \
  z.v[3] = F(A.v[3]);                                                          \
  return z;
#define _op(A, B, O)                                                           \
  F32vec4 z;                                                                   \
  z.v[0] = A.v[0] O B.v[0];                                                    \
  z.v[1] = A.v[1] O B.v[1];                                                    \
  z.v[2] = A.v[2] O B.v[2];                                                    \
  z.v[3] = A.v[3] O B.v[3];                                                    \
  return z;
 
  /* Arithmetic Operators */
  friend F32vec4 operator+(const F32vec4& a, const F32vec4& b) { _op(a, b, +) }
  friend F32vec4 operator-(const F32vec4& a, const F32vec4& b) { _op(a, b, -) }
  friend F32vec4 operator*(const F32vec4& a, const F32vec4& b) { _op(a, b, *) }
  friend F32vec4 operator/(const F32vec4& a, const F32vec4& b) { _op(a, b, /) }
 
  /* Comparison */
  friend F32vec4 operator<(const F32vec4& a, const F32vec4& b) { _op(a, b, <) }
  friend F32vec4 operator<=(const F32vec4& a, const F32vec4& b) {
    _op(a, b, <=)
  }
  friend F32vec4 operator>(const F32vec4& a, const F32vec4& b) { _op(a, b, >) }
  friend F32vec4 operator>=(const F32vec4& a, const F32vec4& b) {
    _op(a, b, >=)
  }
 
  /* Logic */
  friend F32vec4 operator&(const F32vec4& a, const F32vec4& b) { _op(a, b, &&) }
  friend F32vec4 operator|(const F32vec4& a, const F32vec4& b) { _op(a, b, ||) }
  friend F32vec4 operator||(const F32vec4& a, const F32vec4& b) {
    _op(a, b, ||)
  }
 
  friend F32vec4 operator!(const F32vec4& a) {
    F32vec4 z;
    z[0] = !a[0];
    z[1] = !a[1];
    z[2] = !a[2];
    z[3] = !a[3];
 
    return z;
  }
 
  friend F32vec4 if3(const F32vec4& a, const F32vec4& b, const F32vec4& c) {
    F32vec4 z;
    z[0] = (a[0]) ? b[0] : c[0];
    z[1] = (a[1]) ? b[1] : c[1];
    z[2] = (a[2]) ? b[2] : c[2];
    z[3] = (a[3]) ? b[3] : c[3];
 
    return z;
  }
 
#define NotEmpty(a) bool((a)[0]) | bool((a)[1]) | bool((a)[2]) | bool((a)[3])
#define Empty(a) !(bool((a)[0]) | bool((a)[1]) | bool((a)[2]) | bool((a)[3]))
  // bool NotEmpty(const F32vec4 &a) { return a[0]||a[1]||a[2]||a[3]; }
  // bool    Empty(const F32vec4 &a) { return !(a[0]||a[1]||a[2]||a[3]); } // optimize
  friend F32vec4 bool2int(const F32vec4& a) {  // mask returned
    return if3(a, 1, 0);
  }
 
 
  /* Functions */
  friend float min(float x, float y) { return x < y ? x : y; }
  friend float max(float x, float y) { return x < y ? y : x; }
  friend float asgnb(float x, float y) { return y >= 0 ? fabs(x) : -fabs(x); }
  friend float rsqrt(float x) { return 1. / sqrt(x); }
  friend float rcp(float x) { return 1. / x; }
  friend float sgn(float x) { return x >= 0 ? 1 : -1; }
 
  friend F32vec4 min(const F32vec4& a, const F32vec4& b) { _f2(a, b, min) }
  friend F32vec4 max(const F32vec4& a, const F32vec4& b) { _f2(a, b, max) }
  friend F32vec4 asgnb(const F32vec4& a, const F32vec4& b) { _f2(a, b, asgnb) }
  friend F32vec4 sqrt(const F32vec4& a) { _f1(a, sqrt) }
  friend F32vec4 rsqrt(const F32vec4& a) { _f1(a, rsqrt) }
  friend F32vec4 rcp(const F32vec4& a) { _f1(a, rcp) }
  friend F32vec4 fabs(const F32vec4& a) { _f1(a, fabs) }
  friend F32vec4 sgn(const F32vec4& a) { _f1(a, sgn) }
  friend F32vec4 exp(const F32vec4& a) { _f1(a, exp) }
  friend F32vec4 log(const F32vec4& a) { _f1(a, log) }
  friend F32vec4 sin(const F32vec4& a) { _f1(a, sin) }
  friend F32vec4 cos(const F32vec4& a) { _f1(a, cos) }
#undef _f1
#undef _f2
#undef _op
 
  /* Define all operators for consistensy */
 
  vec_arithmetic(F32vec4, float);
 
  friend ostream& operator<<(ostream& strm, const F32vec4& a) {
    strm << a[0] << " " << a[1] << " " << a[2] << " " << a[3];
    return strm;
  }
 
  friend istream& operator>>(istream& strm, F32vec4& a) {
    float tmp;
    strm >> tmp;
    a = tmp;
    return strm;
  }
 
} __attribute__((aligned(16)));
;
 
typedef F32vec4 fvec;
typedef float fscal;
const int fvecLen = 4;
//#define fvec_true  _f32vec4_true
//#define fvec_false _f32vec4_false
#define _fvecalignment
 
namespace nsL1 {
  template<typename T>
  struct vector {
    typedef std::vector<T> TStd;
    typedef std::vector<T> TSimd;
  };
 
  typedef nsL1::vector<fvec>::TSimd vector_fvec;
};  // namespace nsL1
 
template<typename T>
struct nsL1vector :
  public nsL1::vector<T>  // just for use std::vector simultaniosly
{};
 
#endif