Дискретная математика. Класс-Группа:множество+бинарная операция - C++ - Ответ 6655735

/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <set>
#include <utility>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
template
    <
        typename    T_elem,
        typename    T_less,
        typename    T_bin_op,
        typename    T_inverse_elem,
        typename    T_print_elem
    >
class   T_group
{
    //-----------------------------------------------------------------------------------
    static  const   int     MAX_GROUP_SIZE  =   10;
    //-----------------------------------------------------------------------------------
    typedef std::set    < T_elem,                       T_less  >   T_elements;
    typedef std::map    < T_elem,           T_elem,     T_less  >   T_inverse_element_of;
    typedef std::pair   < T_elem,           T_elem              >   T_elements_pair;
    typedef std::map    < T_elements_pair,  T_elem              >   T_product_of_elements;
    //-----------------------------------------------------------------------------------
    T_elements                  elements_;
    T_inverse_element_of        inverse_element_of_;
    T_product_of_elements       product_of_elements_;
    T_elem                  *   identity_element_ptr_;
    bool                        generation_is_stopped_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_group( T_elements     const   &   elements )
        :
        elements_               ( elements  ),
        identity_element_ptr_   ()
    {
        generate_elements();
    }
    //-----------------------------------------------------------------------------------
    ~T_group()
    {
        delete  identity_element_ptr_;
    }
    //-----------------------------------------------------------------------------------
    int     size()                                                                  const
    {
        return  elements_.size();
    }
    //-----------------------------------------------------------------------------------
    void    print()                                                                 const
    {
        T_print_elem    print_elem;
 
        if( generation_is_stopped_ )
        {
            std::cout   <<  "Генерация элементов группы приостановлена."
                        <<  std::endl;
        }//if
 
        std::cout   <<  "Группа состоит из "
                    <<  size()
                    <<  " элементов"
                    <<  std::endl
                    <<  std::endl
                    <<  "Нейтральный элемент: "
                    <<  std::endl;
 
        if  (
                get_identity_element_ptr()
            )
        {
            print_elem
                (
                    *get_identity_element_ptr()
                );
        }
        else
        {
            std::cout   <<  "не сформирован"
                        <<  std::endl;
        }//else
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  "Элемент"
                    <<  "\t\t\t"
                    <<  "Обратный элемент"
                    <<  std::endl;
 
        std::for_each
            (
                inverse_element_of_.begin   (),
                inverse_element_of_.end     (),
 
                [=]                         ( T_inverse_element_of::value_type  const   &  elem_and_this_inv_elem )
                {
                    print_elem( elem_and_this_inv_elem.first    );
                    std::cout   <<  '\t';
                    print_elem( elem_and_this_inv_elem.second   );
                    std::cout   <<  std::endl;
                }
            );
 
        std::cout   <<  std::endl
                    <<  "Произведения элементов"
                    <<  std::endl;
 
        std::for_each
            (
                product_of_elements_.begin  (),
                product_of_elements_.end    (),
 
                [=]                         ( T_product_of_elements::value_type  elements_pair_and_their_product )
                {
                    print_elem( elements_pair_and_their_product     .first.first    );
                    std::cout   <<  "\t* ";
                    print_elem( elements_pair_and_their_product     .first.second   );
                    std::cout   <<  "\t= ";
                    print_elem( elements_pair_and_their_product     .second         );
                    std::cout   <<  std::endl;
                }
            );
    }
    //-----------------------------------------------------------------------------------
    T_elem  const   &   mult
        (
            T_elem  const   &   L,
            T_elem  const   &   R
        )
    {
        T_bin_op    bin_op;
        auto    elem_pair   =   std::make_pair( L, R );
        auto    it          =   product_of_elements_.find( elem_pair );
 
        return  it  ==  product_of_elements_.end()
                    ?   product_of_elements_[ elem_pair ]   =   bin_op( L, R )
                    :   product_of_elements_[ elem_pair ];
    }
    //-----------------------------------------------------------------------------------
    T_elem  *   get_identity_element_ptr()                                      const
    {
        return  identity_element_ptr_;
    }
    //-----------------------------------------------------------------------------------
    T_elem  const   &   get_inverse_element( T_elem    const   &   elem    )
    {
        T_inverse_elem  inverse_elem;
        auto    it      =   inverse_element_of_.find( elem );
 
        if  (
                it  ==  inverse_element_of_.end()
            )
        {
            inverse_element_of_[ elem ]   =   inverse_elem( elem );
 
            if  (
                        inverse_element_of_[ elem ]     ==  elem
                    &&  !identity_element_ptr_
                )
            {
                identity_element_ptr_    =   new     T_elem (
                                                                inverse_element_of_[ elem ]
                                                            );
            }//if
        }//if
 
        return  inverse_element_of_[ elem ];
    }
    //-----------------------------------------------------------------------------------
    T_elem  left_division
        (
            T_elem  const   &   L,
            T_elem  const   &   R
        )
    {
        return  mult    (
                            get_inverse_element( R ),
                            L
                        );
    }
    //-----------------------------------------------------------------------------------
    T_elem  right_division
        (
            T_elem  const   &   L,
            T_elem  const   &   R
        )
    {
        return  mult    (
                            L,
                            get_inverse_element( R )
                        );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    //Из математики известно, что множество с определенной на нем ассоциативной операцией
    //является группой только в том случае, если на этом множестве выполняется левое и правое 
    //деление для любых двух его элементов.
    //В данной процедуре выполняется левое и правое деление для элементов стартового множества,
    //пока не будут получены все элементы группы, или пока процесс не будет приостановлен 
    //из-за превышения заданного предельного количества элементов группы.
    void    generate_elements()
    {
        int     old_elements_size   =   0;
        generation_is_stopped_      =   false;
 
        do
        {
            old_elements_size   =   elements_.size();
 
            for (
                    auto
                    L_elem_it     =   elements_.begin     ();
                    L_elem_it     !=  elements_.end       ();
                    ++L_elem_it
                )
            {
                for (
                        auto
                        R_elem_it     =   elements_.begin     ();
                        R_elem_it     !=  elements_.end       ();
                        ++R_elem_it
                    )
                {
                    elements_.insert
                        (
                            left_division   ( *L_elem_it,   *R_elem_it )
                        );
 
                    elements_.insert
                        (
                            right_division  ( *L_elem_it,   *R_elem_it )
                        );
 
                    if  (
                            elements_.size()    >   MAX_GROUP_SIZE
                        )
                    {
                        generation_is_stopped_  =   true;
                        break;
                    }
                }//for
            }//for
        }while  (
                    elements_.size()    !=  old_elements_size
                );
    }
    //-----------------------------------------------------------------------------------
};