Instigate Open Source Documentation

---

src/algebra/interface.hpp

Go to the documentation of this file.

#ifndef INSTIGATE_ALGEBRA_INTERFACE_HPP
#define INSTIGATE_ALGEBRA_INTERFACE_HPP

// Headers from this project

// Headers from other projects

// Headers from standard libraries

// Forward declarations
namespace instigate {
        
        namespace algebra {
                template <typename T> struct interface;
                template <> struct interface<int>;
                template <> struct interface<float>;
                template <> struct interface<long>;
                template <> struct interface<unsigned long>;
                template <> struct interface<long long>;
                template <> struct interface<unsigned long long>;
                template <> struct interface<double>;
                template <> struct interface<long double>;
                template <> struct interface<wchar_t>;
                template <> struct interface<unsigned int>;
                template <> struct interface<short>;            
                template <> struct interface<unsigned short>;
                template <> struct interface<char>;
                
        } // namespace instigate::algebra
        
} // namespace instigate

template <typename T>
struct instigate::algebra::interface
{
        static T plus(const T& a, const T& b)
        {
                return a + b;
        }
        
        static T minus(const T& a, const T& b)
        {
                return a - b;
        }
        
        static T multiply(const T& a, const T& b)
        {
                return a * b;
        }

        static T divide(const T& a, const T& b)
        {
                return a / b;
        }
        static const bool is_additive_assocativity = false;

        static const bool is_multiplicative_assocativity = false;

        static T get_zero()
        {
                return 0;
        }
        
        static T get_one()
        {
                return 1;
        }
        
        static T opposite(const T& a)
        {
                return -a;
        }
        
        static T inverse(const T& a)
        {
                return get_one() / a;
        }
        
        static const bool is_comutativity_addition = false;

        static const bool is_comutativity_multiplication = false;

        static const bool is_distributivity = false;
};

template <>
struct instigate::algebra::interface<int>
{
        static int plus(const int& a, const int& b)
        {
                return a + b;
        }
        
        static int minus(const int& a, const int& b)
        {
                return a - b;
        }
        
