Functional.h

Go to the documentation of this file.

#pragma once
#include "Platform.h"
#include "Math/SimpleMath.h"
 
 
namespace dyno
{
    template<typename T>
    struct PlusFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs + rhs; }
    }; // end plus
 
    template<typename T>
    struct MinusFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs - rhs; }
    }; // end minus
 
    template<typename T>
    struct MultiplyFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs * rhs; }
    }; // end multiplies
 
    template<typename T>
    struct DivideFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs / rhs; }
    }; // end divides
 
    template<typename T>
    struct ModulusFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs % rhs; }
    }; // end modulus
 
    template<typename T>
    struct NegateFunc
    {
        DYN_FUNC inline T operator()(const T x) const { return -x; }
    }; // end negate
 
    template<typename T>
    struct EqualFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs == rhs; }
    }; // end equal_to
 
    template<typename T>
    struct NotEqualFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs != rhs; }
    }; // end not_equal_to
 
    template<typename T>
    struct GreaterFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs > rhs; }
    }; // end greater
 
    template<typename T>
    struct LessFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs < rhs; }
    }; // end less
 
    template<typename T>
    struct GreaterEqualFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs >= rhs; }
    }; // end greater_equal
 
    template<typename T>
    struct LessEqualFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs <= rhs; }
    }; // end less_equal
 
    template<typename T>
    struct LogicalAndFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs && rhs; }
    }; // end logical_and
 
    template<typename T>
    struct LogicalOrFunc
    {
        DYN_FUNC inline bool operator()(const T lhs, const T rhs) const { return lhs || rhs; }
    }; // end logical_or
 
    template<typename T>
    struct LogicalNotFunc
    {
        DYN_FUNC inline bool operator()(const T &x) const { return !x; }
    }; // end logical_not
 
    template<typename T>
    struct BitAndFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs & rhs; }
    }; // end bit_and
 
    template<typename T>
    struct BitOrFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs | rhs; }
    }; // end bit_or
 
    template<typename T>
    struct BitXorFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return lhs ^ rhs; }
    }; // end bit_xor
 
    template<typename T>
    struct MaximumFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return maximum(lhs, rhs); }
    }; // end maximum
 
    template<typename T>
    struct MinimumFunc
    {
        DYN_FUNC inline T operator()(const T lhs, const T rhs) const { return minimum(lhs, rhs); }
    }; // end minimum
}