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/Proxy.hpp | 2537 ++++++++++++++++++++++++ 1 file changed, 2537 insertions(+) create mode 100644 src/armadillo/include/armadillo_bits/Proxy.hpp (limited to 'src/armadillo/include/armadillo_bits/Proxy.hpp') diff --git a/src/armadillo/include/armadillo_bits/Proxy.hpp b/src/armadillo/include/armadillo_bits/Proxy.hpp new file mode 100644 index 0000000..ca3f713 --- /dev/null +++ b/src/armadillo/include/armadillo_bits/Proxy.hpp @@ -0,0 +1,2537 @@ +// 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 Proxy +//! @{ + + +// within each specialisation of the Proxy class: +// +// elem_type = the type of the elements obtained from object Q +// pod_type = the underlying type of elements if elem_type is std::complex +// stored_type = the type of the Q object +// ea_type = the type of the object that provides access to elements via operator[i] +// aligned_ea_type = the type of the object that provides access to elements via at_alt(i) +// +// use_at = boolean indicating whether at(row,col) must be used to get elements +// use_mp = boolean indicating whether OpenMP can be used while processing elements +// has_subview = boolean indicating whether the Q object has a subview +// +// is_row = boolean indicating whether the Q object can be treated a row vector +// is_col = boolean indicating whether the Q object can be treated a column vector +// is_xvec = boolean indicating whether the Q object is a vector with unknown orientation +// +// Q = object that can be unwrapped via the unwrap family of classes (ie. Q must be convertible to Mat) +// +// get_n_rows() = return the number of rows in Q +// get_n_cols() = return the number of columns in Q +// get_n_elem() = return the number of elements in Q +// +// operator[i] = linear element accessor; valid only if the 'use_at' boolean is false +// at(row,col) = access elements via (row,col); valid only if the 'use_at' boolean is true +// at_alt(i) = aligned linear element accessor; valid only if the 'use_at' boolean is false and is_aligned() returns true +// +// get_ea() = return the object that provides linear access to elements via operator[i] +// get_aligned_ea() = return the object that provides linear access to elements via at_alt(i); valid only if is_aligned() returns true +// +// is_alias(X) = return true/false indicating whether the Q object aliases matrix X +// has_overlap(X) = return true/false indicating whether the Q object has overlap with subview X +// is_aligned() = return true/false indicating whether the Q object has aligned memory + + + +template +struct Proxy_default + { + inline Proxy_default(const T1&) + { + arma_type_check(( is_arma_type::value == false )); + } + }; + + + +template +struct Proxy_fixed + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef T1 stored_type; + typedef const elem_type* ea_type; + typedef const T1& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = T1::is_row; + static constexpr bool is_col = T1::is_col; + static constexpr bool is_xvec = T1::is_xvec; + + arma_aligned const T1& Q; + + inline explicit Proxy_fixed(const T1& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + //// this may require T1::n_elem etc to be declared as static constexpr inline variables (C++17) + //// see also the notes in Mat::fixed + //// https://en.cppreference.com/w/cpp/language/static + //// https://en.cppreference.com/w/cpp/language/inline + // + // static constexpr uword get_n_rows() { return T1::n_rows; } + // static constexpr uword get_n_cols() { return T1::n_cols; } + // static constexpr uword get_n_elem() { return T1::n_elem; } + + arma_inline uword get_n_rows() const { return is_row ? 1 : T1::n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : T1::n_cols; } + arma_inline uword get_n_elem() const { return T1::n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&Q) == void_ptr(&X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const + { + #if defined(ARMA_HAVE_ALIGNED_ATTRIBUTE) + return true; + #else + return memory::is_aligned(Q.memptr()); + #endif + } + }; + + + +template +struct Proxy_redirect {}; + +template +struct Proxy_redirect { typedef Proxy_default result; }; + +template +struct Proxy_redirect { typedef Proxy_fixed result; }; + + + +template +struct Proxy : public Proxy_redirect::value>::result + { + inline Proxy(const T1& A) + : Proxy_redirect::value>::result(A) + { + } + }; + + + +template +struct Proxy< Mat > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const eT* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + arma_aligned const Mat& Q; + + inline explicit Proxy(const Mat& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&Q) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< Col > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Col stored_type; + typedef const eT* ea_type; + typedef const Col& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const Col& Q; + + inline explicit Proxy(const Col& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&Q) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< Row > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Row stored_type; + typedef const eT* ea_type; + typedef const Row& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = true; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + arma_aligned const Row& Q; + + inline explicit Proxy(const Row& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + constexpr uword get_n_rows() const { return 1; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword, const uword c) const { return Q[c]; } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&Q) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< Gen > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Gen stored_type; + typedef const Gen& ea_type; + typedef const Gen& aligned_ea_type; + + static constexpr bool use_at = Gen::use_at; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = Gen::is_row; + static constexpr bool is_col = Gen::is_col; + static constexpr bool is_xvec = Gen::is_xvec; + + arma_aligned const Gen& Q; + + inline explicit Proxy(const Gen& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return (is_row ? 1 : Q.n_rows); } + arma_inline uword get_n_cols() const { return (is_col ? 1 : Q.n_cols); } + arma_inline uword get_n_elem() const { return (is_row ? 1 : Q.n_rows) * (is_col ? 1 : Q.n_cols); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + constexpr bool is_aligned() const { return Gen::is_simple; } + }; + + + +template +struct Proxy< eOp > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef eOp stored_type; + typedef const eOp& ea_type; + typedef const eOp& aligned_ea_type; + + static constexpr bool use_at = eOp::use_at; + static constexpr bool use_mp = eOp::use_mp; + static constexpr bool has_subview = eOp::has_subview; + + static constexpr bool is_row = eOp::is_row; + static constexpr bool is_col = eOp::is_col; + static constexpr bool is_xvec = eOp::is_xvec; + + arma_aligned const eOp& Q; + + inline explicit Proxy(const eOp& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.get_n_rows(); } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.get_n_cols(); } + arma_inline uword get_n_elem() const { return Q.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return Q.P.is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return Q.P.has_overlap(X); } + + arma_inline bool is_aligned() const { return Q.P.is_aligned(); } + }; + + + +template +struct Proxy< eGlue > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef eGlue stored_type; + typedef const eGlue& ea_type; + typedef const eGlue& aligned_ea_type; + + static constexpr bool use_at = eGlue::use_at; + static constexpr bool use_mp = eGlue::use_mp; + static constexpr bool has_subview = eGlue::has_subview; + + static constexpr bool is_row = eGlue::is_row; + static constexpr bool is_col = eGlue::is_col; + static constexpr bool is_xvec = eGlue::is_xvec; + + arma_aligned const eGlue& Q; + + inline explicit Proxy(const eGlue& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.get_n_rows(); } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.get_n_cols(); } + arma_inline uword get_n_elem() const { return Q.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (Q.P1.is_alias(X) || Q.P2.is_alias(X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return (Q.P1.has_overlap(X) || Q.P2.has_overlap(X)); } + + arma_inline bool is_aligned() const { return (Q.P1.is_aligned() && Q.P2.is_aligned()); } + }; + + + +template +struct Proxy< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = Op::is_row; + static constexpr bool is_col = Op::is_col; + static constexpr bool is_xvec = Op::is_xvec; + + arma_aligned const Mat Q; + + inline explicit Proxy(const Op& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< Glue > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = Glue::is_row; + static constexpr bool is_col = Glue::is_col; + static constexpr bool is_xvec = Glue::is_xvec; + + arma_aligned const Mat Q; + + inline explicit Proxy(const Glue& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< Glue > + { + typedef Glue this_Glue_type; + typedef Proxy< Glue > this_Proxy_type; + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef this_Glue_type stored_type; + typedef const this_Proxy_type& ea_type; + typedef const this_Proxy_type& aligned_ea_type; + + static constexpr bool use_at = (Proxy::use_at || Proxy::use_at ); + static constexpr bool use_mp = (Proxy::use_mp || Proxy::use_mp ); + static constexpr bool has_subview = (Proxy::has_subview || Proxy::has_subview); + + static constexpr bool is_row = this_Glue_type::is_row; + static constexpr bool is_col = this_Glue_type::is_col; + static constexpr bool is_xvec = this_Glue_type::is_xvec; + + arma_aligned const this_Glue_type& Q; + arma_aligned const Proxy P1; + arma_aligned const Proxy P2; + + arma_lt_comparator comparator; + + inline explicit Proxy(const this_Glue_type& X) + : Q (X ) + , P1(X.A) + , P2(X.B) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(P1, P2, "element-wise min()"); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : P1.get_n_rows(); } + arma_inline uword get_n_cols() const { return is_col ? 1 : P1.get_n_cols(); } + arma_inline uword get_n_elem() const { return P1.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { const elem_type A = P1[i]; const elem_type B = P2[i]; return comparator(A,B) ? A : B; } + arma_inline elem_type at (const uword r, const uword c) const { const elem_type A = P1.at(r,c); const elem_type B = P2.at(r,c); return comparator(A,B) ? A : B; } + arma_inline elem_type at_alt (const uword i) const { const elem_type A = P1.at_alt(i); const elem_type B = P2.at_alt(i); return comparator(A,B) ? A : B; } + + arma_inline ea_type get_ea() const { return *this; } + arma_inline aligned_ea_type get_aligned_ea() const { return *this; } + + template + arma_inline bool is_alias(const Mat& X) const { return (P1.is_alias(X) || P2.is_alias(X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return (P1.has_overlap(X) || P2.has_overlap(X)); } + + arma_inline bool is_aligned() const { return (P1.is_aligned() && P2.is_aligned()); } + }; + + + +template +struct Proxy< Glue > + { + typedef Glue this_Glue_type; + typedef Proxy< Glue > this_Proxy_type; + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef this_Glue_type stored_type; + typedef const this_Proxy_type& ea_type; + typedef const this_Proxy_type& aligned_ea_type; + + static constexpr bool use_at = (Proxy::use_at || Proxy::use_at ); + static constexpr bool use_mp = (Proxy::use_mp || Proxy::use_mp ); + static constexpr bool has_subview = (Proxy::has_subview || Proxy::has_subview); + + static constexpr bool is_row = this_Glue_type::is_row; + static constexpr bool is_col = this_Glue_type::is_col; + static constexpr bool is_xvec = this_Glue_type::is_xvec; + + arma_aligned const this_Glue_type& Q; + arma_aligned const Proxy P1; + arma_aligned const Proxy P2; + + arma_gt_comparator comparator; + + inline explicit Proxy(const this_Glue_type& X) + : Q (X ) + , P1(X.A) + , P2(X.B) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(P1, P2, "element-wise max()"); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : P1.get_n_rows(); } + arma_inline uword get_n_cols() const { return is_col ? 1 : P1.get_n_cols(); } + arma_inline uword get_n_elem() const { return P1.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { const elem_type A = P1[i]; const elem_type B = P2[i]; return comparator(A,B) ? A : B; } + arma_inline elem_type at (const uword r, const uword c) const { const elem_type A = P1.at(r,c); const elem_type B = P2.at(r,c); return comparator(A,B) ? A : B; } + arma_inline elem_type at_alt (const uword i) const { const elem_type A = P1.at_alt(i); const elem_type B = P2.at_alt(i); return comparator(A,B) ? A : B; } + + arma_inline ea_type get_ea() const { return *this; } + arma_inline aligned_ea_type get_aligned_ea() const { return *this; } + + template + arma_inline bool is_alias(const Mat& X) const { return (P1.is_alias(X) || P2.is_alias(X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return (P1.has_overlap(X) || P2.has_overlap(X)); } + + arma_inline bool is_aligned() const { return (P1.is_aligned() && P2.is_aligned()); } + }; + + + +template +struct Proxy< mtOp > + { + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = mtOp::is_row; + static constexpr bool is_col = mtOp::is_col; + static constexpr bool is_xvec = mtOp::is_xvec; + + arma_aligned const Mat Q; + + inline explicit Proxy(const mtOp& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r,c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< mtGlue > + { + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = mtGlue::is_row; + static constexpr bool is_col = mtGlue::is_col; + static constexpr bool is_xvec = mtGlue::is_xvec; + + arma_aligned const Mat Q; + + inline explicit Proxy(const mtGlue& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r,c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< CubeToMatOp > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = CubeToMatOp::is_row; + static constexpr bool is_col = CubeToMatOp::is_col; + static constexpr bool is_xvec = CubeToMatOp::is_xvec; + + arma_aligned const Mat Q; + + inline explicit Proxy(const CubeToMatOp& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< CubeToMatOp > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const unwrap_cube U; + arma_aligned const Mat Q; + + inline explicit Proxy(const CubeToMatOp& A) + : U(A.m) + , Q(const_cast(U.M.memptr()), U.M.n_elem, 1, false, true) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< SpToDOp > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = SpToDOp::is_row; + static constexpr bool is_col = SpToDOp::is_col; + static constexpr bool is_xvec = SpToDOp::is_xvec; + + arma_aligned const Mat Q; + + inline explicit Proxy(const SpToDOp& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< SpToDOp > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const unwrap_spmat U; + arma_aligned const Mat Q; + + inline explicit Proxy(const SpToDOp& A) + : U(A.m) + , Q(const_cast(U.M.values), U.M.n_nonzero, 1, false, true) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< SpToDGlue > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = SpToDGlue::is_row; + static constexpr bool is_col = SpToDGlue::is_col; + static constexpr bool is_xvec = SpToDGlue::is_xvec; + + arma_aligned const Mat Q; + + inline explicit Proxy(const SpToDGlue& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< subview > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview stored_type; + typedef const subview& ea_type; + typedef const subview& aligned_ea_type; + + static constexpr bool use_at = true; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + arma_aligned const subview& Q; + + inline explicit Proxy(const subview& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&(Q.m)) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return Q.check_overlap(X); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< subview_col > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_col stored_type; + typedef const eT* ea_type; + typedef const subview_col& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const subview_col& Q; + + inline explicit Proxy(const subview_col& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.colmem; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&(Q.m)) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return Q.check_overlap(X); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.colmem); } + }; + + + +template +struct Proxy< subview_cols > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const eT* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + arma_aligned const subview_cols& sv; + arma_aligned const Mat Q; + + inline explicit Proxy(const subview_cols& A) + : sv(A) + , Q ( const_cast( A.colptr(0) ), A.n_rows, A.n_cols, false, false ) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r,c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&(sv.m)) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return sv.check_overlap(X); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< subview_row > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_row stored_type; + typedef const subview_row& ea_type; + typedef const subview_row& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = true; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + arma_aligned const subview_row& Q; + + inline explicit Proxy(const subview_row& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + constexpr uword get_n_rows() const { return 1; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword, const uword c) const { return Q[c]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&(Q.m)) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return Q.check_overlap(X); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< subview_elem1 > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_elem1 stored_type; + typedef const Proxy< subview_elem1 >& ea_type; + typedef const Proxy< subview_elem1 >& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const subview_elem1& Q; + arma_aligned const Proxy R; + + inline explicit Proxy(const subview_elem1& A) + : Q(A) + , R(A.a.get_ref()) + { + arma_extra_debug_sigprint(); + + const bool R_is_vec = ((R.get_n_rows() == 1) || (R.get_n_cols() == 1)); + const bool R_is_empty = (R.get_n_elem() == 0); + + arma_debug_check( ((R_is_vec == false) && (R_is_empty == false)), "Mat::elem(): given object must be a vector" ); + } + + arma_inline uword get_n_rows() const { return R.get_n_elem(); } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return R.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { const uword ii = (Proxy::use_at) ? R.at(i,0) : R[i]; arma_debug_check_bounds( (ii >= Q.m.n_elem), "Mat::elem(): index out of bounds" ); return Q.m[ii]; } + arma_inline elem_type at (const uword r, const uword) const { const uword ii = (Proxy::use_at) ? R.at(r,0) : R[r]; arma_debug_check_bounds( (ii >= Q.m.n_elem), "Mat::elem(): index out of bounds" ); return Q.m[ii]; } + arma_inline elem_type at_alt (const uword i) const { const uword ii = (Proxy::use_at) ? R.at(i,0) : R[i]; arma_debug_check_bounds( (ii >= Q.m.n_elem), "Mat::elem(): index out of bounds" ); return Q.m[ii]; } + + arma_inline ea_type get_ea() const { return (*this); } + arma_inline aligned_ea_type get_aligned_ea() const { return (*this); } + + template + arma_inline bool is_alias(const Mat& X) const { return ( (void_ptr(&X) == void_ptr(&(Q.m))) || (R.is_alias(X)) ); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< subview_elem2 > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const eT* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const subview_elem2& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< diagview > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef diagview stored_type; + typedef const diagview& ea_type; + typedef const diagview& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const diagview& Q; + + inline explicit Proxy(const diagview& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q.at(r, 0); } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (is_same_type::value) ? (void_ptr(&(Q.m)) == void_ptr(&X)) : false; } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy_diagvec_mat + { + inline Proxy_diagvec_mat(const T1&) {} + }; + + + +template +struct Proxy_diagvec_mat< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef diagview stored_type; + typedef const diagview& ea_type; + typedef const diagview& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const Mat& R; + arma_aligned const diagview Q; + + inline explicit Proxy_diagvec_mat(const Op& A) + : R(A.m), Q( R.diag() ) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q.at(r, 0); } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&R) == void_ptr(&X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy_diagvec_expr + { + inline Proxy_diagvec_expr(const T1&) {} + }; + + + +template +struct Proxy_diagvec_expr< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const Mat Q; + + inline explicit Proxy_diagvec_expr(const Op& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q.at(r, 0); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy_diagvec_redirect {}; + +template +struct Proxy_diagvec_redirect< Op, true > { typedef Proxy_diagvec_mat < Op > result; }; + +template +struct Proxy_diagvec_redirect< Op, false> { typedef Proxy_diagvec_expr< Op > result; }; + + + +template +struct Proxy< Op > + : public Proxy_diagvec_redirect< Op, is_Mat::value >::result + { + typedef typename Proxy_diagvec_redirect< Op, is_Mat::value >::result Proxy_diagvec; + + inline explicit Proxy(const Op& A) + : Proxy_diagvec(A) + { + arma_extra_debug_sigprint(); + } + }; + + + +template +struct Proxy< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const Op& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q.at(r, 0); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy_xtrans_default + { + inline Proxy_xtrans_default(const T1&) {} + }; + + + +template +struct Proxy_xtrans_default< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef xtrans_mat stored_type; + typedef const xtrans_mat& ea_type; + typedef const xtrans_mat& aligned_ea_type; + + static constexpr bool use_at = true; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + const unwrap U; + const xtrans_mat Q; + + inline explicit Proxy_xtrans_default(const Op& A) + : U(A.m) + , Q(U.M) + { + arma_extra_debug_sigprint(); + } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return void_ptr(&(U.M)) == void_ptr(&X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy_xtrans_default< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef xtrans_mat stored_type; + typedef const xtrans_mat& ea_type; + typedef const xtrans_mat& aligned_ea_type; + + static constexpr bool use_at = true; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + const unwrap U; + const xtrans_mat Q; + + inline explicit Proxy_xtrans_default(const Op& A) + : U(A.m) + , Q(U.M) + { + arma_extra_debug_sigprint(); + } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return void_ptr(&(U.M)) == void_ptr(&X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy_xtrans_vector + { + inline Proxy_xtrans_vector(const T1&) {} + }; + + + +template +struct Proxy_xtrans_vector< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = quasi_unwrap::has_subview; + + // NOTE: the Op class takes care of swapping row and col for op_htrans + static constexpr bool is_row = Op::is_row; + static constexpr bool is_col = Op::is_col; + static constexpr bool is_xvec = Op::is_xvec; + + arma_aligned const quasi_unwrap U; // avoid copy if T1 is a Row, Col or subview_col + arma_aligned const Mat Q; + + inline Proxy_xtrans_vector(const Op& A) + : U(A.m) + , Q(const_cast(U.M.memptr()), U.M.n_cols, U.M.n_rows, false, false) + { + arma_extra_debug_sigprint(); + } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return U.is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy_xtrans_vector< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = quasi_unwrap::has_subview; + + // NOTE: the Op class takes care of swapping row and col for op_strans + static constexpr bool is_row = Op::is_row; + static constexpr bool is_col = Op::is_col; + static constexpr bool is_xvec = Op::is_xvec; + + arma_aligned const quasi_unwrap U; // avoid copy if T1 is a Row, Col or subview_col + arma_aligned const Mat Q; + + inline Proxy_xtrans_vector(const Op& A) + : U(A.m) + , Q(const_cast(U.M.memptr()), U.M.n_cols, U.M.n_rows, false, false) + { + arma_extra_debug_sigprint(); + } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return U.is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy_xtrans_redirect {}; + +template +struct Proxy_xtrans_redirect { typedef Proxy_xtrans_default result; }; + +template +struct Proxy_xtrans_redirect { typedef Proxy_xtrans_vector result; }; + + + +template +struct Proxy< Op > + : public + Proxy_xtrans_redirect + < + Op, + ((is_cx::no) && ((Op::is_row) || (Op::is_col)) ) + >::result + { + typedef + typename + Proxy_xtrans_redirect + < + Op, + ((is_cx::no) && ((Op::is_row) || (Op::is_col)) ) + >::result + Proxy_xtrans; + + typedef typename Proxy_xtrans::elem_type elem_type; + typedef typename Proxy_xtrans::pod_type pod_type; + typedef typename Proxy_xtrans::stored_type stored_type; + typedef typename Proxy_xtrans::ea_type ea_type; + typedef typename Proxy_xtrans::aligned_ea_type aligned_ea_type; + + static constexpr bool use_at = Proxy_xtrans::use_at; + static constexpr bool use_mp = Proxy_xtrans::use_mp; + static constexpr bool has_subview = Proxy_xtrans::has_subview; + + static constexpr bool is_row = Proxy_xtrans::is_row; + static constexpr bool is_col = Proxy_xtrans::is_col; + static constexpr bool is_xvec = Proxy_xtrans::is_xvec; + + using Proxy_xtrans::Q; + + inline explicit Proxy(const Op& A) + : Proxy_xtrans(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Proxy_xtrans::get_ea(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Proxy_xtrans::get_aligned_ea(); } + + template + arma_inline bool is_alias(const Mat& X) const { return Proxy_xtrans::is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return Proxy_xtrans::has_overlap(X); } + + arma_inline bool is_aligned() const { return Proxy_xtrans::is_aligned(); } + }; + + + +template +struct Proxy< Op > + : public + Proxy_xtrans_redirect + < + Op, + ( (Op::is_row) || (Op::is_col) ) + >::result + { + typedef + typename + Proxy_xtrans_redirect + < + Op, + ( (Op::is_row) || (Op::is_col) ) + >::result + Proxy_xtrans; + + typedef typename Proxy_xtrans::elem_type elem_type; + typedef typename Proxy_xtrans::pod_type pod_type; + typedef typename Proxy_xtrans::stored_type stored_type; + typedef typename Proxy_xtrans::ea_type ea_type; + typedef typename Proxy_xtrans::aligned_ea_type aligned_ea_type; + + static constexpr bool use_at = Proxy_xtrans::use_at; + static constexpr bool use_mp = Proxy_xtrans::use_mp; + static constexpr bool has_subview = Proxy_xtrans::has_subview; + + static constexpr bool is_row = Proxy_xtrans::is_row; + static constexpr bool is_col = Proxy_xtrans::is_col; + static constexpr bool is_xvec = Proxy_xtrans::is_xvec; + + using Proxy_xtrans::Q; + + inline explicit Proxy(const Op& A) + : Proxy_xtrans(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Proxy_xtrans::get_ea(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Proxy_xtrans::get_aligned_ea(); } + + template + arma_inline bool is_alias(const Mat& X) const { return Proxy_xtrans::is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return Proxy_xtrans::has_overlap(X); } + + arma_inline bool is_aligned() const { return Proxy_xtrans::is_aligned(); } + }; + + + +template +struct Proxy_subview_row_htrans_cx + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_row_htrans stored_type; + typedef const subview_row_htrans& ea_type; + typedef const subview_row_htrans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const subview_row_htrans Q; + + inline explicit Proxy_subview_row_htrans_cx(const Op, op_htrans>& A) + : Q(A.m) + { + arma_extra_debug_sigprint(); + } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&(Q.sv_row.m)) == void_ptr(&X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + }; + + + +template +struct Proxy_subview_row_htrans_non_cx + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_row_strans stored_type; + typedef const subview_row_strans& ea_type; + typedef const subview_row_strans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const subview_row_strans Q; + + inline explicit Proxy_subview_row_htrans_non_cx(const Op, op_htrans>& A) + : Q(A.m) + { + arma_extra_debug_sigprint(); + } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&(Q.sv_row.m)) == void_ptr(&X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + }; + + + +template +struct Proxy_subview_row_htrans_redirect {}; + +template +struct Proxy_subview_row_htrans_redirect { typedef Proxy_subview_row_htrans_cx result; }; + +template +struct Proxy_subview_row_htrans_redirect { typedef Proxy_subview_row_htrans_non_cx result; }; + + + +template +struct Proxy< Op, op_htrans> > + : public + Proxy_subview_row_htrans_redirect + < + eT, + is_cx::yes + >::result + { + typedef + typename + Proxy_subview_row_htrans_redirect + < + eT, + is_cx::yes + >::result + Proxy_sv_row_ht; + + typedef typename Proxy_sv_row_ht::elem_type elem_type; + typedef typename Proxy_sv_row_ht::pod_type pod_type; + typedef typename Proxy_sv_row_ht::stored_type stored_type; + typedef typename Proxy_sv_row_ht::ea_type ea_type; + typedef typename Proxy_sv_row_ht::ea_type aligned_ea_type; + + static constexpr bool use_at = Proxy_sv_row_ht::use_at; + static constexpr bool use_mp = Proxy_sv_row_ht::use_mp; + static constexpr bool has_subview = Proxy_sv_row_ht::has_subview; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + using Proxy_sv_row_ht::Q; + + inline explicit Proxy(const Op, op_htrans>& A) + : Proxy_sv_row_ht(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return Proxy_sv_row_ht::is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return Proxy_sv_row_ht::has_overlap(X); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< Op, op_strans> > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_row_strans stored_type; + typedef const subview_row_strans& ea_type; + typedef const subview_row_strans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const subview_row_strans Q; + + inline explicit Proxy(const Op, op_strans>& A) + : Q(A.m) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&(Q.sv_row.m)) == void_ptr(&X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< Op< Row< std::complex >, op_htrans> > + { + typedef typename std::complex eT; + + typedef typename std::complex elem_type; + typedef T pod_type; + typedef xvec_htrans stored_type; + typedef const xvec_htrans& ea_type; + typedef const xvec_htrans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + const xvec_htrans Q; + const Row& src; + + inline explicit Proxy(const Op< Row< std::complex >, op_htrans>& A) + : Q (A.m.memptr(), A.m.n_rows, A.m.n_cols) + , src(A.m) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return void_ptr(&src) == void_ptr(&X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< Op< Col< std::complex >, op_htrans> > + { + typedef typename std::complex eT; + + typedef typename std::complex elem_type; + typedef T pod_type; + typedef xvec_htrans stored_type; + typedef const xvec_htrans& ea_type; + typedef const xvec_htrans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = true; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + const xvec_htrans Q; + const Col& src; + + inline explicit Proxy(const Op< Col< std::complex >, op_htrans>& A) + : Q (A.m.memptr(), A.m.n_rows, A.m.n_cols) + , src(A.m) + { + arma_extra_debug_sigprint(); + } + + constexpr uword get_n_rows() const { return 1; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword, const uword c) const { return Q[c]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return void_ptr(&src) == void_ptr(&X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< Op< subview_col< std::complex >, op_htrans> > + { + typedef typename std::complex eT; + + typedef typename std::complex elem_type; + typedef T pod_type; + typedef xvec_htrans stored_type; + typedef const xvec_htrans& ea_type; + typedef const xvec_htrans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = true; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + const xvec_htrans Q; + const subview_col& src; + + inline explicit Proxy(const Op< subview_col< std::complex >, op_htrans>& A) + : Q (A.m.colptr(0), A.m.n_rows, A.m.n_cols) + , src(A.m) + { + arma_extra_debug_sigprint(); + } + + constexpr uword get_n_rows() const { return 1; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword, const uword c) const { return Q[c]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return void_ptr(&src.m) == void_ptr(&X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef eOp< Op, eop_scalar_times> stored_type; + typedef const eOp< Op, eop_scalar_times>& ea_type; + typedef const eOp< Op, eop_scalar_times>& aligned_ea_type; + + static constexpr bool use_at = eOp< Op, eop_scalar_times>::use_at; + static constexpr bool use_mp = eOp< Op, eop_scalar_times>::use_mp; + static constexpr bool has_subview = eOp< Op, eop_scalar_times>::has_subview; + + // NOTE: the Op class takes care of swapping row and col for op_htrans + static constexpr bool is_row = eOp< Op, eop_scalar_times>::is_row; + static constexpr bool is_col = eOp< Op, eop_scalar_times>::is_col; + static constexpr bool is_xvec = eOp< Op, eop_scalar_times>::is_xvec; + + arma_aligned const Op R; + arma_aligned const eOp< Op, eop_scalar_times > Q; + + inline explicit Proxy(const Op& A) + : R(A.m) + , Q(R, A.aux) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return is_row ? 1 : Q.get_n_rows(); } + arma_inline uword get_n_cols() const { return is_col ? 1 : Q.get_n_cols(); } + arma_inline uword get_n_elem() const { return Q.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r, c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return Q.P.is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return Q.P.is_aligned(); } + }; + + + +template +struct Proxy< subview_row_strans > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_row_strans stored_type; + typedef const subview_row_strans& ea_type; + typedef const subview_row_strans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const subview_row_strans& Q; + + inline explicit Proxy(const subview_row_strans& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&(Q.sv_row.m)) == void_ptr(&X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< subview_row_htrans > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_row_htrans stored_type; + typedef const subview_row_htrans& ea_type; + typedef const subview_row_htrans& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const subview_row_htrans& Q; + + inline explicit Proxy(const subview_row_htrans& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q[i]; } + + arma_inline ea_type get_ea() const { return Q; } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&(Q.sv_row.m)) == void_ptr(&X)); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + constexpr bool is_aligned() const { return false; } + }; + + + +template +struct Proxy< xtrans_mat > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const eT* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const xtrans_mat& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r,c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy< xvec_htrans > + { + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const eT* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = false; + + static constexpr bool is_row = false; + static constexpr bool is_col = false; + static constexpr bool is_xvec = true; + + arma_aligned const Mat Q; + + inline explicit Proxy(const xvec_htrans& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword c) const { return Q.at(r,c); } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + constexpr bool is_alias(const Mat&) const { return false; } + + template + constexpr bool has_overlap(const subview&) const { return false; } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy_vectorise_col_mat + { + inline Proxy_vectorise_col_mat(const T1&) {} + }; + + + +template +struct Proxy_vectorise_col_mat< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + typedef const Mat& aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = false; + static constexpr bool has_subview = true; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const unwrap U; + arma_aligned const Mat Q; + + inline explicit Proxy_vectorise_col_mat(const Op& A) + : U(A.m) + , Q(const_cast(U.M.memptr()), U.M.n_elem, 1, false, false) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword r, const uword) const { return Q[r]; } + arma_inline elem_type at_alt (const uword i) const { return Q.at_alt(i); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + arma_inline aligned_ea_type get_aligned_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return ( void_ptr(&X) == void_ptr(&(U.M)) ); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return memory::is_aligned(Q.memptr()); } + }; + + + +template +struct Proxy_vectorise_col_expr + { + inline Proxy_vectorise_col_expr(const T1&) {} + }; + + + +template +struct Proxy_vectorise_col_expr< Op > + { + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Op stored_type; + typedef typename Proxy::ea_type ea_type; + typedef typename Proxy::aligned_ea_type aligned_ea_type; + + static constexpr bool use_at = false; + static constexpr bool use_mp = Proxy::use_mp; + static constexpr bool has_subview = Proxy::has_subview; + + static constexpr bool is_row = false; + static constexpr bool is_col = true; + static constexpr bool is_xvec = false; + + arma_aligned const Op& Q; + arma_aligned const Proxy R; + + inline explicit Proxy_vectorise_col_expr(const Op& A) + : Q(A) + , R(A.m) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return R.get_n_elem(); } + constexpr uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return R.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return R[i]; } + arma_inline elem_type at (const uword r, const uword) const { return R.at(r, 0); } + arma_inline elem_type at_alt (const uword i) const { return R.at_alt(i); } + + arma_inline ea_type get_ea() const { return R.get_ea(); } + arma_inline aligned_ea_type get_aligned_ea() const { return R.get_aligned_ea(); } + + template + arma_inline bool is_alias(const Mat& X) const { return R.is_alias(X); } + + template + arma_inline bool has_overlap(const subview& X) const { return is_alias(X.m); } + + arma_inline bool is_aligned() const { return R.is_aligned(); } + }; + + + +template +struct Proxy_vectorise_col_redirect {}; + +template +struct Proxy_vectorise_col_redirect< Op, true > { typedef Proxy_vectorise_col_mat < Op > result; }; + +template +struct Proxy_vectorise_col_redirect< Op, false> { typedef Proxy_vectorise_col_expr< Op > result; }; + + + +template +struct Proxy< Op > + : public Proxy_vectorise_col_redirect< Op, (Proxy::use_at) >::result + { + typedef typename Proxy_vectorise_col_redirect< Op, (Proxy::use_at) >::result Proxy_vectorise_col; + + inline explicit Proxy(const Op& A) + : Proxy_vectorise_col(A) + { + arma_extra_debug_sigprint(); + } + }; + + + +//! @} -- cgit v1.2.1