Вычисление дуги сферы, если известны положения двух точек и радиус

/////////////////////////////////////////////////////////////////////////////////////////
//  В первой строке входного файла -    радиус планеты; 
//  во второй -                         географические координаты точки старта,
//      т.е.:   градусы, минуты и секунды долготы,
//              символ w (западная) или e (восточная),
//              градусы, минуты и секунды широты,
//              символ n (северная) или s (южная);
//  в третьей -                         количество N точек финиша,
//  в каждой из следующих N строк -     географические координаты одной из точек финиша.
//
//  В выходной файл выводится расстояние до ближайшей точки финиша.
/////////////////////////////////////////////////////////////////////////////////////////
#define _USE_MATH_DEFINES
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <complex>
#include <fstream>
#include <iostream>
#include <set>
#include <map>
#include <numeric>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                                             T_str;
typedef double                                                  T_real;
typedef T_real                                                  T_longitude_latitude_distance;
typedef std::set        <   T_longitude_latitude_distance   >   T_longitude_latitude_distances;
typedef std::complex    <   T_real                          >   T_longitude_latitude_point;
typedef std::vector     <   T_longitude_latitude_point      >   T_longitude_latitude_points;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_XYZ
{
    T_real  X;    
    T_real  Y;    
    T_real  Z;
    //-----------------------------------------------------------------------------------
    T_XYZ()
        :
        X(),
        Y(),
        Z()
    {}
    //-----------------------------------------------------------------------------------
    T_real  dot_product(const  T_XYZ  vect) const
    {
        return      X * vect.X
                +   Y * vect.Y
                +   Z * vect.Z;
    }
    //-----------------------------------------------------------------------------------
    T_real  norm() const
    {
        return  sqrt( dot_product(*this) );
    }
    //-----------------------------------------------------------------------------------
    T_real  angle(const  T_XYZ  vect) const
    {
        T_real  angle_cos   =       dot_product(vect)
                                /   norm()
                                /   vect.norm();  
 
        return  acos(angle_cos);
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
T_real  input_degree_min_sec_and_get_radians(std::ifstream&  ifile)
{
    T_real  degrees = 0;
    ifile >> degrees;
 
    T_real  minutes = 0;
    ifile >> minutes;
 
    T_real  seconds = 0;
    ifile >> seconds;
 
    T_real  all_degrees     =       degrees    
                                +   minutes / 60
                                +   seconds / (60 * 60);
 
    return  all_degrees / 180 * M_PI;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_longitude_latitude_point
    (
        std::ifstream&                  ifile,
        T_longitude_latitude_point&     longitude_latitude_point
    )
{
    T_real  longitude_radians   =   input_degree_min_sec_and_get_radians(ifile);
 
    char    longitude_symb      = 0;
    ifile >> longitude_symb;
 
    if(longitude_symb == 'w')
    {
        longitude_radians *= -1;
    }
 
    T_real  latitude_radians    =   input_degree_min_sec_and_get_radians(ifile);
 
    char    latitude_symb = 0;
    ifile >> latitude_symb;
 
    if(latitude_symb == 's')
    {
        latitude_radians *= -1;
    }
 
    longitude_latitude_point    =   T_longitude_latitude_point
                                        (
                                            longitude_radians,
                                            latitude_radians
                                        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_planet_radius_and_geographic_coordinates
    (
        std::ifstream&                  ifile,
        T_real&                         planet_radius,
        T_longitude_latitude_point&     start_longitude_latitude_point,
        T_longitude_latitude_points&    longitude_latitude_points
    )
{    
    ifile >> planet_radius;
 
    input_longitude_latitude_point
        (
            ifile,
            start_longitude_latitude_point
        );
 
    int     longitude_latitude_points_total = 0;
    ifile >> longitude_latitude_points_total;
 
    longitude_latitude_points.resize(longitude_latitude_points_total);
 
    for(
        T_longitude_latitude_points::iterator  
        longitude_latitude_point_it = longitude_latitude_points.begin();
        longitude_latitude_point_it != longitude_latitude_points.end();
        ++longitude_latitude_point_it
       )
    {
        input_longitude_latitude_point
            (
                ifile,
                *longitude_latitude_point_it
            );
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
T_XYZ  longitude_latitude_to_XYZ
    (const T_longitude_latitude_point&   longitude_latitude_point)
{
    T_real  longitude   =   longitude_latitude_point.real();
    T_real  latitude    =   longitude_latitude_point.imag();
 
    T_XYZ   res_XYZ;
    res_XYZ.Z   =   sin(latitude);
    T_real  r   =   cos(latitude);
    res_XYZ.X   =   r * cos(longitude);
    res_XYZ.Y   =   r * sin(longitude);
    return  res_XYZ;  
}
/////////////////////////////////////////////////////////////////////////////////////////
T_real  get_min_longitude_latitude_dist
    (
        T_real                              planet_radius,
        const T_longitude_latitude_point&   start_longitude_latitude_point,
        const T_longitude_latitude_points&  longitude_latitude_points
    )
{
    struct  T_get_longitude_latitude_distance
    {
        T_real  planet_radius_;
        T_XYZ   XYZ_start_vect_;
        //-------------------------------------------------------------------------------
        T_get_longitude_latitude_distance
            (
                T_real                              planet_radius,
                const T_longitude_latitude_point&   start_longitude_latitude_point
            )
            :
            planet_radius_(planet_radius)
        {
            XYZ_start_vect_ = longitude_latitude_to_XYZ(start_longitude_latitude_point);  
        }
        //-------------------------------------------------------------------------------
        T_real  operator()
            (
                const T_longitude_latitude_point&  longitude_latitude_point
            )
        {
            T_XYZ   XYZ_vect    =   longitude_latitude_to_XYZ( longitude_latitude_point ); 
            T_real  angle       =   XYZ_start_vect_.angle(XYZ_vect);   
 
            return  abs(angle * planet_radius_); 
        }
    };
 
    T_longitude_latitude_distances  longitude_latitude_distances;
 
    std::transform
        (
            longitude_latitude_points.begin(),
            longitude_latitude_points.end(),
            std::inserter
                (
                    longitude_latitude_distances,
                    longitude_latitude_distances.begin()
                ),
 
            T_get_longitude_latitude_distance
                (
                    planet_radius,
                    start_longitude_latitude_point
                )
        );
 
    return  *longitude_latitude_distances.begin();
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    const T_str  ifilename = "input.txt";       
    const T_str  ofilename = "output.txt";
 
    T_real                         planet_radius = 0;
    T_longitude_latitude_point      start_longitude_latitude_point;
    T_longitude_latitude_points     longitude_latitude_points;
 
    std::ifstream   ifile( ifilename.c_str() );
 
    input_planet_radius_and_geographic_coordinates
        (
            ifile,
            planet_radius,
            start_longitude_latitude_point,
            longitude_latitude_points
        );
 
    T_real  min_longitude_latitude_dist    =   get_min_longitude_latitude_dist
                                                    (
                                                        planet_radius,
                                                        start_longitude_latitude_point,
                                                        longitude_latitude_points
                                                    );
 
    std::ofstream  ofile( ofilename.c_str() );
    ofile << min_longitude_latitude_dist;
}