// 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 Mat //! @{ //! Dense matrix class template class Mat : public Base< eT, Mat > { public: typedef eT elem_type; //!< the type of elements stored in the matrix typedef typename get_pod_type::result pod_type; //!< if eT is std::complex, pod_type is T; otherwise pod_type is eT 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_alloc; //!< number of allocated elements (read-only); NOTE: n_alloc can be 0, even if n_elem > 0 const uhword vec_state; //!< 0: matrix layout; 1: column vector layout; 2: row vector layout const uhword mem_state; // mem_state = 0: normal matrix which manages its own memory // mem_state = 1: use auxiliary memory until a size change // mem_state = 2: use auxiliary memory and don't allow the number of elements to be changed // mem_state = 3: fixed size (eg. via template based size specification) arma_aligned const eT* const mem; //!< pointer to the memory used for storing elements (memory is read-only) protected: arma_align_mem eT mem_local[ arma_config::mat_prealloc ]; // local storage, for small vectors and matrices public: static constexpr bool is_col = false; static constexpr bool is_row = false; static constexpr bool is_xvec = false; inline ~Mat(); inline Mat(); inline explicit Mat(const uword in_n_rows, const uword in_n_cols); inline explicit Mat(const SizeMat& s); template inline explicit Mat(const uword in_n_rows, const uword in_n_cols, const arma_initmode_indicator&); template inline explicit Mat(const SizeMat& s, const arma_initmode_indicator&); template inline Mat(const uword in_n_rows, const uword in_n_cols, const fill::fill_class& f); template inline Mat(const SizeMat& s, const fill::fill_class& f); inline Mat(const uword in_n_rows, const uword in_n_cols, const fill::scalar_holder f); inline Mat(const SizeMat& s, const fill::scalar_holder f); arma_cold inline Mat(const char* text); arma_cold inline Mat& operator=(const char* text); arma_cold inline Mat(const std::string& text); arma_cold inline Mat& operator=(const std::string& text); inline Mat(const std::vector& x); inline Mat& operator=(const std::vector& x); inline Mat(const std::initializer_list& list); inline Mat& operator=(const std::initializer_list& list); inline Mat(const std::initializer_list< std::initializer_list >& list); inline Mat& operator=(const std::initializer_list< std::initializer_list >& list); inline Mat(Mat&& m); inline Mat& operator=(Mat&& m); inline Mat( eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const bool copy_aux_mem = true, const bool strict = false); inline Mat(const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols); inline Mat& operator= (const eT val); inline Mat& operator+=(const eT val); inline Mat& operator-=(const eT val); inline Mat& operator*=(const eT val); inline Mat& operator/=(const eT val); inline Mat(const Mat& m, const arma_vec_indicator&, const uhword in_vec_state); inline Mat(const Mat& m); inline Mat& operator= (const Mat& m); inline Mat& operator+=(const Mat& m); inline Mat& operator-=(const Mat& m); inline Mat& operator*=(const Mat& m); inline Mat& operator%=(const Mat& m); inline Mat& operator/=(const Mat& m); template inline Mat(const BaseCube& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const BaseCube& X); template inline Mat& operator= (const BaseCube& X); template inline Mat& operator+=(const BaseCube& X); template inline Mat& operator-=(const BaseCube& X); template inline Mat& operator*=(const BaseCube& X); template inline Mat& operator%=(const BaseCube& X); template inline Mat& operator/=(const BaseCube& X); template inline explicit Mat(const Base& A, const Base& B, const arma_vec_indicator&, const uhword in_vec_state); template inline explicit Mat(const Base& A, const Base& B); inline explicit Mat(const subview& X, const bool reuse_mem); // only to be used by quasi_unwrap and partial_unwrap inline Mat(const subview& X, const arma_vec_indicator&, const uhword in_vec_state); inline Mat(const subview& X); inline Mat& operator= (const subview& X); inline Mat& operator+=(const subview& X); inline Mat& operator-=(const subview& X); inline Mat& operator*=(const subview& X); inline Mat& operator%=(const subview& X); inline Mat& operator/=(const subview& X); inline Mat(const subview_row_strans& X); // subview_row_strans can only be generated by the Proxy class inline Mat(const subview_row_htrans& X); // subview_row_htrans can only be generated by the Proxy class inline Mat(const xvec_htrans& X); // xvec_htrans can only be generated by the Proxy class template inline Mat(const xtrans_mat& X); // xtrans_mat can only be generated by the Proxy class inline Mat(const subview_cube& X, const arma_vec_indicator&, const uhword in_vec_state); inline Mat(const subview_cube& X); inline Mat& operator= (const subview_cube& X); inline Mat& operator+=(const subview_cube& X); inline Mat& operator-=(const subview_cube& X); inline Mat& operator*=(const subview_cube& X); inline Mat& operator%=(const subview_cube& X); inline Mat& operator/=(const subview_cube& X); inline Mat(const diagview& X, const arma_vec_indicator&, const uhword in_vec_state); inline Mat(const diagview& X); inline Mat& operator= (const diagview& X); inline Mat& operator+=(const diagview& X); inline Mat& operator-=(const diagview& X); inline Mat& operator*=(const diagview& X); inline Mat& operator%=(const diagview& X); inline Mat& operator/=(const diagview& X); template inline Mat(const subview_elem1& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const subview_elem1& X); template inline Mat& operator= (const subview_elem1& X); template inline Mat& operator+=(const subview_elem1& X); template inline Mat& operator-=(const subview_elem1& X); template inline Mat& operator*=(const subview_elem1& X); template inline Mat& operator%=(const subview_elem1& X); template inline Mat& operator/=(const subview_elem1& X); template inline Mat(const subview_elem2& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const subview_elem2& X); template inline Mat& operator= (const subview_elem2& X); template inline Mat& operator+=(const subview_elem2& X); template inline Mat& operator-=(const subview_elem2& X); template inline Mat& operator*=(const subview_elem2& X); template inline Mat& operator%=(const subview_elem2& X); template inline Mat& operator/=(const subview_elem2& X); // Operators on sparse matrices (and subviews) template inline explicit Mat(const SpBase& m, const arma_vec_indicator&, const uhword in_vec_state); template inline explicit Mat(const SpBase& m); template inline Mat& operator= (const SpBase& m); template inline Mat& operator+=(const SpBase& m); template inline Mat& operator-=(const SpBase& m); template inline Mat& operator*=(const SpBase& m); template inline Mat& operator%=(const SpBase& m); template inline Mat& operator/=(const SpBase& m); inline explicit Mat(const SpSubview& X, const arma_vec_indicator&, const uhword in_vec_state); inline explicit Mat(const SpSubview& X); inline Mat& operator= (const SpSubview& X); inline Mat& operator+=(const SpSubview& X); inline Mat& operator-=(const SpSubview& X); inline explicit Mat(const spdiagview& X, const arma_vec_indicator&, const uhword in_vec_state); inline explicit Mat(const spdiagview& X); inline Mat& operator= (const spdiagview& X); inline Mat& operator+=(const spdiagview& X); inline Mat& operator-=(const spdiagview& X); inline Mat& operator*=(const spdiagview& X); inline Mat& operator%=(const spdiagview& X); inline Mat& operator/=(const spdiagview& X); [[deprecated("use braced initialiser list instead")]] inline mat_injector operator<<(const eT val); [[deprecated("use braced initialiser list instead")]] inline mat_injector operator<<(const injector_end_of_row<>& x); arma_inline subview_row row(const uword row_num); arma_inline const subview_row row(const uword row_num) const; inline subview_row operator()(const uword row_num, const span& col_span); inline const subview_row operator()(const uword row_num, const span& col_span) const; arma_inline subview_col col(const uword col_num); arma_inline const subview_col col(const uword col_num) const; inline subview_col operator()(const span& row_span, const uword col_num); inline const subview_col operator()(const span& row_span, const uword col_num) const; inline Col unsafe_col(const uword col_num); inline const Col unsafe_col(const uword col_num) const; arma_inline subview rows(const uword in_row1, const uword in_row2); arma_inline const subview rows(const uword in_row1, const uword in_row2) const; arma_inline subview_cols cols(const uword in_col1, const uword in_col2); arma_inline const subview_cols cols(const uword in_col1, const uword in_col2) const; inline subview rows(const span& row_span); inline const subview rows(const span& row_span) const; arma_inline subview_cols cols(const span& col_span); arma_inline const subview_cols cols(const span& col_span) const; arma_inline subview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2); arma_inline const subview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const; arma_inline subview submat(const uword in_row1, const uword in_col1, const SizeMat& s); arma_inline const subview submat(const uword in_row1, const uword in_col1, const SizeMat& s) const; inline subview submat (const span& row_span, const span& col_span); inline const subview submat (const span& row_span, const span& col_span) const; inline subview operator()(const span& row_span, const span& col_span); inline const subview operator()(const span& row_span, const span& col_span) const; inline subview operator()(const uword in_row1, const uword in_col1, const SizeMat& s); inline const subview operator()(const uword in_row1, const uword in_col1, const SizeMat& s) const; inline subview head_rows(const uword N); inline const subview head_rows(const uword N) const; inline subview tail_rows(const uword N); inline const subview tail_rows(const uword N) const; inline subview_cols head_cols(const uword N); inline const subview_cols head_cols(const uword N) const; inline subview_cols tail_cols(const uword N); inline const subview_cols tail_cols(const uword N) const; template arma_inline subview_elem1 elem(const Base& a); template arma_inline const subview_elem1 elem(const Base& a) const; template arma_inline subview_elem1 operator()(const Base& a); template arma_inline const subview_elem1 operator()(const Base& a) const; template arma_inline subview_elem2 elem(const Base& ri, const Base& ci); template arma_inline const subview_elem2 elem(const Base& ri, const Base& ci) const; template arma_inline subview_elem2 submat(const Base& ri, const Base& ci); template arma_inline const subview_elem2 submat(const Base& ri, const Base& ci) const; template arma_inline subview_elem2 operator()(const Base& ri, const Base& ci); template arma_inline const subview_elem2 operator()(const Base& ri, const Base& ci) const; template arma_inline subview_elem2 rows(const Base& ri); template arma_inline const subview_elem2 rows(const Base& ri) const; template arma_inline subview_elem2 cols(const Base& ci); template arma_inline const subview_elem2 cols(const Base& ci) const; arma_inline subview_each1< Mat, 0 > each_col(); arma_inline subview_each1< Mat, 1 > each_row(); arma_inline const subview_each1< Mat, 0 > each_col() const; arma_inline const subview_each1< Mat, 1 > each_row() const; template inline subview_each2< Mat, 0, T1 > each_col(const Base& indices); template inline subview_each2< Mat, 1, T1 > each_row(const Base& indices); template inline const subview_each2< Mat, 0, T1 > each_col(const Base& indices) const; template inline const subview_each2< Mat, 1, T1 > each_row(const Base& indices) const; inline Mat& each_col(const std::function< void( Col&) >& F); inline const Mat& each_col(const std::function< void(const Col&) >& F) const; inline Mat& each_row(const std::function< void( Row&) >& F); inline const Mat& each_row(const std::function< void(const Row&) >& F) const; arma_inline diagview diag(const sword in_id = 0); arma_inline const diagview 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); template inline void shed_rows(const Base& indices); template inline void shed_cols(const Base& indices); [[deprecated("use insert_rows(row_num, N) instead")]] inline void insert_rows(const uword row_num, const uword N, const bool set_to_zero); [[deprecated("use insert_cols(col_num, N) instead")]] inline void insert_cols(const uword col_num, const uword N, const bool set_to_zero); inline void insert_rows(const uword row_num, const uword N); inline void insert_cols(const uword col_num, const uword N); template inline void insert_rows(const uword row_num, const Base& X); template inline void insert_cols(const uword col_num, const Base& X); template inline Mat(const Gen& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const Gen& X); template inline Mat& operator= (const Gen& X); template inline Mat& operator+=(const Gen& X); template inline Mat& operator-=(const Gen& X); template inline Mat& operator*=(const Gen& X); template inline Mat& operator%=(const Gen& X); template inline Mat& operator/=(const Gen& X); template inline Mat(const Op& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const Op& X); template inline Mat& operator= (const Op& X); template inline Mat& operator+=(const Op& X); template inline Mat& operator-=(const Op& X); template inline Mat& operator*=(const Op& X); template inline Mat& operator%=(const Op& X); template inline Mat& operator/=(const Op& X); template inline Mat(const eOp& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const eOp& X); template inline Mat& operator= (const eOp& X); template inline Mat& operator+=(const eOp& X); template inline Mat& operator-=(const eOp& X); template inline Mat& operator*=(const eOp& X); template inline Mat& operator%=(const eOp& X); template inline Mat& operator/=(const eOp& X); template inline Mat(const mtOp& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const mtOp& X); template inline Mat& operator= (const mtOp& X); template inline Mat& operator+=(const mtOp& X); template inline Mat& operator-=(const mtOp& X); template inline Mat& operator*=(const mtOp& X); template inline Mat& operator%=(const mtOp& X); template inline Mat& operator/=(const mtOp& X); template inline Mat(const CubeToMatOp& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const CubeToMatOp& X); template inline Mat& operator= (const CubeToMatOp& X); template inline Mat& operator+=(const CubeToMatOp& X); template inline Mat& operator-=(const CubeToMatOp& X); template inline Mat& operator*=(const CubeToMatOp& X); template inline Mat& operator%=(const CubeToMatOp& X); template inline Mat& operator/=(const CubeToMatOp& X); template inline Mat(const SpToDOp& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const SpToDOp& X); template inline Mat& operator= (const SpToDOp& X); template inline Mat& operator+=(const SpToDOp& X); template inline Mat& operator-=(const SpToDOp& X); template inline Mat& operator*=(const SpToDOp& X); template inline Mat& operator%=(const SpToDOp& X); template inline Mat& operator/=(const SpToDOp& X); template inline explicit Mat(const mtSpReduceOp& X, const arma_vec_indicator&, const uhword in_vec_state); template inline explicit Mat(const mtSpReduceOp& X); template inline Mat& operator= (const mtSpReduceOp& X); template inline Mat& operator+=(const mtSpReduceOp& X); template inline Mat& operator-=(const mtSpReduceOp& X); template inline Mat& operator*=(const mtSpReduceOp& X); template inline Mat& operator%=(const mtSpReduceOp& X); template inline Mat& operator/=(const mtSpReduceOp& X); template inline Mat(const Glue& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const Glue& X); template inline Mat& operator= (const Glue& X); template inline Mat& operator+=(const Glue& X); template inline Mat& operator-=(const Glue& X); template inline Mat& operator*=(const Glue& X); template inline Mat& operator%=(const Glue& X); template inline Mat& operator/=(const Glue& X); template inline Mat& operator+=(const Glue& X); template inline Mat& operator-=(const Glue& X); template inline Mat(const eGlue& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const eGlue& X); template inline Mat& operator= (const eGlue& X); template inline Mat& operator+=(const eGlue& X); template inline Mat& operator-=(const eGlue& X); template inline Mat& operator*=(const eGlue& X); template inline Mat& operator%=(const eGlue& X); template inline Mat& operator/=(const eGlue& X); template inline Mat(const mtGlue& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const mtGlue& X); template inline Mat& operator= (const mtGlue& X); template inline Mat& operator+=(const mtGlue& X); template inline Mat& operator-=(const mtGlue& X); template inline Mat& operator*=(const mtGlue& X); template inline Mat& operator%=(const mtGlue& X); template inline Mat& operator/=(const mtGlue& X); template inline Mat(const SpToDGlue& X, const arma_vec_indicator&, const uhword in_vec_state); template inline Mat(const SpToDGlue& X); template inline Mat& operator= (const SpToDGlue& X); template inline Mat& operator+=(const SpToDGlue& X); template inline Mat& operator-=(const SpToDGlue& X); template inline Mat& operator*=(const SpToDGlue& X); template inline Mat& operator%=(const SpToDGlue& X); template inline Mat& operator/=(const SpToDGlue& X); arma_warn_unused arma_inline const eT& at_alt (const uword ii) const; arma_warn_unused arma_inline eT& operator[] (const uword ii); arma_warn_unused arma_inline const eT& operator[] (const uword ii) const; arma_warn_unused arma_inline eT& at (const uword ii); arma_warn_unused arma_inline const eT& at (const uword ii) const; arma_warn_unused arma_inline eT& operator() (const uword ii); arma_warn_unused arma_inline const eT& operator() (const uword ii) const; #if defined(__cpp_multidimensional_subscript) arma_warn_unused arma_inline eT& operator[] (const uword in_row, const uword in_col); arma_warn_unused arma_inline const eT& operator[] (const uword in_row, const uword in_col) const; #endif arma_warn_unused arma_inline eT& at (const uword in_row, const uword in_col); arma_warn_unused arma_inline const eT& at (const uword in_row, const uword in_col) const; arma_warn_unused arma_inline eT& operator() (const uword in_row, const uword in_col); arma_warn_unused arma_inline const eT& operator() (const uword in_row, const uword in_col) const; arma_inline const Mat& operator++(); arma_inline void operator++(int); arma_inline const Mat& operator--(); arma_inline void operator--(int); 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 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 inline bool is_sorted(const char* direction = "ascend") const; arma_warn_unused inline bool is_sorted(const char* direction, const uword dim) const; template arma_warn_unused inline bool is_sorted_helper(const comparator& comp, const uword dim) const; arma_warn_unused arma_inline bool in_range(const uword ii) 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; arma_warn_unused arma_inline eT* colptr(const uword in_col); arma_warn_unused arma_inline const eT* colptr(const uword in_col) const; arma_warn_unused arma_inline eT* memptr(); arma_warn_unused arma_inline const eT* memptr() const; template inline Mat& copy_size(const Base& X); inline Mat& set_size(const uword new_n_elem); inline Mat& set_size(const uword new_n_rows, const uword new_n_cols); inline Mat& set_size(const SizeMat& s); inline Mat& resize(const uword new_n_elem); inline Mat& resize(const uword new_n_rows, const uword new_n_cols); inline Mat& resize(const SizeMat& s); inline Mat& reshape(const uword new_n_rows, const uword new_n_cols); inline Mat& reshape(const SizeMat& s); [[deprecated("use reshape(n_rows, n_cols) instead")]] inline void reshape(const uword new_n_rows, const uword new_n_cols, const uword dim); //!< NOTE: don't use this form: it will be removed template inline Mat& for_each(functor F); template inline const Mat& for_each(functor F) const; template inline Mat& transform(functor F); template inline Mat& imbue(functor F); inline Mat& replace(const eT old_val, const eT new_val); inline Mat& clean(const pod_type threshold); inline Mat& clamp(const eT min_val, const eT max_val); inline Mat& fill(const eT val); template inline Mat& fill(const fill::fill_class& f); inline Mat& zeros(); inline Mat& zeros(const uword new_n_elem); inline Mat& zeros(const uword new_n_rows, const uword new_n_cols); inline Mat& zeros(const SizeMat& s); inline Mat& ones(); inline Mat& ones(const uword new_n_elem); inline Mat& ones(const uword new_n_rows, const uword new_n_cols); inline Mat& ones(const SizeMat& s); inline Mat& randu(); inline Mat& randu(const uword new_n_elem); inline Mat& randu(const uword new_n_rows, const uword new_n_cols); inline Mat& randu(const SizeMat& s); inline Mat& randn(); inline Mat& randn(const uword new_n_elem); inline Mat& randn(const uword new_n_rows, const uword new_n_cols); inline Mat& randn(const SizeMat& s); inline Mat& eye(); inline Mat& eye(const uword new_n_rows, const uword new_n_cols); inline Mat& eye(const SizeMat& s); arma_cold inline void reset(); arma_cold inline void soft_reset(); template inline void set_real(const Base& X); template inline void set_imag(const Base& X); arma_warn_unused inline eT min() const; arma_warn_unused inline eT max() const; [[deprecated("use .index_min() instead")]] inline eT min(uword& index_of_min_val) const; [[deprecated("use .index_max() instead")]] inline eT max(uword& index_of_max_val) const; [[deprecated("use .index_min() with ind2sub() instead")]] inline eT min(uword& row_of_min_val, uword& col_of_min_val) const; [[deprecated("use .index_max() with ind2sub() instead")]] inline eT max(uword& row_of_max_val, uword& col_of_max_val) const; arma_cold inline bool save(const std::string name, const file_type type = arma_binary) const; arma_cold inline bool save(const hdf5_name& spec, const file_type type = hdf5_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 = auto_detect); arma_cold inline bool load(const hdf5_name& spec, const file_type type = hdf5_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 = auto_detect); [[deprecated("use save() instead")]] inline bool quiet_save(const std::string name, const file_type type = arma_binary) const; [[deprecated("use save() instead")]] inline bool quiet_save(const hdf5_name& spec, const file_type type = hdf5_binary) const; [[deprecated("use save() instead")]] inline bool quiet_save(const csv_name& spec, const file_type type = csv_ascii) const; [[deprecated("use save() instead")]] inline bool quiet_save( std::ostream& os, const file_type type = arma_binary) const; [[deprecated("use load() instead")]] inline bool quiet_load(const std::string name, const file_type type = auto_detect); [[deprecated("use load() instead")]] inline bool quiet_load(const hdf5_name& spec, const file_type type = hdf5_binary); [[deprecated("use load() instead")]] inline bool quiet_load(const csv_name& spec, const file_type type = csv_ascii); [[deprecated("use load() instead")]] inline bool quiet_load( std::istream& is, const file_type type = auto_detect); // for container-like functionality typedef eT value_type; typedef uword size_type; typedef eT* iterator; typedef const eT* const_iterator; typedef eT* col_iterator; typedef const eT* const_col_iterator; class const_row_iterator; class row_iterator { public: inline row_iterator(); inline row_iterator(const row_iterator& X); inline row_iterator(Mat& in_M, const uword in_row, const uword in_col); arma_warn_unused inline eT& operator* (); inline row_iterator& operator++(); arma_warn_unused inline row_iterator operator++(int); inline row_iterator& operator--(); arma_warn_unused inline row_iterator operator--(int); arma_warn_unused inline bool operator!=(const row_iterator& X) const; arma_warn_unused inline bool operator==(const row_iterator& X) const; arma_warn_unused inline bool operator!=(const const_row_iterator& X) const; arma_warn_unused inline bool operator==(const const_row_iterator& X) const; typedef std::bidirectional_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 Mat* M; arma_aligned uword current_row; arma_aligned uword current_col; }; class const_row_iterator { public: inline const_row_iterator(); inline const_row_iterator(const row_iterator& X); inline const_row_iterator(const const_row_iterator& X); inline const_row_iterator(const Mat& in_M, const uword in_row, const uword in_col); arma_warn_unused inline const eT& operator*() const; inline const_row_iterator& operator++(); arma_warn_unused inline const_row_iterator operator++(int); inline const_row_iterator& operator--(); arma_warn_unused inline const_row_iterator operator--(int); arma_warn_unused inline bool operator!=(const row_iterator& X) const; arma_warn_unused inline bool operator==(const row_iterator& X) const; arma_warn_unused inline bool operator!=(const const_row_iterator& X) const; arma_warn_unused inline bool operator==(const const_row_iterator& X) const; 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; arma_aligned const Mat* M; arma_aligned uword current_row; arma_aligned uword current_col; }; class const_row_col_iterator; class row_col_iterator { public: inline row_col_iterator(); inline row_col_iterator(const row_col_iterator& in_it); inline row_col_iterator(Mat& in_M, const uword row = 0, const uword col = 0); arma_warn_unused inline eT& operator*(); inline row_col_iterator& operator++(); arma_warn_unused inline row_col_iterator operator++(int); inline row_col_iterator& operator--(); arma_warn_unused inline row_col_iterator operator--(int); arma_warn_unused inline uword row() const; arma_warn_unused inline uword col() const; arma_warn_unused inline bool operator==(const row_col_iterator& rhs) const; arma_warn_unused inline bool operator!=(const row_col_iterator& rhs) const; arma_warn_unused inline bool operator==(const const_row_col_iterator& rhs) const; arma_warn_unused inline bool operator!=(const const_row_col_iterator& rhs) const; typedef std::bidirectional_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 Mat* M; arma_aligned eT* current_ptr; arma_aligned uword current_col; arma_aligned uword current_row; }; class const_row_col_iterator { public: inline const_row_col_iterator(); inline const_row_col_iterator(const row_col_iterator& in_it); inline const_row_col_iterator(const const_row_col_iterator& in_it); inline const_row_col_iterator(const Mat& in_M, const uword row = 0, const uword col = 0); arma_warn_unused inline const eT& operator*() const; inline const_row_col_iterator& operator++(); arma_warn_unused inline const_row_col_iterator operator++(int); inline const_row_col_iterator& operator--(); arma_warn_unused inline const_row_col_iterator operator--(int); arma_warn_unused inline uword row() const; arma_warn_unused inline uword col() const; arma_warn_unused inline bool operator==(const const_row_col_iterator& rhs) const; arma_warn_unused inline bool operator!=(const const_row_col_iterator& rhs) const; arma_warn_unused inline bool operator==(const row_col_iterator& rhs) const; arma_warn_unused inline bool operator!=(const row_col_iterator& rhs) const; // So that we satisfy the STL iterator types. 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; arma_aligned const Mat* M; arma_aligned const eT* current_ptr; arma_aligned uword current_col; arma_aligned uword current_row; }; 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 end_col (const uword col_num); inline const_col_iterator end_col (const uword col_num) const; inline row_iterator begin_row(const uword row_num); inline const_row_iterator begin_row(const uword row_num) 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 inline eT& front(); arma_warn_unused inline const eT& front() const; arma_warn_unused inline eT& back(); arma_warn_unused inline const eT& back() const; inline void swap(Mat& B); inline void steal_mem(Mat& X); //!< don't use this unless you're writing code internal to Armadillo inline void steal_mem(Mat& X, const bool is_move); //!< don't use this unless you're writing code internal to Armadillo inline void steal_mem_col(Mat& X, const uword max_n_rows); template arma_inline bool is_alias(const Mat& X) const; //!< don't use this unless you're writing code internal to Armadillo template class fixed; protected: inline void init_cold(); inline void init_warm(uword in_n_rows, uword in_n_cols); arma_cold inline void init(const std::string& text); inline void init(const std::initializer_list& list); inline void init(const std::initializer_list< std::initializer_list >& list); template inline void init(const Base& A, const Base& B); inline Mat(const char junk, const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols); inline Mat(const arma_vec_indicator&, const uhword in_vec_state); inline Mat(const arma_vec_indicator&, const uword in_n_rows, const uword in_n_cols, const uhword in_vec_state); inline Mat(const arma_fixed_indicator&, const uword in_n_rows, const uword in_n_cols, const uhword in_vec_state, const eT* in_mem); friend class Cube; friend class subview_cube; friend struct glue_join; friend struct op_strans; friend struct op_htrans; friend struct op_resize; friend struct op_mean; friend struct op_max; friend struct op_min; public: #if defined(ARMA_EXTRA_MAT_PROTO) #include ARMA_INCFILE_WRAP(ARMA_EXTRA_MAT_PROTO) #endif }; template template class Mat::fixed : public Mat { private: using Mat::mem_local; static constexpr uword fixed_n_elem = fixed_n_rows * fixed_n_cols; static constexpr bool use_extra = (fixed_n_elem > arma_config::mat_prealloc); arma_align_mem eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ]; public: typedef fixed Mat_fixed_type; typedef eT elem_type; typedef typename get_pod_type::result pod_type; static constexpr bool is_col = (fixed_n_cols == 1); static constexpr bool is_row = (fixed_n_rows == 1); static constexpr bool is_xvec = false; static const uword n_rows; // value provided below the class definition static const uword n_cols; // value provided below the class definition static const uword n_elem; // value provided below the class definition arma_inline fixed(); arma_inline fixed(const fixed& X); inline fixed(const fill::scalar_holder f); template inline fixed(const fill::fill_class& f); template inline fixed(const Base& A); template inline fixed(const Base& A, const Base& B); inline fixed(const eT* aux_mem); inline fixed(const char* text); inline fixed(const std::string& text); using Mat::operator=; using Mat::operator(); inline fixed(const std::initializer_list& list); inline Mat& operator=(const std::initializer_list& list); inline fixed(const std::initializer_list< std::initializer_list >& list); inline Mat& operator=(const std::initializer_list< std::initializer_list >& list); arma_inline Mat& operator=(const fixed& X); #if defined(ARMA_GOOD_COMPILER) template inline Mat& operator=(const eOp& X); template inline Mat& operator=(const eGlue& X); #endif arma_warn_unused arma_inline const Op< Mat_fixed_type, op_htrans > t() const; arma_warn_unused arma_inline const Op< Mat_fixed_type, op_htrans > ht() const; arma_warn_unused arma_inline const Op< Mat_fixed_type, op_strans > st() const; arma_warn_unused arma_inline const eT& at_alt (const uword i) const; arma_warn_unused arma_inline eT& operator[] (const uword i); arma_warn_unused arma_inline const eT& operator[] (const uword i) const; arma_warn_unused arma_inline eT& at (const uword i); arma_warn_unused arma_inline const eT& at (const uword i) const; arma_warn_unused arma_inline eT& operator() (const uword i); arma_warn_unused arma_inline const eT& operator() (const uword i) const; #if defined(__cpp_multidimensional_subscript) arma_warn_unused arma_inline eT& operator[] (const uword in_row, const uword in_col); arma_warn_unused arma_inline const eT& operator[] (const uword in_row, const uword in_col) const; #endif arma_warn_unused arma_inline eT& at (const uword in_row, const uword in_col); arma_warn_unused arma_inline const eT& at (const uword in_row, const uword in_col) const; arma_warn_unused arma_inline eT& operator() (const uword in_row, const uword in_col); arma_warn_unused arma_inline const eT& operator() (const uword in_row, const uword in_col) const; arma_warn_unused arma_inline eT* colptr(const uword in_col); arma_warn_unused arma_inline const eT* colptr(const uword in_col) const; arma_warn_unused arma_inline eT* memptr(); arma_warn_unused arma_inline const eT* memptr() const; arma_warn_unused arma_inline bool is_vec() const; inline const Mat& fill(const eT val); inline const Mat& zeros(); inline const Mat& ones(); }; // these definitions are outside of the class due to bizarre C++ rules; // C++17 has inline variables to address this shortcoming template template const uword Mat::fixed::n_rows = fixed_n_rows; template template const uword Mat::fixed::n_cols = fixed_n_cols; template template const uword Mat::fixed::n_elem = fixed_n_rows * fixed_n_cols; class Mat_aux { public: template inline static void prefix_pp(Mat& x); template inline static void prefix_pp(Mat< std::complex >& x); template inline static void postfix_pp(Mat& x); template inline static void postfix_pp(Mat< std::complex >& x); template inline static void prefix_mm(Mat& x); template inline static void prefix_mm(Mat< std::complex >& x); template inline static void postfix_mm(Mat& x); template inline static void postfix_mm(Mat< std::complex >& x); template inline static void set_real(Mat& out, const Base& X); template inline static void set_real(Mat< std::complex >& out, const Base< T,T1>& X); template inline static void set_imag(Mat& out, const Base& X); template inline static void set_imag(Mat< std::complex >& out, const Base< T,T1>& X); }; template class Mat_noalias : public Mat {}; //! @}