From eda5bc26f44ee9a6f83dcf8c91f17296d7fc509d Mon Sep 17 00:00:00 2001 From: Nao Pross Date: Mon, 12 Feb 2024 14:52:43 +0100 Subject: Move into version control --- src/armadillo/include/armadillo_bits/Mat_bones.hpp | 945 +++++++++++++++++++++ 1 file changed, 945 insertions(+) create mode 100644 src/armadillo/include/armadillo_bits/Mat_bones.hpp (limited to 'src/armadillo/include/armadillo_bits/Mat_bones.hpp') diff --git a/src/armadillo/include/armadillo_bits/Mat_bones.hpp b/src/armadillo/include/armadillo_bits/Mat_bones.hpp new file mode 100644 index 0000000..baa41da --- /dev/null +++ b/src/armadillo/include/armadillo_bits/Mat_bones.hpp @@ -0,0 +1,945 @@ +// 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 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); + 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); + 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); + + inline explicit Mat(const subview& X, const bool use_colmem); // only to be used by the quasi_unwrap class + + 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); + 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); + 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); + 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); + 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); + 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); + inline Mat& operator= (const SpSubview& X); + + 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); + + + arma_frown("use braced initialiser list instead") inline mat_injector operator<<(const eT val); + arma_frown("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); + + arma_deprecated inline void insert_rows(const uword row_num, const uword N, const bool set_to_zero); + arma_deprecated 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); + 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); + 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); + 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); + 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); + 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); + 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 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); + 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); + 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); + 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); + + arma_deprecated 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; + + inline eT min(uword& index_of_min_val) const; + inline eT max(uword& index_of_max_val) const; + + inline eT min(uword& row_of_min_val, uword& col_of_min_val) const; + 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); + + arma_deprecated inline bool quiet_save(const std::string name, const file_type type = arma_binary) const; + arma_deprecated inline bool quiet_save(const hdf5_name& spec, const file_type type = hdf5_binary) const; + arma_deprecated inline bool quiet_save(const csv_name& spec, const file_type type = csv_ascii) 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 = auto_detect); + arma_deprecated inline bool quiet_load(const hdf5_name& spec, const file_type type = hdf5_binary); + arma_deprecated inline bool quiet_load(const csv_name& spec, const file_type type = csv_ascii); + arma_deprecated 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 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 class glue_join; + friend class op_strans; + friend class op_htrans; + friend class op_resize; + friend class op_mean; + friend class op_max; + friend class 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: + + 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); + }; + + + +//! @} -- cgit v1.2.1