499 lines
11 KiB
C++
499 lines
11 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 BaseCube
|
|
//! @{
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
arma_inline
|
|
const derived&
|
|
BaseCube<elem_type,derived>::get_ref() const
|
|
{
|
|
return static_cast<const derived&>(*this);
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
void
|
|
BaseCube<elem_type,derived>::print(const std::string extra_text) const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
const unwrap_cube<derived> tmp( (*this).get_ref() );
|
|
|
|
if(extra_text.length() != 0)
|
|
{
|
|
const std::streamsize orig_width = get_cout_stream().width();
|
|
|
|
get_cout_stream() << extra_text << '\n';
|
|
|
|
get_cout_stream().width(orig_width);
|
|
}
|
|
|
|
arma_ostream::print(get_cout_stream(), tmp.M, true);
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
void
|
|
BaseCube<elem_type,derived>::print(std::ostream& user_stream, const std::string extra_text) const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
const unwrap_cube<derived> tmp( (*this).get_ref() );
|
|
|
|
if(extra_text.length() != 0)
|
|
{
|
|
const std::streamsize orig_width = user_stream.width();
|
|
|
|
user_stream << extra_text << '\n';
|
|
|
|
user_stream.width(orig_width);
|
|
}
|
|
|
|
arma_ostream::print(user_stream, tmp.M, true);
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
void
|
|
BaseCube<elem_type,derived>::raw_print(const std::string extra_text) const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
const unwrap_cube<derived> tmp( (*this).get_ref() );
|
|
|
|
if(extra_text.length() != 0)
|
|
{
|
|
const std::streamsize orig_width = get_cout_stream().width();
|
|
|
|
get_cout_stream() << extra_text << '\n';
|
|
|
|
get_cout_stream().width(orig_width);
|
|
}
|
|
|
|
arma_ostream::print(get_cout_stream(), tmp.M, false);
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
void
|
|
BaseCube<elem_type,derived>::raw_print(std::ostream& user_stream, const std::string extra_text) const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
const unwrap_cube<derived> tmp( (*this).get_ref() );
|
|
|
|
if(extra_text.length() != 0)
|
|
{
|
|
const std::streamsize orig_width = user_stream.width();
|
|
|
|
user_stream << extra_text << '\n';
|
|
|
|
user_stream.width(orig_width);
|
|
}
|
|
|
|
arma_ostream::print(user_stream, tmp.M, false);
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
void
|
|
BaseCube<elem_type,derived>::brief_print(const std::string extra_text) const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
const unwrap_cube<derived> tmp( (*this).get_ref() );
|
|
|
|
if(extra_text.length() != 0)
|
|
{
|
|
const std::streamsize orig_width = get_cout_stream().width();
|
|
|
|
get_cout_stream() << extra_text << '\n';
|
|
|
|
get_cout_stream().width(orig_width);
|
|
}
|
|
|
|
arma_ostream::brief_print(get_cout_stream(), tmp.M);
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
void
|
|
BaseCube<elem_type,derived>::brief_print(std::ostream& user_stream, const std::string extra_text) const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
const unwrap_cube<derived> tmp( (*this).get_ref() );
|
|
|
|
if(extra_text.length() != 0)
|
|
{
|
|
const std::streamsize orig_width = user_stream.width();
|
|
|
|
user_stream << extra_text << '\n';
|
|
|
|
user_stream.width(orig_width);
|
|
}
|
|
|
|
arma_ostream::brief_print(user_stream, tmp.M);
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
elem_type
|
|
BaseCube<elem_type,derived>::min() const
|
|
{
|
|
return op_min::min( (*this).get_ref() );
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
elem_type
|
|
BaseCube<elem_type,derived>::max() const
|
|
{
|
|
return op_max::max( (*this).get_ref() );
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
uword
|
|
BaseCube<elem_type,derived>::index_min() const
|
|
{
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
uword index = 0;
|
|
|
|
if(P.get_n_elem() == 0)
|
|
{
|
|
arma_conform_check(true, "index_min(): object has no elements");
|
|
}
|
|
else
|
|
{
|
|
op_min::min_with_index(P, index);
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
uword
|
|
BaseCube<elem_type,derived>::index_max() const
|
|
{
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
uword index = 0;
|
|
|
|
if(P.get_n_elem() == 0)
|
|
{
|
|
arma_conform_check(true, "index_max(): object has no elements");
|
|
}
|
|
else
|
|
{
|
|
op_max::max_with_index(P, index);
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
bool
|
|
BaseCube<elem_type,derived>::is_zero(const typename get_pod_type<elem_type>::result tol) const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
typedef typename get_pod_type<elem_type>::result T;
|
|
|
|
arma_conform_check( (tol < T(0)), "is_zero(): parameter 'tol' must be >= 0" );
|
|
|
|
if(ProxyCube<derived>::use_at || is_Cube<typename ProxyCube<derived>::stored_type>::value)
|
|
{
|
|
const unwrap_cube<derived> U( (*this).get_ref() );
|
|
|
|
return arrayops::is_zero( U.M.memptr(), U.M.n_elem, tol );
|
|
}
|
|
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
const uword n_elem = P.get_n_elem();
|
|
|
|
if(n_elem == 0) { return false; }
|
|
|
|
const typename ProxyCube<derived>::ea_type Pea = P.get_ea();
|
|
|
|
if(is_cx<elem_type>::yes)
|
|
{
|
|
for(uword i=0; i<n_elem; ++i)
|
|
{
|
|
const elem_type val = Pea[i];
|
|
|
|
const T val_real = access::tmp_real(val);
|
|
const T val_imag = access::tmp_imag(val);
|
|
|
|
if(eop_aux::arma_abs(val_real) > tol) { return false; }
|
|
if(eop_aux::arma_abs(val_imag) > tol) { return false; }
|
|
}
|
|
}
|
|
else // not complex
|
|
{
|
|
for(uword i=0; i < n_elem; ++i)
|
|
{
|
|
if(eop_aux::arma_abs(Pea[i]) > tol) { return false; }
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
bool
|
|
BaseCube<elem_type,derived>::is_empty() const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
return (P.get_n_elem() == uword(0));
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
bool
|
|
BaseCube<elem_type,derived>::is_finite() const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
if(arma_config::fast_math_warn) { arma_warn(1, "is_finite(): detection of non-finite values is not reliable in fast math mode"); }
|
|
|
|
if(is_Cube<typename ProxyCube<derived>::stored_type>::value)
|
|
{
|
|
const unwrap_cube<derived> U( (*this).get_ref() );
|
|
|
|
return arrayops::is_finite( U.M.memptr(), U.M.n_elem );
|
|
}
|
|
else
|
|
{
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
const uword n_r = P.get_n_rows();
|
|
const uword n_c = P.get_n_cols();
|
|
const uword n_s = P.get_n_slices();
|
|
|
|
for(uword s=0; s<n_s; ++s)
|
|
for(uword c=0; c<n_c; ++c)
|
|
for(uword r=0; r<n_r; ++r)
|
|
{
|
|
if( arma_isnonfinite(P.at(r,c,s)) ) { return false; }
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
bool
|
|
BaseCube<elem_type,derived>::has_inf() const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
if(arma_config::fast_math_warn) { arma_warn(1, "has_inf(): detection of non-finite values is not reliable in fast math mode"); }
|
|
|
|
if(is_Cube<typename ProxyCube<derived>::stored_type>::value)
|
|
{
|
|
const unwrap_cube<derived> U( (*this).get_ref() );
|
|
|
|
return arrayops::has_inf( U.M.memptr(), U.M.n_elem );
|
|
}
|
|
else
|
|
{
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
const uword n_r = P.get_n_rows();
|
|
const uword n_c = P.get_n_cols();
|
|
const uword n_s = P.get_n_slices();
|
|
|
|
for(uword s=0; s<n_s; ++s)
|
|
for(uword c=0; c<n_c; ++c)
|
|
for(uword r=0; r<n_r; ++r)
|
|
{
|
|
if(arma_isinf(P.at(r,c,s))) { return true; }
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
bool
|
|
BaseCube<elem_type,derived>::has_nan() const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
if(arma_config::fast_math_warn) { arma_warn(1, "has_nan(): detection of non-finite values is not reliable in fast math mode"); }
|
|
|
|
if(is_Cube<typename ProxyCube<derived>::stored_type>::value)
|
|
{
|
|
const unwrap_cube<derived> U( (*this).get_ref() );
|
|
|
|
return arrayops::has_nan( U.M.memptr(), U.M.n_elem );
|
|
}
|
|
else
|
|
{
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
const uword n_r = P.get_n_rows();
|
|
const uword n_c = P.get_n_cols();
|
|
const uword n_s = P.get_n_slices();
|
|
|
|
for(uword s=0; s<n_s; ++s)
|
|
for(uword c=0; c<n_c; ++c)
|
|
for(uword r=0; r<n_r; ++r)
|
|
{
|
|
if(arma_isnan(P.at(r,c,s))) { return true; }
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
bool
|
|
BaseCube<elem_type,derived>::has_nonfinite() const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
if(arma_config::fast_math_warn) { arma_warn(1, "has_nonfinite(): detection of non-finite values is not reliable in fast math mode"); }
|
|
|
|
if(is_Cube<typename ProxyCube<derived>::stored_type>::value)
|
|
{
|
|
const unwrap_cube<derived> U( (*this).get_ref() );
|
|
|
|
return (arrayops::is_finite( U.M.memptr(), U.M.n_elem ) == false);
|
|
}
|
|
else
|
|
{
|
|
const ProxyCube<derived> P( (*this).get_ref() );
|
|
|
|
const uword n_r = P.get_n_rows();
|
|
const uword n_c = P.get_n_cols();
|
|
const uword n_s = P.get_n_slices();
|
|
|
|
for(uword s=0; s<n_s; ++s)
|
|
for(uword c=0; c<n_c; ++c)
|
|
for(uword r=0; r<n_r; ++r)
|
|
{
|
|
if(arma_isnonfinite(P.at(r,c,s))) { return true; }
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
const CubeToMatOp<derived, op_row_as_mat>
|
|
BaseCube<elem_type,derived>::row_as_mat(const uword in_row) const
|
|
{
|
|
return CubeToMatOp<derived, op_row_as_mat>( (*this).get_ref(), in_row );
|
|
}
|
|
|
|
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
const CubeToMatOp<derived, op_col_as_mat>
|
|
BaseCube<elem_type,derived>::col_as_mat(const uword in_col) const
|
|
{
|
|
return CubeToMatOp<derived, op_col_as_mat>( (*this).get_ref(), in_col );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// extra functions defined in BaseCube_eval_Cube
|
|
|
|
template<typename elem_type, typename derived>
|
|
arma_inline
|
|
const derived&
|
|
BaseCube_eval_Cube<elem_type, derived>::eval() const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
return static_cast<const derived&>(*this);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// extra functions defined in BaseCube_eval_expr
|
|
|
|
template<typename elem_type, typename derived>
|
|
inline
|
|
Cube<elem_type>
|
|
BaseCube_eval_expr<elem_type, derived>::eval() const
|
|
{
|
|
arma_debug_sigprint();
|
|
|
|
return Cube<elem_type>( static_cast<const derived&>(*this) );
|
|
}
|
|
|
|
|
|
|
|
//! @}
|