Площадь пересечения окружностей

//////////////////////////////////////////////////////////////////////////////////////
//Найти площадь пересечения двух окружностей. Дано координаты центров и радиусы. 
//Окружности могут быть одна внутри другой, пересекаться в одной точке, 
//пересекаться в двух точках и не пересекаться вообще. 
//////////////////////////////////////////////////////////////////////////////////////
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <complex>
#include <iostream>
#include <limits>
#include <vector>
//////////////////////////////////////////////////////////////////////////////////////
typedef double                 T_coord;
typedef std::complex<T_coord>  T_point;
//////////////////////////////////////////////////////////////////////////////////////
struct  T_circle
{
    T_point  center_;
    T_coord  radius_;
};
//////////////////////////////////////////////////////////////////////////////////////
typedef std::vector<T_circle>  T_circles;
//////////////////////////////////////////////////////////////////////////////////////
struct  T_circles_rad_comp
{
    bool  operator() (const T_circle&  A, const T_circle&  B)
    {
        return  A.radius_ < B.radius_;
    }
};
//////////////////////////////////////////////////////////////////////////////////////
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);
}
//////////////////////////////////////////////////////////////////////////////////////
T_coord  get_angle_opposite
    (
        T_coord  a_side,
        T_coord  b_side,
        T_coord  c_side
    )
{
    T_coord  cos_A = (b_side * b_side + c_side * c_side - a_side * a_side) 
                     / (2 * b_side * c_side);
 
    return  acos(cos_A);
}
//////////////////////////////////////////////////////////////////////////////////////
T_coord  get_segment_area(T_coord  radius, T_coord  segm_theta)
{
    return  0.5 * radius * radius * (segm_theta - sin(segm_theta));
}
//////////////////////////////////////////////////////////////////////////////////////
T_coord  get_circles_intersection_area(T_circles&  circles)
{    
    std::sort(circles.begin(), circles.end(), T_circles_rad_comp());
    T_coord   intersection_area  = 0;
    T_coord   centers_dist       = abs(circles.front().center_ - circles.back().center_);
    T_coord&  r                  = circles.front()  .radius_;
    T_coord&  R                  = circles.back()   .radius_;
 
    if(greater_equal_for_real(abs(R - centers_dist), r))
    {
        intersection_area = greater_for_real(centers_dist, R) ? 0 : M_PI * r * r;
    }
    else
    {
        T_coord   segment_theta_half  = get_angle_opposite(R, r, centers_dist); 
        T_coord   Segment_theta_half  = get_angle_opposite(r, R, centers_dist); 
        intersection_area     =   get_segment_area(r, segment_theta_half * 2)
                                + get_segment_area(R, Segment_theta_half * 2);                
    }    
    return  intersection_area;
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));   
    std::cout << "Введите координаты центров и радиусы двух окружностей:"
              << std::endl;    
 
    struct  T_input_circle
    {
        int circle_num_;
        //----------------------------------------------------------------------------
        T_input_circle() : circle_num_()
        {}
        //----------------------------------------------------------------------------
        void  operator() (T_circle&  circle)
        {
            std::cout << std::endl
                      << "ОКРУЖНОСТЬ #"
                      << circle_num_ + 1
                      << ":"
                      << std::endl;
 
            std::cout << '\t'
                      << "координаты центра: ";                      
 
            std::cout << std::endl
                      << '\t'
                      << '\t'
                      << "Cx = "; 
 
            T_coord  Cx = 0;
            std::cin >> Cx;            
 
            std::cout << '\t'
                      << '\t'
                      << "Cy = "; 
 
            T_coord  Cy = 0;
            std::cin >> Cy;
 
            circle.center_ = T_point(Cx, Cy);            
 
            std::cout << std::endl
                      << '\t'
                      << "радиус: ";
 
            std::cin >> circle.radius_;
            ++circle_num_;
        }
    };
 
    T_circles  circles(2);
    std::for_each(circles.begin(), circles.end(), T_input_circle());
 
    std::cout << "Площадь пересечения заданных окружностей равна "
              << get_circles_intersection_area(circles)
              << std::endl;
}