Instigate Open Source Documentation

---

src/algebra/_multiplicative_group.hpp

Go to the documentation of this file.

#ifndef _INSTIGATE_OPEN_SOURCE_INTERNAL_HEADER_IN_CONCEPT
#error This is an internal header file used to implement Instigate Algebra.\
        It should never be included directly by a program.
#endif

#ifndef INSTIGATE_ALGEBRA_MULTIPLICATIVE_GROUP
#define INSTIGATE_ALGEBRA_MULTIPLICATIVE_GROUP

// Headers from this project
#include "_multiplicative_monoid.hpp"

// Headers from other projects
#include <generic/base.hpp>
// Headers from standard libraries

// Forward declarations
namespace instigate {
        
        namespace algebra {
                
                namespace multiplicative_group {
                        struct tag;
                        template <typename T> struct interface;
                        template <typename T> struct requirements;
                        
                } // namespace instigate::algebra::multiplicative_group
                
        } // namespace instigate::algebra
        
} // namespace instigate

struct instigate::algebra::multiplicative_group::tag : 
        instigate::algebra::multiplicative_monoid::tag {};

template <typename T>
struct instigate::algebra::multiplicative_group::interface : 
        instigate::algebra::multiplicative_monoid::interface<T>
{
        static T divide(const T& a, const T& b)
        {
                return instigate::algebra::interface<T>::divide(a, b);
        }
        
        static T inverse(const T& a)
        {
                return instigate::algebra::interface<T>::inverse(a);
        }
};

template <typename T>
struct instigate::algebra::multiplicative_group::requirements : 
        instigate::algebra::multiplicative_monoid::requirements<T>
{
        static void require_inverse(const T& a)
        {
                instigate::algebra::multiplicative_group::interface<T>::
							inverse(a);
        }
        
        static void require_inverse_return_type(const T& a)
        {
                REQUIRE_SAME_TYPE(a, interface<T>::inverse(a));
        }

        static void require_divide(const T& a, const T& b)
        {
                instigate::algebra::multiplicative_group::interface<T>::
							divide(a, b);
        }
        
        static void require_divide_return_type(const T& a, const T& b)
        {
                REQUIRE_SAME_TYPE(a, interface<T>::divide(a, b));
        }
        
        requirements()
        {
                (void)&require_inverse;
                (void)&require_inverse_return_type;
                (void)&require_divide;
                (void)&require_divide_return_type;
        }
};

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

#endif // INSTIGATE_ALGEBRA_MULTIPLICATIVE_GROUP

---

© Instigate CJSC, Open Source