ClickHouse/dbms/include/DB/Functions/FunctionsArithmetic.h

1122 lines
40 KiB
C++
Raw Normal View History

2011-08-09 15:57:33 +00:00
#pragma once
#include <DB/DataTypes/DataTypesNumber.h>
2014-09-08 10:46:30 +00:00
#include <DB/DataTypes/DataTypeDate.h>
#include <DB/DataTypes/DataTypeDateTime.h>
#include <DB/Columns/ColumnVector.h>
#include <DB/Columns/ColumnConst.h>
2011-08-09 15:57:33 +00:00
#include <DB/Functions/IFunction.h>
#include <DB/Functions/NumberTraits.h>
#include <DB/Functions/AccurateComparison.h>
#include <DB/Core/FieldVisitors.h>
2011-08-09 15:57:33 +00:00
namespace DB
{
2016-01-12 02:21:15 +00:00
namespace ErrorCodes
{
extern const int ILLEGAL_DIVISION;
}
/** Arithmetic operations: +, -, *, /, %,
* intDiv (integer division), unary minus.
* Bitwise operations: |, &, ^, ~.
* Etc.
2011-08-09 15:57:33 +00:00
*/
2014-09-08 10:46:30 +00:00
template<typename A, typename B, typename Op, typename ResultType_ = typename Op::ResultType>
struct BinaryOperationImplBase
2011-08-09 15:57:33 +00:00
{
using ResultType = ResultType_;
static void vector_vector(const PaddedPODArray<A> & a, const PaddedPODArray<B> & b, PaddedPODArray<ResultType> & c)
2011-08-09 15:57:33 +00:00
{
size_t size = a.size();
for (size_t i = 0; i < size; ++i)
2014-09-08 10:46:30 +00:00
c[i] = Op::template apply<ResultType>(a[i], b[i]);
2011-08-09 15:57:33 +00:00
}
static void vector_constant(const PaddedPODArray<A> & a, B b, PaddedPODArray<ResultType> & c)
2011-08-09 15:57:33 +00:00
{
size_t size = a.size();
for (size_t i = 0; i < size; ++i)
2014-09-08 10:46:30 +00:00
c[i] = Op::template apply<ResultType>(a[i], b);
2011-08-09 15:57:33 +00:00
}
static void constant_vector(A a, const PaddedPODArray<B> & b, PaddedPODArray<ResultType> & c)
2011-08-20 23:56:07 +00:00
{
size_t size = b.size();
for (size_t i = 0; i < size; ++i)
2014-09-08 10:46:30 +00:00
c[i] = Op::template apply<ResultType>(a, b[i]);
2011-08-20 23:56:07 +00:00
}
2011-08-09 15:57:33 +00:00
static void constant_constant(A a, B b, ResultType & c)
{
2014-09-08 10:46:30 +00:00
c = Op::template apply<ResultType>(a, b);
2011-08-09 15:57:33 +00:00
}
};
2014-09-08 10:46:30 +00:00
template<typename A, typename B, typename Op, typename ResultType = typename Op::ResultType>
struct BinaryOperationImpl : BinaryOperationImplBase<A, B, Op, ResultType>
{
};
2014-09-08 10:46:30 +00:00
template<typename A, typename Op>
struct UnaryOperationImpl
2011-08-09 17:24:17 +00:00
{
using ResultType = typename Op::ResultType;
2011-08-09 17:24:17 +00:00
static void vector(const PaddedPODArray<A> & a, PaddedPODArray<ResultType> & c)
2011-08-09 17:24:17 +00:00
{
size_t size = a.size();
for (size_t i = 0; i < size; ++i)
c[i] = Op::apply(a[i]);
2011-08-09 17:24:17 +00:00
}
static void constant(A a, ResultType & c)
2011-08-09 17:24:17 +00:00
{
c = Op::apply(a);
2011-08-09 17:24:17 +00:00
}
};
2011-08-09 17:24:17 +00:00
2011-08-20 23:56:07 +00:00
template<typename A, typename B>
struct PlusImpl
{
using ResultType = typename NumberTraits::ResultOfAdditionMultiplication<A, B>::Type;
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
2011-08-09 17:24:17 +00:00
{
/// Далее везде, static_cast - чтобы не было неправильного результата в выражениях вида Int64 c = UInt32(a) * Int32(-1).
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a) + b;
2011-08-09 17:24:17 +00:00
}
};
2014-09-08 10:46:30 +00:00
2011-08-09 17:24:17 +00:00
template<typename A, typename B>
struct MultiplyImpl
2011-08-09 17:24:17 +00:00
{
using ResultType = typename NumberTraits::ResultOfAdditionMultiplication<A, B>::Type;
2011-08-09 17:24:17 +00:00
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
2011-08-09 17:24:17 +00:00
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a) * b;
2011-08-09 17:24:17 +00:00
}
};
2011-08-09 17:24:17 +00:00
template<typename A, typename B>
struct MinusImpl
{
using ResultType = typename NumberTraits::ResultOfSubtraction<A, B>::Type;
2011-08-20 23:56:07 +00:00
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
2011-08-09 17:24:17 +00:00
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a) - b;
2011-08-09 17:24:17 +00:00
}
};
template<typename A, typename B>
struct DivideFloatingImpl
{
using ResultType = typename NumberTraits::ResultOfFloatingPointDivision<A, B>::Type;
2011-08-09 17:24:17 +00:00
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
2011-08-09 17:24:17 +00:00
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a) / b;
2011-08-09 17:24:17 +00:00
}
};
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
template <typename A, typename B>
inline void throwIfDivisionLeadsToFPE(A a, B b)
{
/// Возможно, лучше вместо проверок использовать siglongjmp?
if (unlikely(b == 0))
throw Exception("Division by zero", ErrorCodes::ILLEGAL_DIVISION);
/// http://avva.livejournal.com/2548306.html
2014-01-08 16:33:28 +00:00
if (unlikely(std::is_signed<A>::value && std::is_signed<B>::value && a == std::numeric_limits<A>::min() && b == -1))
throw Exception("Division of minimal signed number by minus one", ErrorCodes::ILLEGAL_DIVISION);
}
2013-06-07 17:32:12 +00:00
template <typename A, typename B>
inline bool divisionLeadsToFPE(A a, B b)
{
/// Возможно, лучше вместо проверок использовать siglongjmp?
if (unlikely(b == 0))
return true;
/// http://avva.livejournal.com/2548306.html
if (unlikely(std::is_signed<A>::value && std::is_signed<B>::value && a == std::numeric_limits<A>::min() && b == -1))
return true;
return false;
}
2013-06-07 17:32:12 +00:00
#pragma GCC diagnostic pop
2011-08-09 17:24:17 +00:00
template<typename A, typename B>
struct DivideIntegralImpl
{
using ResultType = typename NumberTraits::ResultOfIntegerDivision<A, B>::Type;
2011-08-09 17:24:17 +00:00
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
2011-08-09 17:24:17 +00:00
{
throwIfDivisionLeadsToFPE(a, b);
return a / b;
2011-08-09 17:24:17 +00:00
}
};
template<typename A, typename B>
struct DivideIntegralOrZeroImpl
{
using ResultType = typename NumberTraits::ResultOfIntegerDivision<A, B>::Type;
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
return unlikely(divisionLeadsToFPE(a, b)) ? 0 : a / b;
}
};
2011-08-09 17:24:17 +00:00
template<typename A, typename B>
struct ModuloImpl
{
using ResultType = typename NumberTraits::ResultOfModulo<A, B>::Type;
2011-08-09 17:24:17 +00:00
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
2011-08-09 17:24:17 +00:00
{
throwIfDivisionLeadsToFPE(typename NumberTraits::ToInteger<A>::Type(a), typename NumberTraits::ToInteger<A>::Type(b));
return typename NumberTraits::ToInteger<A>::Type(a)
2011-08-21 03:41:37 +00:00
% typename NumberTraits::ToInteger<A>::Type(b);
2011-08-09 17:24:17 +00:00
}
};
template<typename A, typename B>
struct BitAndImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a)
& static_cast<Result>(b);
}
};
template<typename A, typename B>
struct BitOrImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a)
| static_cast<Result>(b);
}
};
template<typename A, typename B>
struct BitXorImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a)
^ static_cast<Result>(b);
}
};
template<typename A, typename B>
struct BitShiftLeftImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a)
<< static_cast<Result>(b);
}
};
template<typename A, typename B>
struct BitShiftRightImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
2014-09-08 10:46:30 +00:00
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
2014-09-08 10:46:30 +00:00
return static_cast<Result>(a)
>> static_cast<Result>(b);
}
};
template<typename A, typename B>
struct BitRotateLeftImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
return (static_cast<Result>(a) << static_cast<Result>(b))
| (static_cast<Result>(a) >> ((sizeof(Result) * 8) - static_cast<Result>(b)));
}
};
template<typename A, typename B>
struct BitRotateRightImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
return (static_cast<Result>(a) >> static_cast<Result>(b))
| (static_cast<Result>(a) << ((sizeof(Result) * 8) - static_cast<Result>(b)));
}
};
2015-07-10 03:06:00 +00:00
template<typename A, typename B>
struct LeastBaseImpl
{
using ResultType = NumberTraits::ResultOfLeast<A, B>;
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
2015-07-10 03:06:00 +00:00
/** gcc 4.9.2 успешно векторизует цикл из этой функции. */
return static_cast<Result>(a) < static_cast<Result>(b) ? static_cast<Result>(a) : static_cast<Result>(b);
}
};
template<typename A, typename B>
struct LeastSpecialImpl
{
using ResultType = std::make_signed_t<A>;
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
static_assert(std::is_same<Result, ResultType>::value, "ResultType != Result");
return accurate::lessOp(a, b) ? static_cast<Result>(a) : static_cast<Result>(b);
}
};
template<typename A, typename B>
using LeastImpl = std::conditional_t<!NumberTraits::LeastGreatestSpecialCase<A, B>::value, LeastBaseImpl<A, B>, LeastSpecialImpl<A, B>>;
template<typename A, typename B>
struct GreatestBaseImpl
{
using ResultType = NumberTraits::ResultOfGreatest<A, B>;
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
return static_cast<Result>(a) > static_cast<Result>(b) ? static_cast<Result>(a) : static_cast<Result>(b);
}
};
template<typename A, typename B>
struct GreatestSpecialImpl
{
using ResultType = std::make_unsigned_t<A>;
template <typename Result = ResultType>
static inline Result apply(A a, B b)
{
static_assert(std::is_same<Result, ResultType>::value, "ResultType != Result");
return accurate::greaterOp(a, b) ? static_cast<Result>(a) : static_cast<Result>(b);
}
};
template<typename A, typename B>
using GreatestImpl = std::conditional_t<!NumberTraits::LeastGreatestSpecialCase<A, B>::value, GreatestBaseImpl<A, B>, GreatestSpecialImpl<A, B>>;
2011-09-05 00:32:22 +00:00
template<typename A>
struct NegateImpl
{
using ResultType = typename NumberTraits::ResultOfNegate<A>::Type;
2011-09-05 00:32:22 +00:00
static inline ResultType apply(A a)
2011-09-05 00:32:22 +00:00
{
return -static_cast<ResultType>(a);
2011-09-05 00:32:22 +00:00
}
};
2011-09-05 00:32:22 +00:00
template<typename A>
struct BitNotImpl
{
using ResultType = typename NumberTraits::ResultOfBitNot<A>::Type;
static inline ResultType apply(A a)
2011-09-05 00:32:22 +00:00
{
return ~static_cast<ResultType>(a);
2011-09-05 00:32:22 +00:00
}
};
2014-11-28 16:09:29 +00:00
template<typename A>
struct AbsImpl
{
using ResultType = typename NumberTraits::ResultOfAbs<A>::Type;
2014-11-28 16:09:29 +00:00
template<typename T = A>
static inline ResultType apply(T a,
typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, void>::type * = nullptr)
{
return a < 0 ? static_cast<ResultType>(~a) + 1 : a;
}
template<typename T = A>
static inline ResultType apply(T a,
typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, void>::type * = nullptr)
{
return static_cast<ResultType>(a);
}
template<typename T = A>
static inline ResultType apply(T a, typename std::enable_if<std::is_floating_point<T>::value, void>::type * = nullptr)
{
return static_cast<ResultType>(std::abs(a));
}
};
2011-08-09 15:57:33 +00:00
2014-09-08 10:46:30 +00:00
/// this one is just for convenience
template <bool B, typename T1, typename T2> using If = typename std::conditional<B, T1, T2>::type;
/// these ones for better semantics
template <typename T> using Then = T;
template <typename T> using Else = T;
/// Used to indicate undefined operation
struct InvalidType;
2014-09-08 10:46:30 +00:00
template <typename T>
struct DataTypeFromFieldType
{
using Type = DataTypeNumber<T>;
};
template <>
struct DataTypeFromFieldType<NumberTraits::Error>
{
using Type = InvalidType;
};
2014-09-08 10:46:30 +00:00
template <typename DataType> struct IsIntegral { static constexpr auto value = false; };
template <> struct IsIntegral<DataTypeUInt8> { static constexpr auto value = true; };
template <> struct IsIntegral<DataTypeUInt16> { static constexpr auto value = true; };
template <> struct IsIntegral<DataTypeUInt32> { static constexpr auto value = true; };
template <> struct IsIntegral<DataTypeUInt64> { static constexpr auto value = true; };
template <> struct IsIntegral<DataTypeInt8> { static constexpr auto value = true; };
template <> struct IsIntegral<DataTypeInt16> { static constexpr auto value = true; };
template <> struct IsIntegral<DataTypeInt32> { static constexpr auto value = true; };
template <> struct IsIntegral<DataTypeInt64> { static constexpr auto value = true; };
template <typename DataType> struct IsFloating { static constexpr auto value = false; };
template <> struct IsFloating<DataTypeFloat32> { static constexpr auto value = true; };
template <> struct IsFloating<DataTypeFloat64> { static constexpr auto value = true; };
template <typename DataType> struct IsNumeric
{
static constexpr auto value = IsIntegral<DataType>::value || IsFloating<DataType>::value;
};
template <typename DataType> struct IsDateOrDateTime { static constexpr auto value = false; };
template <> struct IsDateOrDateTime<DataTypeDate> { static constexpr auto value = true; };
template <> struct IsDateOrDateTime<DataTypeDateTime> { static constexpr auto value = true; };
2014-09-08 10:46:30 +00:00
/** Returns appropriate result type for binary operator on dates (or datetimes):
2014-09-08 10:46:30 +00:00
* Date + Integral -> Date
* Integral + Date -> Date
* Date - Date -> Int32
2014-09-08 10:46:30 +00:00
* Date - Integral -> Date
* least(Date, Date) -> Date
* greatest(Date, Date) -> Date
2014-09-08 10:46:30 +00:00
* All other operations are not defined and return InvalidType, operations on
* distinct date types are also undefined (e.g. DataTypeDate - DataTypeDateTime) */
template <template <typename, typename> class Operation, typename LeftDataType, typename RightDataType>
struct DateBinaryOperationTraits
{
using T0 = typename LeftDataType::FieldType;
using T1 = typename RightDataType::FieldType;
using Op = Operation<T0, T1>;
using ResultDataType =
If<std::is_same<Op, PlusImpl<T0, T1>>::value,
Then<
If<IsDateOrDateTime<LeftDataType>::value && IsIntegral<RightDataType>::value,
2014-09-08 10:46:30 +00:00
Then<LeftDataType>,
Else<
If<IsIntegral<LeftDataType>::value && IsDateOrDateTime<RightDataType>::value,
2014-09-08 10:46:30 +00:00
Then<RightDataType>,
Else<InvalidType>
>
>
>
>,
Else<
If<std::is_same<Op, MinusImpl<T0, T1>>::value,
Then<
If<IsDateOrDateTime<LeftDataType>::value,
2014-09-08 10:46:30 +00:00
Then<
If<std::is_same<LeftDataType, RightDataType>::value,
Then<DataTypeInt32>,
Else<
If<IsIntegral<RightDataType>::value,
Then<LeftDataType>,
Else<InvalidType>
>
>
>
>,
Else<InvalidType>
>
>,
Else<
If<std::is_same<T0, T1>::value
&& (std::is_same<Op, LeastImpl<T0, T1>>::value || std::is_same<Op, GreatestImpl<T0, T1>>::value),
Then<LeftDataType>,
Else<InvalidType>
>
>
2014-09-08 10:46:30 +00:00
>
>
>;
};
/// Decides among date and numeric operations
template <template <typename, typename> class Operation, typename LeftDataType, typename RightDataType>
struct BinaryOperationTraits
{
using ResultDataType =
If<IsDateOrDateTime<LeftDataType>::value || IsDateOrDateTime<RightDataType>::value,
2014-09-08 10:46:30 +00:00
Then<
typename DateBinaryOperationTraits<
Operation, LeftDataType, RightDataType
>::ResultDataType
>,
Else<
typename DataTypeFromFieldType<
typename Operation<
typename LeftDataType::FieldType,
typename RightDataType::FieldType
>::ResultType
>::Type
>
>;
};
template <template <typename, typename> class Op, typename Name>
2011-08-09 15:57:33 +00:00
class FunctionBinaryArithmetic : public IFunction
{
public:
static constexpr auto name = Name::name;
static FunctionPtr create(const Context & context) { return std::make_shared<FunctionBinaryArithmetic>(); }
2011-08-12 20:39:42 +00:00
private:
/// Overload for InvalidType
template <typename ResultDataType,
typename std::enable_if<std::is_same<ResultDataType, InvalidType>::value>::type * = nullptr>
bool checkRightTypeImpl(DataTypePtr & type_res) const
2014-09-08 10:46:30 +00:00
{
return false;
}
/// Overload for well-defined operations
template <typename ResultDataType,
typename std::enable_if<!std::is_same<ResultDataType, InvalidType>::value>::type * = nullptr>
bool checkRightTypeImpl(DataTypePtr & type_res) const
2014-09-08 10:46:30 +00:00
{
type_res = std::make_shared<ResultDataType>();
2014-09-08 10:46:30 +00:00
return true;
}
template <typename LeftDataType, typename RightDataType>
2011-09-24 20:32:41 +00:00
bool checkRightType(const DataTypes & arguments, DataTypePtr & type_res) const
2011-08-12 20:39:42 +00:00
{
2014-09-08 10:46:30 +00:00
using ResultDataType = typename BinaryOperationTraits<Op, LeftDataType, RightDataType>::ResultDataType;
if (typeid_cast<const RightDataType *>(&*arguments[1]))
return checkRightTypeImpl<ResultDataType>(type_res);
2014-09-08 10:46:30 +00:00
2011-08-12 20:39:42 +00:00
return false;
}
template <typename T0>
2011-09-24 20:32:41 +00:00
bool checkLeftType(const DataTypes & arguments, DataTypePtr & type_res) const
2011-08-12 20:39:42 +00:00
{
if (typeid_cast<const T0 *>(&*arguments[0]))
2011-08-12 20:39:42 +00:00
{
2014-09-08 10:46:30 +00:00
if ( checkRightType<T0, DataTypeDate>(arguments, type_res)
|| checkRightType<T0, DataTypeDateTime>(arguments, type_res)
|| checkRightType<T0, DataTypeUInt8>(arguments, type_res)
2011-09-24 20:32:41 +00:00
|| checkRightType<T0, DataTypeUInt16>(arguments, type_res)
|| checkRightType<T0, DataTypeUInt32>(arguments, type_res)
|| checkRightType<T0, DataTypeUInt64>(arguments, type_res)
|| checkRightType<T0, DataTypeInt8>(arguments, type_res)
|| checkRightType<T0, DataTypeInt16>(arguments, type_res)
|| checkRightType<T0, DataTypeInt32>(arguments, type_res)
|| checkRightType<T0, DataTypeInt64>(arguments, type_res)
|| checkRightType<T0, DataTypeFloat32>(arguments, type_res)
|| checkRightType<T0, DataTypeFloat64>(arguments, type_res))
2011-08-12 20:39:42 +00:00
return true;
else
throw Exception("Illegal type " + arguments[1]->getName() + " of second argument of function " + getName(),
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
}
return false;
}
/// Overload for date operations
template <typename LeftDataType, typename RightDataType, typename ColumnType>
bool executeRightType(Block & block, const ColumnNumbers & arguments, const size_t result, const ColumnType * col_left)
{
if (!typeid_cast<const RightDataType *>(block.safeGetByPosition(arguments[1]).type.get()))
return false;
using ResultDataType = typename BinaryOperationTraits<Op, LeftDataType, RightDataType>::ResultDataType;
return executeRightTypeDispatch<LeftDataType, RightDataType, ResultDataType>(
block, arguments, result, col_left);
}
/// Overload for InvalidType
template <typename LeftDataType, typename RightDataType, typename ResultDataType, typename ColumnType,
typename std::enable_if<std::is_same<ResultDataType, InvalidType>::value>::type * = nullptr>
bool executeRightTypeDispatch(Block & block, const ColumnNumbers & arguments, const size_t result,
const ColumnType * col_left)
{
throw Exception("Types " + TypeName<typename LeftDataType::FieldType>::get()
+ " and " + TypeName<typename LeftDataType::FieldType>::get()
+ " are incompatible for function " + getName() + " or not upscaleable to common type", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
}
/// Overload for well-defined operations
template <typename LeftDataType, typename RightDataType, typename ResultDataType, typename ColumnType,
typename std::enable_if<!std::is_same<ResultDataType, InvalidType>::value>::type * = nullptr>
bool executeRightTypeDispatch(Block & block, const ColumnNumbers & arguments, const size_t result,
const ColumnType * col_left)
{
using T0 = typename LeftDataType::FieldType;
using T1 = typename RightDataType::FieldType;
using ResultType = typename ResultDataType::FieldType;
return executeRightTypeImpl<T0, T1, ResultType>(block, arguments, result, col_left);
}
/// ColumnVector overload
2014-09-08 10:46:30 +00:00
template <typename T0, typename T1, typename ResultType = typename Op<T0, T1>::ResultType>
bool executeRightTypeImpl(Block & block, const ColumnNumbers & arguments, size_t result, const ColumnVector<T0> * col_left)
2011-08-12 20:39:42 +00:00
{
if (auto col_right = typeid_cast<const ColumnVector<T1> *>(block.safeGetByPosition(arguments[1]).column.get()))
2011-08-12 20:39:42 +00:00
{
auto col_res = std::make_shared<ColumnVector<ResultType>>();
block.safeGetByPosition(result).column = col_res;
2011-08-12 20:39:42 +00:00
2014-09-08 10:46:30 +00:00
auto & vec_res = col_res->getData();
2011-08-12 20:39:42 +00:00
vec_res.resize(col_left->getData().size());
2014-09-08 10:46:30 +00:00
BinaryOperationImpl<T0, T1, Op<T0, T1>, ResultType>::vector_vector(col_left->getData(), col_right->getData(), vec_res);
2011-08-12 20:39:42 +00:00
return true;
}
else if (auto col_right = typeid_cast<const ColumnConst<T1> *>(block.safeGetByPosition(arguments[1]).column.get()))
2011-08-12 20:39:42 +00:00
{
auto col_res = std::make_shared<ColumnVector<ResultType>>();
block.safeGetByPosition(result).column = col_res;
2011-08-12 20:39:42 +00:00
2014-09-08 10:46:30 +00:00
auto & vec_res = col_res->getData();
2011-08-12 20:39:42 +00:00
vec_res.resize(col_left->getData().size());
2014-09-08 10:46:30 +00:00
BinaryOperationImpl<T0, T1, Op<T0, T1>, ResultType>::vector_constant(col_left->getData(), col_right->getData(), vec_res);
2011-08-12 20:39:42 +00:00
return true;
}
throw Exception("Logical error: unexpected type of column", ErrorCodes::LOGICAL_ERROR);
2011-08-12 20:39:42 +00:00
}
/// ColumnConst overload
2014-09-08 10:46:30 +00:00
template <typename T0, typename T1, typename ResultType = typename Op<T0, T1>::ResultType>
bool executeRightTypeImpl(Block & block, const ColumnNumbers & arguments, size_t result, const ColumnConst<T0> * col_left)
2011-08-12 20:39:42 +00:00
{
if (auto col_right = typeid_cast<const ColumnVector<T1> *>(block.safeGetByPosition(arguments[1]).column.get()))
2011-08-12 20:39:42 +00:00
{
auto col_res = std::make_shared<ColumnVector<ResultType>>();
block.safeGetByPosition(result).column = col_res;
2011-08-12 20:39:42 +00:00
2014-09-08 10:46:30 +00:00
auto & vec_res = col_res->getData();
2011-08-12 20:39:42 +00:00
vec_res.resize(col_left->size());
2014-09-08 10:46:30 +00:00
BinaryOperationImpl<T0, T1, Op<T0, T1>, ResultType>::constant_vector(col_left->getData(), col_right->getData(), vec_res);
2011-08-12 20:39:42 +00:00
return true;
}
else if (auto col_right = typeid_cast<const ColumnConst<T1> *>(block.safeGetByPosition(arguments[1]).column.get()))
2011-08-12 20:39:42 +00:00
{
ResultType res = 0;
2014-09-08 10:46:30 +00:00
BinaryOperationImpl<T0, T1, Op<T0, T1>, ResultType>::constant_constant(col_left->getData(), col_right->getData(), res);
auto col_res = std::make_shared<ColumnConst<ResultType>>(col_left->size(), res);
block.safeGetByPosition(result).column = col_res;
2011-08-12 20:39:42 +00:00
return true;
}
return false;
}
template <typename LeftDataType>
bool executeLeftType(Block & block, const ColumnNumbers & arguments, const size_t result)
2011-08-12 20:39:42 +00:00
{
if (!typeid_cast<const LeftDataType *>(block.safeGetByPosition(arguments[0]).type.get()))
2014-09-08 10:46:30 +00:00
return false;
using T0 = typename LeftDataType::FieldType;
if ( executeLeftTypeImpl<LeftDataType, ColumnVector<T0>>(block, arguments, result)
|| executeLeftTypeImpl<LeftDataType, ColumnConst<T0>>(block, arguments, result))
return true;
2014-09-08 10:46:30 +00:00
return false;
2014-09-08 10:46:30 +00:00
}
template <typename LeftDataType, typename ColumnType>
bool executeLeftTypeImpl(Block & block, const ColumnNumbers & arguments, const size_t result)
2014-09-08 10:46:30 +00:00
{
if (auto col_left = typeid_cast<const ColumnType *>(block.safeGetByPosition(arguments[0]).column.get()))
2014-09-08 10:46:30 +00:00
{
if ( executeRightType<LeftDataType, DataTypeDate>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeDateTime>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeUInt8>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeUInt16>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeUInt32>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeUInt64>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeInt8>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeInt16>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeInt32>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeInt64>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeFloat32>(block, arguments, result, col_left)
|| executeRightType<LeftDataType, DataTypeFloat64>(block, arguments, result, col_left))
2014-09-08 10:46:30 +00:00
return true;
else
throw Exception("Illegal column " + block.safeGetByPosition(arguments[1]).column->getName()
2014-09-08 10:46:30 +00:00
+ " of second argument of function " + getName(),
ErrorCodes::ILLEGAL_COLUMN);
}
return false;
}
2011-08-09 15:57:33 +00:00
public:
String getName() const override
2011-08-09 15:57:33 +00:00
{
return name;
2011-08-09 15:57:33 +00:00
}
2016-12-29 19:38:10 +00:00
size_t getNumberOfArguments() const override { return 2; }
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
2011-08-09 15:57:33 +00:00
{
2011-09-24 20:32:41 +00:00
DataTypePtr type_res;
2014-09-08 10:46:30 +00:00
if (!( checkLeftType<DataTypeDate>(arguments, type_res)
|| checkLeftType<DataTypeDateTime>(arguments, type_res)
|| checkLeftType<DataTypeUInt8>(arguments, type_res)
2011-09-24 20:32:41 +00:00
|| checkLeftType<DataTypeUInt16>(arguments, type_res)
|| checkLeftType<DataTypeUInt32>(arguments, type_res)
|| checkLeftType<DataTypeUInt64>(arguments, type_res)
|| checkLeftType<DataTypeInt8>(arguments, type_res)
|| checkLeftType<DataTypeInt16>(arguments, type_res)
|| checkLeftType<DataTypeInt32>(arguments, type_res)
|| checkLeftType<DataTypeInt64>(arguments, type_res)
|| checkLeftType<DataTypeFloat32>(arguments, type_res)
|| checkLeftType<DataTypeFloat64>(arguments, type_res)))
2011-08-09 15:57:33 +00:00
throw Exception("Illegal type " + arguments[0]->getName() + " of first argument of function " + getName(),
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
2011-09-24 20:32:41 +00:00
return type_res;
2011-08-09 15:57:33 +00:00
}
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
2011-08-09 15:57:33 +00:00
{
if (!( executeLeftType<DataTypeDate>(block, arguments, result)
|| executeLeftType<DataTypeDateTime>(block, arguments, result)
|| executeLeftType<DataTypeUInt8>(block, arguments, result)
|| executeLeftType<DataTypeUInt16>(block, arguments, result)
|| executeLeftType<DataTypeUInt32>(block, arguments, result)
|| executeLeftType<DataTypeUInt64>(block, arguments, result)
|| executeLeftType<DataTypeInt8>(block, arguments, result)
|| executeLeftType<DataTypeInt16>(block, arguments, result)
|| executeLeftType<DataTypeInt32>(block, arguments, result)
|| executeLeftType<DataTypeInt64>(block, arguments, result)
|| executeLeftType<DataTypeFloat32>(block, arguments, result)
|| executeLeftType<DataTypeFloat64>(block, arguments, result)))
throw Exception("Illegal column " + block.safeGetByPosition(arguments[0]).column->getName()
2011-08-28 00:31:30 +00:00
+ " of first argument of function " + getName(),
2011-08-09 15:57:33 +00:00
ErrorCodes::ILLEGAL_COLUMN);
}
};
template <typename FunctionName>
struct FunctionUnaryArithmeticMonotonicity;
template <template <typename> class Op, typename Name, bool is_injective>
2011-09-05 00:32:22 +00:00
class FunctionUnaryArithmetic : public IFunction
{
public:
static constexpr auto name = Name::name;
static FunctionPtr create(const Context & context) { return std::make_shared<FunctionUnaryArithmetic>(); }
2011-09-05 00:32:22 +00:00
private:
template <typename T0>
2011-09-25 05:29:13 +00:00
bool checkType(const DataTypes & arguments, DataTypePtr & result) const
2011-09-05 00:32:22 +00:00
{
if (typeid_cast<const T0 *>(&*arguments[0]))
2011-09-05 00:32:22 +00:00
{
result = std::make_shared<DataTypeNumber<typename Op<typename T0::FieldType>::ResultType>>();
2011-09-05 00:32:22 +00:00
return true;
}
return false;
}
template <typename T0>
2011-09-24 20:32:41 +00:00
bool executeType(Block & block, const ColumnNumbers & arguments, size_t result)
2011-09-05 00:32:22 +00:00
{
if (const ColumnVector<T0> * col = typeid_cast<const ColumnVector<T0> *>(block.safeGetByPosition(arguments[0]).column.get()))
2011-09-05 00:32:22 +00:00
{
using ResultType = typename Op<T0>::ResultType;
2011-09-05 00:32:22 +00:00
std::shared_ptr<ColumnVector<ResultType>> col_res = std::make_shared<ColumnVector<ResultType>>();
block.safeGetByPosition(result).column = col_res;
2011-09-05 00:32:22 +00:00
typename ColumnVector<ResultType>::Container_t & vec_res = col_res->getData();
vec_res.resize(col->getData().size());
UnaryOperationImpl<T0, Op<T0> >::vector(col->getData(), vec_res);
2011-09-05 00:32:22 +00:00
return true;
}
else if (const ColumnConst<T0> * col = typeid_cast<const ColumnConst<T0> *>(block.safeGetByPosition(arguments[0]).column.get()))
2011-09-05 00:32:22 +00:00
{
using ResultType = typename Op<T0>::ResultType;
2011-09-05 00:32:22 +00:00
ResultType res = 0;
UnaryOperationImpl<T0, Op<T0> >::constant(col->getData(), res);
2011-09-05 00:32:22 +00:00
std::shared_ptr<ColumnConst<ResultType>> col_res = std::make_shared<ColumnConst<ResultType>>(col->size(), res);
block.safeGetByPosition(result).column = col_res;
2011-09-05 00:32:22 +00:00
return true;
}
return false;
}
public:
String getName() const override
2011-09-05 00:32:22 +00:00
{
return name;
2011-09-05 00:32:22 +00:00
}
2016-12-29 19:38:10 +00:00
size_t getNumberOfArguments() const override { return 1; }
bool isInjective(const Block &) override { return is_injective; }
2016-12-29 19:38:10 +00:00
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
2011-09-05 00:32:22 +00:00
{
2011-09-24 20:32:41 +00:00
DataTypePtr result;
if (!( checkType<DataTypeUInt8>(arguments, result)
|| checkType<DataTypeUInt16>(arguments, result)
|| checkType<DataTypeUInt32>(arguments, result)
|| checkType<DataTypeUInt64>(arguments, result)
|| checkType<DataTypeInt8>(arguments, result)
|| checkType<DataTypeInt16>(arguments, result)
|| checkType<DataTypeInt32>(arguments, result)
|| checkType<DataTypeInt64>(arguments, result)
|| checkType<DataTypeFloat32>(arguments, result)
|| checkType<DataTypeFloat64>(arguments, result)))
2011-09-05 00:32:22 +00:00
throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(),
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
2011-09-24 20:32:41 +00:00
return result;
2011-09-05 00:32:22 +00:00
}
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
2011-09-05 00:32:22 +00:00
{
if (!( executeType<UInt8>(block, arguments, result)
|| executeType<UInt16>(block, arguments, result)
|| executeType<UInt32>(block, arguments, result)
|| executeType<UInt64>(block, arguments, result)
|| executeType<Int8>(block, arguments, result)
|| executeType<Int16>(block, arguments, result)
|| executeType<Int32>(block, arguments, result)
|| executeType<Int64>(block, arguments, result)
|| executeType<Float32>(block, arguments, result)
|| executeType<Float64>(block, arguments, result)))
throw Exception("Illegal column " + block.safeGetByPosition(arguments[0]).column->getName()
2011-09-05 00:32:22 +00:00
+ " of argument of function " + getName(),
ErrorCodes::ILLEGAL_COLUMN);
}
bool hasInformationAboutMonotonicity() const override
{
return FunctionUnaryArithmeticMonotonicity<Name>::has();
}
Monotonicity getMonotonicityForRange(const IDataType & type, const Field & left, const Field & right) const override
{
return FunctionUnaryArithmeticMonotonicity<Name>::get(left, right);
}
2011-09-05 00:32:22 +00:00
};
struct NamePlus { static constexpr auto name = "plus"; };
struct NameMinus { static constexpr auto name = "minus"; };
struct NameMultiply { static constexpr auto name = "multiply"; };
struct NameDivideFloating { static constexpr auto name = "divide"; };
struct NameDivideIntegral { static constexpr auto name = "intDiv"; };
struct NameDivideIntegralOrZero { static constexpr auto name = "intDivOrZero"; };
struct NameModulo { static constexpr auto name = "modulo"; };
struct NameNegate { static constexpr auto name = "negate"; };
2014-11-28 16:09:29 +00:00
struct NameAbs { static constexpr auto name = "abs"; };
struct NameBitAnd { static constexpr auto name = "bitAnd"; };
struct NameBitOr { static constexpr auto name = "bitOr"; };
struct NameBitXor { static constexpr auto name = "bitXor"; };
struct NameBitNot { static constexpr auto name = "bitNot"; };
struct NameBitShiftLeft { static constexpr auto name = "bitShiftLeft"; };
struct NameBitShiftRight { static constexpr auto name = "bitShiftRight"; };
struct NameBitRotateLeft { static constexpr auto name = "bitRotateLeft"; };
struct NameBitRotateRight { static constexpr auto name = "bitRotateRight"; };
struct NameLeast { static constexpr auto name = "least"; };
struct NameGreatest { static constexpr auto name = "greatest"; };
using FunctionPlus = FunctionBinaryArithmetic<PlusImpl, NamePlus>;
using FunctionMinus = FunctionBinaryArithmetic<MinusImpl, NameMinus>;
using FunctionMultiply = FunctionBinaryArithmetic<MultiplyImpl, NameMultiply>;
using FunctionDivideFloating = FunctionBinaryArithmetic<DivideFloatingImpl, NameDivideFloating>;
using FunctionDivideIntegral = FunctionBinaryArithmetic<DivideIntegralImpl, NameDivideIntegral>;
using FunctionDivideIntegralOrZero = FunctionBinaryArithmetic<DivideIntegralOrZeroImpl, NameDivideIntegralOrZero>;
using FunctionModulo = FunctionBinaryArithmetic<ModuloImpl, NameModulo>;
using FunctionNegate = FunctionUnaryArithmetic<NegateImpl, NameNegate, true>;
using FunctionAbs = FunctionUnaryArithmetic<AbsImpl, NameAbs, false>;
using FunctionBitAnd = FunctionBinaryArithmetic<BitAndImpl, NameBitAnd>;
using FunctionBitOr = FunctionBinaryArithmetic<BitOrImpl, NameBitOr>;
using FunctionBitXor = FunctionBinaryArithmetic<BitXorImpl, NameBitXor>;
using FunctionBitNot = FunctionUnaryArithmetic<BitNotImpl, NameBitNot, true>;
using FunctionBitShiftLeft = FunctionBinaryArithmetic<BitShiftLeftImpl, NameBitShiftLeft>;
using FunctionBitShiftRight = FunctionBinaryArithmetic<BitShiftRightImpl, NameBitShiftRight>;
using FunctionBitRotateLeft = FunctionBinaryArithmetic<BitRotateLeftImpl, NameBitRotateLeft>;
using FunctionBitRotateRight = FunctionBinaryArithmetic<BitRotateRightImpl, NameBitRotateRight>;
using FunctionLeast = FunctionBinaryArithmetic<LeastImpl, NameLeast>;
using FunctionGreatest = FunctionBinaryArithmetic<GreatestImpl, NameGreatest>;
2011-08-09 15:57:33 +00:00
/// Свойства монотонности для некоторых функций.
template <> struct FunctionUnaryArithmeticMonotonicity<NameNegate>
{
static bool has() { return true; }
static IFunction::Monotonicity get(const Field & left, const Field & right)
{
return { true, false };
}
};
template <> struct FunctionUnaryArithmeticMonotonicity<NameAbs>
{
static bool has() { return true; }
static IFunction::Monotonicity get(const Field & left, const Field & right)
{
Squashed commit of the following: commit c567d4e1fe8d54e6363e47548f1e3927cc5ee78f Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 20:35:01 2017 +0300 Style [#METR-2944]. commit 26bf3e1228e03f46c29b13edb0e3770bd453e3f1 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 20:33:11 2017 +0300 Miscellaneous [#METR-2944]. commit eb946f4c6fd4bb0e9e5c7fb1468d36be3dfca5a5 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 20:30:19 2017 +0300 Miscellaneous [#METR-2944]. commit 78c867a14744b5af2db8d37caf7804fc2057ea51 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 20:11:41 2017 +0300 Miscellaneous [#METR-2944]. commit 6604c5c83cfcedc81c8da4da026711920d5963b4 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 19:56:15 2017 +0300 Miscellaneous [#METR-2944]. commit 23fbf05c1d4bead636458ec21b05a101b1152e33 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 19:47:52 2017 +0300 Miscellaneous [#METR-2944]. commit 98772faf11a7d450d473f7fa84f8a9ae24f7b59b Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 19:46:05 2017 +0300 Miscellaneous [#METR-2944]. commit 3dc636ab9f9359dbeac2e8d997ae563d4ca147e2 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 19:39:46 2017 +0300 Miscellaneous [#METR-2944]. commit 3e16aee95482f374ee3eda1a4dbe9ba5cdce02e8 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 19:38:03 2017 +0300 Miscellaneous [#METR-2944]. commit ae7e7e90eb1f82bd0fe0f887708d08b9e7755612 Author: Alexey Milovidov <milovidov@yandex-team.ru> Date: Fri Jan 6 19:34:15 2017 +0300 Miscellaneous [#METR-2944].
2017-01-06 17:41:19 +00:00
Float64 left_float = left.isNull() ? -std::numeric_limits<Float64>::infinity() : applyVisitor(FieldVisitorConvertToNumber<Float64>(), left);
Float64 right_float = right.isNull() ? std::numeric_limits<Float64>::infinity() : applyVisitor(FieldVisitorConvertToNumber<Float64>(), right);
if ((left_float < 0 && right_float > 0) || (left_float > 0 && right_float < 0))
return {};
return { true, (left_float > 0) };
}
};
template <> struct FunctionUnaryArithmeticMonotonicity<NameBitNot>
{
static bool has() { return false; }
static IFunction::Monotonicity get(const Field & left, const Field & right)
{
return {};
}
};
2017-03-12 11:09:25 +00:00
}
2011-08-09 15:57:33 +00:00
/// Оптимизации для целочисленного деления на константу.
#if __SSE2__
#define LIBDIVIDE_USE_SSE2 1
#endif
#include <libdivide.h>
2017-03-12 11:09:25 +00:00
namespace DB
{
template <typename A, typename B>
struct DivideIntegralByConstantImpl
: BinaryOperationImplBase<A, B, DivideIntegralImpl<A, B>>
{
using ResultType = typename DivideIntegralImpl<A, B>::ResultType;
static void vector_constant(const PaddedPODArray<A> & a, B b, PaddedPODArray<ResultType> & c)
{
if (unlikely(b == 0))
throw Exception("Division by zero", ErrorCodes::ILLEGAL_DIVISION);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
if (unlikely(std::is_signed<B>::value && b == -1))
{
size_t size = a.size();
for (size_t i = 0; i < size; ++i)
c[i] = -c[i];
return;
}
#pragma GCC diagnostic pop
libdivide::divider<A> divider(b);
size_t size = a.size();
const A * a_pos = &a[0];
const A * a_end = a_pos + size;
ResultType * c_pos = &c[0];
#if __SSE2__
static constexpr size_t values_per_sse_register = 16 / sizeof(A);
const A * a_end_sse = a_pos + size / values_per_sse_register * values_per_sse_register;
while (a_pos < a_end_sse)
{
_mm_storeu_si128(reinterpret_cast<__m128i *>(c_pos),
_mm_loadu_si128(reinterpret_cast<const __m128i *>(a_pos)) / divider);
a_pos += values_per_sse_register;
c_pos += values_per_sse_register;
}
#endif
while (a_pos < a_end)
{
*c_pos = *a_pos / divider;
++a_pos;
++c_pos;
}
}
};
template <typename A, typename B>
struct ModuloByConstantImpl
: BinaryOperationImplBase<A, B, ModuloImpl<A, B>>
{
using ResultType = typename ModuloImpl<A, B>::ResultType;
static void vector_constant(const PaddedPODArray<A> & a, B b, PaddedPODArray<ResultType> & c)
{
if (unlikely(b == 0))
throw Exception("Division by zero", ErrorCodes::ILLEGAL_DIVISION);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
if (unlikely((std::is_signed<B>::value && b == -1) || b == 1))
{
size_t size = a.size();
for (size_t i = 0; i < size; ++i)
c[i] = 0;
return;
}
#pragma GCC diagnostic pop
libdivide::divider<A> divider(b);
/// Тут не удалось сделать так, чтобы SSE вариант из libdivide давал преимущество.
size_t size = a.size();
for (size_t i = 0; i < size; ++i)
c[i] = a[i] - (a[i] / divider) * b; /// NOTE: возможно, не сохраняется семантика деления с остатком отрицательных чисел.
}
};
/** Прописаны специализации для деления чисел типа UInt64 и UInt32 на числа той же знаковости.
* Можно дополнить до всех возможных комбинаций, но потребуется больше кода.
*/
template <> struct BinaryOperationImpl<UInt64, UInt8, DivideIntegralImpl<UInt64, UInt8>> : DivideIntegralByConstantImpl<UInt64, UInt8> {};
template <> struct BinaryOperationImpl<UInt64, UInt16, DivideIntegralImpl<UInt64, UInt16>> : DivideIntegralByConstantImpl<UInt64, UInt16> {};
template <> struct BinaryOperationImpl<UInt64, UInt32, DivideIntegralImpl<UInt64, UInt32>> : DivideIntegralByConstantImpl<UInt64, UInt32> {};
template <> struct BinaryOperationImpl<UInt64, UInt64, DivideIntegralImpl<UInt64, UInt64>> : DivideIntegralByConstantImpl<UInt64, UInt64> {};
template <> struct BinaryOperationImpl<UInt32, UInt8, DivideIntegralImpl<UInt32, UInt8>> : DivideIntegralByConstantImpl<UInt32, UInt8> {};
template <> struct BinaryOperationImpl<UInt32, UInt16, DivideIntegralImpl<UInt32, UInt16>> : DivideIntegralByConstantImpl<UInt32, UInt16> {};
template <> struct BinaryOperationImpl<UInt32, UInt32, DivideIntegralImpl<UInt32, UInt32>> : DivideIntegralByConstantImpl<UInt32, UInt32> {};
template <> struct BinaryOperationImpl<UInt32, UInt64, DivideIntegralImpl<UInt32, UInt64>> : DivideIntegralByConstantImpl<UInt32, UInt64> {};
template <> struct BinaryOperationImpl<Int64, Int8, DivideIntegralImpl<Int64, Int8>> : DivideIntegralByConstantImpl<Int64, Int8> {};
template <> struct BinaryOperationImpl<Int64, Int16, DivideIntegralImpl<Int64, Int16>> : DivideIntegralByConstantImpl<Int64, Int16> {};
template <> struct BinaryOperationImpl<Int64, Int32, DivideIntegralImpl<Int64, Int32>> : DivideIntegralByConstantImpl<Int64, Int32> {};
template <> struct BinaryOperationImpl<Int64, Int64, DivideIntegralImpl<Int64, Int64>> : DivideIntegralByConstantImpl<Int64, Int64> {};
template <> struct BinaryOperationImpl<Int32, Int8, DivideIntegralImpl<Int32, Int8>> : DivideIntegralByConstantImpl<Int32, Int8> {};
template <> struct BinaryOperationImpl<Int32, Int16, DivideIntegralImpl<Int32, Int16>> : DivideIntegralByConstantImpl<Int32, Int16> {};
template <> struct BinaryOperationImpl<Int32, Int32, DivideIntegralImpl<Int32, Int32>> : DivideIntegralByConstantImpl<Int32, Int32> {};
template <> struct BinaryOperationImpl<Int32, Int64, DivideIntegralImpl<Int32, Int64>> : DivideIntegralByConstantImpl<Int32, Int64> {};
template <> struct BinaryOperationImpl<UInt64, UInt8, ModuloImpl<UInt64, UInt8>> : ModuloByConstantImpl<UInt64, UInt8> {};
template <> struct BinaryOperationImpl<UInt64, UInt16, ModuloImpl<UInt64, UInt16>> : ModuloByConstantImpl<UInt64, UInt16> {};
template <> struct BinaryOperationImpl<UInt64, UInt32, ModuloImpl<UInt64, UInt32>> : ModuloByConstantImpl<UInt64, UInt32> {};
template <> struct BinaryOperationImpl<UInt64, UInt64, ModuloImpl<UInt64, UInt64>> : ModuloByConstantImpl<UInt64, UInt64> {};
template <> struct BinaryOperationImpl<UInt32, UInt8, ModuloImpl<UInt32, UInt8>> : ModuloByConstantImpl<UInt32, UInt8> {};
template <> struct BinaryOperationImpl<UInt32, UInt16, ModuloImpl<UInt32, UInt16>> : ModuloByConstantImpl<UInt32, UInt16> {};
template <> struct BinaryOperationImpl<UInt32, UInt32, ModuloImpl<UInt32, UInt32>> : ModuloByConstantImpl<UInt32, UInt32> {};
template <> struct BinaryOperationImpl<UInt32, UInt64, ModuloImpl<UInt32, UInt64>> : ModuloByConstantImpl<UInt32, UInt64> {};
template <> struct BinaryOperationImpl<Int64, Int8, ModuloImpl<Int64, Int8>> : ModuloByConstantImpl<Int64, Int8> {};
template <> struct BinaryOperationImpl<Int64, Int16, ModuloImpl<Int64, Int16>> : ModuloByConstantImpl<Int64, Int16> {};
template <> struct BinaryOperationImpl<Int64, Int32, ModuloImpl<Int64, Int32>> : ModuloByConstantImpl<Int64, Int32> {};
template <> struct BinaryOperationImpl<Int64, Int64, ModuloImpl<Int64, Int64>> : ModuloByConstantImpl<Int64, Int64> {};
template <> struct BinaryOperationImpl<Int32, Int8, ModuloImpl<Int32, Int8>> : ModuloByConstantImpl<Int32, Int8> {};
template <> struct BinaryOperationImpl<Int32, Int16, ModuloImpl<Int32, Int16>> : ModuloByConstantImpl<Int32, Int16> {};
template <> struct BinaryOperationImpl<Int32, Int32, ModuloImpl<Int32, Int32>> : ModuloByConstantImpl<Int32, Int32> {};
template <> struct BinaryOperationImpl<Int32, Int64, ModuloImpl<Int32, Int64>> : ModuloByConstantImpl<Int32, Int64> {};
2011-08-09 15:57:33 +00:00
}