PSEUDO_F32vec1.h

Go to the documentation of this file.

#ifndef CBM_KF_F32vec1_H
#define CBM_KF_F32vec1_H
 
#include <iostream>
#include <cmath>
 
/**********************************
 *
 *   Vector of one single float
 *
 **********************************/
 
// const union
// {
//     int i[1];
//     float m;
// } 
// __f32vec1_true_cheat     = {0xFFFFFFFF},
// __f32vec1_false_cheat    = {0x00000000};
 
// #define _f32vec1_true     ((F32vec1)__f32vec1_true_cheat.m)
// #define _f32vec1_false    ((F32vec1)__f32vec1_false_cheat.m)
 
class F32vec1 
{
 public:
 
  float v;
 
  float & operator[]( int i ){ return v;}
  float   operator[]( int i ) const { return v;}
 
  F32vec1( ){}
  F32vec1( const float &v0 ){ 
    v = v0;
  }
 
  /* Conversion function */
  operator  float() const { return v; }   /* Convert to __m128 */
 
  /* Arithmetic Operators */
 
  /* Functions */
  //friend F32vec1 min( const F32vec1 &a, const F32vec1 &b ){ return a<b ?a :b; }
  //friend F32vec1 max( const F32vec1 &a, const F32vec1 &b ){ return a>b ?a :b; }
 
  /* Square Root */
 
  /* Reciprocal( inverse) Square Root */
  //friend F32vec1 rsqrt( const F32vec1 &a ){ return 1./sqrt(a); }
 
  /* Reciprocal (inversion) */
  friend F32vec1 rcp  ( const F32vec1 &a ){ return 1./a; }
 
  /* Absolute value */
  //friend F32vec1 fabs(const F32vec1 &a){ return fabs(a); }
 
  /* Sign */
  //friend F32vec1 sgn(const F32vec1 &a){ return a<0 ?-1 :(a>0 ?1 :0); }
 
  /* Logical */
  /*
  friend F32vec1 operator&( const F32vec1 &a, const F32vec1 &b ){ // mask returned
    F32vec1 tmp;
    int *x = (int*)&tmp;
    int *y = (int*)&a;
    int *z = (int*)&b;
    x[0] = y[0] & z[0];
    x[1] = y[1] & z[1];
    return tmp;
  }
  */
  /* Non intrinsic functions */
 
  /* Define all operators for consistensy */
  
  friend void operator+=( F32vec1 &a, const F32vec1 &b ){ a = a + b ; } 
  friend void operator-=( F32vec1 &a, const F32vec1 &b ){ a = a - b ; } 
  friend void operator*=( F32vec1 &a, const F32vec1 &b ){ a = a * b ; } 
  friend void operator/=( F32vec1 &a, const F32vec1 &b ){ a = a / b ; } 
 
#define _op(A,B,O) F32vec1 z; z.v = A.v O B.v; return z; 
  
//   /* Comparison */
  friend F32vec1 operator <(const F32vec1 &a, const F32vec1 &b){ _op(a,b,<) }
  friend F32vec1 operator <=(const F32vec1 &a, const F32vec1 &b){ _op(a,b,<=) }
  friend F32vec1 operator >(const F32vec1 &a, const F32vec1 &b){ _op(a,b,>) }
  friend F32vec1 operator >=(const F32vec1 &a, const F32vec1 &b){ _op(a,b,>=) }
 
//   /* Logic */
  friend F32vec1 operator &(const F32vec1 &a, const F32vec1 &b){ _op(a,b,&&) }
  friend F32vec1 operator |(const F32vec1 &a, const F32vec1 &b){ _op(a,b,||) }
  friend F32vec1 operator ||(const F32vec1 &a, const F32vec1 &b){ _op(a,b,||) }
#undef _op
  
  friend F32vec1 operator !(const F32vec1 &a) {
    F32vec1 z;
    z[0] = !a[0];
 
    return z;
  }
  
  friend F32vec1 if3(const F32vec1 &a, const F32vec1 &b, const F32vec1 &c) {
    F32vec1 z;
    z[0] = (a[0]) ? b[0] : c[0];
 
    return z;
  }
 
#define NotEmpty(a)   bool((a)[0])
#define    Empty(a) !(bool((a)[0]))
  friend F32vec1 bool2int( const F32vec1 &a){ // mask returned
    return if3(a,1,0);
  }
 
 
  
  friend ostream & operator<<(ostream &strm, const F32vec1 &a ){
    strm<<a[0];
    return strm;
  }
 
  friend istream & operator>>(istream &strm, F32vec1 &a ){
    float tmp;
    strm>>tmp;
    a = tmp;
    return strm;
  }
 
} __attribute__ ((aligned(4)));;
 
typedef F32vec1 fvec;
const int fvecLen = 1;
// #define fvec_true  _f32vec1_true
// #define fvec_false _f32vec1_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