finitegroup.h

#ifndef GM_GROUP_H
#define GM_GROUP_H

// A binary operator abstract base class
template<class T>
class BinaryOp
{   
    BinaryOp();
public:
    static T binary(T left, T right) = 0;
};

// The Addition operator mod something
template<class T, unsigned int Modulus>
class PlusOp: public BinaryOp<T>
{
    PlusOp();
public:

    static T binary(T left, T right)
    {
        return (left + right) % Modulus;
    }
};

template<class T>
class PlusOp: public BinaryOp<T>
{
    PlusOp();
public:

    static T binary(T left, T right)
    {
        return left + right;
    }
};

template<class T, unsigned int Modulus>
class MultOp: public BinaryOp<T>
{
    MultOp();
public:

    static T binary(T left, T right)
    {
        return (left * right) % Modulus;
    }
};

template<class T>
class MultOp: public BinaryOp<T>
{
    MultOp();
public:

    static T binary(T left, T right)
    {
        return left * right;
    }
};


    
template<class T, class O>
class FiniteGroup
{
public:
    FiniteGroup(const vector<T>& elements);

    // harder
    bool isGroup()
    {
        // what must be:
        //  closed under binary star operator
        //  must exist an element 'e' that satisfies: x*e = x; (identity)
        //  must exist a unique inverse

        return true;
    }

    // easy
    virtual bool isGenerator(T element) const = 0;

    // easy
    virtual vector<T> findGenerators() const = 0;

    // trivial
    virtual unsigned int order() { return m_elements.size(); }

    // ?? harder
    virtual unsigned int order(T element) = 0;
    
    virtual friend T operator *(T element1, T element2) 
    { 
        return O::binary(element1, element2);
    }

    static int gcd(int p, int q) { return 1; }

    // trivial
    bool isElement(T element) 
    { 
        for (unsigned int i = 0; i < m_elements.size(); i++) 
            if (m_elements[i] == T)
                return true;
        return false;
    }
    
protected:
    vector<T> m_elements;
};

template <class O>
class IntegerGroup: public FiniteGroup<unsigned int, O>
{
public:
    IntegerGroup(const vector<unsigned int>& elements): FiniteGroup(elements) {}

    virtual bool isGroup() const { return true; }

    virtual bool isGenerator(unsigned int element) const 
    { 
        if (isElement(element) && (gcd(element, order()) == 1) 
            return true; 
        return false; 
    }

    virtual vector<unsigned int> findGenerators() const
    {
        vector<unsigned int> generators;

        for (unsigned int i = 0; i < order(); i++)
        {
            if (gcd(m_elements[i], order()) == 1)
                generators.push_back(m_elements[i]);
        }
        return generators;

    }
};

#endif

---