astronoby 0.3.0 → 0.4.0

data/lib/astronoby/events/observation_events.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Events
+    class ObservationEvents
+      STANDARD_ALTITUDE = Angle.from_dms(0, -34, 0)
+      RISING_SETTING_HOUR_ANGLE_RATIO_RANGE = (-1..1)
+      EARTH_SIDEREAL_ROTATION_RATE = 360.98564736629
+
+      attr_reader :rising_time,
+        :rising_azimuth,
+        :transit_time,
+        :transit_altitude,
+        :setting_time,
+        :setting_azimuth
+
+      # Source:
+      #  Title: Astronomical Algorithms
+      #  Author: Jean Meeus
+      #  Edition: 2nd edition
+      #  Chapter: 15 - Rising, Transit, and Setting
+
+      # @param observer [Astronoby::Observer] Observer
+      # @param date [Date] Date of the event
+      # @param coordinates_of_the_previous_day [Astronoby::Coordinates::Equatorial]
+      #   Coordinates of the body of the previous day
+      # @param coordinates_of_the_day [Astronoby::Coordinates::Equatorial]
+      #   Coordinates of the body of the day
+      # @param coordinates_of_the_next_day [Astronoby::Coordinates::Equatorial]
+      #   Coordinates of the body of the next day
+      # @param additional_altitude [Astronoby::Angle] Additional altitude to the
+      #   standard altitude adjustment
+      def initialize(
+        observer:,
+        date:,
+        coordinates_of_the_previous_day:,
+        coordinates_of_the_day:,
+        coordinates_of_the_next_day:,
+        additional_altitude: Angle.zero
+      )
+        @observer = observer
+        @date = date
+        @coordinates_of_the_previous_day = coordinates_of_the_previous_day
+        @coordinates_of_the_day = coordinates_of_the_day
+        @coordinates_of_the_next_day = coordinates_of_the_next_day
+        @standard_altitude = STANDARD_ALTITUDE
+        @additional_altitude = additional_altitude
+        compute
+      end
+
+      private
+
+      def compute
+        @transit_time = Util::Time.decimal_hour_to_time(@date, initial_transit)
+        @transit_altitude = local_horizontal_altitude_transit
+
+        return if h0.nil?
+
+        delta_m_rising = (local_horizontal_altitude_rising - shift).degrees./(
+          Constants::DEGREES_PER_CIRCLE *
+            declination_rising.cos *
+            @observer.latitude.cos *
+            local_hour_angle_rising.sin
+        )
+        delta_m_transit = -local_hour_angle_transit.degrees / Constants::DEGREES_PER_CIRCLE
+        delta_m_setting = (local_horizontal_altitude_setting - shift).degrees./(
+          Constants::DEGREES_PER_CIRCLE *
+            declination_setting.cos *
+            @observer.latitude.cos *
+            local_hour_angle_setting.sin
+        )
+
+        corrected_rising = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * (initial_rising + delta_m_rising)
+        )
+        corrected_transit = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * (initial_transit + delta_m_transit)
+        )
+        corrected_setting = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * (initial_setting + delta_m_setting)
+        )
+
+        @rising_time = Util::Time.decimal_hour_to_time(@date, corrected_rising)
+        @rising_azimuth = local_horizontal_azimuth_rising
+        @transit_time = Util::Time.decimal_hour_to_time(@date, corrected_transit)
+        @setting_time = Util::Time.decimal_hour_to_time(@date, corrected_setting)
+        @setting_azimuth = local_horizontal_azimuth_setting
+      end
+
+      def observer_longitude
+        # Longitude must be treated positively westwards from the meridian of
+        # Greenwich, and negatively to the east
+        @observer_longitude ||= -@observer.longitude
+      end
+
+      def h0
+        @h0 ||= begin
+          term1 = shift.sin -
+            @observer.latitude.sin * @coordinates_of_the_day.declination.sin
+          term2 = @observer.latitude.cos * @coordinates_of_the_day.declination.cos
+          ratio = term1 / term2
+          return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(ratio)
+
+          Angle.acos(ratio)
+        end
+      end
+
+      def apparent_gst_at_midnight
+        @apparent_gst_at_midnight ||= Angle.from_hours(
+          GreenwichSiderealTime.from_utc(
+            Time.utc(@date.year, @date.month, @date.day)
+          ).time
+        )
+      end
+
+      def initial_transit
+        @initial_transit ||= rationalize_decimal_time(
+          (
+            @coordinates_of_the_day.right_ascension.degrees +
+              observer_longitude.degrees -
+              apparent_gst_at_midnight.degrees
+          ) / Constants::DEGREES_PER_CIRCLE
+        )
+      end
+
+      def initial_rising
+        @initial_rising ||=
+          rationalize_decimal_time(
+            initial_transit - h0.degrees / Constants::DEGREES_PER_CIRCLE
+          )
+      end
+
+      def initial_setting
+        @initial_setting ||=
+          rationalize_decimal_time(
+            initial_transit + h0.degrees / Constants::DEGREES_PER_CIRCLE
+          )
+      end
+
+      def gst_rising
+        @gst_rising ||= Angle.from_degrees(
+          apparent_gst_at_midnight.degrees +
+            EARTH_SIDEREAL_ROTATION_RATE * initial_rising
+        )
+      end
+
+      def gst_transit
+        @gst_transit ||= Angle.from_degrees(
+          apparent_gst_at_midnight.degrees +
+            EARTH_SIDEREAL_ROTATION_RATE * initial_transit
+        )
+      end
+
+      def gst_setting
+        @gst_setting ||= Angle.from_degrees(
+          apparent_gst_at_midnight.degrees +
+            EARTH_SIDEREAL_ROTATION_RATE * initial_setting
+        )
+      end
+
+      def leap_day_portion
+        @leap_day_portion ||= begin
+          leap_seconds = Util::Time.terrestrial_universal_time_delta(@date)
+          leap_seconds / Constants::SECONDS_PER_DAY
+        end
+      end
+
+      def local_hour_angle_rising
+        @local_hour_angle_rising ||=
+          gst_rising - observer_longitude - right_ascension_rising
+      end
+
+      def local_hour_angle_transit
+        @local_hour_angle_transit ||=
+          gst_transit - observer_longitude - right_ascension_transit
+      end
+
+      def local_hour_angle_setting
+        @local_hour_angle_setting ||=
+          gst_setting - observer_longitude - right_ascension_setting
+      end
+
+      def local_horizontal_altitude_rising
+        @local_horizontal_altitude_rising ||= Angle.asin(
+          @observer.latitude.sin * declination_rising.sin +
+            @observer.latitude.cos * declination_rising.cos * local_hour_angle_rising.cos
+        )
+      end
+
+      def local_horizontal_azimuth_rising
+        @local_horizontal_azimuth_rising ||= begin
+          shift = -@standard_altitude
+          term1 = declination_rising.sin + shift.sin * @observer.latitude.cos
+          term2 = shift.cos * @observer.latitude.cos
+          angle = term1 / term2
+          Angle.acos(angle)
+        end
+      end
+
+      def local_horizontal_altitude_transit
+        @local_horizontal_altitude_transit ||= Angle.asin(
+          @observer.latitude.sin * declination_transit.sin +
+            @observer.latitude.cos * declination_transit.cos * local_hour_angle_transit.cos
+        )
+      end
+
+      def local_horizontal_altitude_setting
+        @local_horizontal_altitude_setting ||= Angle.asin(
+          @observer.latitude.sin * declination_setting.sin +
+            @observer.latitude.cos * declination_setting.cos * local_hour_angle_setting.cos
+        )
+      end
+
+      def local_horizontal_azimuth_setting
+        shift = -@standard_altitude
+        term1 = declination_setting.sin + shift.sin * @observer.latitude.cos
+        term2 = shift.cos * @observer.latitude.cos
+        angle = term1 / term2
+        Angle.from_degrees(
+          Constants::DEGREES_PER_CIRCLE - Angle.acos(angle).degrees
+        )
+      end
+
+      def rationalize_decimal_time(decimal_time)
+        decimal_time += 1 if decimal_time.negative?
+        decimal_time -= 1 if decimal_time > 1
+        decimal_time
+      end
+
+      def rationalize_decimal_hours(decimal_hours)
+        decimal_hours += Constants::HOURS_PER_DAY if decimal_hours.negative?
+        decimal_hours -= Constants::HOURS_PER_DAY if decimal_hours > Constants::HOURS_PER_DAY
+        decimal_hours
+      end
+
+      def right_ascension_rising
+        Angle.from_degrees(
+          Util::Maths.interpolate(
+            [
+              @coordinates_of_the_previous_day.right_ascension.degrees,
+              @coordinates_of_the_day.right_ascension.degrees,
+              @coordinates_of_the_next_day.right_ascension.degrees
+            ],
+            initial_rising + leap_day_portion
+          )
+        )
+      end
+
+      def right_ascension_transit
+        Angle.from_degrees(
+          Util::Maths.interpolate(
+            [
+              @coordinates_of_the_previous_day.right_ascension.degrees,
+              @coordinates_of_the_day.right_ascension.degrees,
+              @coordinates_of_the_next_day.right_ascension.degrees
+            ],
+            initial_transit + leap_day_portion
+          )
+        )
+      end
+
+      def right_ascension_setting
+        Angle.from_degrees(
+          Util::Maths.interpolate(
+            [
+              @coordinates_of_the_previous_day.right_ascension.degrees,
+              @coordinates_of_the_day.right_ascension.degrees,
+              @coordinates_of_the_next_day.right_ascension.degrees
+            ],
+            initial_setting + leap_day_portion
+          )
+        )
+      end
+
+      def declination_rising
+        Angle.from_degrees(
+          Util::Maths.interpolate(
+            [
+              @coordinates_of_the_previous_day.declination.degrees,
+              @coordinates_of_the_day.declination.degrees,
+              @coordinates_of_the_next_day.declination.degrees
+            ],
+            initial_rising + leap_day_portion
+          )
+        )
+      end
+
+      def declination_transit
+        Angle.from_degrees(
+          Util::Maths.interpolate(
+            [
+              @coordinates_of_the_previous_day.declination.degrees,
+              @coordinates_of_the_day.declination.degrees,
+              @coordinates_of_the_next_day.declination.degrees
+            ],
+            initial_transit + leap_day_portion
+          )
+        )
+      end
+
+      def declination_setting
+        Angle.from_degrees(
+          Util::Maths.interpolate(
+            [
+              @coordinates_of_the_previous_day.declination.degrees,
+              @coordinates_of_the_day.declination.degrees,
+              @coordinates_of_the_next_day.declination.degrees
+            ],
+            initial_setting + leap_day_portion
+          )
+        )
+      end
+
+      def shift
+        @standard_altitude - @additional_altitude
+      end
+    end
+  end
+end

