PSEUDO_F64vec1.h

Go to the documentation of this file.

#ifndef L1Algo_PSEUDO_F64vec1_H
#define L1Algo_PSEUDO_F64vec1_H
 
#include "vec_arithmetic.h"
 
#include <cmath>
#include <iostream>
 
/**********************************
 *
 *   Vector of four doubles
 *
 **********************************/
 
class F64vec1
{
  public:
    double v[1];
 
    double& operator[](int i) { return ((double*)&v)[i]; }
    double operator[](int i) const { return ((double*)&v)[i]; }
 
    F64vec1() {}
    F64vec1(const F64vec1& a) { v[0] = a.v[0]; }
    F64vec1(const double& a) { v[0] = a; }
 
    friend double min(double x, double y) { return x < y ? x : y; }
    friend double max(double x, double y) { return x < y ? y : x; }
    friend double asgnb(double x, double y) { return y >= 0 ? fabs(x) : -fabs(x); }
    friend double rsqrt(double x) { return 1. / sqrt(x); }
    friend double rcp(double x) { return 1. / x; }
    friend double sgn(double x) { return x >= 0 ? 1 : -1; }
 
#define _f2(A, B, F)            \
    F64vec1 z;                  \
    z.v[0] = F(A.v[0], B.v[0]); \
    return z;
#define _f1(A, F)       \
    F64vec1 z;          \
    z.v[0] = F(A.v[0]); \
    return z;
#define _op(A, B, O)          \
    F64vec1 z;                \
    z.v[0] = A.v[0] O B.v[0]; \
    return z;
 
    /* Arithmetic Operators */
    friend F64vec1 operator+(const F64vec1& a, const F64vec1& b) { _op(a, b, +) }
    friend F64vec1 operator-(const F64vec1& a, const F64vec1& b) { _op(a, b, -) }
    friend F64vec1 operator*(const F64vec1& a, const F64vec1& b) { _op(a, b, *) }
    friend F64vec1 operator/(const F64vec1& a, const F64vec1& b) { _op(a, b, /) }
 
    /* Functions */
    friend F64vec1 min(const F64vec1& a, const F64vec1& b) { _f2(a, b, min) }
    friend F64vec1 max(const F64vec1& a, const F64vec1& b) { _f2(a, b, max) }
    friend F64vec1 asgnb(const F64vec1& a, const F64vec1& b) { _f2(a, b, asgnb) }
    friend F64vec1 sqrt(const F64vec1& a) { _f1(a, sqrt) }
    friend F64vec1 rsqrt(const F64vec1& a) { _f1(a, rsqrt) }
    friend F64vec1 rcp(const F64vec1& a) { _f1(a, rcp) }
    friend F64vec1 fabs(const F64vec1& a) { _f1(a, fabs) }
    friend F64vec1 sgn(const F64vec1& a) { _f1(a, sgn) }
    friend F64vec1 exp(const F64vec1& a) { _f1(a, exp) }
    friend F64vec1 log(const F64vec1& a) { _f1(a, log) }
    friend F64vec1 sin(const F64vec1& a) { _f1(a, sin) }
    friend F64vec1 cos(const F64vec1& a){_f1(a, cos)}
#undef _f1
#undef _f2
#undef _op
 
    /* Define all operators for consistensy */
 
    vec_arithmetic(F64vec1, double);
 
    friend std::ostream& operator<<(std::ostream& strm, const F64vec1& a)
    {
        strm << a[0];
        return strm;
    }
 
    friend std::istream& operator>>(std::istream& strm, F64vec1& a)
    {
        double tmp;
        strm >> tmp;
        a = tmp;
        return strm;
    }
 
};   // __attribute__ ((aligned(16)));;
 
typedef F64vec1 fvec;
const int fvecLen = 1;
typedef double fscal;
 
// #define fvec_true  _f32vec1_true
// #define fvec_false _f32vec1_false
#define _fvecalignment
 
#endif