RKSmallVector.h

Go to the documentation of this file.

#ifndef RKSmallVector_H
#define RKSmallVector_H

#include "FWCore/Utilities/interface/Visibility.h"
#include "DataFormats/GeometryVector/interface/PreciseFloatType.h"

#include <iostream>

template<typename T, int N> 
class dso_internal RKSmallVector {
public:
  typedef T                                   Scalar;

  RKSmallVector() {}

  RKSmallVector( const Scalar* d) {
    for (int i=0; i<N; ++i) data_[i] = d[i];
  }

  template <class Iter> RKSmallVector(Iter begin, Iter end) {
    for (int i=0; i<N; i++) data_[i] = *begin++;
  }

  int size() const {return N;}
  int dim() const {return N;}

  const T& operator()(int i) const {return data_[i];}
  T& operator()(int i) {return data_[i];}
  const T& operator[](int i) const {return data_[i];}
  T& operator[](int i) {return data_[i];}


  template <class U> 
  RKSmallVector& operator+= ( const RKSmallVector<U,N>& v) {
    for (int i=0; i<N; ++i) data_[i] += v[i];
    return *this;
  } 

  template <class U> 
  RKSmallVector& operator-= ( const RKSmallVector<U,N>& v) {
    for (int i=0; i<N; ++i) data_[i] -= v[i];
    return *this;
  } 

  template <class U> 
  RKSmallVector& increment( const RKSmallVector<U,N>& v, const T& t) {
    for (int i=0; i<N; ++i) data_[i] += t*v[i];
    return *this;
  } 


  RKSmallVector operator-() const { 
    RKSmallVector r;
    for (int i=0; i<N; ++i) r[i] = -data_[i];
    return r;
  }

  RKSmallVector& operator*= ( const T& t) {
    for (int i=0; i<N; ++i) data_[i] *= t;
    return *this;
  }
  RKSmallVector& operator/= ( const T& t) {
    for (int i=0; i<N; ++i) data_[i] /= t;
    return *this;
  }

  T dot( const RKSmallVector& v) const {
    RKSmallVector r;
    for (int i=0; i<N; ++i) r[i] = data_[i]*data_[i];
    return r;
  }

private:

  Scalar data_[N];

};

template <class T, int N>
inline std::ostream & operator<<( std::ostream& s, const RKSmallVector<T,N>& v) {
  s << std::endl;
  for (int i=0; i<N; ++i) s << "v[" << i << "] = " << v[i] << std::endl;
  return s;
} 

template <class T, class U, int N>
inline RKSmallVector<typename PreciseFloatType<T,U>::Type, N>
operator+( const RKSmallVector<T, N>& a, const RKSmallVector<U, N>& b) {
  typedef RKSmallVector<typename PreciseFloatType<T,U>::Type, N> RT;
  RT r;
  for (int i=0; i<N; ++i) r[i] = a[i]+b[i];
  return r;
}
template <class T, class U, int N>
inline RKSmallVector<typename PreciseFloatType<T,U>::Type, N>
operator-( const RKSmallVector<T, N>& a, const RKSmallVector<U, N>& b) {
  typedef RKSmallVector<typename PreciseFloatType<T,U>::Type, N> RT;
  RT r;
  for (int i=0; i<N; ++i) r[i] = a[i]-b[i];
  return r;
}

template <class T, class Scal, int N>
inline RKSmallVector<T,N> operator*( const RKSmallVector<T,N>& v, const Scal& s) {
  T t = static_cast<T>(s);
  RKSmallVector<T,N> r;
  for (int i=0; i<N; ++i) r[i] = t*v[i];
  return r;
}
template <class T, class Scal, int N>
inline RKSmallVector<T,N> operator*( const Scal& s, const RKSmallVector<T,N>& v) {
  T t = static_cast<T>(s);
  RKSmallVector<T,N> r;
  for (int i=0; i<N; ++i) r[i] = t*v[i];
  return r;
}

template <class T, class Scal, int N>
inline RKSmallVector<T,N> operator/( const RKSmallVector<T,N>& v, const Scal& s) {
  T t = static_cast<T>(s);
  RKSmallVector<T,N> r;
  for (int i=0; i<N; ++i) r[i] = v[i]/t;
  return r;
}


#endif