data/lib/astronoby/events/twilight_events.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Events
+    class TwilightEvents
+      TWILIGHTS = [
+        CIVIL = :civil,
+        NAUTICAL = :nautical,
+        ASTRONOMICAL = :astronomical
+      ].freeze
+
+      TWILIGHT_ANGLES = {
+        CIVIL => Angle.from_degrees(96),
+        NAUTICAL => Angle.from_degrees(102),
+        ASTRONOMICAL => Angle.from_degrees(108)
+      }.freeze
+
+      PERIODS_OF_THE_DAY = [
+        MORNING = :morning,
+        EVENING = :evening
+      ].freeze
+
+      attr_reader :morning_civil_twilight_time,
+        :evening_civil_twilight_time,
+        :morning_nautical_twilight_time,
+        :evening_nautical_twilight_time,
+        :morning_astronomical_twilight_time,
+        :evening_astronomical_twilight_time
+
+      def initialize(observer:, sun:)
+        @observer = observer
+        @sun = sun
+        PERIODS_OF_THE_DAY.each do |period_of_the_day|
+          TWILIGHT_ANGLES.each do |twilight, _|
+            zenith_angle = TWILIGHT_ANGLES[twilight]
+            instance_variable_set(
+              :"@#{period_of_the_day}_#{twilight}_twilight_time",
+              compute(period_of_the_day, zenith_angle)
+            )
+          end
+        end
+      end
+
+      # @param period_of_the_day [Symbol] :morning or :evening
+      # @param zenith_angle [Angle] The zenith angle of the twilight
+      def time_for_zenith_angle(period_of_the_day:, zenith_angle:)
+        unless PERIODS_OF_THE_DAY.include?(period_of_the_day)
+          raise IncompatibleArgumentsError,
+            "Only #{PERIODS_OF_THE_DAY.join(" or ")} are allowed as period_of_the_day, got #{period_of_the_day}"
+        end
+
+        compute(period_of_the_day, zenith_angle)
+      end
+
+      private
+
+      # Source:
+      #  Title: Practical Astronomy with your Calculator or Spreadsheet
+      #  Authors: Peter Duffett-Smith and Jonathan Zwart
+      #  Edition: Cambridge University Press
+      #  Chapter: 50 - Twilight
+      def compute(period_of_the_day, zenith_angle)
+        period_time = if period_of_the_day == MORNING
+          observation_events.rising_time
+        else
+          observation_events.setting_time
+        end
+
+        hour_angle_at_period = equatorial_coordinates_at_midday
+          .compute_hour_angle(time: period_time, longitude: @observer.longitude)
+
+        term1 = zenith_angle.cos -
+          @observer.latitude.sin *
+            @equatorial_coordinates_at_midday.declination.sin
+        term2 = @observer.latitude.cos *
+          equatorial_coordinates_at_midday.declination.cos
+        hour_angle_ratio_at_twilight = term1 / term2
+
+        return unless hour_angle_ratio_at_twilight.between?(-1, 1)
+
+        hour_angle_at_twilight = Angle.acos(hour_angle_ratio_at_twilight)
+        time_sign = -1
+
+        if period_of_the_day == MORNING
+          hour_angle_at_twilight = Angle.from_degrees(
+            Constants::DEGREES_PER_CIRCLE - hour_angle_at_twilight.degrees
+          )
+          time_sign = 1
+        end
+
+        twilight_in_hours =
+          time_sign * (hour_angle_at_twilight - hour_angle_at_period).hours *
+          GreenwichSiderealTime::SIDEREAL_MINUTE_IN_UT_MINUTE
+        twilight_in_seconds = time_sign *
+          twilight_in_hours *
+          Constants::SECONDS_PER_HOUR
+
+        (period_time + twilight_in_seconds).round
+      end
+
+      def observation_events
+        @observation_events ||= @sun.observation_events(observer: @observer)
+      end
+
+      def midday
+        date = @sun.time.to_date
+        Time.utc(date.year, date.month, date.day, 12)
+      end
+
+      def sun_at_midday
+        Sun.new(time: midday)
+      end
+
+      def equatorial_coordinates_at_midday
+        @equatorial_coordinates_at_midday ||= sun_at_midday
+          .apparent_ecliptic_coordinates
+          .to_apparent_equatorial(epoch: Epoch.from_time(midday))
+      end
+    end
+  end
+end

