// SPDX-License-Identifier: Apache-2.0 // // Copyright 2008-2016 Conrad Sanderson (http://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 // http://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 SpSubview //! @{ template class SpSubview : public SpBase< eT, SpSubview > { public: const SpMat& m; typedef eT elem_type; typedef typename get_pod_type::result pod_type; static constexpr bool is_row = false; static constexpr bool is_col = false; static constexpr bool is_xvec = false; const uword aux_row1; const uword aux_col1; const uword n_rows; const uword n_cols; const uword n_elem; const uword n_nonzero; protected: inline SpSubview(const SpMat& in_m, const uword in_row1, const uword in_col1, const uword in_n_rows, const uword in_n_cols); public: inline ~SpSubview(); inline SpSubview() = delete; inline SpSubview(const SpSubview& in); inline SpSubview( SpSubview&& in); inline const SpSubview& operator+= (const eT val); inline const SpSubview& operator-= (const eT val); inline const SpSubview& operator*= (const eT val); inline const SpSubview& operator/= (const eT val); inline const SpSubview& operator=(const SpSubview& x); template inline const SpSubview& operator= (const Base& x); template inline const SpSubview& operator+=(const Base& x); template inline const SpSubview& operator-=(const Base& x); template inline const SpSubview& operator*=(const Base& x); template inline const SpSubview& operator%=(const Base& x); template inline const SpSubview& operator/=(const Base& x); template inline const SpSubview& operator_equ_common(const SpBase& x); template inline const SpSubview& operator= (const SpBase& x); template inline const SpSubview& operator+=(const SpBase& x); template inline const SpSubview& operator-=(const SpBase& x); template inline const SpSubview& operator*=(const SpBase& x); template inline const SpSubview& operator%=(const SpBase& x); template inline const SpSubview& operator/=(const SpBase& x); /* inline static void extract(SpMat& out, const SpSubview& in); inline static void plus_inplace(Mat& out, const subview& in); inline static void minus_inplace(Mat& out, const subview& in); inline static void schur_inplace(Mat& out, const subview& in); inline static void div_inplace(Mat& out, const subview& in); */ template inline void for_each(functor F); template inline void for_each(functor F) const; template inline void transform(functor F); 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 eye(); inline void randu(); inline void randn(); arma_warn_unused inline SpSubview_MapMat_val operator[](const uword i); arma_warn_unused inline eT operator[](const uword i) const; arma_warn_unused inline SpSubview_MapMat_val operator()(const uword i); arma_warn_unused inline eT operator()(const uword i) const; arma_warn_unused inline SpSubview_MapMat_val operator()(const uword in_row, const uword in_col); arma_warn_unused inline eT operator()(const uword in_row, const uword in_col) const; arma_warn_unused inline SpSubview_MapMat_val at(const uword i); arma_warn_unused inline eT at(const uword i) const; arma_warn_unused inline SpSubview_MapMat_val at(const uword in_row, const uword in_col); arma_warn_unused inline eT at(const uword in_row, const uword in_col) const; inline bool check_overlap(const SpSubview& x) const; arma_warn_unused inline bool is_vec() const; inline SpSubview_row row(const uword row_num); inline const SpSubview_row row(const uword row_num) const; inline SpSubview_col col(const uword col_num); inline const SpSubview_col col(const uword col_num) const; inline SpSubview rows(const uword in_row1, const uword in_row2); inline const SpSubview rows(const uword in_row1, const uword in_row2) const; inline SpSubview cols(const uword in_col1, const uword in_col2); inline const SpSubview cols(const uword in_col1, const uword in_col2) const; inline SpSubview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2); inline const SpSubview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const; inline SpSubview submat(const span& row_span, const span& col_span); inline const SpSubview submat(const span& row_span, const span& col_span) const; inline SpSubview operator()(const uword row_num, const span& col_span); inline const SpSubview operator()(const uword row_num, const span& col_span) const; inline SpSubview operator()(const span& row_span, const uword col_num); inline const SpSubview operator()(const span& row_span, const uword col_num) const; inline SpSubview operator()(const span& row_span, const span& col_span); inline const SpSubview operator()(const span& row_span, const span& col_span) const; inline void swap_rows(const uword in_row1, const uword in_row2); inline void swap_cols(const uword in_col1, const uword in_col2); // Forward declarations. class iterator_base; class const_iterator; class iterator; class const_row_iterator; class row_iterator; // Similar to SpMat iterators but automatically iterates past and ignores values not in the subview. class iterator_base { public: inline iterator_base(const SpSubview& in_M); inline iterator_base(const SpSubview& in_M, const uword col, const uword pos); arma_inline uword col() const { return internal_col; } arma_inline uword pos() const { return internal_pos; } arma_aligned const SpSubview* M; arma_aligned uword internal_col; arma_aligned uword internal_pos; typedef std::bidirectional_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; }; class const_iterator : public iterator_base { public: inline const_iterator(const SpSubview& in_M, uword initial_pos = 0); inline const_iterator(const SpSubview& in_M, uword in_row, uword in_col); inline const_iterator(const SpSubview& in_M, uword in_row, uword in_col, uword in_pos, uword skip_pos); inline const_iterator(const const_iterator& other); arma_inline eT operator*() const; // Don't hold location internally; call "dummy" methods to get that information. arma_inline uword row() const { return iterator_base::M->m.row_indices[iterator_base::internal_pos + skip_pos] - iterator_base::M->aux_row1; } arma_hot inline const_iterator& operator++(); arma_warn_unused inline const_iterator operator++(int); arma_hot inline const_iterator& operator--(); arma_warn_unused inline const_iterator operator--(int); arma_hot inline bool operator!=(const const_iterator& rhs) const; arma_hot inline bool operator==(const const_iterator& rhs) const; arma_hot inline bool operator!=(const typename SpMat::const_iterator& rhs) const; arma_hot inline bool operator==(const typename SpMat::const_iterator& rhs) const; arma_hot inline bool operator!=(const const_row_iterator& rhs) const; arma_hot inline bool operator==(const const_row_iterator& rhs) const; arma_hot inline bool operator!=(const typename SpMat::const_row_iterator& rhs) const; arma_hot inline bool operator==(const typename SpMat::const_row_iterator& rhs) const; arma_aligned uword skip_pos; // not used in row_iterator or const_row_iterator }; class iterator : public const_iterator { public: inline iterator(SpSubview& in_M, const uword initial_pos = 0) : const_iterator(in_M, initial_pos) { } inline iterator(SpSubview& in_M, const uword in_row, const uword in_col) : const_iterator(in_M, in_row, in_col) { } inline iterator(SpSubview& in_M, const uword in_row, const uword in_col, const uword in_pos, const uword in_skip_pos) : const_iterator(in_M, in_row, in_col, in_pos, in_skip_pos) { } inline iterator(const iterator& other) : const_iterator(other) { } arma_hot inline SpValProxy< SpSubview > operator*(); // overloads needed for return type correctness arma_hot inline iterator& operator++(); arma_warn_unused inline iterator operator++(int); arma_hot inline iterator& operator--(); arma_warn_unused inline iterator operator--(int); // This has a different value_type than iterator_base. typedef SpValProxy< SpSubview > value_type; typedef const SpValProxy< SpSubview >* pointer; typedef const SpValProxy< SpSubview >& reference; }; class const_row_iterator : public iterator_base { public: inline const_row_iterator(); inline const_row_iterator(const SpSubview& in_M, uword initial_pos = 0); inline const_row_iterator(const SpSubview& in_M, uword in_row, uword in_col); inline const_row_iterator(const const_row_iterator& other); arma_hot inline const_row_iterator& operator++(); arma_warn_unused inline const_row_iterator operator++(int); arma_hot inline const_row_iterator& operator--(); arma_warn_unused inline const_row_iterator operator--(int); uword internal_row; // Hold row internally because we use internal_pos differently. uword actual_pos; // Actual position in subview's parent matrix. arma_inline eT operator*() const { return iterator_base::M->m.values[actual_pos]; } arma_inline uword row() const { return internal_row; } arma_hot inline bool operator!=(const const_iterator& rhs) const; arma_hot inline bool operator==(const const_iterator& rhs) const; arma_hot inline bool operator!=(const typename SpMat::const_iterator& rhs) const; arma_hot inline bool operator==(const typename SpMat::const_iterator& rhs) const; arma_hot inline bool operator!=(const const_row_iterator& rhs) const; arma_hot inline bool operator==(const const_row_iterator& rhs) const; arma_hot inline bool operator!=(const typename SpMat::const_row_iterator& rhs) const; arma_hot inline bool operator==(const typename SpMat::const_row_iterator& rhs) const; }; class row_iterator : public const_row_iterator { public: inline row_iterator(SpSubview& in_M, uword initial_pos = 0) : const_row_iterator(in_M, initial_pos) { } inline row_iterator(SpSubview& in_M, uword in_row, uword in_col) : const_row_iterator(in_M, in_row, in_col) { } inline row_iterator(const row_iterator& other) : const_row_iterator(other) { } arma_hot inline SpValProxy< SpSubview > operator*(); // overloads needed for return type correctness arma_hot inline row_iterator& operator++(); arma_warn_unused inline row_iterator operator++(int); arma_hot inline row_iterator& operator--(); arma_warn_unused inline row_iterator operator--(int); // This has a different value_type than iterator_base. typedef SpValProxy< SpSubview > value_type; typedef const SpValProxy< SpSubview >* pointer; typedef const SpValProxy< SpSubview >& reference; }; inline iterator begin(); inline const_iterator begin() const; inline const_iterator cbegin() const; inline iterator begin_col(const uword col_num); inline const_iterator begin_col(const uword col_num) const; inline row_iterator begin_row(const uword row_num = 0); inline const_row_iterator begin_row(const uword row_num = 0) const; inline iterator end(); inline const_iterator end() const; inline const_iterator cend() const; inline row_iterator end_row(); inline const_row_iterator end_row() const; inline row_iterator end_row(const uword row_num); inline const_row_iterator end_row(const uword row_num) const; //! don't use this unless you're writing internal Armadillo code arma_inline bool is_alias(const SpMat& X) const; private: friend class SpMat; friend class SpSubview_col; friend class SpSubview_row; friend class SpValProxy< SpSubview >; // allow SpValProxy to call insert_element() and delete_element() arma_warn_unused inline eT& insert_element(const uword in_row, const uword in_col, const eT in_val = eT(0)); inline void delete_element(const uword in_row, const uword in_col); inline void invalidate_cache() const; }; template class SpSubview_col : public SpSubview { public: typedef eT elem_type; typedef typename get_pod_type::result pod_type; static constexpr bool is_row = false; static constexpr bool is_col = true; static constexpr bool is_xvec = false; inline void operator= (const SpSubview& x); inline void operator= (const SpSubview_col& x); template inline void operator= (const SpBase& x); template inline void operator= (const Base& x); arma_warn_unused inline const SpOp,spop_htrans> t() const; arma_warn_unused inline const SpOp,spop_htrans> ht() const; arma_warn_unused inline const SpOp,spop_strans> st() const; protected: inline SpSubview_col(const SpMat& in_m, const uword in_col); inline SpSubview_col(const SpMat& in_m, const uword in_col, const uword in_row1, const uword in_n_rows); inline SpSubview_col() = delete; private: friend class SpMat; friend class SpSubview; }; template class SpSubview_row : public SpSubview { public: typedef eT elem_type; typedef typename get_pod_type::result pod_type; static constexpr bool is_row = true; static constexpr bool is_col = false; static constexpr bool is_xvec = false; inline void operator= (const SpSubview& x); inline void operator= (const SpSubview_row& x); template inline void operator= (const SpBase& x); template inline void operator= (const Base& x); arma_warn_unused inline const SpOp,spop_htrans> t() const; arma_warn_unused inline const SpOp,spop_htrans> ht() const; arma_warn_unused inline const SpOp,spop_strans> st() const; protected: inline SpSubview_row(const SpMat& in_m, const uword in_row); inline SpSubview_row(const SpMat& in_m, const uword in_row, const uword in_col1, const uword in_n_cols); inline SpSubview_row() = delete; private: friend class SpMat; friend class SpSubview; }; //! @}