| /* ----------------------------------------------------------------------- *//** |
| * |
| * @file Vector_const.hpp |
| * |
| * @brief MADlib immutable vector class -- a thin wrapper around arma::Col or arma::Row |
| * |
| *//* ----------------------------------------------------------------------- */ |
| |
| /** |
| * @brief MADlib immutable vector class -- a thin wrapper around arma::Col or arma::Row |
| * |
| * @internal Unfortunately, we have some code duplication from Vector.hpp. Also, |
| * we need to define a proxy for all const operators and methods of |
| * arma::Col and arma::Row. This includes, e.g., operator(), operator[] and |
| * a few others. |
| */ |
| template<template <class> class T, typename eT> |
| class Vector_const : public arma::Base< eT, Vector_const<T, eT> > { |
| friend class arma::unwrap< Vector_const<T,eT> >; |
| friend class arma::Proxy< Vector_const<T,eT> >; |
| |
| public: |
| typedef eT elem_type; |
| |
| inline Vector_const( |
| AllocatorSPtr inAllocator, |
| const uint32_t inNumElem) |
| : mMemoryHandle( |
| inAllocator->allocateArray( |
| inNumElem, |
| static_cast<eT*>(NULL) /* pure type parameter */)), |
| mVector( |
| mMemoryHandle->ptr(), |
| inNumElem, |
| false /* copy_aux_mem */, |
| true /* strict */), |
| n_rows(mVector.n_rows), |
| n_cols(mVector.n_cols), |
| n_elem(mVector.n_elem) |
| { } |
| |
| inline Vector_const( |
| const MemHandleSPtr inHandle, |
| const uint32_t inNumElem) |
| : mMemoryHandle(inHandle), |
| mVector( |
| static_cast<eT*>(mMemoryHandle->ptr()), |
| inNumElem, |
| false /* copy_aux_mem */, |
| true /* strict */), |
| n_rows(mVector.n_rows), |
| n_cols(mVector.n_cols), |
| n_elem(mVector.n_elem) |
| { } |
| |
| inline Vector_const( |
| const Vector<T, eT> &inVec) |
| : mMemoryHandle( |
| AbstractHandle::cloneIfNotGlobal(inVec.mMemoryHandle)), |
| mVector( |
| const_cast<eT*>(mMemoryHandle->ptr()), |
| inVec.n_elem, |
| false /* copy_aux_mem */, |
| true /* strict */), |
| n_rows(mVector.n_rows), |
| n_cols(mVector.n_cols), |
| n_elem(mVector.n_elem) |
| { } |
| |
| inline Vector_const( |
| const Array<eT> &inArray) |
| : mMemoryHandle( |
| AbstractHandle::cloneIfNotGlobal(inArray.memoryHandle())), |
| mVector( |
| static_cast<eT*>(mMemoryHandle->ptr()), |
| inArray.size(), |
| false /* copy_aux_mem */, |
| true /* strict */), |
| n_rows(mVector.n_rows), |
| n_cols(mVector.n_cols), |
| n_elem(mVector.n_elem) |
| { } |
| |
| inline Vector_const( |
| const Array_const<eT> &inArray) |
| : mMemoryHandle( |
| AbstractHandle::cloneIfNotGlobal(inArray.memoryHandle())), |
| mVector( |
| static_cast<eT*>(mMemoryHandle->ptr()), |
| inArray.size(), |
| false /* copy_aux_mem */, |
| true /* strict */), |
| n_rows(mVector.n_rows), |
| n_cols(mVector.n_cols), |
| n_elem(mVector.n_elem) |
| { } |
| |
| inline operator const T<eT>&() const { |
| return mVector; |
| } |
| |
| /** |
| * @internal This function accesses internal elements of arma::mat. |
| * While these elements are all declared as public, this is not |
| * entirely clean. |
| */ |
| inline Vector_const &rebind(const MemHandleSPtr inHandle, |
| const uint32_t inNumElem) { |
| |
| using arma::access; |
| using arma::Mat; |
| |
| // Unfortunately, C++ does not allow to partially specialize a member |
| // function. (We would need to partially specialize the whole class |
| // template.) For that reason, we use boost::is_same to do the check |
| // at compile time instead of execution time. |
| if (boost::is_same<T<eT>, arma::Col<eT> >::value) |
| access::rw(mVector.n_rows) = inNumElem; |
| else |
| access::rw(mVector.n_cols) = inNumElem; |
| |
| access::rw(mVector.n_elem) = inNumElem; |
| access::rw(mVector.mem) = static_cast<eT*>(inHandle->ptr()); |
| mMemoryHandle = inHandle; |
| return *this; |
| } |
| |
| inline bool is_finite() const { |
| return mVector.is_finite(); |
| } |
| |
| inline MemHandleSPtr memoryHandle() const { |
| return mMemoryHandle; |
| } |
| |
| protected: |
| MemHandleSPtr mMemoryHandle; |
| const T<eT> mVector; |
| |
| public: |
| const arma::u32 &n_rows; //!< number of rows in the matrix (read-only) |
| const arma::u32 &n_cols; //!< number of columns in the matrix (read-only) |
| const arma::u32 &n_elem; |
| }; |