data/lib/astronoby/geocentric_parallax.rb

@@ -9,8 +9,8 @@ module Astronoby
     #  Chapter: 39 - Calculating correction for parallax
 
     ASTRONOMICAL_UNIT_IN_METERS = 149_597_870_700
-    EARTH_FLATTENING_CORRECTION = BigDecimal("0.996647")
-    EARTH_EQUATORIAL_RADIUS = BigDecimal("6378140")
+    EARTH_FLATTENING_CORRECTION = 0.996647
+    EARTH_EQUATORIAL_RADIUS = 6378140.0
 
     # Equatorial horizontal parallax
     # @param distance [Numeric] Distance of the body from the center of the

data/lib/astronoby/mean_obliquity.rb

@@ -14,14 +14,14 @@ module Astronoby
     def self.for_epoch(epoch)
       return obliquity_of_reference if epoch == EPOCH_OF_REFERENCE
 
-      t = (epoch - EPOCH_OF_REFERENCE) / Epoch::DAYS_PER_JULIAN_CENTURY
+      t = (epoch - EPOCH_OF_REFERENCE) / Constants::DAYS_PER_JULIAN_CENTURY
 
       Angle.from_degrees(
         obliquity_of_reference.degrees - (
           46.815 * t -
           0.0006 * t * t +
           0.00181 * t * t * t
-        ) / 3600
+        ) / Constants::SECONDS_PER_DEGREE
       )
     end
 

