VectorSlice.h

Go to the documentation of this file.

#ifndef VECTORSLICE_H
#define VECTORSLICE_H
 
#include <vector>
#include <Eigen/Core>
 
namespace muq {
namespace Utilities {
 
    template<typename VecType, typename ScalarType>
    class VectorSlice
    {
    public:
 
      VectorSlice(VectorSlice<VecType, ScalarType> const& vec) : VectorSlice(vec.data, vec.startInd, vec.endInd, vec.skip){};
 
      VectorSlice<VecType, ScalarType>& operator=(VectorSlice<VecType, ScalarType> const& vec){
          data = vec.data;
          startInd = vec.startInd;
          endInd = vec.endInd;
          skip = vec.skip;
          return *this;
      }
 
      VectorSlice(VecType& dataIn,
                  int startIndIn,
                  int endIndIn,
                  int skipIn=1) : data(dataIn),
                                  startInd(startIndIn),
                                  endInd(endIndIn),
                                  skip(skipIn)
      {
        assert(skip!=0);
        assert(startInd>=0);
        assert(endInd>=-1);
        if(skip>0){
          assert(endInd>startInd);
        }else{
          assert(endInd<startInd);
        }
      }
 
      ScalarType& operator()(int i) {
        CheckBounds(i);
        return data[startInd + i*skip];
      }
 
      ScalarType operator()(int i) const {
        CheckBounds(i);
        return data[startInd + i*skip];
      }
 
      ScalarType& operator[](int i) {
        return data[startInd + i*skip];
      }
 
      ScalarType operator[](int i) const {
        return data[startInd + i*skip];
      }
 
      unsigned int size() const{
        return std::ceil( double(std::abs(endInd-startInd)) / double(std::abs(skip)) );
      };
 
 
      VecType& data;
      int startInd, endInd, skip;
 
      void CheckBounds(int i) const {
        if(skip>0){
          assert(startInd + i*skip < endInd);
        }else{
          assert(startInd + i*skip > endInd);
        }
      }
 
    };
 
 
    template<typename ScalarType>
    VectorSlice<std::vector<ScalarType>, ScalarType> GetSlice(std::vector<ScalarType>& dataIn,
                         int                            startIndIn,
                         int                            endIndIn,
                         int                            skipIn=1)
    {
      return VectorSlice<std::vector<ScalarType>,ScalarType>(dataIn, startIndIn, endIndIn, skipIn);
    }
 
    template<typename ScalarType>
    VectorSlice<Eigen::Matrix<ScalarType,Eigen::Dynamic,1>, ScalarType> GetSlice(Eigen::Matrix<ScalarType,Eigen::Dynamic,1>& dataIn,
                         int                                               startIndIn,
                         int                                               endIndIn,
                         int                                               skipIn=1)
    {
      return VectorSlice<Eigen::Matrix<ScalarType,Eigen::Dynamic,1>,ScalarType>(dataIn, startIndIn, endIndIn, skipIn);
    }
 
    template<typename VectorType, typename ScalarType>
    VectorSlice<VectorType, ScalarType> GetSlice(VectorSlice<VectorType, ScalarType>& dataIn,
                         int                                        startIndIn,
                         int                                        endIndIn,
                         int                                        skipIn=1)
    {
        return VectorSlice<VectorType,ScalarType>(dataIn.data,
                                                  dataIn.startInd + dataIn.skip*startIndIn,
                                                  std::max(dataIn.startInd + dataIn.skip*endIndIn,-1),
                                                  dataIn.skip * skipIn);
 
    }
 
}
}
 
 
#endif // #ifndef VECTORSLICE_H