mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-02-13 10:13:56 +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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// //
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void> template<typename T = void>
struct address_of; struct address_of;
template<> template<>
struct address_of<void> { struct address_of<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T> template<typename T>
SPROUT_CONSTEXPR decltype(&std::declval<T>()) SPROUT_CONSTEXPR decltype(&std::declval<T>())

7
sprout/functional/assign.hpp
View file

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

7
sprout/functional/bit_or.hpp
View file

@ -11,6 +11,7 @@
#include <utility> #include <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// 20.8.7 bitwise operations // 20.8.7 bitwise operations
@ -27,9 +28,9 @@ namespace sprout {
}; };
template<> template<>
struct bit_or<void> { struct bit_or<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() | std::declval<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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// //
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void> template<typename T = void>
struct bit_or_assign; struct bit_or_assign;
template<> template<>
struct bit_or_assign<void> { struct bit_or_assign<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() |= std::declval<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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// 20.8.7 bitwise operations // 20.8.7 bitwise operations
@ -27,9 +28,9 @@ namespace sprout {
}; };
template<> template<>
struct bit_xor<void> { struct bit_xor<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() ^ std::declval<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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// //
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void> template<typename T = void>
struct bit_xor_assign; struct bit_xor_assign;
template<> template<>
struct bit_xor_assign<void> { struct bit_xor_assign<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() ^= std::declval<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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// //
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void> template<typename T = void>
struct call_fun; struct call_fun;
template<> template<>
struct call_fun<void> { struct call_fun<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename F, typename... As> template<typename F, typename... As>
SPROUT_CONSTEXPR decltype(std::declval<F>()(std::declval<As>()...)) SPROUT_CONSTEXPR decltype(std::declval<F>()(std::declval<As>()...))

7
sprout/functional/comma.hpp
View file

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

7
sprout/functional/cond.hpp
View file

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

7
sprout/functional/divides.hpp
View file

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

7
sprout/functional/greater.hpp
View file

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

7
sprout/functional/less.hpp
View file

@ -14,6 +14,7 @@
#include <utility> #include <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
}; };
template<> template<>
struct less<void> { struct less<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() < std::declval<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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
@ -31,9 +32,9 @@ namespace sprout {
}; };
template<> template<>
struct less_equal<void> { struct less_equal<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() <= std::declval<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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// 20.8.6 logical operations // 20.8.6 logical operations
@ -27,9 +28,9 @@ namespace sprout {
}; };
template<> template<>
struct logical_and<void> { struct logical_and<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>() && std::declval<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 <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// 20.8.6 logical operations // 20.8.6 logical operations
@ -26,9 +27,9 @@ namespace sprout {
}; };
template<> template<>
struct logical_not<void> { struct logical_not<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T> template<typename T>
SPROUT_CONSTEXPR decltype(!std::declval<T>()) SPROUT_CONSTEXPR decltype(!std::declval<T>())

7
sprout/functional/logical_or.hpp
View file

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

7
sprout/functional/member.hpp
View file

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

7
sprout/functional/minus.hpp
View file

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

7
sprout/functional/modulus.hpp
View file

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

7
sprout/functional/multiplies.hpp
View file

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

7
sprout/functional/negate.hpp
View file

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

7
sprout/functional/plus.hpp
View file

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

7
sprout/functional/posite.hpp
View file

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

7
sprout/functional/post_dec.hpp
View file

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

7
sprout/functional/post_inc.hpp
View file

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

7
sprout/functional/pre_dec.hpp
View file

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

7
sprout/functional/pre_inc.hpp
View file

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

7
sprout/functional/shift_left.hpp
View file

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

7
sprout/functional/subscript.hpp
View file

@ -11,6 +11,7 @@
#include <utility> #include <utility>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/functional/transparent.hpp>
namespace sprout { namespace sprout {
// //
@ -19,9 +20,9 @@ namespace sprout {
template<typename T = void> template<typename T = void>
struct subscript; struct subscript;
template<> template<>
struct subscript<void> { struct subscript<void>
public: : public sprout::transparent<>
typedef void is_transparent; {
public: public:
template<typename T, typename U> template<typename T, typename U>
SPROUT_CONSTEXPR decltype(std::declval<T>()[std::declval<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/valarray/valarray.hpp>
#include <sprout/algorithm/fixed/transform.hpp> #include <sprout/algorithm/fixed/transform.hpp>
#include <sprout/functional/equal_to.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/less.hpp>
#include <sprout/functional/greater_equal.hpp>
#include <sprout/functional/less_equal.hpp>
#include <sprout/functional/bind2nd.hpp> #include <sprout/functional/bind2nd.hpp>
#include <sprout/functional/bind1st.hpp> #include <sprout/functional/bind1st.hpp>
@ -42,17 +46,17 @@ namespace sprout {
template<typename T, std::size_t N> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator!=(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator!=(sprout::valarray<T, N> const& lhs, T const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator!=(T const& lhs, sprout::valarray<T, N> const& rhs) { 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< // operator<
@ -78,17 +82,17 @@ namespace sprout {
template<typename T, std::size_t N> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>(sprout::valarray<T, N> const& lhs, T const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>(T const& lhs, sprout::valarray<T, N> const& rhs) { 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<= // operator<=
@ -96,17 +100,17 @@ namespace sprout {
template<typename T, std::size_t N> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator<=(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator<=(sprout::valarray<T, N> const& lhs, T const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator<=(T const& lhs, sprout::valarray<T, N> const& rhs) { 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>= // operator>=
@ -114,17 +118,17 @@ namespace sprout {
template<typename T, std::size_t N> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>=(sprout::valarray<T, N> const& lhs, sprout::valarray<T, N> const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>=(sprout::valarray<T, N> const& lhs, T const& rhs) { 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> template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR sprout::valarray<bool, N> inline SPROUT_CONSTEXPR sprout::valarray<bool, N>
operator>=(T const& lhs, sprout::valarray<T, N> const& rhs) { 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 } // namespace sprout