data/lib/astronoby/nutation.rb

@@ -45,18 +45,20 @@ module Astronoby
     private
 
     def julian_centuries
-      (@epoch - Epoch::J1900) / Epoch::DAYS_PER_JULIAN_CENTURY
+      (@epoch - Epoch::J1900) / Constants::DAYS_PER_JULIAN_CENTURY
     end
 
     def sun_mean_longitude
       Angle.from_degrees(
-        (279.6967 + 360.0 * (centuries_a - centuries_a.to_i)) % 360
+        (279.6967 + Constants::DEGREES_PER_CIRCLE * (centuries_a - centuries_a.to_i)) %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 
     def moon_ascending_node_longitude
       Angle.from_degrees(
-        (259.1833 - 360.0 * (centuries_b - centuries_b.to_i)) % 360
+        (259.1833 - Constants::DEGREES_PER_CIRCLE * (centuries_b - centuries_b.to_i)) %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 

data/lib/astronoby/observer.rb

@@ -3,14 +3,14 @@
 module Astronoby
   class Observer
     DEFAULT_ELEVATION = 0
-    DEFAULT_TEMPERATURE = BigDecimal("283.15")
-    PRESSURE_AT_SEA_LEVEL = BigDecimal("1013.25")
-    PASCAL_PER_MILLIBAR = BigDecimal("0.01")
-    EARTH_GRAVITATIONAL_ACCELERATION = BigDecimal("9.80665")
-    MOLAR_MASS_OF_AIR = BigDecimal("0.0289644")
-    UNIVERSAL_GAS_CONSTANT = BigDecimal("8.31432")
+    DEFAULT_TEMPERATURE = 283.15
+    PRESSURE_AT_SEA_LEVEL = 1013.25
+    PASCAL_PER_MILLIBAR = 0.01
+    EARTH_GRAVITATIONAL_ACCELERATION = 9.80665
+    MOLAR_MASS_OF_AIR = 0.0289644
+    UNIVERSAL_GAS_CONSTANT = 8.31432
 
-    attr_reader :latitude, :longitude, :elevation, :temperature
+    attr_reader :latitude, :longitude, :elevation, :temperature, :pressure
 
     # @param latitude [Angle] geographic latitude of the observer
     # @param longitude [Angle] geographic longitude of the observer
@@ -31,19 +31,38 @@ module Astronoby
       @longitude = longitude
       @elevation = elevation
       @temperature = temperature
-      @pressure = pressure
+      @pressure = pressure || compute_pressure
     end
 
-    # Compute an estimation of the atmospheric pressure based on the elevation
-    # and temperature
-    #
-    # @return [BigDecimal] the atmospheric pressure in millibars.
-    def pressure
-      @pressure ||= PRESSURE_AT_SEA_LEVEL * pressure_ratio
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      @latitude == other.latitude &&
+        @longitude == other.longitude &&
+        @elevation == other.elevation &&
+        @temperature == other.temperature &&
+        @pressure == other.pressure
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [
+        self.class,
+        @latitude,
+        @longitude,
+        @elevation,
+        @temperature,
+        @pressure
+      ].hash
     end
 
     private
 
+    # @return [Float] the atmospheric pressure in millibars.
+    def compute_pressure
+      @pressure ||= PRESSURE_AT_SEA_LEVEL * pressure_ratio
+    end
+
     # Source:
     # Barometric formula
     # https://en.wikipedia.org/wiki/Barometric_formula

data/lib/astronoby/precession.rb

@@ -45,7 +45,7 @@ module Astronoby
     private
 
     def matrix_for_epoch(epoch)
-      t = (epoch - Epoch::DEFAULT_EPOCH) / Epoch::DAYS_PER_JULIAN_CENTURY
+      t = (epoch - Epoch::DEFAULT_EPOCH) / Constants::DAYS_PER_JULIAN_CENTURY
 
       zeta = Angle.from_degrees(
         0.6406161 * t + 0.0000839 * t * t + 0.000005 * t * t * t

data/lib/astronoby/time/greenwich_sidereal_time.rb

@@ -3,11 +3,13 @@
 module Astronoby
   class GreenwichSiderealTime
     JULIAN_CENTURIES_EXPONENTS = [
-      BigDecimal("6.697374558"),
-      BigDecimal("2400.051336"),
-      BigDecimal("0.000025862")
+      6.697374558,
+      2400.051336,
+      0.000025862
     ].freeze
 
+    SIDEREAL_MINUTE_IN_UT_MINUTE = 0.9972695663
+
     attr_reader :date, :time
 
     # Source:
@@ -18,20 +20,20 @@ module Astronoby
     def self.from_utc(utc)
       date = utc.to_date
       julian_day = utc.to_date.ajd
-      t = (julian_day - Epoch::J2000) / Epoch::DAYS_PER_JULIAN_CENTURY
+      t = (julian_day - Epoch::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
       t0 = (
         (JULIAN_CENTURIES_EXPONENTS[0] +
           (JULIAN_CENTURIES_EXPONENTS[1] * t) +
-          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % 24
+          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % Constants::HOURS_PER_DAY
       ).abs
 
       ut_in_hours = utc.hour +
-        utc.min / 60.0 +
-        (utc.sec + utc.subsec) / 3600.0
+        utc.min / Constants::MINUTES_PER_HOUR +
+        (utc.sec + utc.subsec) / Constants::SECONDS_PER_HOUR
 
-      gmst = BigDecimal("1.002737909") * ut_in_hours + t0
-      gmst += 24 if gmst.negative?
-      gmst -= 24 if gmst > 24
+      gmst = 1.002737909 * ut_in_hours + t0
+      gmst += Constants::HOURS_PER_DAY if gmst.negative?
+      gmst -= Constants::HOURS_PER_DAY if gmst > Constants::HOURS_PER_DAY
 
       new(date: date, time: gmst)
     end
@@ -49,38 +51,25 @@ module Astronoby
     def to_utc
       date = @date
       julian_day = @date.ajd
-      t = (julian_day - Epoch::J2000) / Epoch::DAYS_PER_JULIAN_CENTURY
+      t = (julian_day - Epoch::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
 
       t0 = (
         (JULIAN_CENTURIES_EXPONENTS[0] +
           (JULIAN_CENTURIES_EXPONENTS[1] * t) +
-          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % 24
+          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % Constants::HOURS_PER_DAY
       ).abs
 
       a = @time - t0
-      a += 24 if a.negative?
-      a -= 24 if a > 24
+      a += Constants::HOURS_PER_DAY if a.negative?
+      a -= Constants::HOURS_PER_DAY if a > Constants::HOURS_PER_DAY
 
-      utc = BigDecimal("0.9972695663") * a
+      utc = SIDEREAL_MINUTE_IN_UT_MINUTE * a
 
-      decimal_hour_to_time(date, utc)
+      Util::Time.decimal_hour_to_time(date, utc)
     end
 
     def to_lst(longitude:)
       LocalSiderealTime.from_gst(gst: self, longitude: longitude)
     end
-
-    private
-
-    def decimal_hour_to_time(date, decimal)
-      absolute_hour = decimal.abs
-      hour = absolute_hour.floor
-      decimal_minute = 60 * (absolute_hour - hour)
-      absolute_decimal_minute = (60 * (absolute_hour - hour)).abs
-      minute = decimal_minute.floor
-      second = 60 * (absolute_decimal_minute - absolute_decimal_minute.floor)
-
-      ::Time.utc(date.year, date.month, date.day, hour, minute, second).round
-    end
   end
 end

data/lib/astronoby/time/local_sidereal_time.rb

@@ -12,8 +12,8 @@ module Astronoby
     def self.from_gst(gst:, longitude:)
       date = gst.date
       time = gst.time + longitude.hours
-      time += 24 if time.negative?
-      time -= 24 if time > 24
+      time += Constants::HOURS_PER_DAY if time.negative?
+      time -= Constants::HOURS_PER_DAY if time > Constants::HOURS_PER_DAY
 
       new(date: date, time: time, longitude: longitude)
     end
@@ -32,8 +32,8 @@ module Astronoby
     def to_gst
       date = @date
       time = @time - @longitude.hours
-      time += 24 if time.negative?
-      time -= 24 if time > 24
+      time += Constants::HOURS_PER_DAY if time.negative?
+      time -= Constants::HOURS_PER_DAY if time > Constants::HOURS_PER_DAY
 
       GreenwichSiderealTime.new(date: date, time: time)
     end