starcoord.hpp

#ifndef STAR_COORD_H
#define STAR_COORD_H
 
#include <cmath>
 
#include "json.hpp"
 
/*
 * Radius is measured in kilo-Km, or kkm (consider the distance between sun and earth is average 150.000.000Km - 150M Km)
 *
 * The reason is that "kkm" cannot be easily confused with something else, and at the same time gives reasonable numbers
 * like 150.000 for a earth-like planet, or 20.500.000 for the outer edges of the solar system itself (neptune is at 4.5bln km)
 *
 */
class StarCoord
{
public:
    static constexpr double precision = 0.01;
 
    StarCoord()
        : _x( 0.0 )
        , _y( 0.0 ) {}
 
    StarCoord(double x, double y )
        : _x( x )
        , _y( y ) {}
 
    StarCoord( const StarCoord& other )
        : _x( other._x )
        , _y( other._y ) {}
 
    double distanceKkm( const StarCoord& other ) const {
        double dx = deltaX_kkm( other );
        double dy = deltaY_kkm( other );
        return std::sqrt( dx*dx + dy*dy );
    }
 
    double deltaX_kkm( const StarCoord& other ) const {
        return _x - other._x;
    }
 
    double deltaY_kkm( const StarCoord& other ) const {
        return _y - other._y;
    }
 
 
    double lenght() const {
        return std::fabs( std::sqrt( _x*_x + _y*_y ) );
    }
 
 
    void operator += ( const StarCoord &b) {
        _x += b._x;
        _y += b._y;
    }
 
    const StarCoord &operator =( const StarCoord &b) {
        _x = b._x;
        _y = b._y;
        return b;
    }
 
    double x() const { return _x; }
    double y() const { return _y; }
    double x( double x ) {
        return _x = x;
    }
 
    double y( double y ) {
        return _y = y;
    }
 
    bool isNaN() const {
        return (_x == NAN) || (_y == NAN);
    }
 
    friend void to_json(nlohmann::json& j, const StarCoord& s) {
        j = nlohmann::json{
            {"x", s.x()},
            {"y", s.y()}
        };
    }
 
    friend void from_json(const nlohmann::json& j, StarCoord& s) {
        s.x(j.at("x").get<double>());
        s.y(j.at("y").get<double>());
    }
 
    friend StarCoord operator - (const StarCoord &a, const StarCoord &b) {
        return StarCoord( a.x() - b.x(), a.y() - b.y() );
    }
 
    friend StarCoord operator + (const StarCoord &a, const StarCoord &b) {
        return StarCoord( a.x() + b.x(), a.y() + b.y() );
    }
 
    friend bool operator < (const StarCoord &a, const StarCoord &b) {
        if ( a.x() < b.x() )
            return true;
        if ( a.x() > b.x() )
            return false;
        return a.y() < b.y();
    }
 
    friend bool operator == (const StarCoord &a, const StarCoord &b) {
        double delta_x = std::fabs( a.x() - b.x() );
        double delta_y = std::fabs( a.y() - b.y() );
        if ( ( delta_x < StarCoord::precision ) &&
            ( delta_y < StarCoord::precision ) )
            return true;
        return false;
    }
 
    friend bool operator != (const StarCoord &a, const StarCoord &b) {
        double delta_x = std::fabs( a.x() - b.x() );
        double delta_y = std::fabs( a.y() - b.y() );
        if ( ( delta_x > StarCoord::precision ) ||
            ( delta_y > StarCoord::precision ) )
            return true;
        return false;
    }
 
private:
    double _x;
    double _y;
 
};
 
 
#endif // STAR_COORD_H