Chris@49: // Copyright (C) 2008-2013 NICTA (www.nicta.com.au)
Chris@49: // Copyright (C) 2008-2013 Conrad Sanderson
Chris@49: // 
Chris@49: // This Source Code Form is subject to the terms of the Mozilla Public
Chris@49: // License, v. 2.0. If a copy of the MPL was not distributed with this
Chris@49: // file, You can obtain one at http://mozilla.org/MPL/2.0/.
Chris@49: 
Chris@49: 
Chris@49: //! \addtogroup Cube
Chris@49: //! @{
Chris@49: 
Chris@49: 
Chris@49: 
Chris@49: struct Cube_prealloc
Chris@49:   {
Chris@49:   static const uword mat_ptrs_size = 4;
Chris@49:   static const uword mem_n_elem    = 64;
Chris@49:   };
Chris@49: 
Chris@49: 
Chris@49: 
Chris@49: //! Dense cube class
Chris@49: 
Chris@49: template<typename eT>
Chris@49: class Cube : public BaseCube< eT, Cube<eT> >
Chris@49:   {
Chris@49:   public:
Chris@49:   
Chris@49:   typedef eT                                elem_type; //!< the type of elements stored in the cube
Chris@49:   typedef typename get_pod_type<eT>::result pod_type;  //!< if eT is non-complex, pod_type is same as eT. otherwise, pod_type is the underlying type used by std::complex
Chris@49:   
Chris@49:   const uword  n_rows;       //!< number of rows in each slice (read-only)
Chris@49:   const uword  n_cols;       //!< number of columns in each slice (read-only)
Chris@49:   const uword  n_elem_slice; //!< number of elements in each slice (read-only)
Chris@49:   const uword  n_slices;     //!< number of slices in the cube (read-only)
Chris@49:   const uword  n_elem;       //!< number of elements in the cube (read-only)
Chris@49:   const uword  mem_state;
Chris@49:   
Chris@49:   // mem_state = 0: normal cube that can be resized; 
Chris@49:   // mem_state = 1: use auxiliary memory until change in the number of elements is requested;  
Chris@49:   // mem_state = 2: use auxiliary memory and don't allow the number of elements to be changed; 
Chris@49:   // mem_state = 3: fixed size (e.g. via template based size specification).
Chris@49:   
Chris@49:   
Chris@49:   arma_aligned const Mat<eT>** const mat_ptrs; //!< pointer to an array containing pointers to Mat instances (one for each slice)
Chris@49:   arma_aligned const eT*       const mem;      //!< pointer to the memory used by the cube (memory is read-only)
Chris@49:   
Chris@49:   protected:
Chris@49:   arma_align_mem Mat<eT>* mat_ptrs_local[ Cube_prealloc::mat_ptrs_size ];
Chris@49:   arma_align_mem eT            mem_local[ Cube_prealloc::mem_n_elem    ];
Chris@49:   
Chris@49:   
Chris@49:   public:
Chris@49:   
Chris@49:   inline ~Cube();
Chris@49:   inline  Cube();
Chris@49:   
Chris@49:   inline Cube(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   
Chris@49:   inline Cube(      eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const uword aux_n_slices, const bool copy_aux_mem = true, const bool strict = true);
Chris@49:   inline Cube(const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const uword aux_n_slices);
Chris@49:   
Chris@49:   arma_inline const Cube&  operator=(const eT val);
Chris@49:   arma_inline const Cube& operator+=(const eT val);
Chris@49:   arma_inline const Cube& operator-=(const eT val);
Chris@49:   arma_inline const Cube& operator*=(const eT val);
Chris@49:   arma_inline const Cube& operator/=(const eT val);
Chris@49:   
Chris@49:   inline                   Cube(const Cube& m);
Chris@49:   inline const Cube&  operator=(const Cube& m);
Chris@49:   inline const Cube& operator+=(const Cube& m);
Chris@49:   inline const Cube& operator-=(const Cube& m);
Chris@49:   inline const Cube& operator%=(const Cube& m);
Chris@49:   inline const Cube& operator/=(const Cube& m);
Chris@49:   
Chris@49:   template<typename T1, typename T2>
Chris@49:   inline explicit Cube(const BaseCube<pod_type,T1>& A, const BaseCube<pod_type,T2>& B);
Chris@49:   
Chris@49:   inline                   Cube(const subview_cube<eT>& X);
Chris@49:   inline const Cube&  operator=(const subview_cube<eT>& X);
Chris@49:   inline const Cube& operator+=(const subview_cube<eT>& X);
Chris@49:   inline const Cube& operator-=(const subview_cube<eT>& X);
Chris@49:   inline const Cube& operator%=(const subview_cube<eT>& X);
Chris@49:   inline const Cube& operator/=(const subview_cube<eT>& X);
Chris@49:   
Chris@49:   arma_inline       Mat<eT>& slice(const uword in_slice);
Chris@49:   arma_inline const Mat<eT>& slice(const uword in_slice) const;
Chris@49:   
Chris@49:   arma_inline       subview_cube<eT> slices(const uword in_slice1, const uword in_slice2);
Chris@49:   arma_inline const subview_cube<eT> slices(const uword in_slice1, const uword in_slice2) const;
Chris@49:   
Chris@49:   arma_inline       subview_cube<eT> subcube(const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_row2, const uword in_col2, const uword in_slice2);
Chris@49:   arma_inline const subview_cube<eT> subcube(const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_row2, const uword in_col2, const uword in_slice2) const;
Chris@49:   
Chris@49:   inline            subview_cube<eT> subcube(const span& row_span, const span& col_span, const span& slice_span);
Chris@49:   inline      const subview_cube<eT> subcube(const span& row_span, const span& col_span, const span& slice_span) const;
Chris@49:   
Chris@49:   inline            subview_cube<eT> operator()(const span& row_span, const span& col_span, const span& slice_span);
Chris@49:   inline      const subview_cube<eT> operator()(const span& row_span, const span& col_span, const span& slice_span) const;
Chris@49:   
Chris@49:   
Chris@49:   inline void shed_slice(const uword slice_num);
Chris@49:   
Chris@49:   inline void shed_slices(const uword in_slice1, const uword in_slice2);
Chris@49:   
Chris@49:   inline void insert_slices(const uword slice_num, const uword N, const bool set_to_zero = true);
Chris@49:   
Chris@49:   template<typename T1>
Chris@49:   inline void insert_slices(const uword row_num, const BaseCube<eT,T1>& X);
Chris@49:   
Chris@49:   
Chris@49:   template<typename gen_type> inline                   Cube(const GenCube<eT, gen_type>& X);
Chris@49:   template<typename gen_type> inline const Cube&  operator=(const GenCube<eT, gen_type>& X);
Chris@49:   template<typename gen_type> inline const Cube& operator+=(const GenCube<eT, gen_type>& X);
Chris@49:   template<typename gen_type> inline const Cube& operator-=(const GenCube<eT, gen_type>& X);
Chris@49:   template<typename gen_type> inline const Cube& operator%=(const GenCube<eT, gen_type>& X);
Chris@49:   template<typename gen_type> inline const Cube& operator/=(const GenCube<eT, gen_type>& X);
Chris@49:   
Chris@49:   template<typename T1, typename op_type> inline                   Cube(const OpCube<T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube&  operator=(const OpCube<T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator+=(const OpCube<T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator-=(const OpCube<T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator%=(const OpCube<T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator/=(const OpCube<T1, op_type>& X);
Chris@49:   
Chris@49:   template<typename T1, typename eop_type> inline                   Cube(const eOpCube<T1, eop_type>& X);
Chris@49:   template<typename T1, typename eop_type> inline const Cube&  operator=(const eOpCube<T1, eop_type>& X);
Chris@49:   template<typename T1, typename eop_type> inline const Cube& operator+=(const eOpCube<T1, eop_type>& X);
Chris@49:   template<typename T1, typename eop_type> inline const Cube& operator-=(const eOpCube<T1, eop_type>& X);
Chris@49:   template<typename T1, typename eop_type> inline const Cube& operator%=(const eOpCube<T1, eop_type>& X);
Chris@49:   template<typename T1, typename eop_type> inline const Cube& operator/=(const eOpCube<T1, eop_type>& X);
Chris@49:   
Chris@49:   template<typename T1, typename op_type> inline                   Cube(const mtOpCube<eT, T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube&  operator=(const mtOpCube<eT, T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator+=(const mtOpCube<eT, T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator-=(const mtOpCube<eT, T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator%=(const mtOpCube<eT, T1, op_type>& X);
Chris@49:   template<typename T1, typename op_type> inline const Cube& operator/=(const mtOpCube<eT, T1, op_type>& X);
Chris@49:   
Chris@49:   template<typename T1, typename T2, typename glue_type> inline                   Cube(const GlueCube<T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube&  operator=(const GlueCube<T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator+=(const GlueCube<T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator-=(const GlueCube<T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator%=(const GlueCube<T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator/=(const GlueCube<T1, T2, glue_type>& X);
Chris@49:   
Chris@49:   template<typename T1, typename T2, typename eglue_type> inline                   Cube(const eGlueCube<T1, T2, eglue_type>& X);
Chris@49:   template<typename T1, typename T2, typename eglue_type> inline const Cube&  operator=(const eGlueCube<T1, T2, eglue_type>& X);
Chris@49:   template<typename T1, typename T2, typename eglue_type> inline const Cube& operator+=(const eGlueCube<T1, T2, eglue_type>& X);
Chris@49:   template<typename T1, typename T2, typename eglue_type> inline const Cube& operator-=(const eGlueCube<T1, T2, eglue_type>& X);
Chris@49:   template<typename T1, typename T2, typename eglue_type> inline const Cube& operator%=(const eGlueCube<T1, T2, eglue_type>& X);
Chris@49:   template<typename T1, typename T2, typename eglue_type> inline const Cube& operator/=(const eGlueCube<T1, T2, eglue_type>& X);
Chris@49:   
Chris@49:   template<typename T1, typename T2, typename glue_type> inline                   Cube(const mtGlueCube<eT, T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube&  operator=(const mtGlueCube<eT, T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator+=(const mtGlueCube<eT, T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator-=(const mtGlueCube<eT, T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator%=(const mtGlueCube<eT, T1, T2, glue_type>& X);
Chris@49:   template<typename T1, typename T2, typename glue_type> inline const Cube& operator/=(const mtGlueCube<eT, T1, T2, glue_type>& X);
Chris@49:   
Chris@49:   
Chris@49:   arma_inline arma_warn_unused const eT& at_alt     (const uword i) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& operator[] (const uword i);
Chris@49:   arma_inline arma_warn_unused const eT& operator[] (const uword i) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& at(const uword i);
Chris@49:   arma_inline arma_warn_unused const eT& at(const uword i) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& operator() (const uword i);
Chris@49:   arma_inline arma_warn_unused const eT& operator() (const uword i) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& at         (const uword in_row, const uword in_col, const uword in_slice);
Chris@49:   arma_inline arma_warn_unused const eT& at         (const uword in_row, const uword in_col, const uword in_slice) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& operator() (const uword in_row, const uword in_col, const uword in_slice);
Chris@49:   arma_inline arma_warn_unused const eT& operator() (const uword in_row, const uword in_col, const uword in_slice) const;
Chris@49:   
Chris@49:   arma_inline const Cube& operator++();
Chris@49:   arma_inline void        operator++(int);
Chris@49:   
Chris@49:   arma_inline const Cube& operator--();
Chris@49:   arma_inline void        operator--(int);
Chris@49:   
Chris@49:   arma_inline arma_warn_unused bool is_finite() const;
Chris@49:   arma_inline arma_warn_unused bool is_empty()  const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused bool in_range(const uword i) const;
Chris@49:   arma_inline arma_warn_unused bool in_range(const span& x) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused bool in_range(const uword   in_row, const uword   in_col, const uword   in_slice) const;
Chris@49:        inline arma_warn_unused bool in_range(const span& row_span, const span& col_span, const span& slice_span) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT* memptr();
Chris@49:   arma_inline arma_warn_unused const eT* memptr() const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT* slice_memptr(const uword slice);
Chris@49:   arma_inline arma_warn_unused const eT* slice_memptr(const uword slice) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT* slice_colptr(const uword in_slice, const uword in_col);
Chris@49:   arma_inline arma_warn_unused const eT* slice_colptr(const uword in_slice, const uword in_col) const;
Chris@49:   
Chris@49:   inline void impl_print(const std::string& extra_text) const;
Chris@49:   inline void impl_print(std::ostream& user_stream, const std::string& extra_text) const;
Chris@49:   
Chris@49:   inline void impl_raw_print(const std::string& extra_text) const;
Chris@49:   inline void impl_raw_print(std::ostream& user_stream, const std::string& extra_text) const;
Chris@49:   
Chris@49:   inline void  set_size(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   inline void   reshape(const uword in_rows, const uword in_cols, const uword in_slices, const uword dim = 0);
Chris@49:   inline void    resize(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   
Chris@49:   template<typename eT2> inline void copy_size(const Cube<eT2>& m);
Chris@49:   
Chris@49:   
Chris@49:   template<typename functor>
Chris@49:   inline const Cube& transform(functor F);
Chris@49:   
Chris@49:   template<typename functor>
Chris@49:   inline const Cube& imbue(functor F);
Chris@49:   
Chris@49:   
Chris@49:   inline const Cube& fill(const eT val);
Chris@49:   
Chris@49:   inline const Cube& zeros();
Chris@49:   inline const Cube& zeros(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   
Chris@49:   inline const Cube& ones();
Chris@49:   inline const Cube& ones(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   
Chris@49:   inline const Cube& randu();
Chris@49:   inline const Cube& randu(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   
Chris@49:   inline const Cube& randn();
Chris@49:   inline const Cube& randn(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   
Chris@49:   inline void reset();
Chris@49:   
Chris@49:   
Chris@49:   template<typename T1> inline void set_real(const BaseCube<pod_type,T1>& X);
Chris@49:   template<typename T1> inline void set_imag(const BaseCube<pod_type,T1>& X);
Chris@49:   
Chris@49:   
Chris@49:   inline arma_warn_unused eT min() const;
Chris@49:   inline arma_warn_unused eT max() const;
Chris@49:   
Chris@49:   inline eT min(uword& index_of_min_val) const;
Chris@49:   inline eT max(uword& index_of_max_val) const;
Chris@49:   
Chris@49:   inline eT min(uword& row_of_min_val, uword& col_of_min_val, uword& slice_of_min_val) const;
Chris@49:   inline eT max(uword& row_of_max_val, uword& col_of_max_val, uword& slice_of_max_val) const;
Chris@49:   
Chris@49:   
Chris@49:   inline bool save(const std::string   name, const file_type type = arma_binary, const bool print_status = true) const;
Chris@49:   inline bool save(      std::ostream& os,   const file_type type = arma_binary, const bool print_status = true) const;
Chris@49:   
Chris@49:   inline bool load(const std::string   name, const file_type type = auto_detect, const bool print_status = true);
Chris@49:   inline bool load(      std::istream& is,   const file_type type = auto_detect, const bool print_status = true);
Chris@49:   
Chris@49:   inline bool quiet_save(const std::string   name, const file_type type = arma_binary) const;
Chris@49:   inline bool quiet_save(      std::ostream& os,   const file_type type = arma_binary) const;
Chris@49:   
Chris@49:   inline bool quiet_load(const std::string   name, const file_type type = auto_detect);
Chris@49:   inline bool quiet_load(      std::istream& is,   const file_type type = auto_detect);
Chris@49:   
Chris@49:   
Chris@49:   // iterators
Chris@49:   
Chris@49:   typedef       eT*       iterator;
Chris@49:   typedef const eT* const_iterator;
Chris@49:   
Chris@49:   typedef       eT*       slice_iterator;
Chris@49:   typedef const eT* const_slice_iterator;
Chris@49:   
Chris@49:   inline       iterator  begin();
Chris@49:   inline const_iterator  begin() const;
Chris@49:   inline const_iterator cbegin() const;
Chris@49:   
Chris@49:   inline       iterator  end();
Chris@49:   inline const_iterator  end() const;
Chris@49:   inline const_iterator cend() const;
Chris@49:   
Chris@49:   inline       slice_iterator begin_slice(const uword slice_num);
Chris@49:   inline const_slice_iterator begin_slice(const uword slice_num) const;
Chris@49:   
Chris@49:   inline       slice_iterator end_slice(const uword slice_num);
Chris@49:   inline const_slice_iterator end_slice(const uword slice_num)   const;
Chris@49:   
Chris@49:   inline void  clear();
Chris@49:   inline bool  empty() const;
Chris@49:   inline uword size()  const;
Chris@49:   
Chris@49:   // inline void swap(Cube& B); // TODO
Chris@49:   
Chris@49:   inline void steal_mem(Cube& X);  //!< don't use this unless you're writing code internal to Armadillo
Chris@49:   
Chris@49:   template<uword fixed_n_rows, uword fixed_n_cols, uword fixed_n_slices> class fixed;
Chris@49:   
Chris@49:   
Chris@49:   protected:
Chris@49:   
Chris@49:   inline void init_cold();
Chris@49:   inline void init_warm(const uword in_rows, const uword in_cols, const uword in_slices);
Chris@49:   
Chris@49:   template<typename T1, typename T2>
Chris@49:   inline void init(const BaseCube<pod_type,T1>& A, const BaseCube<pod_type,T2>& B);
Chris@49:   
Chris@49:   inline void delete_mat();
Chris@49:   inline void create_mat();
Chris@49:   
Chris@49:   friend class glue_join;
Chris@49:   friend class op_reshape;
Chris@49:   friend class op_resize;
Chris@49:   
Chris@49:   
Chris@49:   public:
Chris@49:   
Chris@49:   #ifdef ARMA_EXTRA_CUBE_PROTO
Chris@49:     #include ARMA_INCFILE_WRAP(ARMA_EXTRA_CUBE_PROTO)
Chris@49:   #endif
Chris@49:   };
Chris@49: 
Chris@49: 
Chris@49: 
Chris@49: template<typename eT>
Chris@49: template<uword fixed_n_rows, uword fixed_n_cols, uword fixed_n_slices>
Chris@49: class Cube<eT>::fixed : public Cube<eT>
Chris@49:   {
Chris@49:   private:
Chris@49:   
Chris@49:   static const uword fixed_n_elem       = fixed_n_rows * fixed_n_cols * fixed_n_slices;
Chris@49:   static const uword fixed_n_elem_slice = fixed_n_rows * fixed_n_cols;
Chris@49:   
Chris@49:   static const bool use_extra = (fixed_n_elem > Cube_prealloc::mem_n_elem);
Chris@49:   
Chris@49:   arma_aligned   Mat<eT>* mat_ptrs_local_extra[ (fixed_n_slices > Cube_prealloc::mat_ptrs_size) ? fixed_n_slices : 1 ];
Chris@49:   arma_align_mem eT       mem_local_extra     [ use_extra                                       ? fixed_n_elem   : 1 ];
Chris@49:   
Chris@49:   arma_inline void mem_setup();
Chris@49:   
Chris@49:   
Chris@49:   public:
Chris@49:   
Chris@49:   inline fixed() { mem_setup(); }
Chris@49:   
Chris@49:   inline const Cube& operator=(const eT val) { mem_setup(); Cube<eT>::operator=(val); return *this; }
Chris@49:   
Chris@49:   template<typename T1>
Chris@49:   inline fixed(const BaseCube<eT,T1>& A) { mem_setup(); Cube<eT>::operator=(A.get_ref()); }
Chris@49:   
Chris@49:   template<typename T1>
Chris@49:   inline const Cube& operator=(const BaseCube<eT,T1>& A) { Cube<eT>::operator=(A.get_ref()); return *this; }
Chris@49:   
Chris@49:   template<typename T1, typename T2>
Chris@49:   inline explicit fixed(const BaseCube<pod_type,T1>& A, const BaseCube<pod_type,T2>& B) { mem_setup(); Cube<eT>::init(A,B); }
Chris@49:   
Chris@49:   
Chris@49:   using Cube<eT>::operator();
Chris@49:   
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& operator[] (const uword i);
Chris@49:   arma_inline arma_warn_unused const eT& operator[] (const uword i) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& at         (const uword i);
Chris@49:   arma_inline arma_warn_unused const eT& at         (const uword i) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& operator() (const uword i);
Chris@49:   arma_inline arma_warn_unused const eT& operator() (const uword i) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& at         (const uword in_row, const uword in_col, const uword in_slice);
Chris@49:   arma_inline arma_warn_unused const eT& at         (const uword in_row, const uword in_col, const uword in_slice) const;
Chris@49:   
Chris@49:   arma_inline arma_warn_unused       eT& operator() (const uword in_row, const uword in_col, const uword in_slice);
Chris@49:   arma_inline arma_warn_unused const eT& operator() (const uword in_row, const uword in_col, const uword in_slice) const;
Chris@49:   };
Chris@49: 
Chris@49: 
Chris@49: 
Chris@49: class Cube_aux
Chris@49:   {
Chris@49:   public:
Chris@49:   
Chris@49:   template<typename eT> arma_inline static void prefix_pp(Cube<eT>& x);
Chris@49:   template<typename T>  arma_inline static void prefix_pp(Cube< std::complex<T> >& x);
Chris@49:   
Chris@49:   template<typename eT> arma_inline static void postfix_pp(Cube<eT>& x);
Chris@49:   template<typename T>  arma_inline static void postfix_pp(Cube< std::complex<T> >& x);
Chris@49:   
Chris@49:   template<typename eT> arma_inline static void prefix_mm(Cube<eT>& x);
Chris@49:   template<typename T>  arma_inline static void prefix_mm(Cube< std::complex<T> >& x);
Chris@49:   
Chris@49:   template<typename eT> arma_inline static void postfix_mm(Cube<eT>& x);
Chris@49:   template<typename T>  arma_inline static void postfix_mm(Cube< std::complex<T> >& x);
Chris@49:   
Chris@49:   template<typename eT, typename T1> inline static void set_real(Cube<eT>&                out, const BaseCube<eT,T1>& X);
Chris@49:   template<typename eT, typename T1> inline static void set_imag(Cube<eT>&                out, const BaseCube<eT,T1>& X);
Chris@49:   
Chris@49:   template<typename T,  typename T1> inline static void set_real(Cube< std::complex<T> >& out, const BaseCube< T,T1>& X);
Chris@49:   template<typename T,  typename T1> inline static void set_imag(Cube< std::complex<T> >& out, const BaseCube< T,T1>& X);
Chris@49:   };
Chris@49: 
Chris@49: 
Chris@49: 
Chris@49: //! @}