376 lines
9.3 KiB
C++
376 lines
9.3 KiB
C++
// 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 diagmat_proxy
|
|
//! @{
|
|
|
|
|
|
|
|
template<typename T1>
|
|
class diagmat_proxy_default
|
|
{
|
|
public:
|
|
|
|
typedef typename T1::elem_type elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
inline
|
|
diagmat_proxy_default(const T1& X)
|
|
: P ( X )
|
|
, P_is_vec( (resolves_to_vector<T1>::yes) || (P.get_n_rows() == 1) || (P.get_n_cols() == 1) )
|
|
, P_is_col( T1::is_col || (P.get_n_cols() == 1) )
|
|
, n_rows ( P_is_vec ? P.get_n_elem() : P.get_n_rows() )
|
|
, n_cols ( P_is_vec ? P.get_n_elem() : P.get_n_cols() )
|
|
{
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
|
|
arma_inline
|
|
elem_type
|
|
operator[](const uword i) const
|
|
{
|
|
if(Proxy<T1>::use_at == false)
|
|
{
|
|
return P_is_vec ? P[i] : P.at(i,i);
|
|
}
|
|
else
|
|
{
|
|
if(P_is_vec)
|
|
{
|
|
return (P_is_col) ? P.at(i,0) : P.at(0,i);
|
|
}
|
|
else
|
|
{
|
|
return P.at(i,i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
arma_inline
|
|
elem_type
|
|
at(const uword row, const uword col) const
|
|
{
|
|
if(row == col)
|
|
{
|
|
if(Proxy<T1>::use_at == false)
|
|
{
|
|
return (P_is_vec) ? P[row] : P.at(row,row);
|
|
}
|
|
else
|
|
{
|
|
if(P_is_vec)
|
|
{
|
|
return (P_is_col) ? P.at(row,0) : P.at(0,row);
|
|
}
|
|
else
|
|
{
|
|
return P.at(row,row);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return elem_type(0);
|
|
}
|
|
}
|
|
|
|
|
|
inline bool is_alias(const Mat<elem_type>& X) const { return P.is_alias(X); }
|
|
|
|
const Proxy<T1> P;
|
|
const bool P_is_vec;
|
|
const bool P_is_col;
|
|
const uword n_rows;
|
|
const uword n_cols;
|
|
};
|
|
|
|
|
|
|
|
template<typename T1>
|
|
class diagmat_proxy_fixed
|
|
{
|
|
public:
|
|
|
|
typedef typename T1::elem_type elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
inline
|
|
diagmat_proxy_fixed(const T1& X)
|
|
: P(X)
|
|
{
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
|
|
arma_inline
|
|
elem_type
|
|
operator[](const uword i) const
|
|
{
|
|
return (P_is_vec) ? P[i] : P.at(i,i);
|
|
}
|
|
|
|
|
|
arma_inline
|
|
elem_type
|
|
at(const uword row, const uword col) const
|
|
{
|
|
if(row == col)
|
|
{
|
|
return (P_is_vec) ? P[row] : P.at(row,row);
|
|
}
|
|
else
|
|
{
|
|
return elem_type(0);
|
|
}
|
|
}
|
|
|
|
arma_inline bool is_alias(const Mat<elem_type>& X) const { return (void_ptr(&X) == void_ptr(&P)); }
|
|
|
|
const T1& P;
|
|
|
|
//// this may require T1::n_elem etc to be declared as static constexpr inline variables (C++17)
|
|
//// see also the notes in Mat::fixed
|
|
// static constexpr bool P_is_vec = (T1::n_rows == 1) || (T1::n_cols == 1);
|
|
// static constexpr uword n_rows = P_is_vec ? T1::n_elem : T1::n_rows;
|
|
// static constexpr uword n_cols = P_is_vec ? T1::n_elem : T1::n_cols;
|
|
|
|
static const bool P_is_vec = (T1::n_rows == 1) || (T1::n_cols == 1);
|
|
static const uword n_rows = P_is_vec ? T1::n_elem : T1::n_rows;
|
|
static const uword n_cols = P_is_vec ? T1::n_elem : T1::n_cols;
|
|
};
|
|
|
|
|
|
|
|
template<typename T1, bool condition>
|
|
struct diagmat_proxy_redirect {};
|
|
|
|
template<typename T1>
|
|
struct diagmat_proxy_redirect<T1, false> { typedef diagmat_proxy_default<T1> result; };
|
|
|
|
template<typename T1>
|
|
struct diagmat_proxy_redirect<T1, true> { typedef diagmat_proxy_fixed<T1> result; };
|
|
|
|
|
|
template<typename T1>
|
|
class diagmat_proxy : public diagmat_proxy_redirect<T1, is_Mat_fixed<T1>::value>::result
|
|
{
|
|
public:
|
|
inline diagmat_proxy(const T1& X)
|
|
: diagmat_proxy_redirect<T1, is_Mat_fixed<T1>::value>::result(X)
|
|
{
|
|
}
|
|
};
|
|
|
|
|
|
|
|
template<typename eT>
|
|
class diagmat_proxy< Mat<eT> >
|
|
{
|
|
public:
|
|
|
|
typedef eT elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
inline
|
|
diagmat_proxy(const Mat<eT>& X)
|
|
: P ( X )
|
|
, P_is_vec( (X.n_rows == 1) || (X.n_cols == 1) )
|
|
, n_rows ( P_is_vec ? X.n_elem : X.n_rows )
|
|
, n_cols ( P_is_vec ? X.n_elem : X.n_cols )
|
|
{
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
arma_inline elem_type operator[] (const uword i) const { return P_is_vec ? P[i] : P.at(i,i); }
|
|
arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? ( P_is_vec ? P[row] : P.at(row,row) ) : elem_type(0); }
|
|
|
|
arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&X) == void_ptr(&P)); }
|
|
|
|
const Mat<eT>& P;
|
|
const bool P_is_vec;
|
|
const uword n_rows;
|
|
const uword n_cols;
|
|
};
|
|
|
|
|
|
|
|
template<typename eT>
|
|
class diagmat_proxy< Row<eT> >
|
|
{
|
|
public:
|
|
|
|
typedef eT elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
|
|
inline
|
|
diagmat_proxy(const Row<eT>& X)
|
|
: P(X)
|
|
, n_rows(X.n_elem)
|
|
, n_cols(X.n_elem)
|
|
{
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
arma_inline elem_type operator[] (const uword i) const { return P[i]; }
|
|
arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); }
|
|
|
|
arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&X) == void_ptr(&P)); }
|
|
|
|
static constexpr bool P_is_vec = true;
|
|
|
|
const Row<eT>& P;
|
|
const uword n_rows;
|
|
const uword n_cols;
|
|
};
|
|
|
|
|
|
|
|
template<typename eT>
|
|
class diagmat_proxy< Col<eT> >
|
|
{
|
|
public:
|
|
|
|
typedef eT elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
|
|
inline
|
|
diagmat_proxy(const Col<eT>& X)
|
|
: P(X)
|
|
, n_rows(X.n_elem)
|
|
, n_cols(X.n_elem)
|
|
{
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
arma_inline elem_type operator[] (const uword i) const { return P[i]; }
|
|
arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); }
|
|
|
|
arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&X) == void_ptr(&P)); }
|
|
|
|
static constexpr bool P_is_vec = true;
|
|
|
|
const Col<eT>& P;
|
|
const uword n_rows;
|
|
const uword n_cols;
|
|
};
|
|
|
|
|
|
|
|
template<typename eT>
|
|
class diagmat_proxy< subview_row<eT> >
|
|
{
|
|
public:
|
|
|
|
typedef eT elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
|
|
inline
|
|
diagmat_proxy(const subview_row<eT>& X)
|
|
: P(X)
|
|
, n_rows(X.n_elem)
|
|
, n_cols(X.n_elem)
|
|
{
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
arma_inline elem_type operator[] (const uword i) const { return P[i]; }
|
|
arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); }
|
|
|
|
arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&X) == void_ptr(&(P.m))); }
|
|
|
|
static constexpr bool P_is_vec = true;
|
|
|
|
const subview_row<eT>& P;
|
|
const uword n_rows;
|
|
const uword n_cols;
|
|
};
|
|
|
|
|
|
|
|
template<typename eT>
|
|
class diagmat_proxy< subview_col<eT> >
|
|
{
|
|
public:
|
|
|
|
typedef eT elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
|
|
inline
|
|
diagmat_proxy(const subview_col<eT>& X)
|
|
: P(X)
|
|
, n_rows(X.n_elem)
|
|
, n_cols(X.n_elem)
|
|
{
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
arma_inline elem_type operator[] (const uword i) const { return P[i]; }
|
|
arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); }
|
|
|
|
arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&X) == void_ptr(&(P.m))); }
|
|
|
|
static constexpr bool P_is_vec = true;
|
|
|
|
const subview_col<eT>& P;
|
|
const uword n_rows;
|
|
const uword n_cols;
|
|
};
|
|
|
|
|
|
|
|
template<typename T1, typename T2>
|
|
class diagmat_proxy< Glue<T1,T2,glue_times> >
|
|
{
|
|
public:
|
|
|
|
typedef typename T1::elem_type elem_type;
|
|
typedef typename get_pod_type<elem_type>::result pod_type;
|
|
|
|
inline
|
|
diagmat_proxy(const Glue<T1,T2,glue_times>& X)
|
|
{
|
|
op_diagmat::apply_times(P, X.A, X.B);
|
|
|
|
n_rows = P.n_rows;
|
|
n_cols = P.n_cols;
|
|
|
|
arma_debug_sigprint();
|
|
}
|
|
|
|
arma_inline elem_type operator[] (const uword i) const { return P.at(i,i); }
|
|
arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P.at(row,row) : elem_type(0); }
|
|
|
|
constexpr bool is_alias(const Mat<elem_type>&) const { return false; }
|
|
|
|
static constexpr bool P_is_vec = false;
|
|
|
|
Mat<elem_type> P;
|
|
uword n_rows;
|
|
uword n_cols;
|
|
};
|
|
|
|
|
|
|
|
//! @}
|