Move into version control

1 files changed, 747 insertions, 0 deletions

diff --git a/src/armadillo/include/armadillo_bits/SpMat_bones.hpp b/src/armadillo/include/armadillo_bits/SpMat_bones.hpp
new file mode 100644
index 0000000..e96f153
--- /dev/null
+++ b/src/armadillo/include/armadillo_bits/SpMat_bones.hpp
@@ -0,0 +1,747 @@
+// 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 SpMat
+//! @{
+
+
+//! Sparse matrix class, with data stored in compressed sparse column (CSC) format
+template<typename eT>
+class SpMat : public SpBase< eT, SpMat<eT> >
+  {
+  public:
+  
+  typedef eT                                elem_type;  //!< the type of elements stored in the matrix
+  typedef typename get_pod_type<eT>::result  pod_type;  //!< if eT is std::complex<T>, pod_type is T; otherwise pod_type is eT
+  
+  static constexpr bool is_row  = false;
+  static constexpr bool is_col  = false;
+  static constexpr bool is_xvec = false;
+  
+  const uword n_rows;    //!< number of rows             (read-only)
+  const uword n_cols;    //!< number of columns          (read-only)
+  const uword n_elem;    //!< number of elements         (read-only)
+  const uword n_nonzero; //!< number of nonzero elements (read-only)
+  const uword vec_state; //!< 0: matrix; 1: column vector; 2: row vector
+  
+  
+  // The memory used to store the values of the matrix.
+  // In accordance with the CSC format, this stores only the actual values.
+  // The correct locations of the values are assembled from the row indices and column pointers.
+  // 
+  // The length of this array is (n_nonzero + 1).
+  // The final value values[n_nonzero] must be zero to ensure integrity of iterators.
+  // Use mem_resize(new_n_nonzero) to resize this array.
+  // 
+  // WARNING: the 'values' array is only valid after sync() is called;
+  // WARNING: there is a separate cache for fast element insertion
+  
+  arma_aligned const eT* const values;
+  
+  
+  // The row indices of each value.  row_indices[i] is the row of values[i].
+  // 
+  // The length of this array is (n_nonzero + 1).
+  // The final value row_indices[n_nonzero] must be zero to ensure integrity of iterators.
+  // Use mem_resize(new_n_nonzero) to resize this array.
+  // 
+  // WARNING: the 'row_indices' array is only valid after sync() is called;
+  // WARNING: there is a separate cache for fast element insertion
+  
+  arma_aligned const uword* const row_indices;
+  
+  
+  // The column pointers.  This stores the index of the first item in column i.
+  // That is, values[col_ptrs[i]] is the first value in column i,
+  // and it is in the row indicated by row_indices[col_ptrs[i]].
+  // 
+  // The length of this array is (n_cols + 2).
+  // The element col_ptrs[n_cols] must be equal to n_nonzero.
+  // The element col_ptrs[n_cols + 1] must be an invalid very large value to ensure integrity of iterators.
+  // 
+  // The col_ptrs array is set by the init() function
+  // (which is called by constructors, set_size() and other functions that change the matrix size).
+  // 
+  // WARNING: the 'col_ptrs' array is only valid after sync() is called;
+  // WARNING: there is a separate cache for fast element insertion
+  
+  arma_aligned const uword* const col_ptrs;
+  
+  inline  SpMat();
+  inline ~SpMat();
+  
+  inline explicit SpMat(const uword in_rows, const uword in_cols);
+  inline explicit SpMat(const SizeMat& s);
+  
+  inline            SpMat(const char*        text);
+  inline SpMat& operator=(const char*        text);
+  inline            SpMat(const std::string& text);
+  inline SpMat& operator=(const std::string& text);
+  inline            SpMat(const SpMat<eT>&   x);
+  
+  inline            SpMat(SpMat&& m);
+  inline SpMat& operator=(SpMat&& m);
+  
+  inline explicit    SpMat(const MapMat<eT>& x);
+  inline SpMat& operator= (const MapMat<eT>& x);
+  
+  template<typename T1, typename T2, typename T3>
+  inline SpMat(const Base<uword,T1>& rowind, const Base<uword,T2>& colptr, const Base<eT,T3>& values, const uword n_rows, const uword n_cols, const bool check_for_zeros = true);
+  
+  template<typename T1, typename T2>
+  inline SpMat(const Base<uword,T1>& locations, const Base<eT,T2>& values, const bool sort_locations = true);
+  
+  template<typename T1, typename T2>
+  inline SpMat(const Base<uword,T1>& locations, const Base<eT,T2>& values, const uword n_rows, const uword n_cols, const bool sort_locations = true, const bool check_for_zeros = true);
+  
+  template<typename T1, typename T2>
+  inline SpMat(const bool add_values, const Base<uword,T1>& locations, const Base<eT,T2>& values, const uword n_rows, const uword n_cols, const bool sort_locations = true, const bool check_for_zeros = true);
+  
+  inline SpMat& operator= (const eT val); //! sets size to 1x1
+  inline SpMat& operator*=(const eT val);
+  inline SpMat& operator/=(const eT val);
+  // operator+=(val) and operator-=(val) are not defined as they don't make sense for sparse matrices
+  
+  inline SpMat& operator= (const SpMat& m);
+  inline SpMat& operator+=(const SpMat& m);
+  inline SpMat& operator-=(const SpMat& m);
+  inline SpMat& operator*=(const SpMat& m);
+  inline SpMat& operator%=(const SpMat& m);
+  inline SpMat& operator/=(const SpMat& m);
+  
+  template<typename T1> inline explicit    SpMat(const Base<eT, T1>& m);
+  template<typename T1> inline SpMat& operator= (const Base<eT, T1>& m);
+  template<typename T1> inline SpMat& operator+=(const Base<eT, T1>& m);
+  template<typename T1> inline SpMat& operator-=(const Base<eT, T1>& m);
+  template<typename T1> inline SpMat& operator*=(const Base<eT, T1>& m);
+  template<typename T1> inline SpMat& operator/=(const Base<eT, T1>& m);
+  template<typename T1> inline SpMat& operator%=(const Base<eT, T1>& m);
+  
+  template<typename T1> inline explicit    SpMat(const Op<T1, op_diagmat>& expr);
+  template<typename T1> inline SpMat& operator= (const Op<T1, op_diagmat>& expr);
+  template<typename T1> inline SpMat& operator+=(const Op<T1, op_diagmat>& expr);
+  template<typename T1> inline SpMat& operator-=(const Op<T1, op_diagmat>& expr);
+  template<typename T1> inline SpMat& operator*=(const Op<T1, op_diagmat>& expr);
+  template<typename T1> inline SpMat& operator/=(const Op<T1, op_diagmat>& expr);
+  template<typename T1> inline SpMat& operator%=(const Op<T1, op_diagmat>& expr);
+
+  //! explicit specification of sparse +/- scalar
+  template<typename T1, typename op_type> inline explicit SpMat(const SpToDOp<T1, op_type>& expr);
+  
+  //! construction of complex matrix out of two non-complex matrices
+  template<typename T1, typename T2>
+  inline explicit SpMat(const SpBase<pod_type, T1>& A, const SpBase<pod_type, T2>& B);
+  
+  inline             SpMat(const SpSubview<eT>& X);
+  inline SpMat& operator= (const SpSubview<eT>& X);
+  inline SpMat& operator+=(const SpSubview<eT>& X);
+  inline SpMat& operator-=(const SpSubview<eT>& X);
+  inline SpMat& operator*=(const SpSubview<eT>& X);
+  inline SpMat& operator%=(const SpSubview<eT>& X);
+  inline SpMat& operator/=(const SpSubview<eT>& X);
+  
+  template<typename T1> inline             SpMat(const SpSubview_col_list<eT,T1>& X);
+  template<typename T1> inline SpMat& operator= (const SpSubview_col_list<eT,T1>& X);
+  template<typename T1> inline SpMat& operator+=(const SpSubview_col_list<eT,T1>& X);
+  template<typename T1> inline SpMat& operator-=(const SpSubview_col_list<eT,T1>& X);
+  template<typename T1> inline SpMat& operator*=(const SpSubview_col_list<eT,T1>& X);
+  template<typename T1> inline SpMat& operator%=(const SpSubview_col_list<eT,T1>& X);
+  template<typename T1> inline SpMat& operator/=(const SpSubview_col_list<eT,T1>& X);
+  
+  inline             SpMat(const spdiagview<eT>& X);
+  inline SpMat& operator= (const spdiagview<eT>& X);
+  inline SpMat& operator+=(const spdiagview<eT>& X);
+  inline SpMat& operator-=(const spdiagview<eT>& X);
+  inline SpMat& operator*=(const spdiagview<eT>& X);
+  inline SpMat& operator%=(const spdiagview<eT>& X);
+  inline SpMat& operator/=(const spdiagview<eT>& X);
+  
+  // delayed unary ops
+  template<typename T1, typename spop_type> inline             SpMat(const SpOp<T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator= (const SpOp<T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator+=(const SpOp<T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator-=(const SpOp<T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator*=(const SpOp<T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator%=(const SpOp<T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator/=(const SpOp<T1, spop_type>& X);
+  
+  // delayed binary ops
+  template<typename T1, typename T2, typename spglue_type> inline             SpMat(const SpGlue<T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator= (const SpGlue<T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator+=(const SpGlue<T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator-=(const SpGlue<T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator*=(const SpGlue<T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator%=(const SpGlue<T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator/=(const SpGlue<T1, T2, spglue_type>& X);
+  
+  // delayed mixed-type unary ops
+  template<typename T1, typename spop_type> inline             SpMat(const mtSpOp<eT, T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator= (const mtSpOp<eT, T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator+=(const mtSpOp<eT, T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator-=(const mtSpOp<eT, T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator*=(const mtSpOp<eT, T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator%=(const mtSpOp<eT, T1, spop_type>& X);
+  template<typename T1, typename spop_type> inline SpMat& operator/=(const mtSpOp<eT, T1, spop_type>& X);
+  
+  // delayed mixed-type binary ops
+  template<typename T1, typename T2, typename spglue_type> inline             SpMat(const mtSpGlue<eT, T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator= (const mtSpGlue<eT, T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator+=(const mtSpGlue<eT, T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator-=(const mtSpGlue<eT, T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator*=(const mtSpGlue<eT, T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator%=(const mtSpGlue<eT, T1, T2, spglue_type>& X);
+  template<typename T1, typename T2, typename spglue_type> inline SpMat& operator/=(const mtSpGlue<eT, T1, T2, spglue_type>& X);
+  
+  
+  arma_inline       SpSubview_row<eT> row(const uword row_num);
+  arma_inline const SpSubview_row<eT> row(const uword row_num) const;
+  
+  inline            SpSubview_row<eT> operator()(const uword row_num, const span& col_span);
+  inline      const SpSubview_row<eT> operator()(const uword row_num, const span& col_span) const;
+  
+  arma_inline       SpSubview_col<eT> col(const uword col_num);
+  arma_inline const SpSubview_col<eT> col(const uword col_num) const;
+  
+  inline            SpSubview_col<eT> operator()(const span& row_span, const uword col_num);
+  inline      const SpSubview_col<eT> operator()(const span& row_span, const uword col_num) const;
+  
+  arma_inline       SpSubview<eT> rows(const uword in_row1, const uword in_row2);
+  arma_inline const SpSubview<eT> rows(const uword in_row1, const uword in_row2) const;
+  
+  arma_inline       SpSubview<eT> cols(const uword in_col1, const uword in_col2);
+  arma_inline const SpSubview<eT> cols(const uword in_col1, const uword in_col2) const;
+  
+  arma_inline       SpSubview<eT> submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2);
+  arma_inline const SpSubview<eT> submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const;
+  
+  arma_inline       SpSubview<eT> submat(const uword in_row1, const uword in_col1, const SizeMat& s);
+  arma_inline const SpSubview<eT> submat(const uword in_row1, const uword in_col1, const SizeMat& s) const;
+  
+  inline            SpSubview<eT> submat    (const span& row_span, const span& col_span);
+  inline      const SpSubview<eT> submat    (const span& row_span, const span& col_span) const;
+  
+  inline            SpSubview<eT> operator()(const span& row_span, const span& col_span);
+  inline      const SpSubview<eT> operator()(const span& row_span, const span& col_span) const;
+  
+  arma_inline       SpSubview<eT> operator()(const uword in_row1, const uword in_col1, const SizeMat& s);
+  arma_inline const SpSubview<eT> operator()(const uword in_row1, const uword in_col1, const SizeMat& s) const;
+  
+  
+  inline       SpSubview<eT> head_rows(const uword N);
+  inline const SpSubview<eT> head_rows(const uword N) const;
+  
+  inline       SpSubview<eT> tail_rows(const uword N);
+  inline const SpSubview<eT> tail_rows(const uword N) const;
+  
+  inline       SpSubview<eT> head_cols(const uword N);
+  inline const SpSubview<eT> head_cols(const uword N) const;
+  
+  inline       SpSubview<eT> tail_cols(const uword N);
+  inline const SpSubview<eT> tail_cols(const uword N) const;
+  
+  
+  template<typename T1> arma_inline       SpSubview_col_list<eT,T1> cols(const Base<uword,T1>& ci);
+  template<typename T1> arma_inline const SpSubview_col_list<eT,T1> cols(const Base<uword,T1>& ci) const;
+  
+  
+  inline       spdiagview<eT> diag(const sword in_id = 0);
+  inline const spdiagview<eT> diag(const sword in_id = 0) 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);
+  
+  inline void shed_row(const uword row_num);
+  inline void shed_col(const uword col_num);
+  
+  inline void shed_rows(const uword in_row1, const uword in_row2);
+  inline void shed_cols(const uword in_col1, const uword in_col2);
+  
+  
+  // access the i-th element; if there is nothing at element i, 0 is returned
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> operator[] (const uword i);
+  arma_warn_unused arma_inline eT                   operator[] (const uword i) const;
+  
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> at         (const uword i);
+  arma_warn_unused arma_inline eT                   at         (const uword i) const;
+  
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> operator() (const uword i);
+  arma_warn_unused arma_inline eT                   operator() (const uword i) const;
+  
+  // access the element at the given row and column; if there is nothing at that position, 0 is returned
+  #if defined(__cpp_multidimensional_subscript)
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> operator[] (const uword in_row, const uword in_col);
+  arma_warn_unused arma_inline eT                   operator[] (const uword in_row, const uword in_col) const;
+  #endif
+  
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> at         (const uword in_row, const uword in_col);
+  arma_warn_unused arma_inline eT                   at         (const uword in_row, const uword in_col) const;
+  
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> operator() (const uword in_row, const uword in_col);
+  arma_warn_unused arma_inline eT                   operator() (const uword in_row, const uword in_col) const;
+  
+  
+  arma_warn_unused arma_inline bool is_empty()  const;
+  arma_warn_unused arma_inline bool is_vec()    const;
+  arma_warn_unused arma_inline bool is_rowvec() const;
+  arma_warn_unused arma_inline bool is_colvec() const;
+  arma_warn_unused arma_inline bool is_square() const;
+  
+  arma_warn_unused inline bool is_symmetric() const;
+  arma_warn_unused inline bool is_symmetric(const typename get_pod_type<eT>::result tol) const;
+  
+  arma_warn_unused inline bool is_hermitian() const;
+  arma_warn_unused inline bool is_hermitian(const typename get_pod_type<eT>::result tol) const;
+  
+  arma_warn_unused inline bool internal_is_finite()     const;
+  arma_warn_unused inline bool internal_has_inf()       const;
+  arma_warn_unused inline bool internal_has_nan()       const;
+  arma_warn_unused inline bool internal_has_nonfinite() const;
+  
+  arma_warn_unused arma_inline bool in_range(const uword i) const;
+  arma_warn_unused arma_inline bool in_range(const span& x) const;
+  
+  arma_warn_unused arma_inline bool in_range(const uword   in_row, const uword   in_col) const;
+  arma_warn_unused arma_inline bool in_range(const span& row_span, const uword   in_col) const;
+  arma_warn_unused arma_inline bool in_range(const uword   in_row, const span& col_span) const;
+  arma_warn_unused arma_inline bool in_range(const span& row_span, const span& col_span) const;
+  
+  arma_warn_unused arma_inline bool in_range(const uword in_row, const uword in_col, const SizeMat& s) const;
+  
+  
+  template<typename eT2> inline SpMat& copy_size(const SpMat<eT2>& m);
+  template<typename eT2> inline SpMat& copy_size(const   Mat<eT2>& m);
+  
+  inline SpMat& set_size(const uword in_elem);
+  inline SpMat& set_size(const uword in_rows, const uword in_cols);
+  inline SpMat& set_size(const SizeMat& s);
+  
+  inline SpMat&   resize(const uword in_rows, const uword in_cols);
+  inline SpMat&   resize(const SizeMat& s);
+  
+  inline SpMat&  reshape(const uword in_rows, const uword in_cols);
+  inline SpMat&  reshape(const SizeMat& s);
+  
+  inline void  reshape_helper_generic(const uword in_rows, const uword in_cols);  //! internal use only
+  inline void  reshape_helper_intovec();                                          //! internal use only
+  
+  template<typename functor> inline       SpMat&  for_each(functor F);
+  template<typename functor> inline const SpMat&  for_each(functor F) const;
+  
+  template<typename functor> inline       SpMat& transform(functor F);
+  
+  inline SpMat& replace(const eT old_val, const eT new_val);
+  
+  inline SpMat& clean(const pod_type threshold);
+  
+  inline SpMat& clamp(const eT min_val, const eT max_val);
+  
+  inline SpMat& zeros();
+  inline SpMat& zeros(const uword in_elem);
+  inline SpMat& zeros(const uword in_rows, const uword in_cols);
+  inline SpMat& zeros(const SizeMat& s);
+  
+  inline SpMat& eye();
+  inline SpMat& eye(const uword in_rows, const uword in_cols);
+  inline SpMat& eye(const SizeMat& s);
+  
+  inline SpMat& speye();
+  inline SpMat& speye(const uword in_rows, const uword in_cols);
+  inline SpMat& speye(const SizeMat& s);
+  
+  inline SpMat& sprandu(const uword in_rows, const uword in_cols, const double density);
+  inline SpMat& sprandu(const SizeMat& s,                         const double density);
+  
+  inline SpMat& sprandn(const uword in_rows, const uword in_cols, const double density);
+  inline SpMat& sprandn(const SizeMat& s,                         const double density);
+  
+  inline void reset();
+  inline void reset_cache();
+  
+  //! don't use this unless you're writing internal Armadillo code
+  inline void reserve(const uword in_rows, const uword in_cols, const uword new_n_nonzero);
+  
+  //! don't use this unless you're writing internal Armadillo code
+  inline SpMat(const arma_reserve_indicator&, const uword in_rows, const uword in_cols, const uword new_n_nonzero);
+  
+  //! don't use this unless you're writing internal Armadillo code
+  template<typename eT2>
+  inline SpMat(const arma_layout_indicator&, const SpMat<eT2>& x);
+  
+  template<typename T1> inline void set_real(const SpBase<pod_type,T1>& X);
+  template<typename T1> inline void set_imag(const SpBase<pod_type,T1>& X);
+  
+  
+  // saving and loading
+  // TODO: implement auto_detect for sparse matrices
+  
+  arma_cold inline bool save(const std::string   name, const file_type type = arma_binary) const;
+  arma_cold inline bool save(const csv_name&     spec, const file_type type =   csv_ascii) const;
+  arma_cold inline bool save(      std::ostream& os,   const file_type type = arma_binary) const;
+  
+  arma_cold inline bool load(const std::string   name, const file_type type = arma_binary);
+  arma_cold inline bool load(const csv_name&     spec, const file_type type =   csv_ascii);
+  arma_cold inline bool load(      std::istream& is,   const file_type type = arma_binary);
+  
+  arma_deprecated inline bool quiet_save(const std::string   name, const file_type type = arma_binary) const;
+  arma_deprecated inline bool quiet_save(      std::ostream& os,   const file_type type = arma_binary) const;
+  
+  arma_deprecated inline bool quiet_load(const std::string   name, const file_type type = arma_binary);
+  arma_deprecated inline bool quiet_load(      std::istream& is,   const file_type type = arma_binary);
+  
+  
+  
+  // necessary forward declarations
+  class iterator_base;
+  class iterator;
+  class const_iterator;
+  class row_iterator;
+  class const_row_iterator;
+  
+  // iterator_base provides basic operators but not how to compare or how to iterate
+  class iterator_base
+    {
+    public:
+    
+    inline iterator_base();
+    inline iterator_base(const SpMat& in_M);
+    inline iterator_base(const SpMat& in_M, const uword col, const uword pos);
+    
+    arma_inline eT operator*() const;
+    
+    // don't hold location internally; call "dummy" methods to get that information
+    arma_inline uword row() const { return M->row_indices[internal_pos]; }
+    arma_inline uword col() const { return internal_col;                 }
+    arma_inline uword pos() const { return internal_pos;                 }
+    
+    arma_aligned const SpMat* 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();
+    
+    inline const_iterator(const SpMat& in_M, uword initial_pos = 0);                     // assumes initial_pos is valid
+    inline const_iterator(const SpMat& in_M, uword in_row, uword in_col);                // iterator will be at the first nonzero value after the given position (using forward columnwise traversal)
+    inline const_iterator(const SpMat& in_M, uword in_row, uword in_col, uword in_pos);  // if the exact position of the iterator is known; in_row is a dummy argument
+    
+    inline                 const_iterator(const const_iterator& other);
+    inline const_iterator& operator=     (const const_iterator& other) = default;
+    
+    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 SpSubview<eT>::const_iterator& rhs) const;
+    arma_hot inline bool operator!=(const typename SpSubview<eT>::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 SpSubview<eT>::const_row_iterator& rhs) const;
+    arma_hot inline bool operator!=(const typename SpSubview<eT>::const_row_iterator& rhs) const;
+    };
+  
+  /**
+   * So that we can iterate over nonzero values, we need an iterator implementation.
+   * This can't be as simple as for Mat, which is just a pointer to an eT.
+   * If a value is set to 0 using this iterator, the iterator is no longer valid!
+   */
+  class iterator : public const_iterator
+    {
+    public:
+    
+    inline iterator() : const_iterator() { }
+    
+    inline iterator(SpMat& in_M, uword initial_pos = 0)                    : const_iterator(in_M, initial_pos)            { }
+    inline iterator(SpMat& in_M, uword in_row, uword in_col)               : const_iterator(in_M, in_row, in_col)         { }
+    inline iterator(SpMat& in_M, uword in_row, uword in_col, uword in_pos) : const_iterator(in_M, in_row, in_col, in_pos) { }
+    
+    inline           iterator (const iterator& other) : const_iterator(other) { }
+    inline iterator& operator=(const iterator& other) = default;
+    
+    arma_hot inline SpValProxy< SpMat<eT> > 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< SpMat<eT> >   value_type;
+    typedef const SpValProxy< SpMat<eT> >*  pointer;
+    typedef const SpValProxy< SpMat<eT> >&  reference;
+    };
+  
+  class const_row_iterator : public iterator_base
+    {
+    public:
+    
+    inline const_row_iterator();
+    inline const_row_iterator(const SpMat& in_M, uword initial_pos = 0);
+    inline const_row_iterator(const SpMat& in_M, uword in_row, uword in_col);
+    
+    inline                     const_row_iterator(const const_row_iterator& other);
+    inline const_row_iterator& operator=         (const const_row_iterator& other) = default;
+    
+    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
+    uword actual_pos;   // hold the true position we are at in the matrix, as column-major indexing
+    
+    arma_inline eT operator*() const { return iterator_base::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 SpSubview<eT>::const_iterator& rhs) const;
+    arma_hot inline bool operator!=(const typename SpSubview<eT>::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 SpSubview<eT>::const_row_iterator& rhs) const;
+    arma_hot inline bool operator!=(const typename SpSubview<eT>::const_row_iterator& rhs) const;
+    };
+  
+  class row_iterator : public const_row_iterator
+    {
+    public:
+    
+    inline row_iterator() : const_row_iterator() {}
+    
+    inline row_iterator(SpMat& in_M, uword initial_pos = 0)      : const_row_iterator(in_M, initial_pos)    { }
+    inline row_iterator(SpMat& 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) { }
+    inline row_iterator& operator=   (const row_iterator& other) = default;
+    
+    arma_hot inline SpValProxy< SpMat<eT> > operator*();
+    
+    // overloads required 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< SpMat<eT> >  value_type;
+    typedef const SpValProxy< SpMat<eT> >* pointer;
+    typedef const SpValProxy< SpMat<eT> >& reference;
+    };
+  
+  
+  typedef       iterator       col_iterator;
+  typedef const_iterator const_col_iterator;
+  
+  typedef       iterator       row_col_iterator;
+  typedef const_iterator const_row_col_iterator;
+  
+  
+  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;
+  
+  inline       col_iterator begin_col(const uword col_num);
+  inline const_col_iterator begin_col(const uword col_num) const;
+  
+  inline       col_iterator begin_col_no_sync(const uword col_num);
+  inline const_col_iterator begin_col_no_sync(const uword col_num) const;
+  
+  inline       col_iterator end_col(const uword col_num);
+  inline const_col_iterator end_col(const uword col_num) const;
+  
+  inline       col_iterator end_col_no_sync(const uword col_num);
+  inline const_col_iterator end_col_no_sync(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       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;
+  
+  inline       row_col_iterator begin_row_col();
+  inline const_row_col_iterator begin_row_col() const;
+  
+  inline       row_col_iterator end_row_col();
+  inline const_row_col_iterator end_row_col() const;
+  
+  
+  inline void  clear();
+  inline bool  empty() const;
+  inline uword size()  const;
+  
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> front();
+  arma_warn_unused arma_inline eT                   front() const;
+  
+  arma_warn_unused arma_inline SpMat_MapMat_val<eT> back();
+  arma_warn_unused arma_inline eT                   back() const;
+  
+  // Resize memory.
+  // If the new size is larger, the column pointers and new memory still need to be correctly set.
+  // If the new size is smaller, the first new_n_nonzero elements will be copied.
+  // n_nonzero is updated.
+  inline void mem_resize(const uword new_n_nonzero);
+  
+  //! synchronise CSC from cache
+  inline void sync() const;
+  
+  //! don't use this unless you're writing internal Armadillo code
+  inline void remove_zeros();
+  
+  //! don't use this unless you're writing internal Armadillo code
+  inline void steal_mem(SpMat& X);
+  
+  //! don't use this unless you're writing internal Armadillo code
+  inline void steal_mem_simple(SpMat& X);
+  
+  //! don't use this unless you're writing internal Armadillo code
+  template<              typename T1, typename Functor> inline void init_xform   (const SpBase<eT, T1>& x, const Functor& func);
+  template<typename eT2, typename T1, typename Functor> inline void init_xform_mt(const SpBase<eT2,T1>& x, const Functor& func);
+  
+  //! don't use this unless you're writing internal Armadillo code
+  arma_inline bool is_alias(const SpMat<eT>& X) const;
+  
+  
+  protected:
+  
+            inline void       init(uword in_rows, uword in_cols, const uword new_n_nonzero = 0);
+  arma_cold inline void  init_cold(uword in_rows, uword in_cols, const uword new_n_nonzero = 0);
+  
+  inline void init(const std::string& text);
+  inline void init(const  SpMat<eT>& x);
+  inline void init(const MapMat<eT>& x);
+  
+  inline void init_simple(const SpMat<eT>& x);
+  
+  inline void init_batch_std(const Mat<uword>& locations, const Mat<eT>& values, const bool sort_locations);
+  inline void init_batch_add(const Mat<uword>& locations, const Mat<eT>& values, const bool sort_locations);
+  
+  inline SpMat(const arma_vec_indicator&, const uword in_vec_state);
+  inline SpMat(const arma_vec_indicator&, const uword in_n_rows, const uword in_n_cols, const uword in_vec_state);
+  
+  
+  private:
+  
+  arma_warn_unused arma_hot inline const eT* find_value_csc(const uword in_row, const uword in_col) const;
+  
+  arma_warn_unused arma_hot inline eT get_value(const uword i                         ) const;
+  arma_warn_unused arma_hot inline eT get_value(const uword in_row, const uword in_col) const;
+  
+  arma_warn_unused arma_hot inline eT get_value_csc(const uword i                         ) const;
+  arma_warn_unused arma_hot inline eT get_value_csc(const uword in_row, const uword in_col) const;
+  
+  arma_warn_unused arma_hot inline bool try_set_value_csc(const uword in_row, const uword in_col, const eT in_val);
+  arma_warn_unused arma_hot inline bool try_add_value_csc(const uword in_row, const uword in_col, const eT in_val);
+  arma_warn_unused arma_hot inline bool try_sub_value_csc(const uword in_row, const uword in_col, const eT in_val);
+  arma_warn_unused arma_hot inline bool try_mul_value_csc(const uword in_row, const uword in_col, const eT in_val);
+  arma_warn_unused arma_hot inline bool try_div_value_csc(const uword in_row, const uword in_col, const eT in_val);
+  
+  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);
+  
+  
+  // cache related
+  
+  arma_aligned mutable MapMat<eT> cache;
+  arma_aligned mutable state_type sync_state;
+  // 0: cache needs to be updated from CSC (ie.   CSC has more recent data)
+  // 1: CSC needs to be updated from cache (ie. cache has more recent data)
+  // 2: no update required                 (ie. CSC and cache contain the same data)
+  
+  #if (!defined(ARMA_DONT_USE_STD_MUTEX))
+  arma_aligned mutable std::mutex cache_mutex;
+  #endif
+  
+  arma_inline void invalidate_cache() const;
+  arma_inline void invalidate_csc()   const;
+  
+  inline void sync_cache()        const;
+  inline void sync_cache_simple() const;
+  inline void sync_csc()          const;
+  inline void sync_csc_simple()   const;
+  
+  
+  friend class SpValProxy< SpMat<eT> >;  // allow SpValProxy to call insert_element() and delete_element()
+  friend class SpSubview<eT>;
+  friend class SpRow<eT>;
+  friend class SpCol<eT>;
+  friend class SpMat_MapMat_val<eT>;
+  friend class SpSubview_MapMat_val<eT>;
+  friend class spdiagview<eT>;
+  
+  template<typename xT1, typename xT2> friend class SpSubview_col_list;
+  
+  public:
+  
+  #if defined(ARMA_EXTRA_SPMAT_PROTO)
+    #include ARMA_INCFILE_WRAP(ARMA_EXTRA_SPMAT_PROTO)
+  #endif
+  };
+
+
+
+class SpMat_aux
+  {
+  public:
+  
+  template<typename eT, typename T1> inline static void set_real(SpMat<eT>&                out, const SpBase<eT,T1>& X);
+  template<typename T,  typename T1> inline static void set_real(SpMat< std::complex<T> >& out, const SpBase< T,T1>& X);
+  
+  template<typename eT, typename T1> inline static void set_imag(SpMat<eT>&                out, const SpBase<eT,T1>& X);
+  template<typename T,  typename T1> inline static void set_imag(SpMat< std::complex<T> >& out, const SpBase< T,T1>& X);
+  };
+
+
+
+#define ARMA_HAS_SPMAT
+
+
+
+//! @}