astronoby 0.3.0 → 0.5.0

data/lib/astronoby/constants.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Constants
+    DAYS_PER_JULIAN_CENTURY = 36525.0
+    DAYS_PER_JULIAN_MILLENIA = DAYS_PER_JULIAN_CENTURY * 10
+
+    HOURS_PER_DAY = 24.0
+    DEGREES_PER_CIRCLE = 360.0
+    RADIANS_PER_CIRCLE = 2 * Math::PI
+
+    SECONDS_PER_MINUTE = 60.0
+    MINUTES_PER_HOUR = 60.0
+    MINUTES_PER_DEGREE = 60.0
+
+    SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR
+    SECONDS_PER_DAY = SECONDS_PER_HOUR * HOURS_PER_DAY
+    SECONDS_PER_DEGREE = SECONDS_PER_MINUTE * MINUTES_PER_DEGREE
+    RADIAN_PER_HOUR = Math::PI / 12.0
+
+    PI_IN_DEGREES = 180.0
+
+    EQUATION_OF_TIME_CONSTANT = 0.0057183
+
+    KILOMETER_IN_METERS = 1_000
+    ASTRONOMICAL_UNIT_IN_METERS = 149_597_870_700
+    EARTH_EQUATORIAL_RADIUS_IN_METERS = 6378140
+
+    EARTH_FLATTENING_CORRECTION = 0.996647
+  end
+end

data/lib/astronoby/coordinates/ecliptic.rb

@@ -18,17 +18,17 @@ module Astronoby
 
       def to_true_equatorial(epoch:)
         mean_obliquity = MeanObliquity.for_epoch(epoch)
-        to_equatorial(obliquity: mean_obliquity)
+        to_equatorial(obliquity: mean_obliquity, epoch: epoch)
       end
 
       def to_apparent_equatorial(epoch:)
         apparent_obliquity = TrueObliquity.for_epoch(epoch)
-        to_equatorial(obliquity: apparent_obliquity)
+        to_equatorial(obliquity: apparent_obliquity, epoch: epoch)
       end
 
       private
 
