Warning, /include/Geant4/tools/lina/vec4 is written in an unsupported language. File is not indexed.
0001 // Copyright (C) 2010, Guy Barrand. All rights reserved.
0002 // See the file tools.license for terms.
0003
0004 #ifndef tools_vec4
0005 #define tools_vec4
0006
0007 #include <cstddef> //size_t
0008
0009 #ifdef TOOLS_MEM
0010 #include "../mem"
0011 #endif
0012
0013 namespace tools {
0014
0015 template <class T>
0016 class vec4 {
0017 #ifdef TOOLS_MEM
0018 public:
0019 static const std::string& s_class() {
0020 static const std::string s_v("tools::vec4");
0021 return s_v;
0022 }
0023 #endif
0024 protected:
0025 static T zero() {return T();}
0026 static T minus_one() {return T(-1);}
0027 public:
0028 typedef T elem_t;
0029 unsigned int dimension() const {return 4;}
0030 public:
0031 vec4(){
0032 #ifdef TOOLS_MEM
0033 mem::increment(s_class().c_str());
0034 #endif
0035 m_data[0] = T();
0036 m_data[1] = T();
0037 m_data[2] = T();
0038 m_data[3] = T();
0039 }
0040 vec4(const T a_vec[4]) {
0041 #ifdef TOOLS_MEM
0042 mem::increment(s_class().c_str());
0043 #endif
0044 m_data[0] = a_vec[0];
0045 m_data[1] = a_vec[1];
0046 m_data[2] = a_vec[2];
0047 m_data[3] = a_vec[3];
0048 }
0049 vec4(const T& a0,const T& a1,const T& a2,const T& a3
0050 #ifdef TOOLS_MEM
0051 ,bool a_inc = true
0052 #endif
0053 ) {
0054 #ifdef TOOLS_MEM
0055 if(a_inc) mem::increment(s_class().c_str());
0056 #endif
0057 m_data[0] = a0;
0058 m_data[1] = a1;
0059 m_data[2] = a2;
0060 m_data[3] = a3;
0061 }
0062 virtual ~vec4() {
0063 #ifdef TOOLS_MEM
0064 mem::decrement(s_class().c_str());
0065 #endif
0066 }
0067 public:
0068 vec4(const vec4& a_from){
0069 #ifdef TOOLS_MEM
0070 mem::increment(s_class().c_str());
0071 #endif
0072 m_data[0] = a_from.m_data[0];
0073 m_data[1] = a_from.m_data[1];
0074 m_data[2] = a_from.m_data[2];
0075 m_data[3] = a_from.m_data[3];
0076 }
0077 vec4& operator=(const vec4& a_from) {
0078 m_data[0] = a_from.m_data[0];
0079 m_data[1] = a_from.m_data[1];
0080 m_data[2] = a_from.m_data[2];
0081 m_data[3] = a_from.m_data[3];
0082 return *this;
0083 }
0084 public:
0085 const T& v0() const { return m_data[0];}
0086 const T& v1() const { return m_data[1];}
0087 const T& v2() const { return m_data[2];}
0088 const T& v3() const { return m_data[3];}
0089
0090 void v0(const T& a_value) { m_data[0] = a_value;}
0091 void v1(const T& a_value) { m_data[1] = a_value;}
0092 void v2(const T& a_value) { m_data[2] = a_value;}
0093 void v3(const T& a_value) { m_data[3] = a_value;}
0094
0095 const T& x() const { return m_data[0];}
0096 const T& y() const { return m_data[1];}
0097 const T& z() const { return m_data[2];}
0098 const T& t() const { return m_data[3];}
0099
0100 void set_value(const T& a0,const T& a1,const T& a2,const T& a3) {
0101 m_data[0] = a0;
0102 m_data[1] = a1;
0103 m_data[2] = a2;
0104 m_data[3] = a3;
0105 }
0106 void set_value(const T aV[4]) {
0107 m_data[0] = aV[0];
0108 m_data[1] = aV[1];
0109 m_data[2] = aV[2];
0110 m_data[3] = aV[3];
0111 }
0112 void value(T& a0,T& a1,T& a2,T& a3) const {
0113 a0 = m_data[0];
0114 a1 = m_data[1];
0115 a2 = m_data[2];
0116 a3 = m_data[3];
0117 }
0118
0119 bool set_value(unsigned int a_index,const T& a_value) {
0120 if(a_index>=4) return false;
0121 m_data[a_index] = a_value;
0122 return true;
0123 }
0124
0125 T length(T(*a_sqrt)(T)) const {
0126 return a_sqrt(m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2]+m_data[3]*m_data[3]);
0127 }
0128
0129 T normalize(T(*a_sqrt)(T)) {
0130 T norme = length(a_sqrt);
0131 if(norme==T()) return T();
0132 divide(norme);
0133 return norme;
0134 }
0135
0136 bool equal(const vec4& a_vec) const {
0137 if(m_data[0]!=a_vec.m_data[0]) return false;
0138 if(m_data[1]!=a_vec.m_data[1]) return false;
0139 if(m_data[2]!=a_vec.m_data[2]) return false;
0140 if(m_data[3]!=a_vec.m_data[3]) return false;
0141 return true;
0142 }
0143 bool equal(const vec4& a_vec,const T& a_epsil) const {
0144 T* tp = (T*)m_data;
0145 T* ap = (T*)a_vec.m_data;
0146 for(unsigned int i=0;i<4;i++,tp++,ap++) {
0147 T diff = (*tp) - (*ap);
0148 if(diff<zero()) diff *= minus_one();
0149 if(diff>=a_epsil) return false;
0150 }
0151 return true;
0152 }
0153
0154 bool is_proportional(const vec4& a_vec,T& a_factor) const {
0155 // If true, then : a_vec = a_factor * this.
0156 a_factor = zero();
0157 bool first = true;
0158 T* tp = (T*)m_data;
0159 T* ap = (T*)a_vec.m_data;
0160 for(unsigned int i=0;i<4;i++,tp++,ap++) {
0161 if( ((*tp)==zero()) && ((*ap)==zero())) {
0162 continue;
0163 } else if( ((*tp)!=zero()) && ((*ap)==zero())) {
0164 return false;
0165 } else if( ((*tp)==zero()) && ((*ap)!=zero())) {
0166 return false;
0167 } else {
0168 if(first) {
0169 a_factor = (*ap)/(*tp);
0170 first = false;
0171 } else {
0172 if((*ap)!=(*tp)*a_factor) return false;
0173 }
0174 }
0175 }
0176 return true;
0177 }
0178
0179 void multiply(const T& a_T) {
0180 m_data[0] *= a_T;
0181 m_data[1] *= a_T;
0182 m_data[2] *= a_T;
0183 m_data[3] *= a_T;
0184 }
0185
0186 bool divide(const T& a_T) {
0187 if(a_T==T()) return false;
0188 m_data[0] /= a_T;
0189 m_data[1] /= a_T;
0190 m_data[2] /= a_T;
0191 m_data[3] /= a_T;
0192 return true;
0193 }
0194
0195 void add(const vec4& a_v) {
0196 m_data[0] += a_v.m_data[0];
0197 m_data[1] += a_v.m_data[1];
0198 m_data[2] += a_v.m_data[2];
0199 m_data[3] += a_v.m_data[3];
0200 }
0201
0202 void add(const T& a0,const T& a1,const T& a2,const T& a3) {
0203 m_data[0] += a0;
0204 m_data[1] += a1;
0205 m_data[2] += a2;
0206 m_data[3] += a3;
0207 }
0208
0209 void subtract(const vec4& a_v) {
0210 m_data[0] -= a_v.m_data[0];
0211 m_data[1] -= a_v.m_data[1];
0212 m_data[2] -= a_v.m_data[2];
0213 m_data[3] -= a_v.m_data[3];
0214 }
0215
0216 void subtract(const T& a0,const T& a1,const T& a2,const T& a3) {
0217 m_data[0] -= a0;
0218 m_data[1] -= a1;
0219 m_data[2] -= a2;
0220 m_data[3] -= a3;
0221 }
0222
0223 public: //operators
0224 T& operator[](size_t a_index) {
0225 //WARNING : no check on a_index.
0226 return m_data[a_index];
0227 }
0228 const T& operator[](size_t a_index) const {
0229 //WARNING : no check on a_index.
0230 return m_data[a_index];
0231 }
0232
0233 vec4 operator+(const vec4& a_v) const {
0234 return vec4(m_data[0]+a_v.m_data[0],
0235 m_data[1]+a_v.m_data[1],
0236 m_data[2]+a_v.m_data[2],
0237 m_data[3]+a_v.m_data[3]);
0238 }
0239
0240 vec4 operator-(const vec4& a_v) const {
0241 return vec4(m_data[0]-a_v.m_data[0],
0242 m_data[1]-a_v.m_data[1],
0243 m_data[2]-a_v.m_data[2],
0244 m_data[3]-a_v.m_data[3]);
0245 }
0246
0247 vec4 operator*(const T& a_v) const {
0248 return vec4(m_data[0]*a_v,
0249 m_data[1]*a_v,
0250 m_data[2]*a_v,
0251 m_data[3]*a_v);
0252 }
0253
0254 bool operator==(const vec4& a_v) const {return equal(a_v);}
0255 bool operator!=(const vec4& a_v) const {return !operator==(a_v);}
0256
0257 public: //for tools/sg/sf_vec
0258 typedef unsigned int size_type;
0259 size_type size() const {return 4;}
0260 const T* data() const {return m_data;}
0261 protected:
0262 T m_data[4];
0263 private:static void check_instantiation() {vec4<float> v;}
0264 };
0265
0266 //for sf, mf :
0267 template <class T>
0268 inline const T* get_data(const vec4<T>& a_v) {return a_v.data();}
0269
0270 }
0271
0272 #include <ostream>
0273
0274 namespace tools {
0275
0276 // for sf_vec::dump().
0277 template <class T>
0278 inline std::ostream& operator<<(std::ostream& a_out,const vec4<T>& a_this){
0279 a_out << "x = " << a_this.v0()
0280 << ",y = " << a_this.v1()
0281 << ",z = " << a_this.v2()
0282 << ",t = " << a_this.v3();
0283 return a_out;
0284 }
0285
0286 }
0287
0288 #endif
