//
|
// Copyright (c) 2018-2019, Cem Bassoy, cem.bassoy@gmail.com
|
//
|
// Distributed under the Boost Software License, Version 1.0. (See
|
// accompanying file LICENSE_1_0.txt or copy at
|
// http://www.boost.org/LICENSE_1_0.txt)
|
//
|
// The authors gratefully acknowledge the support of
|
// Fraunhofer IOSB, Ettlingen, Germany
|
//
|
|
#ifndef BOOST_UBLAS_TENSOR_OPERATORS_COMPARISON_HPP
|
#define BOOST_UBLAS_TENSOR_OPERATORS_COMPARISON_HPP
|
|
#include <boost/numeric/ublas/tensor/expression.hpp>
|
#include <boost/numeric/ublas/tensor/expression_evaluation.hpp>
|
#include <type_traits>
|
#include <functional>
|
|
namespace boost::numeric::ublas {
|
template<class element_type, class storage_format, class storage_type>
|
class tensor;
|
}
|
|
namespace boost::numeric::ublas::detail {
|
|
template<class T, class F, class A, class BinaryPred>
|
bool compare(tensor<T,F,A> const& lhs, tensor<T,F,A> const& rhs, BinaryPred pred)
|
{
|
|
if(lhs.extents() != rhs.extents()){
|
if constexpr(!std::is_same<BinaryPred,std::equal_to<>>::value && !std::is_same<BinaryPred,std::not_equal_to<>>::value)
|
throw std::runtime_error("Error in boost::numeric::ublas::detail::compare: cannot compare tensors with different shapes.");
|
else
|
return false;
|
}
|
|
if constexpr(std::is_same<BinaryPred,std::greater<>>::value || std::is_same<BinaryPred,std::less<>>::value)
|
if(lhs.empty())
|
return false;
|
|
for(auto i = 0u; i < lhs.size(); ++i)
|
if(!pred(lhs(i), rhs(i)))
|
return false;
|
return true;
|
}
|
|
template<class T, class F, class A, class UnaryPred>
|
bool compare(tensor<T,F,A> const& rhs, UnaryPred pred)
|
{
|
for(auto i = 0u; i < rhs.size(); ++i)
|
if(!pred(rhs(i)))
|
return false;
|
return true;
|
}
|
|
|
template<class T, class L, class R, class BinaryPred>
|
bool compare(tensor_expression<T,L> const& lhs, tensor_expression<T,R> const& rhs, BinaryPred pred)
|
{
|
constexpr bool lhs_is_tensor = std::is_same<T,L>::value;
|
constexpr bool rhs_is_tensor = std::is_same<T,R>::value;
|
|
if constexpr (lhs_is_tensor && rhs_is_tensor)
|
return compare(static_cast<T const&>( lhs ), static_cast<T const&>( rhs ), pred);
|
else if constexpr (lhs_is_tensor && !rhs_is_tensor)
|
return compare(static_cast<T const&>( lhs ), T( rhs ), pred);
|
else if constexpr (!lhs_is_tensor && rhs_is_tensor)
|
return compare(T( lhs ), static_cast<T const&>( rhs ), pred);
|
else
|
return compare(T( lhs ), T( rhs ), pred);
|
|
}
|
|
template<class T, class D, class UnaryPred>
|
bool compare(tensor_expression<T,D> const& expr, UnaryPred pred)
|
{
|
if constexpr (std::is_same<T,D>::value)
|
return compare(static_cast<T const&>( expr ), pred);
|
else
|
return compare(T( expr ), pred);
|
}
|
|
}
|
|
|
template<class T, class L, class R>
|
bool operator==( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
|
boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, rhs, std::equal_to<>{} );
|
}
|
template<class T, class L, class R>
|
auto operator!=(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
|
boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, rhs, std::not_equal_to<>{} );
|
}
|
template<class T, class L, class R>
|
auto operator< ( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
|
boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, rhs, std::less<>{} );
|
}
|
template<class T, class L, class R>
|
auto operator<=( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
|
boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, rhs, std::less_equal<>{} );
|
}
|
template<class T, class L, class R>
|
auto operator> ( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
|
boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, rhs, std::greater<>{} );
|
}
|
template<class T, class L, class R>
|
auto operator>=( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs,
|
boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, rhs, std::greater_equal<>{} );
|
}
|
|
|
|
|
|
template<class T, class D>
|
bool operator==( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
|
return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs == r; } );
|
}
|
template<class T, class D>
|
auto operator!=( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
|
return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs != r; } );
|
}
|
template<class T, class D>
|
auto operator< ( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
|
return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs < r; } );
|
}
|
template<class T, class D>
|
auto operator<=( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
|
return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs <= r; } );
|
}
|
template<class T, class D>
|
auto operator> ( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
|
return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs > r; } );
|
}
|
template<class T, class D>
|
auto operator>=( typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,D> const& rhs) {
|
return boost::numeric::ublas::detail::compare( rhs, [lhs](auto const& r){ return lhs >= r; } );
|
}
|
|
|
|
template<class T, class D>
|
bool operator==( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l == rhs; } );
|
}
|
template<class T, class D>
|
auto operator!=( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l != rhs; } );
|
}
|
template<class T, class D>
|
auto operator< ( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l < rhs; } );
|
}
|
template<class T, class D>
|
auto operator<=( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l <= rhs; } );
|
}
|
template<class T, class D>
|
auto operator> ( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l > rhs; } );
|
}
|
template<class T, class D>
|
auto operator>=( boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs, typename T::const_reference rhs) {
|
return boost::numeric::ublas::detail::compare( lhs, [rhs](auto const& l){ return l >= rhs; } );
|
}
|
|
|
#endif
|
