astronoby 0.4.0 → 0.5.0

data/lib/astronoby/coordinates/horizontal.rb

@@ -3,30 +3,28 @@
 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?
@@ -38,7 +36,7 @@ module Astronoby
         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
 
         if right_ascension_decimal.negative?
@@ -52,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/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

@@ -6,6 +6,7 @@ module Astronoby
       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,
@@ -51,46 +52,80 @@ module Astronoby
       private
 
       def compute
-        @transit_time = Util::Time.decimal_hour_to_time(@date, initial_transit)
+        @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?
 
-        delta_m_rising = (local_horizontal_altitude_rising - shift).degrees./(
-          Constants::DEGREES_PER_CIRCLE *
-            declination_rising.cos *
-            @observer.latitude.cos *
-            local_hour_angle_rising.sin
+        initial_rising = rationalize_decimal_time(
+          @initial_transit - h0.degrees / Constants::DEGREES_PER_CIRCLE
         )
-        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
+
+        initial_setting = rationalize_decimal_time(
+          @initial_transit + h0.degrees / Constants::DEGREES_PER_CIRCLE
         )
 
-        corrected_rising = rationalize_decimal_hours(
-          Constants::HOURS_PER_DAY * (initial_rising + delta_m_rising)
+        @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
         )
-        corrected_transit = rationalize_decimal_hours(
-          Constants::HOURS_PER_DAY * (initial_transit + delta_m_transit)
+        rationalized_corrected_transit = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * @final_transit
         )
-        corrected_setting = rationalize_decimal_hours(
-          Constants::HOURS_PER_DAY * (initial_setting + delta_m_setting)
+        rationalized_corrected_setting = rationalize_decimal_hours(
+          Constants::HOURS_PER_DAY * @final_setting
         )
 
-        @rising_time = Util::Time.decimal_hour_to_time(@date, corrected_rising)
+        @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, corrected_transit)
-        @setting_time = Util::Time.decimal_hour_to_time(@date, corrected_setting)
+        @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 ||= -@observer.longitude
+        -@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
@@ -106,115 +141,46 @@ module Astronoby
       end
 
       def apparent_gst_at_midnight
-        @apparent_gst_at_midnight ||= Angle.from_hours(
+        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(
+        Angle.from_degrees(
           apparent_gst_at_midnight.degrees +
-            EARTH_SIDEREAL_ROTATION_RATE * initial_setting
+            EARTH_SIDEREAL_ROTATION_RATE * (@final_transit || @initial_transit)
         )
       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
+        leap_seconds = Util::Time.terrestrial_universal_time_delta(@date)
+        leap_seconds / Constants::SECONDS_PER_DAY
       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
-        )
+        gst_transit - observer_longitude - right_ascension_transit
       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
+        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
-        @local_horizontal_altitude_transit ||= Angle.asin(
+        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
+        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
@@ -233,19 +199,6 @@ module Astronoby
         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(
@@ -254,20 +207,7 @@ module Astronoby
               @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
+            (@final_transit || @initial_transit) + leap_day_portion
           )
         )
       end
@@ -280,7 +220,7 @@ module Astronoby
               @coordinates_of_the_day.declination.degrees,
               @coordinates_of_the_next_day.declination.degrees
             ],
-            initial_rising + leap_day_portion
+            @final_rising + leap_day_portion
           )
         )
       end
@@ -293,7 +233,7 @@ module Astronoby
               @coordinates_of_the_day.declination.degrees,
               @coordinates_of_the_next_day.declination.degrees
             ],
-            initial_transit + leap_day_portion
+            (@final_transit || @initial_transit) + leap_day_portion
           )
         )
       end
@@ -306,7 +246,7 @@ module Astronoby
               @coordinates_of_the_day.declination.degrees,
               @coordinates_of_the_next_day.declination.degrees
             ],
-            initial_setting + leap_day_portion
+            @final_setting + leap_day_portion
           )
         )
       end