JulianDate.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "Duration.hpp"
#include "AstUtil/Constants.h"
 
AST_NAMESPACE_BEGIN
 
class JulianDate;
class Date;
class Time;
class DateTime;
 
 
 
AST_CORE_CAPI void aJDToMJD(const JulianDate& jd, ModJulianDate& mjd);
 
 
AST_CORE_CAPI void aMJDToJD(const ModJulianDate& mjd, JulianDate& jd);
 
 
AST_CORE_API ImpreciseMJD aJDToMJD_Imprecise(ImpreciseJD jd);
 
 
AST_CORE_API ImpreciseMJD aJDToMJD_Imprecise(const JulianDate& jd);
 
 
AST_CORE_API ImpreciseJD aMJDToJD_Imprecise(ImpreciseMJD mjd);
 
 
AST_CORE_API ImpreciseJD aMJDToJD_Imprecise(const ModJulianDate& mjd);
 
 
AST_CORE_API void aMJDToJD_Imprecise(ImpreciseMJD mjd, JulianDate& jd);
 
 
AST_CORE_CAPI void aDateTimeToJD(const DateTime& dttm, JulianDate& jd);
 
 
AST_CORE_CAPI void aJDToDateTime(const JulianDate& jd, DateTime& dttm);
 
 
class JulianDate
{
public:
    static JulianDate FromImpreciseDay(double day){
        int d = static_cast<int>(day);
        double second = (day - d) * 86400.0;
        return JulianDate::FromDaySecond(d, second);
    }
 
    static JulianDate FromDays(double day1, double day2)
    {
        int d1 = static_cast<int>(day1);
        int d2 = static_cast<int>(day2);
        double second = ((day1 - d1) + (day2 - d2)) * 86400.0;
        return JulianDate::FromDaySecond(d1 + d2, second);
    }
 
    static JulianDate FromDaySecond(int day, double second){
        return JulianDate{day, second};
    }
 
    static JulianDate FromDaySecond(double day, double second)
    {
        int d = static_cast<int>(day);
        double s = (day - d) * 86400.0;
        return JulianDate{d, second + s};
    }
 
    static JulianDate FromDateTime(const DateTime& dttm)
    {
        JulianDate jd;
        aDateTimeToJD(dttm, jd);
        return jd;
    }
 
    static JulianDate J2000(){
        return JulianDate::FromDaySecond(static_cast<int>(kJ2000Epoch), 0.0);
    }
 
    AST_CORE_API
    static JulianDate FromDateTime(int year, int month, int day, int hour, int minute, double second);
public:
    double impreciseDay() const{return day_ + second_ /86400.;}
    
    void setImpreciseDay(double jd){
        int day = static_cast<int>(jd);
        double second = (jd - day) * 86400.0;
        setDaySecond(day, second);
    }
public:
    int day() const{return day_;}
    int& day(){return day_;}
    double second() const {return second_;}
    double& second(){return second_;}
    void setDay(int day){day_ = day;}
    void setSecond(double sec){second_ = sec;}
 
    void getDaySecond(int& day, double& second) const{
        day = day_;
        second = second_;
    }
    void setDaySecond(int day, double second){
        day_ = day;
        second_ = second;
    }
public:
    double dayFractional() const{
        return second_ / kSecondsPerDay;
    }
    void setDayFractional(double df){
        second_ = df * kSecondsPerDay;
    }
public:
    double julianCenturyFromJ2000() const{
        return daysFromJ2000() / kDaysPerJulianCentury;
    }
    double daysFromJ2000() const{
        return daysFromJulianDate(kJ2000Epoch);
    }
    double secondsFromJ2000() const{
        return (day_ - kJ2000Epoch) * kSecondsPerDay + second_;
    }
    double daysFromJulianDate(double jd) const
    {
        return ((day_ - jd) + dayFractional());
    }
    
    double daysFrom(const JulianDate& other) const{
        return (*this - other).totalDay();
    }
public:
    JulianDate& operator += (double sec)
    {
        this->second() += sec;  // 适用于任何时间尺度，包括考核闰秒的和不考虑闰秒的
        return *this;
    }
    JulianDate& operator -= (double sec)
    {
        this->second() -= sec;  // 适用于任何时间尺度，包括考核闰秒的和不考虑闰秒的
        return *this;
    }
    JulianDate operator + (double sec) const
    {
        JulianDate jd{ *this };
        jd += sec;
        return jd;
    }
    JulianDate operator - (double sec) const
    {
        JulianDate jd{ *this };
        jd -= sec;
        return jd;
    }
    DaySecDuration operator - (const JulianDate& other) const
    {
        return {day() - other.day(), second() - other.second()};
    }
public:
    JulianDate shiftedBySecond(double second) const{
        return JulianDate::FromDaySecond(day_, second_ + second);
    }
public:
    int    day_;     // 天数部分 day part of julian date
    double second_;  // 秒数部分 second part of julia date
};
 
 
 
AST_NAMESPACE_END