// SPDX-License-Identifier: Apache-2.0 // // Copyright 2008-2016 Conrad Sanderson (https://conradsanderson.id.au) // Copyright 2008-2016 National ICT Australia (NICTA) // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // ------------------------------------------------------------------------ //! \addtogroup subview_cube //! @{ //! Class for storing data required to construct or apply operations to a subcube //! (ie. where the subcube starts and ends as well as a reference/pointer to the original cube), template class subview_cube : public BaseCube< eT, subview_cube > { public: typedef eT elem_type; typedef typename get_pod_type::result pod_type; arma_aligned const Cube& m; const uword aux_row1; const uword aux_col1; const uword aux_slice1; const uword n_rows; const uword n_cols; const uword n_elem_slice; const uword n_slices; const uword n_elem; protected: arma_inline subview_cube(const Cube& in_m, const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_n_rows, const uword in_n_cols, const uword in_n_slices); public: inline ~subview_cube(); inline subview_cube() = delete; inline subview_cube(const subview_cube& in); inline subview_cube( subview_cube&& in); template inline void inplace_op(const eT val ); template inline void inplace_op(const BaseCube& x, const char* identifier); template inline void inplace_op(const subview_cube& x, const char* identifier); inline void operator= (const eT val); inline void operator+= (const eT val); inline void operator-= (const eT val); inline void operator*= (const eT val); inline void operator/= (const eT val); // deliberately returning void template inline void operator= (const BaseCube& x); template inline void operator+= (const BaseCube& x); template inline void operator-= (const BaseCube& x); template inline void operator%= (const BaseCube& x); template inline void operator/= (const BaseCube& x); inline void operator= (const subview_cube& x); inline void operator+= (const subview_cube& x); inline void operator-= (const subview_cube& x); inline void operator%= (const subview_cube& x); inline void operator/= (const subview_cube& x); template inline void operator= (const Base& x); template inline void operator+= (const Base& x); template inline void operator-= (const Base& x); template inline void operator%= (const Base& x); template inline void operator/= (const Base& x); template inline void operator=(const GenCube& x); inline static void extract(Cube& out, const subview_cube& in); inline static void plus_inplace(Cube& out, const subview_cube& in); inline static void minus_inplace(Cube& out, const subview_cube& in); inline static void schur_inplace(Cube& out, const subview_cube& in); inline static void div_inplace(Cube& out, const subview_cube& in); inline static void extract(Mat& out, const subview_cube& in); inline static void plus_inplace(Mat& out, const subview_cube& in); inline static void minus_inplace(Mat& out, const subview_cube& in); inline static void schur_inplace(Mat& out, const subview_cube& in); inline static void div_inplace(Mat& out, const subview_cube& in); template inline void for_each(functor F); template inline void for_each(functor F) const; template inline void transform(functor F); template inline void imbue(functor F); inline void each_slice(const std::function< void( Mat&) >& F); inline void each_slice(const std::function< void(const Mat&) >& F) const; inline void replace(const eT old_val, const eT new_val); inline void clean(const pod_type threshold); inline void clamp(const eT min_val, const eT max_val); inline void fill(const eT val); inline void zeros(); inline void ones(); inline void randu(); inline void randn(); arma_warn_unused inline bool is_finite() const; arma_warn_unused inline bool is_zero(const pod_type tol = 0) const; arma_warn_unused inline bool has_inf() const; arma_warn_unused inline bool has_nan() const; arma_warn_unused inline bool has_nonfinite() const; inline eT at_alt (const uword i) const; inline eT& operator[](const uword i); inline eT operator[](const uword i) const; inline eT& operator()(const uword i); inline eT operator()(const uword i) const; arma_inline eT& operator()(const uword in_row, const uword in_col, const uword in_slice); arma_inline eT operator()(const uword in_row, const uword in_col, const uword in_slice) const; arma_inline eT& at(const uword in_row, const uword in_col, const uword in_slice); arma_inline eT at(const uword in_row, const uword in_col, const uword in_slice) const; arma_inline eT* slice_colptr(const uword in_slice, const uword in_col); arma_inline const eT* slice_colptr(const uword in_slice, const uword in_col) const; template inline bool check_overlap(const subview_cube& x) const; inline bool check_overlap(const Mat& x) const; class const_iterator; class iterator { public: inline iterator(); inline iterator(const iterator& X); inline iterator(subview_cube& in_sv, const uword in_row, const uword in_col, const uword in_slice); arma_warn_unused inline eT& operator*(); inline iterator& operator++(); arma_warn_unused inline iterator operator++(int); arma_warn_unused inline bool operator==(const iterator& rhs) const; arma_warn_unused inline bool operator!=(const iterator& rhs) const; arma_warn_unused inline bool operator==(const const_iterator& rhs) const; arma_warn_unused inline bool operator!=(const const_iterator& rhs) const; typedef std::forward_iterator_tag iterator_category; typedef eT value_type; typedef std::ptrdiff_t difference_type; // TODO: not certain on this one typedef eT* pointer; typedef eT& reference; arma_aligned Cube* M; arma_aligned eT* current_ptr; arma_aligned uword current_row; arma_aligned uword current_col; arma_aligned uword current_slice; arma_aligned const uword aux_row1; arma_aligned const uword aux_col1; arma_aligned const uword aux_row2_p1; arma_aligned const uword aux_col2_p1; }; class const_iterator { public: inline const_iterator(); inline const_iterator(const iterator& X); inline const_iterator(const const_iterator& X); inline const_iterator(const subview_cube& in_sv, const uword in_row, const uword in_col, const uword in_slice); arma_warn_unused inline const eT& operator*(); inline const_iterator& operator++(); arma_warn_unused inline const_iterator operator++(int); arma_warn_unused inline bool operator==(const iterator& rhs) const; arma_warn_unused inline bool operator!=(const iterator& rhs) const; arma_warn_unused inline bool operator==(const const_iterator& rhs) const; arma_warn_unused inline bool operator!=(const const_iterator& rhs) const; // So that we satisfy the STL iterator types. typedef std::forward_iterator_tag iterator_category; typedef eT value_type; typedef std::ptrdiff_t difference_type; // TODO: not certain on this one typedef const eT* pointer; typedef const eT& reference; arma_aligned const Cube* M; arma_aligned const eT* current_ptr; arma_aligned uword current_row; arma_aligned uword current_col; arma_aligned uword current_slice; arma_aligned const uword aux_row1; arma_aligned const uword aux_col1; arma_aligned const uword aux_row2_p1; arma_aligned const uword aux_col2_p1; }; inline iterator begin(); inline const_iterator begin() const; inline const_iterator cbegin() const; inline iterator end(); inline const_iterator end() const; inline const_iterator cend() const; friend class Mat; friend class Cube; }; //! @}