Выпуклый многоугольник - C (СИ)

///////////////////////////////////////////////////////////////////////////////////////
//Многоугольник задан координатами своих вершин при их последовательном  обходе. 
//Составить подпрограмму, определяющую, является ли многоугольник выпуклым.
///////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <complex>
#include <functional>
#include <iostream>
#include <limits>
#include <vector>
///////////////////////////////////////////////////////////////////////////////////////
typedef double                  T_coord;
typedef std::complex<T_coord>   T_vertice;
typedef std::vector<T_vertice>  T_polygon;
typedef std::vector<T_coord>    T_dets;
///////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  equal_to_for_real(T a, T b)
{
    const T  coef = 10;
    return abs(a - b) < std::numeric_limits<T>::epsilon() * coef;
}
///////////////////////////////////////////////////////////////////////////////////////
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_vertice  vert_A, T_vertice  vert_B)
{
    return  equal_to_for_real(vert_A.real(), vert_B.real())
                ? less_for_real(vert_A.imag(), vert_B.imag())
                : less_for_real(vert_A.real(), vert_B.real());
}
///////////////////////////////////////////////////////////////////////////////////////
T_coord  det(T_vertice  A, T_vertice  B)
{
    return  A.real() * B.imag() - B.real() * A.imag();
}
///////////////////////////////////////////////////////////////////////////////////////
bool  polygon_is_convex(const T_polygon&  polygon)
{
    //Сдвигаем циклически вершины.
    T_polygon  turned_polygon(polygon);  
    std::rotate(turned_polygon.begin(), turned_polygon.begin() + 1, turned_polygon.end());
 
    //Находим векторы сторон многоугольника. Для этого вычитаем из элемнтов turned_polygon
    //элементы polygon.
    T_polygon  edges;//Первый элемент - сторона 1-2.  
    std::transform(turned_polygon.begin(), turned_polygon.end(), polygon.begin(),
                   std::back_inserter(edges), std::minus<T_vertice>());
 
    //Сдвигаем циклически стороны многоугольника.
    T_polygon  turned_edges(edges);
    std::rotate(turned_edges.begin(), turned_edges.begin() + 1, turned_edges.end());
 
    //Находим определители между соседними сторонами многоугольника.
    T_dets  dets;
    std::transform(edges.begin(), edges.end(), turned_edges.begin(), 
                   std::back_inserter(dets), det);
 
    //Проверяем, что все определители ненулевые и одного знака.
    //---------------------------------------------------------
    //Ищем нулевой элемент.   
    T_dets::const_iterator  zero_it         
        = std::find_if(dets.begin(), dets.end(), 
                       std::bind2nd(std::ptr_fun(equal_to_for_real<T_coord>), 0.0));
 
    if(zero_it != dets.end()) return false;
 
    //Ищем положительный определитель.
    T_dets::const_iterator  positive_it         
        = std::find_if(dets.begin(), dets.end(), 
                       std::bind2nd(std::ptr_fun(greater_for_real<T_coord>), 0.0));
        
    //Ищем отрицательный определитель.
    T_dets::const_iterator  negative_it         
        = std::find_if(dets.begin(), dets.end(), 
                       std::bind2nd(std::ptr_fun(less_for_real<T_coord>), 0.0));  
    
    return    positive_it == dets.end()
           || negative_it == dets.end();
}
///////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    
    int  n = 0;
    do
    {
        std::cout << "Введите число вершин многоугольника >= 1: ";
        std::cin >> n;
    }while(n < 1);
    
    std::cout << "Введите "
              << n
              << " вершин многоугольника последовательно "
              << std::endl
              <<"в порядке обхода границы в любом направлении:"
              << std::endl;
 
    T_polygon       polygon;
 
    while(polygon.size() < static_cast<size_t>(n))
    {
        std::cout << std::endl
                  << "X["
                  << polygon.size() + 1
                  << "] = ";
 
        T_coord  x = 0;
        std::cin >> x;
 
        std::cout << "Y["
                  << polygon.size() + 1
                  << "] = ";
 
        T_coord  y = 0;
        std::cin >> y;
 
        T_vertice  vertice_cur(x, y);    
        polygon.push_back(vertice_cur);    
    }      
 
    std::cout << "Заданный "
              << n
              << "-угольник "
              << (polygon_is_convex(polygon) ? "" : "НЕ ")
              <<"является выпуклым."
              << std::endl; 
}