        static int multiply(const int& a, const int& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;
        
        static const bool is_multiplicative_assocativity = true;

        static int get_zero()
        {
                return 0;
        }
        
        static int get_one()
        {
                return 1;
        }
        
        static int opposite(const int& a)
        {
                return -a;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;
        
        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<float>
{
        static float plus(const float& a, const float& b)
        {
                return a + b;
        }
        
        static float minus(const float& a, const float& b)
        {
                return a - b;
        }
        
        static float multiply(const float& a, const float& b)
        {
                return a * b;
        }
        
        static float divide(const float& a, const float& b)
        {
                return a / b;
        }
        
        static const bool is_additive_assocativity = true;
        
        static const bool is_multiplicative_assocativity = true;

        static float get_zero()
        {
                return 0;
        }
        
        static float get_one()
        {
                return 1;
        }
        
        static float opposite(const float& a)
        {
                return -a;
        }
        
        static float inverse(const float& a)
        {
                return get_one() / a;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;        

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<unsigned int>
{
        static unsigned int plus(const unsigned int& a, const unsigned int& b)
        {
                return a + b;
        }
        
        static unsigned int multiply(const unsigned int& a, 
                                        const unsigned int& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;

        static const bool is_multiplicative_assocativity = true;
        
        static unsigned int get_zero()
        {
                return 0;
        }
        
        static unsigned int get_one()
        {
                return 1;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<long>
{
        static long plus(const long& a, const long& b)
        {
                return a + b;
        }
        
        static long minus(const long& a, const long& b)
        {
                return a - b;
        }
        
        static long multiply(const long& a, const long& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;

        static const bool is_multiplicative_assocativity = true;

        static long get_zero()
        {
                return 0;
        }
        
        static long get_one()
        {
                return 1;
        }
        
        static long opposite(const long& a)
        {
                return -a;
        }
        

        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<unsigned long>
{
        static unsigned long plus(const unsigned long& a, 
                        const unsigned long& b)
        {
                return a + b;
        }
        
        static unsigned long multiply(const unsigned long& a, 
                        const unsigned long& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;

        static const bool is_multiplicative_assocativity = true;

        static unsigned long get_zero()
        {
                return 0;
        }
        
        static unsigned long get_one()
        {
                return 1;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<long long>
{
        static long long plus(const long long& a, const long long& b)
        {
                return a + b;
        }
        
        static long long minus(const long long& a, const long long& b)
        {
                return a - b;
        }
        
        static long long multiply(const long& a, const long long& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;
        
        static const bool is_multiplicative_assocativity = true;

        static long long get_zero()
        {
                return 0;
        }
        
        static long long get_one()
        {
                return 1;
        }
        
        static long long opposite(const long long& a)
        {
                return -a;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;        
        
        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<unsigned long long>
{
        static unsigned long long plus(const unsigned long long& a, 
                        const unsigned long long& b)
        {
                return a + b;
        }
        
        static unsigned long long multiply(const unsigned long long& a, 
                        const unsigned long long& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;

        static const bool is_multiplicative_assocativity = true;

        static unsigned long long get_zero()
        {
                return 0;
        }
        
        static unsigned long long get_one()
        {
                return 1;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;
        
        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<double>
{
        static double plus(const double& a, const double& b)
        {
                return a + b;
        }
        
        static double minus(const double& a, const double& b)
        {
                return a - b;
        }
        
        static double multiply(const double& a, const double& b)
        {
                return a * b;
        }
        
        static double divide(const double& a, const double& b)
        {
                return a / b;
        }
        
        static const bool is_additive_assocativity = true;
        
        static const bool is_multiplicative_assocativity = true;

        static double get_zero()
        {
                return 0;
        }
        
        static double get_one()
        {
                return 1;
        }
        
        static double opposite(const double& a)
        {
                return -a;
        }
        
        static double inverse(const double& a)
        {
                return get_one() / a;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<long double>
{
        static long double plus(const long double& a, const long double& b)
        {
                return a + b;
        }
        
        static long double minus(const long double& a, const long double& b)
        {
                return a - b;
        }
        
        static long double multiply(const long double& a, const long double& b)
        {
                return a * b;
        }
        
        static long double divide(const long double& a, const long double& b)
        {
                return a / b;
        }
        
        static const bool is_additive_assocativity = true;

        static const bool is_multiplicative_assocativity = true;

        static long double get_zero()
        {
                return 0;
        }
        
        static long double get_one()
        {
                return 1;
        }
        
        static long double opposite(const long double& a)
        {
                return -a;
        }
        
        static long double inverse(const long double& a)
        {
                return get_one() / a;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<wchar_t>
{
        static wchar_t plus(const wchar_t& a, const wchar_t& b)
        {
                return a + b;
        }
        
        static wchar_t minus(const wchar_t& a, const wchar_t& b)
        {
                return a - b;
        }
        
        static wchar_t multiply(const wchar_t& a, const wchar_t& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;

        static const bool is_multiplicative_assocativity = true;

        static wchar_t opposite(const wchar_t& a)
        {
                return -a;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<short>
{
        static short plus(const short& a, const short& b)
        {
                return a + b;
        }
        
        static short minus(const short& a, const short& b)
        {
                return a - b;
        }
        
        static short multiply(const short& a, const short& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;
        
        static const bool is_multiplicative_assocativity = true;

        static short get_zero()
        {
                return 0;
        }
        
        static short get_one()
        {
                return 1;
        }
        
        static short opposite(const short& a)
        {
                return -a;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <>
struct instigate::algebra::interface<unsigned short>
{
        static unsigned short plus(const unsigned short& a, unsigned short& b)
        {
                return a + b;
        }
        
        static unsigned short multiply(const unsigned short& a, 
                                        const unsigned short& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;

        static const bool is_multiplicative_assocativity = true;

        static unsigned short get_zero()
        {
                return 0;
        }
        
        static unsigned short get_one()
        {
                return 1;
        }
        
        static const bool is_comutativity_addition = true;

        static const bool is_comutativity_multiplication = true;

        static const bool is_distributivity = true;
};

template <char>
struct instigate::algebra::interface<char>
{
        static char plus(const char& a, const char& b)
        {
                return a + b;
        }
        
        static char minus(const char& a, const char& b)
        {
                return a - b;
        }
        
        static char multiply(const char& a, const char& b)
        {
                return a * b;
        }
        
        static const bool is_additive_assocativity = true;
        
        static const bool is_multiplicative_assocativity = true;
        
        static const bool is_comutativity_addition = true;
        
        static const bool is_comutativity_multiplication = true;
        
        static const bool is_distributivity = true;
};

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_ALGEBRA_INTERFACE_HPP

---

© Instigate CJSC, Open Source