Merge pull request #548 from ut-issl/feature/add-time-system-library

Update time system library

src/library/CMakeLists.txt

@@ -40,6 +40,8 @@ add_library(${PROJECT_NAME} STATIC
   planet_rotation/moon_rotation_utilities.cpp
 
   time_system/date_time_format.cpp
+  time_system/epoch_time.cpp
+  time_system/gps_time.cpp
 
   external/igrf/igrf.cpp
   external/inih/ini.c

src/library/time_system/date_time_format.cpp

@@ -3,12 +3,43 @@
  * @brief Class to handle Gregorian date and time format
  */
 
+#define _CRT_SECURE_NO_WARNINGS  // for sscanf
+
 #include "date_time_format.hpp"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
+DateTime::DateTime(const std::string date_time) {
+  sscanf(date_time.c_str(), "%zu/%zu/%zu %zu:%zu:%lf", &year_, &month_, &day_, &hour_, &minute_, &second_);
+}
+
+DateTime::DateTime(const EpochTime epoch_time) {
+  // No leap second calculation
+  const int mday[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
+                      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};  //!< Number of days in a month
+  int days, sec, mon, day;
+
+  // leap year if year%4==0 in 1901-2099
+  days = (int)(epoch_time.GetTime_s() / 86400);
+  sec = (int)(epoch_time.GetTime_s() - (time_t)days * 86400);
+
+  for (day = days % 1461, mon = 0; mon < 48; mon++) {
+    if (day >= mday[mon])
+      day -= mday[mon];
+    else
+      break;
+  }
+
+  year_ = 1970 + days / 1461 * 4 + mon / 12;
+  month_ = mon % 12 + 1;
+  day_ = day + 1;
+  hour_ = sec / 3600;
+  minute_ = sec % 3600 / 60;
+  second_ = sec % 60 + epoch_time.GetFraction_s();
+}
+
 std::string DateTime::GetAsString() const {
   std::stringstream stream;
   stream << std::setw(4) << std::setfill('0') << (int)year_ << "/";

src/library/time_system/date_time_format.hpp

@@ -3,13 +3,15 @@
  * @brief Class to handle Gregorian date and time format
  */
 
-#define _CRT_SECURE_NO_WARNINGS  // for sscanf
-
 #ifndef S2E_LIBRARY_TIME_SYSTEM_DATE_TIME_FORMAT_HPP_
 #define S2E_LIBRARY_TIME_SYSTEM_DATE_TIME_FORMAT_HPP_
 
 #include <string>
 
+#include "epoch_time.hpp"
+
+class EpochTime;
+
 /**
  *@class DateTime
  * @brief Class to handle Gregorian date and time format
@@ -28,9 +30,12 @@ class DateTime {
    * @brief Constructor initialized with string expression as YYYY/MM/DD hh:mm:ss.s
    * @note TODO: Support other format like dd.mm.yyyy
    */
-  DateTime(const std::string date_time = "0000/01/01 00:00:00.0") {
-    sscanf(date_time.c_str(), "%zu/%zu/%zu %zu:%zu:%lf", &year_, &month_, &day_, &hour_, &minute_, &second_);
-  }
+  DateTime(const std::string date_time = "0000/01/01 00:00:00.0");
+  /**
+   * @fn DateTime
+   * @brief Constructor initialized with epoch time
+   */
+  DateTime(const EpochTime epoch_time);
 
   // Getters
   inline size_t GetYear() const { return year_; }

src/library/time_system/epoch_time.cpp

@@ -0,0 +1,75 @@
+/**
+ * @file epoch_time.cpp
+ * @brief A class to handle time like UNIX time with fractions
+ */
+
+#include "epoch_time.hpp"
+
+#include <cmath>
+
+EpochTime::EpochTime(const DateTime date_time) {
+  // No leap second calculation
+  const int doy[] = {1, 32, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};  //!< Day of Year for the 1st day of each month
+  // Parse Calender
+  const size_t year = date_time.GetYear();
+  const size_t month = date_time.GetMonth();
+  const size_t day = date_time.GetDay();
+  const size_t hour = date_time.GetHour();
+  const size_t minute = date_time.GetMinute();
+  const size_t second = (size_t)std::floor(date_time.GetSecond());
+
+  // TODO: assertion
+  if (year < 1970 || month < 1 || 12 < month) return;
+  if (day < 1 || 32 <= day) return;
+  if (60 <= minute) return;
+  if (60 <= second) return;
+
+  // leap year if year%4==0 in 1901-2099
+  uint64_t days = (year - 1970) * 365 + (year - 1969) / 4 + doy[month - 1] + day - 2 + (year % 4 == 0 && month >= 3 ? 1 : 0);
+  time_s_ = (uint64_t)days * 86400 + hour * 3600 + minute * 60 + second;
+  fraction_s_ = date_time.GetSecond() - (double)second;
+}
+
+bool EpochTime::operator==(const EpochTime& target) const {
+  if (this->time_s_ != target.time_s_) return false;
+  if (this->fraction_s_ != target.fraction_s_) return false;  // TODO: comparison of double
+  return true;
+}
+
+bool EpochTime::operator>(const EpochTime& right_side) const {
+  if (*this == right_side) return false;
+  if (this->time_s_ < right_side.time_s_) return false;
+  if (this->time_s_ > right_side.time_s_) return true;
+  if (this->fraction_s_ < right_side.fraction_s_) return false;
+  return true;
+}
+
+bool EpochTime::operator<(const EpochTime& right_side) const {
+  if (*this == right_side) return false;
+  if (this->time_s_ > right_side.time_s_) return false;
+  if (this->time_s_ < right_side.time_s_) return true;
+  if (this->fraction_s_ > right_side.fraction_s_) return false;
+  return true;
+}
+
+EpochTime EpochTime::operator+(const EpochTime& right_side) const {
+  time_t time_s = this->time_s_ + right_side.GetTime_s();
+  double fraction_s = this->fraction_s_ + right_side.GetFraction_s();
+  if (fraction_s > 1.0) {
+    fraction_s -= 1.0;
+    time_s += 1;
+  }
+  EpochTime result(time_s, fraction_s);
+  return result;
+}
+
+EpochTime EpochTime::operator-(const EpochTime& right_side) const {
+  time_t time_s = this->time_s_ - right_side.GetTime_s();  // TODO: assertion for negative value
+  double fraction_s = this->fraction_s_ - right_side.GetFraction_s();
+  if (fraction_s < 0.0) {
+    fraction_s += 1.0;
+    time_s -= 1;
+  }
+  EpochTime result(time_s, fraction_s);
+  return result;
+}

src/library/time_system/epoch_time.hpp

@@ -0,0 +1,70 @@
+/**
+ * @file epoch_time.hpp
+ * @brief A class to handle time like UNIX time with fractions
+ */
+
+#ifndef S2E_LIBRARY_TIME_SYSTEM_EPOCH_TIME_HPP_
+#define S2E_LIBRARY_TIME_SYSTEM_EPOCH_TIME_HPP_
+
+#include <cstdint>
+
+#include "date_time_format.hpp"
+
+class DateTime;
+
+/**
+ * @class EpochTime
+ * @brief A class to handle time like UNIX time with fractions.
+ * @note This class doesn't care leap seconds.
+ */
+class EpochTime {
+ public:
+  /**
+   * @fn EpochTime
+   * @brief Constructor initialized with week and second
+   */
+  EpochTime(const uint64_t time_s = 0, const double fraction_s = 0.0) : time_s_(time_s), fraction_s_(fraction_s) {}
+  /**
+   * @fn EpochTime
+   * @brief Constructor initialized with date time expression
+   */
+  EpochTime(const DateTime date_time);
+  /**
+   * @fn ~EpochTime
+   * @brief Destructor
+   */
+  ~EpochTime() {}
+
+  // Getter
+  /**
+   * @fn GetTime_s
+   * @return time [s]
+   */
+  inline uint64_t GetTime_s() const { return time_s_; }
+  /**
+   * @fn GetFraction_s
+   * @return fraction time [s]
+   */
+  inline double GetFraction_s() const { return fraction_s_; }
+  /**
+   * @fn GetTimeWithFraction_s
+   * @return time + fraction [s]
+   */
+  inline double GetTimeWithFraction_s() const { return (double)(time_s_) + fraction_s_; }
+
+  // Operator
+  bool operator==(const EpochTime& target) const;
+  bool operator!=(const EpochTime& target) const { return !(*this == target); }
+  bool operator>(const EpochTime& right_side) const;
+  bool operator<=(const EpochTime& right_side) const { return !(*this > right_side); }
+  bool operator<(const EpochTime& right_side) const;
+  bool operator>=(const EpochTime& right_side) const { return !(*this < right_side); }
+  EpochTime operator+(const EpochTime& right_side) const;
+  EpochTime operator-(const EpochTime& right_side) const;
+
+ private:
+  uint64_t time_s_;    //!< Number of seconds without leap seconds since 00:00:00 Jan 1 1970 UTC.
+  double fraction_s_;  //!< Fraction of second under 1 sec [0, 1)
+};
+
+#endif  // S2E_LIBRARY_TIME_SYSTEM_EPOCH_TIME_HPP_

src/library/time_system/gps_time.cpp

@@ -0,0 +1,25 @@
+/**
+ * @file gps_time.cpp
+ * @brief A class to define GPS time expression
+ */
+
+#include "gps_time.hpp"
+
+const DateTime GpsTime::kEpochOfGpsTimeInDateTime_ = DateTime("1980/1/6 00:00:00.0");
+const EpochTime GpsTime::kEpochOfGpsTimeInEpochTime_ = EpochTime(kEpochOfGpsTimeInDateTime_);
+const EpochTime GpsTime::kLeapSecondAheadFromUtc_ = EpochTime(18, 0);  //!< Leap second ahead from UTC @ May 2023
+
+void GpsTime::CalcGpsWeekTime() {
+  EpochTime time_diff = epoch_time_ - kEpochOfGpsTimeInEpochTime_;
+  week_ = (size_t)(time_diff.GetTime_s() / kSecondsInWeek_);
+  elapsed_time_from_week_s_ = (double)(time_diff.GetTime_s() - week_ * kSecondsInWeek_) + time_diff.GetFraction_s();
+}
+
+void GpsTime::CalcEpochTime() {
+  size_t integer_time_s = (size_t)elapsed_time_from_week_s_;
+  double fraction_s = elapsed_time_from_week_s_ - (double)(integer_time_s);
+  time_t time_s = week_ * kSecondsInWeek_ + integer_time_s;
+  EpochTime time_diff(time_s, fraction_s);
+
+  epoch_time_ = kEpochOfGpsTimeInEpochTime_ + time_diff;
+}

src/library/time_system/gps_time.hpp

@@ -8,6 +8,9 @@
 
 #include <cstddef>
 
+#include "date_time_format.hpp"
+#include "epoch_time.hpp"
+
 /**
  * @class GpsTime
  * @brief A class to define GPS time expression
@@ -19,8 +22,25 @@ class GpsTime {
    * @fn GpsTime
    * @brief Constructor initialized with week and second
    */
-  GpsTime(const size_t week = 0, const double elapsed_time_from_week_s = 0.0) : week_(week), elapsed_time_from_week_s_(elapsed_time_from_week_s) {}
+  GpsTime(const size_t week = 0, const double elapsed_time_from_week_s = 0.0) : week_(week), elapsed_time_from_week_s_(elapsed_time_from_week_s) {
+    CalcEpochTime();
+    date_time_ = DateTime(epoch_time_);
+  }
+  /**
+   * @fn GpsTime
+   * @brief Constructor initialized with epoch time expression
+   */
+  GpsTime(const EpochTime epoch_time) : date_time_(DateTime(epoch_time)), epoch_time_(epoch_time) { CalcGpsWeekTime(); }
+  /**
+   * @fn GpsTime
+   * @brief Constructor initialized with calender expression
+   */
+  GpsTime(const DateTime date_time) : date_time_(date_time), epoch_time_(EpochTime(date_time_)) { CalcGpsWeekTime(); }
 
+  /**
+   * @fn ~GpsTime
+   * @brief Destructor
+   */
   ~GpsTime() {}
 
   /**
@@ -30,13 +50,49 @@ class GpsTime {
   inline size_t GetWeek() const { return week_; }
   /**
    * @fn GetTime
-   * @return GPS time
+   * @return GPS time from week
    */
   inline double GetElapsedTimeFromWeek_s() const { return elapsed_time_from_week_s_; }
+  /**
+   * @fn GetEpochTime
+   * @return GPS time in epoch time expression
+   */
+  inline EpochTime GetEpochTime() const { return epoch_time_; }
+  /**
+   * @fn GetDateTime
+   * @return GPS time in date time expression
+   */
+  inline DateTime GetDateTime() const { return date_time_; }
+  /**
+   * @fn GetDateTimeAsUtc
+   * @return DateTime as UTC including leap seconds
+   */
+  inline DateTime GetDateTimeAsUtc() const { return epoch_time_ - kLeapSecondAheadFromUtc_; }
 
  private:
   size_t week_;                      //!< GPS week (week = 0 at 6th Jan. 1980)
   double elapsed_time_from_week_s_;  //!< Elapsed time from the GPS week [s] [0,0, 604800.0)
+  // Expressions
+  DateTime date_time_;    //!< GPS time in date time expression
+  EpochTime epoch_time_;  //!< GPS time in epoch time expression
+  // Epoch of GPS time
+  static const DateTime kEpochOfGpsTimeInDateTime_;    //!< GPS time epoch in date time expression
+  static const EpochTime kEpochOfGpsTimeInEpochTime_;  //!< GPS time epoch in epoch time expression
+  // Constants
+  static const size_t kSecondsInWeek_ = 86400 * 7;  //!< Seconds in Week
+  static const EpochTime kLeapSecondAheadFromUtc_;  //!< leap second ahead from UTC
+
+  // Functions
+  /**
+   * @fn CalcGpsWeekTime
+   * @brief Calculate GPS Time from epoch time
+   */
+  void CalcGpsWeekTime();
+  /**
+   * @fn CalcEpochTime
+   * @brief Calculate Epoch time from GPS time
+   */
+  void CalcEpochTime();
 };
 
 #endif  // S2E_LIBRARY_TIME_SYSTEM_GPS_TIME_HPP_

src/library/time_system/test_date_time_format.cpp

@@ -30,6 +30,22 @@ TEST(DateTime, ConstructorWithString) {
   EXPECT_DOUBLE_EQ(59.4, date_time.GetSecond());
 }
 
+/**
+ * @brief Test Constructor with epoch time
+ */
+TEST(DateTime, ConstructorWithEpochTime) {
+  // Reference for correctness check: https://www.epochconverter.com/
+  EpochTime epoch_time(1686145305, 0.3);
+  DateTime date_time(epoch_time);
+
+  EXPECT_EQ(2023, date_time.GetYear());
+  EXPECT_EQ(6, date_time.GetMonth());
+  EXPECT_EQ(7, date_time.GetDay());
+  EXPECT_EQ(13, date_time.GetHour());
+  EXPECT_EQ(41, date_time.GetMinute());
+  EXPECT_DOUBLE_EQ(45.3, date_time.GetSecond());
+}
+
 /**
  * @brief Test get as string
  */