Работа для курсовой - C++

/////////////////////////////////////////////////////////////////////////////////////
//Задание: Даны N точек на плоскости. Для всех треугольников, образуемых 
//любыми тремя точками, определить, является ли треугольник равносторонним.
/////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iomanip>
#include <set>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////
typedef double                 T_coord;
typedef std::complex<T_coord>  T_point;
typedef std::set<T_point>      T_points_set;
typedef T_points_set           T_triangle;
typedef std::set<T_triangle>   T_triangles_set;
/////////////////////////////////////////////////////////////////////////////////////
const T_coord  COORD_EPSILON    = 0.001;
const int      COORD_PRECISION  = static_cast<int>(-log10(COORD_EPSILON)) + 1;
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  equal_to_for_real(T a, T b) 
{
    return abs(a - b) < COORD_EPSILON;
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_for_real(T a, T b) 
{
    return a > b
           && !equal_to_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_for_real(T a, T b) 
{
    return a < b
           && !equal_to_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_equal_for_real(T a, T b) 
{
    return !less_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_equal_for_real(T a, T b) 
{
    return !greater_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
bool operator< (T_point A, T_point B)
{
    return equal_to_for_real(A.real(), B.real()) 
           ? less_for_real(A.imag(), B.imag()) : less_for_real(A.real(), B.real());
}
/////////////////////////////////////////////////////////////////////////////////////
T_point  vect(T_point  A, T_point  B)
{
    return B - A;
}
/////////////////////////////////////////////////////////////////////////////////////
void  get_equilateral_triangle_vertices
    (
        T_point   A, 
        T_point   B, 
        T_point&  C, 
        T_point&  D
    )
{
    //Находим точки C и D такие, что треугольники ABC и ABD являются равносторонними.
    C = A + vect(A, B) * std::polar(1.0,  acos(-1.0) / 3.0);
    D = A + vect(A, B) * std::polar(1.0, -acos(-1.0) / 3.0);
}
/////////////////////////////////////////////////////////////////////////////////////
T_points_set  make_points(size_t  n)
{    
    struct  T_generate_point
    {
        T_generate_point() 
        {}
        //----------------------------------------------------------------------------
        T_point  operator() ()
        {
            T_coord  theta_start      = acos(-1.0) * 2 / 3.0 * (rand() % 3);            
            T_coord  delta_theta_max  = COORD_EPSILON * 1000;
            T_coord  delta_theta_rand 
                = delta_theta_max / RAND_MAX * rand() - delta_theta_max / 2.0;  
            return  std::polar(1.0, theta_start + delta_theta_rand);
        }
    };
 
    T_points_set  points_set_res;
    do
    {
        std::generate_n(std::inserter(points_set_res, points_set_res.begin()), 
                        1, T_generate_point());    
    }while(points_set_res.size() < n);
 
    return  points_set_res;
}
/////////////////////////////////////////////////////////////////////////////////////
T_triangles_set  find_equilateral_triangles(const T_points_set&  points_set)
{
    T_triangles_set  triangles_set_res;
    for(T_points_set::const_iterator  A_it = points_set.begin();
        A_it != points_set.end(); ++A_it)
    {
        T_points_set::const_iterator  B_it_start(A_it);
        ++B_it_start;        
        for(T_points_set::const_iterator  B_it = B_it_start;
            B_it != points_set.end(); ++B_it)
        {
            T_point  C;
            T_point  D;
            get_equilateral_triangle_vertices
                (
                    *A_it,
                    *B_it,
                    C, 
                    D
                );
 
            T_points_set::const_iterator  C_it = points_set.find(C);
            if(C_it != points_set.end())
            {
                T_triangle  triangle_cur;
                triangle_cur.insert(*A_it);
                triangle_cur.insert(*B_it);
                triangle_cur.insert(*C_it);
                if(triangle_cur.size() == 3)
                {
                    triangles_set_res.insert(triangle_cur);
                }                
            }
 
            T_points_set::const_iterator  D_it = points_set.find(D);
            if(D_it != points_set.end())
            {
                T_triangle  triangle_cur;
                triangle_cur.insert(*A_it);
                triangle_cur.insert(*B_it);
                triangle_cur.insert(*D_it);
                if(triangle_cur.size() == 3)
                {
                    triangles_set_res.insert(triangle_cur);
                }                
            }
        }    
    }
    return  triangles_set_res;
}
/////////////////////////////////////////////////////////////////////////////////////
void  print_triangles(const T_triangles_set&  triangles_set)
{
    struct  T_print_triangle
    {
        void  operator() (const T_triangle&  triangle)
        {
            static int  counter = 0;
            std::cout << "треугольник #"
                      << ++counter
                      << ": "
                      << std::endl
                      << '\t';                      
 
            std::copy(triangle.begin(), triangle.end(),                       
                      std::ostream_iterator<T_point>(std::cout, "\n\t"));
            std::cout << std::endl;
        }
    };
    std::for_each(triangles_set.begin(),
                  triangles_set.end(),
                  T_print_triangle());
}
/////////////////////////////////////////////////////////////////////////////////////
void  rand_test()
{
    const int  N_MIN  = 3;
    const int  N_MAX  = 1000;
    int        n      = 0;    
 
    do
    {
        std::cout << "Введите количество генерируемых случайных точек "
                  << N_MIN
                  << " <= N <= "
                  << N_MAX
                  << ": ";
 
        std::cin >> n;    
    }while(   n     < N_MIN
           || N_MAX < n     );
 
    T_points_set     points_set(make_points(n));
    T_triangles_set  equilateral_triangles_set(find_equilateral_triangles(points_set));
    
    std::cout << "Случайные точки:"
              << std::endl
              << std::setprecision(COORD_PRECISION);
    std::copy(points_set.begin(), points_set.end(), 
              std::ostream_iterator<T_point>(std::cout, "\n"));
    std::cout << std::endl;
 
    std::cout << "Из "
              << points_set.size()
              << " сгенерированных случайных точек "
              << equilateral_triangles_set.size()
              << " троек точек "
              << std::endl 
              << "образуют равносторонние треугольники с точностью координат вершин до "
              << COORD_EPSILON 
              << ":"
              << std::endl;
    print_triangles(equilateral_triangles_set); 
}
/////////////////////////////////////////////////////////////////////////////////////
void  points_input()
{
    const int  N_MIN  = 3;
    const int  N_MAX  = 100;
    int        n      = 0;
 
    do
    {
        std::cout << "Введите количество точек, вводимых с клавиатуры "
                  << N_MIN
                  << " <= N <= "
                  << N_MAX
                  << ": ";
 
        std::cin >> n;    
    }while(   n     < N_MIN
           || N_MAX < n    );
 
    std::cout << std::endl
              << "Введите координаты "
              << n 
              << " точек с точностью до "
              << COORD_EPSILON 
              << ":"
              << std::endl;        
    
    T_points_set  points_set;
    do
    {
        std::cout << std::endl
                  << "X"
                  << points_set.size() + 1
                  << " = ";
        
        T_coord  x = 0;
        std::cin >> x;
 
        std::cout << "Y"
                  << points_set.size() + 1
                  << " = ";
        
        T_coord  y = 0;
        std::cin >> y;
        
        points_set.insert(T_point(x, y));
    }while(points_set.size() < static_cast<size_t>(n));
 
    T_triangles_set  equilateral_triangles_set(find_equilateral_triangles(points_set));
 
    std::cout << "Заданные точки:"
              << std::endl
              << std::setprecision(COORD_PRECISION);
    std::copy(points_set.begin(), points_set.end(), 
              std::ostream_iterator<T_point>(std::cout, "\n"));
    std::cout << std::endl;
 
    std::cout << "Из "
              << points_set.size()
              << " заданных точек "
              << equilateral_triangles_set.size()
              << " троек точек "
              << std::endl 
              << "образуют равносторонние треугольники с точностью координат вершин до "
              << COORD_EPSILON 
              << ":"
              << std::endl;
    print_triangles(equilateral_triangles_set); 
}
/////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
 
    enum  T_action_variant_num
    {
        RANDOM_POINTS_GENERATING,
        INPUT_OF_POINTS_FROM_THE_KEYBOARD,
        EXIT
    };    
 
    std::cout << "Выберите действие:"
              << std::endl
              << '\t'
              << RANDOM_POINTS_GENERATING
              << " - генерирование случайных точек;"
              << std::endl
              << '\t'
              << INPUT_OF_POINTS_FROM_THE_KEYBOARD
              << " - ввод точек с клавиатуры;"
              << std::endl
              << '\t'
              << EXIT
              << " - выход;"
              << std::endl
              << std::endl
              << "-> ";
 
    int  action_variant_num = 0;
    std::cin >> action_variant_num;
    switch(action_variant_num)
    {
    case RANDOM_POINTS_GENERATING:
        rand_test();
        break;
 
    case INPUT_OF_POINTS_FROM_THE_KEYBOARD:
        points_input();
        break;
 
    default:
    case EXIT:
        ;
    }
}