-      def to_equatorial(obliquity:)
+      def to_equatorial(obliquity:, epoch:)
         y = Angle.from_radians(
           @longitude.sin * obliquity.cos -
             @latitude.tan * obliquity.sin
@@ -45,7 +45,7 @@ module Astronoby
         Equatorial.new(
           right_ascension: right_ascension,
           declination: declination,
-          epoch: @epoch
+          epoch: epoch
         )
       end
     end

data/lib/astronoby/coordinates/equatorial.rb

@@ -23,12 +23,14 @@ module Astronoby
           .to_lst(longitude: longitude)
 
         ha = (lst.time - @right_ascension.hours)
-        ha += 24 if ha.negative?
+        ha += Constants::HOURS_PER_DAY if ha.negative?
 
         Angle.from_hours(ha)
       end
 
-      def to_horizontal(time:, latitude:, longitude:)
+      def to_horizontal(time:, observer:)
+        latitude = observer.latitude
+        longitude = observer.longitude
         ha = @hour_angle || compute_hour_angle(time: time, longitude: longitude)
         t0 = @declination.sin * latitude.sin +
           @declination.cos * latitude.cos * ha.cos
@@ -39,14 +41,14 @@ module Astronoby
         azimuth = Angle.acos(t2)
 
         if ha.sin.positive?
-          azimuth = Angle.from_degrees(BigDecimal("360") - azimuth.degrees)
+          azimuth =
+            Angle.from_degrees(Constants::DEGREES_PER_CIRCLE - azimuth.degrees)
         end
 
         Horizontal.new(
           azimuth: azimuth,
           altitude: altitude,
-          latitude: latitude,
-          longitude: longitude
+          observer: observer
         )
       end
 

data/lib/astronoby/coordinates/horizontal.rb

@@ -3,44 +3,46 @@
 module Astronoby
   module Coordinates
     class Horizontal
-      attr_reader :azimuth, :altitude, :latitude, :longitude
+      attr_reader :azimuth, :altitude, :observer
 
       def initialize(
         azimuth:,
         altitude:,
-        latitude:,
-        longitude:
+        observer:
       )
         @azimuth = azimuth
         @altitude = altitude
-        @latitude = latitude
-        @longitude = longitude
+        @observer = observer
       end
 
       def to_equatorial(time:)
-        t0 = @altitude.sin * @latitude.sin +
-          @altitude.cos * @latitude.cos * @azimuth.cos
+        t0 = @altitude.sin * latitude.sin +
+          @altitude.cos * latitude.cos * @azimuth.cos
 
         declination = Angle.asin(t0)
 
-        t1 = @altitude.sin - @latitude.sin * declination.sin
+        t1 = @altitude.sin - latitude.sin * declination.sin
 
         hour_angle_degrees = Angle
-          .acos(t1 / (@latitude.cos * declination.cos))
+          .acos(t1 / (latitude.cos * declination.cos))
           .degrees
 
         if @azimuth.sin.positive?
           hour_angle_degrees = Angle
-            .from_degrees(BigDecimal("360") - hour_angle_degrees)
+            .from_degrees(Constants::DEGREES_PER_CIRCLE - hour_angle_degrees)
             .degrees
         end
 
         hour_angle_hours = Angle.from_degrees(hour_angle_degrees).hours
         lst = GreenwichSiderealTime
           .from_utc(time.utc)
-          .to_lst(longitude: @longitude)
+          .to_lst(longitude: longitude)
         right_ascension_decimal = lst.time - hour_angle_hours
-        right_ascension_decimal += 24 if right_ascension_decimal.negative?
+
+        if right_ascension_decimal.negative?
+          right_ascension_decimal += Constants::HOURS_PER_DAY
+        end
+
         right_ascension = Angle.from_hours(right_ascension_decimal)
 
         Equatorial.new(
@@ -48,6 +50,16 @@ module Astronoby
           declination: declination
         )
       end
+
+      private
+
+      def latitude
+        @observer.latitude
+      end
+
+      def longitude
+        @observer.longitude
+      end
     end
   end
 end

data/lib/astronoby/distance.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Distance
+    include Comparable
+
+    class << self
+      def zero
+        new(0)
+      end
+
+      def from_meters(meters)
+        new(meters)
+      end
+      alias_method :from_m, :from_meters
+
+      def from_kilometers(kilometers)
+        meters = kilometers * Constants::KILOMETER_IN_METERS
+        from_meters(meters)
+      end
+      alias_method :from_km, :from_kilometers
+
+      def from_astronomical_units(astronomical_units)
+        meters = astronomical_units * Constants::ASTRONOMICAL_UNIT_IN_METERS
+        from_meters(meters)
+      end
+      alias_method :from_au, :from_astronomical_units
+    end
+
+    attr_reader :meters
+    alias_method :m, :meters
+
+    def initialize(meters)
+      @meters = meters
+      freeze
+    end
+
+    def kilometers
+      @meters / Constants::KILOMETER_IN_METERS.to_f
+    end
+    alias_method :km, :kilometers
+
+    def astronomical_units
+      @meters / Constants::ASTRONOMICAL_UNIT_IN_METERS.to_f
+    end
+    alias_method :au, :astronomical_units
+
+    def +(other)
+      self.class.from_meters(meters + other.meters)
+    end
+
+    def -(other)
+      self.class.from_meters(@meters - other.meters)
+    end
+
+    def -@
+      self.class.from_meters(-@meters)
+    end
+
+    def positive?
+      meters > 0
+    end
+
+    def negative?
+      meters < 0
+    end
+
+    def zero?
+      meters.zero?
+    end
+
+    def hash
+      [meters, self.class].hash
+    end
+
+    def <=>(other)
+      return unless other.is_a?(self.class)
+
+      meters <=> other.meters
+    end
+    alias_method :eql?, :==
+  end
+end

data/lib/astronoby/epoch.rb

@@ -9,8 +9,6 @@ module Astronoby
     J2000 = 2451545.0
 
     DEFAULT_EPOCH = J2000
-    DAYS_PER_JULIAN_CENTURY = 36525.0
-
     JULIAN_DAY_NUMBER_OFFSET = 0.5
 
     def self.from_time(time)

data/lib/astronoby/equinox_solstice.rb

@@ -101,7 +101,7 @@ module Astronoby
     end
 
     def compute
-      t = (julian_day - Epoch::J2000) / Epoch::DAYS_PER_JULIAN_CENTURY
+      t = (julian_day - Epoch::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
       w = Angle.from_degrees(35999.373 * t) - Angle.from_degrees(2.47)
       delta = 1 +
         0.0334 * w.cos +
@@ -130,7 +130,8 @@ module Astronoby
     end
 
     def correction(epoch)
-      sun = Sun.new(epoch: epoch)
+      time = Epoch.to_utc(epoch)
+      sun = Sun.new(time: time)
       longitude = sun.apparent_ecliptic_coordinates.longitude
 
       58 * Angle.from_degrees(@event * 90 - longitude.degrees).sin

data/lib/astronoby/events/moon_phases.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Events
+    class MoonPhases
+      BASE_YEAR = 2000
+
+      # Source:
+      #  Title: Astronomical Algorithms
+      #  Author: Jean Meeus
+      #  Edition: 2nd edition
+      #  Chapter: 49 - Phases of the Moon
+
+      # @param year [Integer] Requested year
+      # @param month [Integer] Requested month
+      # @return [Array<Astronoby::MoonPhase>] List of Moon phases
+      def self.phases_for(year:, month:)
+        [
+          MoonPhase.first_quarter(new(year, month, :first_quarter, -0.75).time),
+          MoonPhase.full_moon(new(year, month, :full_moon, -0.5).time),
+          MoonPhase.last_quarter(new(year, month, :last_quarter, -0.25).time),
+          MoonPhase.new_moon(new(year, month, :new_moon, 0).time),
+          MoonPhase.first_quarter(new(year, month, :first_quarter, 0.25).time),
+          MoonPhase.full_moon(new(year, month, :full_moon, 0.5).time),
+          MoonPhase.last_quarter(new(year, month, :last_quarter, 0.75).time),
+          MoonPhase.new_moon(new(year, month, :new_moon, 1).time)
+        ].select { _1.time.month == month }
+      end
+
+      # @param year [Integer] Requested year
+      # @param month [Integer] Requested month
+      # @param phase [Symbol] Moon phase
+      # @param phase_increment [Float] Phase increment
+      def initialize(year, month, phase, phase_increment)
+        @year = year
+        @month = month
+        @phase = phase
+        @phase_increment = phase_increment
+      end
+
+      # @return [Time] Time of the Moon phase
+      def time
+        correction = moon_phases_periodic_terms
+          .public_send(:"#{@phase}_correction")
+        terrestrial_time = Epoch.to_utc(
+          julian_ephemeris_day +
+            correction +
+            moon_phases_periodic_terms.additional_corrections
+        )
+        delta = Util::Time.terrestrial_universal_time_delta(terrestrial_time)
+        (terrestrial_time - delta).round
+      end
+
+      private
+
+      def portion_of_year
+        days_in_year = Date.new(@year, 12, 31) - Date.new(@year, 1, 1)
+        mid_month = Date.new(@year, @month, 15)
+        mid_month.yday / days_in_year.to_f
+      end
+
+      def approximate_time
+        ((@year + portion_of_year - BASE_YEAR) * 12.3685).floor + @phase_increment
+      end
+
+      def julian_centuries
+        approximate_time / 1236.85
+      end
+
+      def julian_ephemeris_day
+        2451550.09766 +
+          29.530588861 * approximate_time +
+          0.00015437 * julian_centuries**2 -
+          0.000000150 * julian_centuries**3 +
+          0.00000000073 * julian_centuries**4
+      end
+
+      def eccentricity_correction
+        1 -
+          0.002516 * julian_centuries -
+          0.0000074 * julian_centuries**2
+      end
+
+      def sun_mean_anomaly
+        Angle.from_degrees(
+          (
+            2.5534 +
+            29.10535670 * approximate_time -
+            0.0000014 * julian_centuries**2 -
+            0.00000011 * julian_centuries**3
+          ) % 360
+        )
+      end
+
+      def moon_mean_anomaly
+        Angle.from_degrees(
+          (
+            201.5643 +
+            385.81693528 * approximate_time +
+            0.0107582 * julian_centuries**2 +
+            0.00001238 * julian_centuries**3 -
+            0.000000058 * julian_centuries**4
+          ) % 360
+        )
+      end
+
+      def moon_argument_of_latitude
+        Angle.from_degrees(
+          (
+            160.7108 +
+            390.67050284 * approximate_time -
+            0.0016118 * julian_centuries**2 -
+            0.00000227 * julian_centuries**3 +
+            0.000000011 * julian_centuries**4
+          ) % 360
+        )
+      end
+
+      def longitude_of_the_ascending_node
+        Angle.from_degrees(
+          (
+            124.7746 -
+            1.56375588 * approximate_time +
+            0.0020672 * julian_centuries**2 +
+            0.00000215 * julian_centuries**3
+          ) % 360
+        )
+      end
+
+      def moon_phases_periodic_terms
+        MoonPhasesPeriodicTerms.new(
+          julian_centuries: julian_centuries,
+          time: approximate_time,
+          eccentricity_correction: eccentricity_correction,
+          moon_mean_anomaly: moon_mean_anomaly,
+          sun_mean_anomaly: sun_mean_anomaly,
+          moon_argument_of_latitude: moon_argument_of_latitude,
+          longitude_of_the_ascending_node: longitude_of_the_ascending_node
+        )
+      end
+    end
+  end
+end

data/lib/astronoby/events/observation_events.rb

@@ -0,0 +1,259 @@
+# 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
+      ITERATION_PRECISION = 0.0001
+
+      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
+        @initial_transit = initial_transit
+        @transit_time = Util::Time.decimal_hour_to_time(@date, @initial_transit)
+        @transit_altitude = local_horizontal_altitude_transit
+
+        return if h0.nil?
+
+        initial_rising = rationalize_decimal_time(
+          @initial_transit - h0.degrees / Constants::DEGREES_PER_CIRCLE
+        )
+
+        initial_setting = rationalize_decimal_time(
+          @initial_transit + h0.degrees / Constants::DEGREES_PER_CIRCLE
+        )
+
+        @final_rising, @final_transit, @final_setting =
+          iterate(initial_rising, @initial_transit, initial_setting)
+
+        rationalized_corrected_rising = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * @final_rising
+        )
+        rationalized_corrected_transit = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * @final_transit
+        )
+        rationalized_corrected_setting = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * @final_setting
+        )
+
+        @rising_time = Util::Time.decimal_hour_to_time(@date, rationalized_corrected_rising)
+        @rising_azimuth = local_horizontal_azimuth_rising
+        @transit_time = Util::Time.decimal_hour_to_time(@date, rationalized_corrected_transit)
+        @transit_altitude = local_horizontal_altitude_transit
+        @setting_time = Util::Time.decimal_hour_to_time(@date, rationalized_corrected_setting)
+        @setting_azimuth = local_horizontal_azimuth_setting
+      end
+
+      def iterate(initial_rising, initial_transit, initial_setting)
+        delta = 1
+        corrected_rising = initial_rising
+        corrected_transit = initial_transit
+        corrected_setting = initial_setting
+        until delta < ITERATION_PRECISION
+          iterate = RiseTransitSetIteration.new(
+            observer: @observer,
+            date: @date,
+            coordinates_of_the_next_day: @coordinates_of_the_next_day,
+            coordinates_of_the_day: @coordinates_of_the_day,
+            coordinates_of_the_previous_day: @coordinates_of_the_previous_day,
+            shift: shift,
+            initial_rising: corrected_rising,
+            initial_transit: corrected_transit,
+            initial_setting: corrected_setting
+          ).iterate
+          delta = iterate.sum
+          corrected_rising = rationalize_decimal_time corrected_rising + iterate[0]
+          corrected_transit = rationalize_decimal_time corrected_transit + iterate[1]
+          corrected_setting = rationalize_decimal_time corrected_setting + iterate[2]
+        end
+        [corrected_rising, corrected_transit, corrected_setting]
+      end
+
+      def observer_longitude
+        # Longitude must be treated positively westwards from the meridian of
+        # Greenwich, and negatively to the east
+        -@observer.longitude
+      end
+
+      def 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 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
+        Angle.from_hours(
+          GreenwichSiderealTime.from_utc(
+            Time.utc(@date.year, @date.month, @date.day)
+          ).time
+        )
+      end
+
+      def gst_transit
+        Angle.from_degrees(
+          apparent_gst_at_midnight.degrees +
+            EARTH_SIDEREAL_ROTATION_RATE * (@final_transit || @initial_transit)
+        )
+      end
+
+      def leap_day_portion
+        leap_seconds = Util::Time.terrestrial_universal_time_delta(@date)
+        leap_seconds / Constants::SECONDS_PER_DAY
+      end
+
+      def local_hour_angle_transit
+        gst_transit - observer_longitude - right_ascension_transit
+      end
+
+      def local_horizontal_azimuth_rising
+        term1 = declination_rising.sin + (-shift).sin * @observer.latitude.cos
+        term2 = (-shift).cos * @observer.latitude.cos
+        angle = term1 / term2
+        Angle.acos(angle)
+      end
+
+      def 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_azimuth_setting
+        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_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
+            ],
+            (@final_transit || @initial_transit) + 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
+            ],
+            @final_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
+            ],
+            (@final_transit || @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
+            ],
+            @final_setting + leap_day_portion
+          )
+        )
+      end
+
+      def shift
+        @standard_altitude - @additional_altitude
+      end
+    end
+  end
+end