mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-02-11 10:03:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix valarray comparison

Browse source
This commit is contained in:
bolero-MURAKAMI 2016-04-03 13:42:12 +09:00
parent 1b8c051008
commit d611090972
45 changed files with 192 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
sprout/functional/address_of.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct address_of;
template<>
struct address_of<void> {
public:
typedef void is_transparent;
struct address_of<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(&std::declval<T>())

7
sprout/functional/assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct assign;
template<>
struct assign<void> {
public:
typedef void is_transparent;
struct assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() = std::declval<U>())

7
sprout/functional/bit_and.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
// 20.8.7 bitwise operations
@ -27,9 +28,9 @@ namespace sprout {
};
template<>
struct bit_and<void> {
public:
typedef void is_transparent;
struct bit_and<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() & std::declval<U>())

7
sprout/functional/bit_and_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct bit_and_assign;
template<>
struct bit_and_assign<void> {
public:
typedef void is_transparent;
struct bit_and_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() &= std::declval<U>())

7
sprout/functional/bit_not.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
// 20.8.7 bitwise operations
@ -26,9 +27,9 @@ namespace sprout {
};
template<>
struct bit_not<void> {
public:
typedef void is_transparent;
struct bit_not<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(~std::declval<T>())

7
sprout/functional/bit_or.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
// 20.8.7 bitwise operations
@ -27,9 +28,9 @@ namespace sprout {
};
template<>
struct bit_or<void> {
public:
typedef void is_transparent;
struct bit_or<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() | std::declval<U>())

7
sprout/functional/bit_or_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct bit_or_assign;
template<>
struct bit_or_assign<void> {
public:
typedef void is_transparent;
struct bit_or_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() |= std::declval<U>())

7
sprout/functional/bit_xor.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
// 20.8.7 bitwise operations
@ -27,9 +28,9 @@ namespace sprout {
};
template<>
struct bit_xor<void> {
public:
typedef void is_transparent;
struct bit_xor<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() ^ std::declval<U>())

7
sprout/functional/bit_xor_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct bit_xor_assign;
template<>
struct bit_xor_assign<void> {
public:
typedef void is_transparent;
struct bit_xor_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() ^= std::declval<U>())

7
sprout/functional/call_fun.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct call_fun;
template<>
struct call_fun<void> {
public:
typedef void is_transparent;
struct call_fun<void>
: public sprout::transparent<>
{
public:
template<typename F, typename... As>
SPROUT_CONSTEXPR decltype(std::declval<F>()(std::declval<As>()...))

7
sprout/functional/comma.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct comma;
template<>
struct comma<void> {
public:
typedef void is_transparent;
struct comma<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>(), std::declval<U>())

7
sprout/functional/cond.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct cond;
template<>
struct cond<void> {
public:
typedef void is_transparent;
struct cond<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U, typename V>
SPROUT_CONSTEXPR decltype(std::declval<T>() ? std::declval<U>() : std::declval<V>())

7
sprout/functional/dereference.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct dereference;
template<>
struct dereference<void> {
public:
typedef void is_transparent;
struct dereference<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(*std::declval<T>())

7
sprout/functional/divides.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct divides<void> {
public:
typedef void is_transparent;
struct divides<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() / std::declval<U>())

7
sprout/functional/divides_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct divides_assign;
template<>
struct divides_assign<void> {
public:
typedef void is_transparent;
struct divides_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() /= std::declval<U>())

7
sprout/functional/equal_to.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct equal_to<void> {
public:
typedef void is_transparent;
struct equal_to<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() == std::declval<U>())

7
sprout/functional/greater.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct greater<void> {
public:
typedef void is_transparent;
struct greater<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() > std::declval<U>())

7
sprout/functional/greater_equal.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct greater_equal<void> {
public:
typedef void is_transparent;
struct greater_equal<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() >= std::declval<U>())

7
sprout/functional/less.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct less<void> {
public:
typedef void is_transparent;
struct less<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() < std::declval<U>())

7
sprout/functional/less_equal.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct less_equal<void> {
public:
typedef void is_transparent;
struct less_equal<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() <= std::declval<U>())

7
sprout/functional/logical_and.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
// 20.8.6 logical operations
@ -27,9 +28,9 @@ namespace sprout {
};
template<>
struct logical_and<void> {
public:
typedef void is_transparent;
struct logical_and<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() && std::declval<U>())

7
sprout/functional/logical_not.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
// 20.8.6 logical operations
@ -26,9 +27,9 @@ namespace sprout {
};
template<>
struct logical_not<void> {
public:
typedef void is_transparent;
struct logical_not<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(!std::declval<T>())

7
sprout/functional/logical_or.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
// 20.8.6 logical operations
@ -27,9 +28,9 @@ namespace sprout {
};
template<>
struct logical_or<void> {
public:
typedef void is_transparent;
struct logical_or<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() || std::declval<U>())

7
sprout/functional/mem_ptr.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct mem_ptr;
template<>
struct mem_ptr<void> {
public:
typedef void is_transparent;
struct mem_ptr<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>()->*std::declval<U>())

7
sprout/functional/member.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct member;
template<>
struct member<void> {
public:
typedef void is_transparent;
struct member<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>().*std::declval<U>())

7
sprout/functional/minus.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct minus<void> {
public:
typedef void is_transparent;
struct minus<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() - std::declval<U>())

7
sprout/functional/minus_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct minus_assign;
template<>
struct minus_assign<void> {
public:
typedef void is_transparent;
struct minus_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() -= std::declval<U>())

7
sprout/functional/modulus.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct modulus<void> {
public:
typedef void is_transparent;
struct modulus<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() % std::declval<U>())

7
sprout/functional/modulus_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct modulus_assign;
template<>
struct modulus_assign<void> {
public:
typedef void is_transparent;
struct modulus_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() %= std::declval<U>())

7
sprout/functional/multiplies.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct multiplies<void> {
public:
typedef void is_transparent;
struct multiplies<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() * std::declval<U>())

7
sprout/functional/multiplies_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct multiplies_assign;
template<>
struct multiplies_assign<void> {
public:
typedef void is_transparent;
struct multiplies_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() *= std::declval<U>())

7
sprout/functional/negate.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -30,9 +31,9 @@ namespace sprout {
};
template<>
struct negate<void> {
public:
typedef void is_transparent;
struct negate<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(-std::declval<T>())

7
sprout/functional/plus.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
};
template<>
struct plus<void> {
public:
typedef void is_transparent;
struct plus<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() + std::declval<U>())

7
sprout/functional/plus_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct plus_assign;
template<>
struct plus_assign<void> {
public:
typedef void is_transparent;
struct plus_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() += std::declval<U>())

7
sprout/functional/posite.hpp
View file

@ -14,6 +14,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
@ -30,9 +31,9 @@ namespace sprout {
};
template<>
struct posite<void> {
public:
typedef void is_transparent;
struct posite<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(+std::declval<T>())

7
sprout/functional/post_dec.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct post_dec;
template<>
struct post_dec<void> {
public:
typedef void is_transparent;
struct post_dec<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(~std::declval<T>()--)

7
sprout/functional/post_inc.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct post_inc;
template<>
struct post_inc<void> {
public:
typedef void is_transparent;
struct post_inc<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(std::declval<T>()++)

7
sprout/functional/pre_dec.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct pre_dec;
template<>
struct pre_dec<void> {
public:
typedef void is_transparent;
struct pre_dec<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(--std::declval<T>())

7
sprout/functional/pre_inc.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct pre_inc;
template<>
struct pre_inc<void> {
public:
typedef void is_transparent;
struct pre_inc<void>
: public sprout::transparent<>
{
public:
template<typename T>
SPROUT_CONSTEXPR decltype(++std::declval<T>())

7
sprout/functional/shift_left.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct shift_left;
template<>
struct shift_left<void> {
public:
typedef void is_transparent;
struct shift_left<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() << std::declval<U>())

7
sprout/functional/shift_left_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct shift_left_assign;
template<>
struct shift_left_assign<void> {
public:
typedef void is_transparent;
struct shift_left_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() <<= std::declval<U>())

7
sprout/functional/shift_right.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct shift_right;
template<>
struct shift_right<void> {
public:
typedef void is_transparent;
struct shift_right<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() >> std::declval<U>())

7
sprout/functional/shift_right_assign.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct shift_right_assign;
template<>
struct shift_right_assign<void> {
public:
typedef void is_transparent;
struct shift_right_assign<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() >>= std::declval<U>())

7
sprout/functional/subscript.hpp
View file

@ -11,6 +11,7 @@
#include <utility>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout {
//
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void>
struct subscript;
template<>
struct subscript<void> {
public:
typedef void is_transparent;
struct subscript<void>
: public sprout::transparent<>
{
public:
template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>()[std::declval<U>()])

28
sprout/valarray/comparison.hpp
View file

@ -13,7 +13,11 @@
#include <sprout/valarray/valarray.hpp>
#include <sprout/algorithm/fixed/transform.hpp>
#include <sprout/functional/equal_to.hpp>
#include <sprout/functional/not_equal_to.hpp>
#include <sprout/functional/greater.hpp>
#include <sprout/functional/less.hpp>
#include <sprout/functional/greater_equal.hpp>
#include <sprout/functional/less_equal.hpp>
#include <sprout/functional/bind2nd.hpp>
#include <sprout/functional/bind1st.hpp>
@ -42,17 +46,17 @@ namespace sprout {
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator!=(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) {
return !(lhs == rhs);
return sprout::fixed::transform(lhs.begin(), lhs.end(), rhs.begin(), sprout::valarray<bool, N>(lhs.size()), sprout::not_equal_to<>());
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator!=(sprout::valarray<T, N> const& lhs, T const& rhs) {
return !(lhs == rhs);
return sprout::fixed::transform(lhs.begin(), lhs.end(), sprout::valarray<bool, N>(lhs.size()), sprout::bind2nd(sprout::not_equal_to<>(), rhs));
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator!=(T const& lhs, sprout::valarray<T, N> const& rhs) {
return !(lhs == rhs);
return sprout::fixed::transform(rhs.begin(), rhs.end(), sprout::valarray<bool, N>(rhs.size()), sprout::bind1st(sprout::not_equal_to<>(), lhs));
}
//
// operator<
@ -78,17 +82,17 @@ namespace sprout {
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) {
return rhs < lhs;
return sprout::fixed::transform(lhs.begin(), lhs.end(), rhs.begin(), sprout::valarray<bool, N>(lhs.size()), sprout::greater<>());
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>(sprout::valarray<T, N> const& lhs, T const& rhs) {
return rhs < lhs;
return sprout::fixed::transform(lhs.begin(), lhs.end(), sprout::valarray<bool, N>(lhs.size()), sprout::bind2nd(sprout::greater<>(), rhs));
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>(T const& lhs, sprout::valarray<T, N> const& rhs) {
return rhs < lhs;
return sprout::fixed::transform(rhs.begin(), rhs.end(), sprout::valarray<bool, N>(rhs.size()), sprout::bind1st(sprout::greater<>(), lhs));
}
//
// operator<=
@ -96,17 +100,17 @@ namespace sprout {
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator<=(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) {
return !(rhs < lhs);
return sprout::fixed::transform(lhs.begin(), lhs.end(), rhs.begin(), sprout::valarray<bool, N>(lhs.size()), sprout::less_equal<>());
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator<=(sprout::valarray<T, N> const& lhs, T const& rhs) {
return !(rhs < lhs);
return sprout::fixed::transform(lhs.begin(), lhs.end(), sprout::valarray<bool, N>(lhs.size()), sprout::bind2nd(sprout::less_equal<>(), rhs));
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator<=(T const& lhs, sprout::valarray<T, N> const& rhs) {
return !(rhs < lhs);
return sprout::fixed::transform(rhs.begin(), rhs.end(), sprout::valarray<bool, N>(rhs.size()), sprout::bind1st(sprout::less_equal<>(), lhs));
}
//
// operator>=
@ -114,17 +118,17 @@ namespace sprout {
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>=(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) {
return !(lhs < rhs);
return sprout::fixed::transform(lhs.begin(), lhs.end(), rhs.begin(), sprout::valarray<bool, N>(lhs.size()), sprout::greater_equal<>());
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>=(sprout::valarray<T, N> const& lhs, T const& rhs) {
return !(lhs < rhs);
return sprout::fixed::transform(lhs.begin(), lhs.end(), sprout::valarray<bool, N>(lhs.size()), sprout::bind2nd(sprout::greater_equal<>(), rhs));
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>=(T const& lhs, sprout::valarray<T, N> const& rhs) {
return !(lhs < rhs);
return sprout::fixed::transform(rhs.begin(), rhs.end(), sprout::valarray<bool, N>(rhs.size()), sprout::bind1st(sprout::greater_equal<>(), lhs));
}
} // namespace sprout