lunation 0.1.0

data/lib/lunation/calculation/angle.rb

@@ -0,0 +1,174 @@
+module Lunation
+  class Calculation
+    class Angle
+      attr_reader :radians, :decimal_degrees
+
+      def initialize(
+        radians: nil,
+        decimal_degrees: nil,
+        decimal_arcseconds: nil,
+        arcminutes: nil,
+        degrees: nil,
+        hours: nil,
+        minutes: nil,
+        decimal_seconds: nil
+      )
+        @radians = radians
+        @decimal_degrees = decimal_degrees
+        @decimal_arcseconds = decimal_arcseconds
+        @arcminutes = arcminutes
+        @degrees = degrees
+        @hours = hours
+        @minutes = minutes
+        @decimal_seconds = decimal_seconds
+      end
+
+      def decimal_arcminutes
+        @decimal_arcminutes ||= (decimal_degrees - degrees) * 60
+      end
+
+      def decimal_arcseconds
+        @decimal_arcseconds ||= ((decimal_arcminutes - arcminutes) * 60).round(6)
+      end
+
+      def degrees
+        @degrees ||= decimal_degrees.to_i
+      end
+
+      def arcminutes
+        @arcminutes ||= decimal_arcminutes.to_i
+      end
+
+      def decimal_hours
+        @decimal_hours ||= decimal_degrees / 15.0
+      end
+
+      def decimal_minutes
+        @decimal_minutes ||= (decimal_hours - hours) * 60
+      end
+
+      def decimal_seconds
+        @decimal_seconds ||= ((decimal_minutes - minutes) * 60).round(6)
+      end
+
+      def hours
+        @hours ||= decimal_hours.to_i
+      end
+
+      def minutes
+        @minutes ||= decimal_minutes.to_i
+      end
+
+      def +(other)
+        self.class.from_decimal_degrees(
+          decimal_degrees + other.decimal_degrees,
+          normalize: false
+        )
+      end
+
+      def -(other)
+        self.class.from_decimal_degrees(
+          decimal_degrees - other.decimal_degrees,
+          normalize: false
+        )
+      end
+
+      class << self
+        def from_radians(radians, normalize: true)
+          new(
+            radians: radians,
+            decimal_degrees: radians_to_decimal_degrees(radians, normalize: normalize)
+          )
+        end
+
+        def from_decimal_degrees(decimal_degrees, normalize: true)
+          new(
+            decimal_degrees: (normalize ? decimal_degrees % 360 : decimal_degrees).round(9),
+            radians: decimal_degrees_to_radians(decimal_degrees, normalize: normalize)
+          )
+        end
+
+        def from_degrees(degrees:, arcminutes:, decimal_arcseconds:, normalize: true)
+          decimal_degrees = degrees_arcminutes_decimal_arcseconds_to_decimal_degrees(
+            degrees,
+            arcminutes,
+            decimal_arcseconds,
+            normalize: normalize
+          )
+          new(
+            decimal_degrees: decimal_degrees,
+            degrees: degrees,
+            arcminutes: arcminutes,
+            decimal_arcseconds: decimal_arcseconds
+          )
+        end
+
+        def from_hours_minutes_decimal_seconds(
+          hours:,
+          minutes:,
+          decimal_seconds:,
+          normalize: true
+        )
+          decimal_degrees = hours_minutes_decimal_seconds_to_decimal_degrees(
+            hours,
+            minutes,
+            decimal_seconds,
+            normalize: normalize
+          )
+          new(
+            decimal_degrees: decimal_degrees,
+            hours: hours,
+            minutes: minutes,
+            decimal_seconds: decimal_seconds
+          )
+        end
+
+        def from_decimal_arcseconds(decimal_arcseconds, normalize: true)
+          decimal_degrees = decimal_arcseconds_to_decimal_degrees(
+            decimal_arcseconds,
+            normalize: normalize
+          )
+          new(decimal_degrees: decimal_degrees, decimal_arcseconds: decimal_arcseconds)
+        end
+
+        private def radians_to_decimal_degrees(radians, normalize: true)
+          result = radians / Math::PI * 180
+          (normalize ? result % 360 : result).round(9)
+        end
+
+        private def decimal_degrees_to_radians(decimal_degrees, normalize: true)
+          result = (normalize ? decimal_degrees % 360 : decimal_degrees) * Math::PI / 180.0
+          result.round(9)
+        end
+
+        private def degrees_arcminutes_decimal_arcseconds_to_decimal_degrees(
+          degrees,
+          arcminutes,
+          decimal_arcseconds,
+          normalize: true
+        )
+          result = degrees + arcminutes / 60.0 + decimal_arcseconds / 3600.0
+          (normalize ? result % 360 : result).round(9)
+        end
+
+        private def hours_minutes_decimal_seconds_to_decimal_degrees(
+          hours,
+          minutes,
+          decimal_seconds,
+          normalize: true
+        )
+          result = hours * 15.0 + minutes / 4.0 + decimal_seconds / 240.0
+          (normalize ? result % 360 : result).round(9)
+        end
+
+        private def decimal_arcseconds_to_decimal_degrees(
+          decimal_arcseconds,
+          normalize: true
+        )
+          result = decimal_arcseconds / 3600.0
+          (normalize ? result % 360 : result).round(9)
+        end
+      end
+    end
+  end
+end

data/lib/lunation/calculation/earth_position_vsop87.rb

@@ -0,0 +1,80 @@
+module Lunation
+  class Calculation
+    module EarthPositionVSOP87
+      # rubocop:disable Layout/LineLength
+      PERIODIC_TERMS_B0 = YAML.load_file("config/periodic_terms_earth_position_b0.yml").freeze
+      PERIODIC_TERMS_B1 = YAML.load_file("config/periodic_terms_earth_position_b1.yml").freeze
+      PERIODIC_TERMS_L0 = YAML.load_file("config/periodic_terms_earth_position_l0.yml").freeze
+      PERIODIC_TERMS_L1 = YAML.load_file("config/periodic_terms_earth_position_l1.yml").freeze
+      PERIODIC_TERMS_L2 = YAML.load_file("config/periodic_terms_earth_position_l2.yml").freeze
+      PERIODIC_TERMS_L3 = YAML.load_file("config/periodic_terms_earth_position_l3.yml").freeze
+      PERIODIC_TERMS_L4 = YAML.load_file("config/periodic_terms_earth_position_l4.yml").freeze
+      PERIODIC_TERMS_L5 = YAML.load_file("config/periodic_terms_earth_position_l5.yml").freeze
+      PERIODIC_TERMS_R0 = YAML.load_file("config/periodic_terms_earth_position_r0.yml").freeze
+      PERIODIC_TERMS_R1 = YAML.load_file("config/periodic_terms_earth_position_r1.yml").freeze
+      PERIODIC_TERMS_R2 = YAML.load_file("config/periodic_terms_earth_position_r2.yml").freeze
+      PERIODIC_TERMS_R3 = YAML.load_file("config/periodic_terms_earth_position_r3.yml").freeze
+      PERIODIC_TERMS_R4 = YAML.load_file("config/periodic_terms_earth_position_r4.yml").freeze
+      # rubocop:enable Layout/LineLength
+
+      # (L) Ecliptical longitude of the earth (A.A. p. 219, 32.2)
+      # UNIT: Angle
+      def ecliptic_longitude_of_earth_using_vsop87
+        @ecliptic_longitude_of_earth_using_vsop87 ||= begin
+          result = Horner.compute(
+            time_millennia,
+            [
+              reduce_periodic_terms(PERIODIC_TERMS_L0),
+              reduce_periodic_terms(PERIODIC_TERMS_L1),
+              reduce_periodic_terms(PERIODIC_TERMS_L2),
+              reduce_periodic_terms(PERIODIC_TERMS_L3),
+              reduce_periodic_terms(PERIODIC_TERMS_L4),
+              reduce_periodic_terms(PERIODIC_TERMS_L5)
+            ]
+          )
+
+          Angle.from_radians(result / 100_000_000.0)
+        end
+      end
+
+      # (B) Ecliptical latitude of the earth (A.A. p. 219, 32.2)
+      # UNIT: Angle
+      def ecliptic_latitude_of_earth_using_vsop87
+        @ecliptic_latitude_of_earth_using_vsop87 ||= begin
+          first_series = reduce_periodic_terms(PERIODIC_TERMS_B0)
+          second_series = reduce_periodic_terms(PERIODIC_TERMS_B1)
+
+          Angle.from_radians(
+            (first_series + second_series * time_millennia) / 100_000_000.0,
+            normalize: false
+          )
+        end
+      end
+
+      # (R) Radius vector (distance to sun) of the earth (A.A. p. 219, 32.2)
+      # UNIT: Astronomical Units (AU)
+      def radius_vector_of_earth_using_vsop87
+        @radius_vector_of_earth_using_vsop87 ||= begin
+          result = Horner.compute(
+            time_millennia,
+            [
+              reduce_periodic_terms(PERIODIC_TERMS_R0),
+              reduce_periodic_terms(PERIODIC_TERMS_R1),
+              reduce_periodic_terms(PERIODIC_TERMS_R2),
+              reduce_periodic_terms(PERIODIC_TERMS_R3),
+              reduce_periodic_terms(PERIODIC_TERMS_R4)
+            ]
+          )
+
+          (result / 100_000_000.0).round(9)
+        end
+      end
+
+      private def reduce_periodic_terms(periodic_terms)
+        periodic_terms.inject(0.0) do |sum, terms|
+          sum + terms[0] * Math.cos(terms[1] + terms[2] * time_millennia)
+        end
+      end
+    end
+  end
+end

data/lib/lunation/calculation/horner.rb

@@ -0,0 +1,26 @@
+module Lunation
+  class Calculation
+    class Horner
+      def initialize(variable, constants)
+        @variable = variable
+        @constants = constants
+      end
+
+      def compute
+        @constants.reverse_each.each_with_index.inject(0.0) do |sum, (constant, index)|
+          if index.zero?
+            constant
+          else
+            constant + @variable * sum
+          end
+        end
+      end
+
+      class << self
+        def compute(variable, constants)
+          new(variable, constants).compute
+        end
+      end
+    end
+  end
+end

data/lib/lunation/calculation/moon_illuminated_fraction.rb

@@ -0,0 +1,51 @@
+module Lunation
+  class Calculation
+    module MoonIlluminatedFraction
+      # (k) illuminated fraction of the moon (48.1, A.A. p. 345)
+      # UNIT: fraction (decimal)
+      def moon_illuminated_fraction
+        @moon_illuminated_fraction ||=
+          ((1 + Math.cos(moon_phase_angle.radians)) / 2.0).round(4)
+      end
+
+      # (i) phase angle of the moon (48.3, A.A. p. 346)
+      # UNIT: Angle
+      def moon_phase_angle
+        @moon_phase_angle ||= begin
+          numerator = distance_between_earth_and_sun_in_kilometers * Math.sin(moon_elongation_from_sun.radians)
+          denominator = distance_between_earth_and_moon -
+            distance_between_earth_and_sun_in_kilometers * Math.cos(moon_elongation_from_sun.radians)
+          Angle.from_radians(Math.atan2(numerator, denominator))
+        end
+      end
+
+      # (ψ) geocentric elongation of the moon (48.2, A.A. p. 345)
+      # UNIT: Angle
+      def moon_elongation_from_sun
+        @moon_elongation_from_sun ||= begin
+          result = Math.sin(sun_declination.radians) *
+            Math.sin(moon_declination.radians) +
+            Math.cos(sun_declination.radians) *
+              Math.cos(moon_declination.radians) *
+              Math.cos((sun_right_ascension - moon_right_ascension).radians)
+          Angle.from_radians(Math.acos(result))
+        end
+      end
+
+      # (χ) Position angle of the moon's bright limb (48.5, A.A. p. 346)
+      # UNIT: Angle
+      def moon_position_angle_of_bright_limb
+        @moon_position_angle_of_bright_limb ||= begin
+          numerator = Math.cos(sun_declination.radians) *
+            Math.sin((sun_right_ascension - moon_right_ascension).radians)
+          denominator = Math.sin(sun_declination.radians) *
+            Math.cos(moon_declination.radians) -
+            Math.cos(sun_declination.radians) *
+              Math.sin(moon_declination.radians) *
+              Math.cos((sun_right_ascension - moon_right_ascension).radians)
+          Angle.from_radians(Math.atan2(numerator, denominator))
+        end
+      end
+    end
+  end
+end

data/lib/lunation/calculation/moon_position.rb

@@ -0,0 +1,227 @@
+require_relative "nutation_and_obliquity"
+
+module Lunation
+  class Calculation
+    module MoonPosition
+      # rubocop:disable Layout/LineLength
+      LONGITUDE_AND_DISTANCE_OF_MOON_PERIODIC_TERMS = YAML.load_file("config/periodic_terms_moon_longitude_distance.yml").freeze
+      LATITUDE_OF_MOON_PERIODIC_TERMS = YAML.load_file("config/periodic_terms_moon_latitude.yml").freeze
+      MOON_MEAN_LONGITUDE_CONSTANTS = [218.3164477, 481_267.88123421, -0.0015786, 1 / 538_841.0, -1 / 65_194_000.0].freeze
+      MOON_MEAN_ELONGATION_CONSTANTS = [297.8501921, 445_267.1114034, -0.0018819, 1 / 545_868.0, -1 / 113_065_000.0].freeze
+      MOON_MEAN_ANOMALY_CONSTANTS = [134.9633964, 477_198.8675055, 0.0087414, 1 / 69_699.0, -1 / 14_712_000.0].freeze
+      MOON_ARGUMENT_OF_LATITUDE_CONSTANTS = [93.2720950, 483_202.0175233, -0.0036539, -1 / 3_526_000.0, 1 / 863_310_000.0].freeze
+      CORRECTION_ECCENTRICITY_OF_EARTH_CONSTANTS = [1, -0.002516, -0.0000074].freeze
+      FIXED_DISTANCE_BETWEEN_EARTH_AND_MOON = 385_000.56
+      RADIUS_OF_EARTH = 6378.14
+      # rubocop:enable Layout/LineLength
+
+      # (L') Moon mean_longitude (47.1, A.A. p. 338)
+      # UNIT: Angle
+      def moon_mean_longitude
+        @moon_mean_longitude ||=
+          Angle.from_decimal_degrees(Horner.compute(time, MOON_MEAN_LONGITUDE_CONSTANTS))
+      end
+
+      # (D) Moon mean_elongation (47.2, A.A. p. 338)
+      # UNIT: Angle
+      def moon_mean_elongation_from_sun_high_precision
+        @moon_mean_elongation_from_sun_high_precision ||=
+          Angle.from_decimal_degrees(Horner.compute(time, MOON_MEAN_ELONGATION_CONSTANTS))
+      end
+
+      # (M') Moon mean_anomaly (47.4, A.A. p. 338)
+      # UNIT: Angle
+      def moon_mean_anomaly_high_precision
+        @moon_mean_anomaly_high_precision ||=
+          Angle.from_decimal_degrees(Horner.compute(time, MOON_MEAN_ANOMALY_CONSTANTS))
+      end
+
+      # (F) Moon argument_of_latitude (47.5, A.A. p. 338)
+      # UNIT: Angle
+      def moon_argument_of_latitude_high_precision
+        @moon_argument_of_latitude_high_precision ||= begin
+          result = Horner.compute(time, MOON_ARGUMENT_OF_LATITUDE_CONSTANTS)
+          Angle.from_decimal_degrees(result)
+        end
+      end
+
+      # (A1) Venus correction (A.A. p. 338)
+      # UNIT: Angle
+      def correction_venus
+        @correction_venus ||= Angle.from_decimal_degrees(119.75 + 131.849 * time)
+      end
+
+      # (A2) Jupiter correction (A.A. p. 338)
+      # UNIT: Angle
+      def correction_jupiter
+        @correction_jupiter ||= Angle.from_decimal_degrees(53.09 + 4_792_64.29 * time)
+      end
+
+      # (A3) latitude correction (A.A. p. 338)
+      # UNIT: Angle
+      def correction_latitude
+        @correction_latitude ||= Angle.from_decimal_degrees(313.45 + 481_266.484 * time)
+      end
+
+      # (E) Earth eccentricity (47.6 A.A. p. 338)
+      def correction_eccentricity_of_earth
+        @correction_eccentricity_of_earth ||= begin
+          result = Horner.compute(time, CORRECTION_ECCENTRICITY_OF_EARTH_CONSTANTS)
+          result.round(6)
+        end
+      end
+
+      # (Σl) Moon longitude (A.A. p. 338)
+      # UNIT: decimal degrees
+      def moon_heliocentric_longitude
+        @moon_heliocentric_longitude ||= begin
+          result = LONGITUDE_AND_DISTANCE_OF_MOON_PERIODIC_TERMS.inject(0.0) do |acc, elem|
+            sine_argument = Angle.from_decimal_degrees(
+              elem["moon_mean_elongation"] * moon_mean_elongation_from_sun_high_precision.decimal_degrees +
+              elem["sun_mean_anomaly"] * sun_mean_anomaly2.decimal_degrees +
+              elem["moon_mean_anomaly"] * moon_mean_anomaly_high_precision.decimal_degrees +
+              elem["moon_argument_of_latitude"] * moon_argument_of_latitude_high_precision.decimal_degrees
+            )
+
+            if elem["sine_coefficient"].nil?
+              next acc
+            elsif [1, -1].include?(elem["sun_mean_anomaly"])
+              acc + elem["sine_coefficient"] * correction_eccentricity_of_earth * Math.sin(sine_argument.radians)
+            elsif [-2, 2].include?(elem["sun_mean_anomaly"])
+              acc + elem["sine_coefficient"] * correction_eccentricity_of_earth**2 * Math.sin(sine_argument.radians)
+            else
+              acc + elem["sine_coefficient"] * Math.sin(sine_argument.radians)
+            end
+          end + 3958 * Math.sin(correction_venus.radians) +
+            1962 * Math.sin((moon_mean_longitude - moon_argument_of_latitude_high_precision).radians) +
+            318 * Math.sin(correction_jupiter.radians)
+          result.round
+        end
+      end
+
+      # (Σb) Moon latitude (A.A. p. 338)
+      # UNIT: decimal degrees
+      def moon_heliocentric_latitude
+        @moon_heliocentric_latitude ||= begin
+          result = LATITUDE_OF_MOON_PERIODIC_TERMS.inject(0.0) do |acc, elem|
+            sine_argument = Angle.from_decimal_degrees(
+              elem["moon_mean_elongation"] * moon_mean_elongation_from_sun_high_precision.decimal_degrees +
+              elem["sun_mean_anomaly"] * sun_mean_anomaly2.decimal_degrees +
+              elem["moon_mean_anomaly"] * moon_mean_anomaly_high_precision.decimal_degrees +
+              elem["moon_argument_of_latitude"] * moon_argument_of_latitude_high_precision.decimal_degrees
+            )
+
+            if elem["sine_coefficient"].nil?
+              next acc
+            elsif [1, -1].include?(elem["sun_mean_anomaly"])
+              acc + elem["sine_coefficient"] * correction_eccentricity_of_earth * Math.sin(sine_argument.radians)
+            elsif [-2, 2].include?(elem["sun_mean_anomaly"])
+              acc + elem["sine_coefficient"] * correction_eccentricity_of_earth**2 * Math.sin(sine_argument.radians)
+            else
+              acc + elem["sine_coefficient"] * Math.sin(sine_argument.radians)
+            end
+          end - 2235 * Math.sin(moon_mean_longitude.radians) +
+            382 * Math.sin(correction_latitude.radians) +
+            175 * Math.sin((correction_venus - moon_argument_of_latitude_high_precision).radians) +
+            175 * Math.sin((correction_venus + moon_argument_of_latitude_high_precision).radians) +
+            127 * Math.sin((moon_mean_longitude - moon_mean_anomaly_high_precision).radians) +
+            -115 * Math.sin((moon_mean_longitude + moon_mean_anomaly_high_precision).radians)
+          result.round
+        end
+      end
+
+      # (Σr) Moon distance (A.A. p. 338)
+      # UNIT: 1000 km
+      def moon_heliocentric_distance
+        @moon_heliocentric_distance ||= begin
+          result = LONGITUDE_AND_DISTANCE_OF_MOON_PERIODIC_TERMS.inject(0.0) do |acc, elem|
+            cosine_argument = Angle.from_decimal_degrees(
+              elem["moon_mean_elongation"] * moon_mean_elongation_from_sun_high_precision.decimal_degrees +
+              elem["sun_mean_anomaly"] * sun_mean_anomaly2.decimal_degrees +
+              elem["moon_mean_anomaly"] * moon_mean_anomaly_high_precision.decimal_degrees +
+              elem["moon_argument_of_latitude"] * moon_argument_of_latitude_high_precision.decimal_degrees
+            )
+
+            if elem["cosine_coefficient"].nil?
+              next acc
+            elsif [1, -1].include?(elem["sun_mean_anomaly"])
+              acc + elem["cosine_coefficient"] * correction_eccentricity_of_earth * Math.cos(cosine_argument.radians)
+            elsif [-2, 2].include?(elem["sun_mean_anomaly"])
+              acc + elem["cosine_coefficient"] * correction_eccentricity_of_earth**2 * Math.cos(cosine_argument.radians)
+            else
+              acc + elem["cosine_coefficient"] * Math.cos(cosine_argument.radians)
+            end
+          end
+          result.round
+        end
+      end
+
+      # (λ) ecliptical longitude (A.A. p. 342)
+      # UNIT: Angle
+      def moon_ecliptic_longitude
+        @moon_ecliptic_longitude ||= Angle.from_decimal_degrees(
+          moon_mean_longitude.decimal_degrees + moon_heliocentric_longitude / 1_000_000.0
+        )
+      end
+
+      # (β) ecliptical latitude (A.A. p. 342)
+      # UNIT: Angle
+      def moon_ecliptic_latitude
+        @moon_ecliptic_latitude ||= Angle.from_decimal_degrees(
+          moon_heliocentric_latitude / 1_000_000.0,
+          normalize: false
+        )
+      end
+
+      # (Δ) Earth-moon distance (in kilometers) (A.A. p. 342)
+      # UNIT: kilometers (km)
+      def distance_between_earth_and_moon
+        @distance_between_earth_and_moon ||= begin
+          result = FIXED_DISTANCE_BETWEEN_EARTH_AND_MOON +
+            (moon_heliocentric_distance / 1_000.0)
+          result.round(1)
+        end
+      end
+
+      # (π) Moon equitorial horizontal parallax (A.A. p. 337)
+      # UNIT: Angle
+      def equatorial_horizontal_parallax
+        @equatorial_horizontal_parallax ||= Angle.from_radians(
+          Math.asin(RADIUS_OF_EARTH / distance_between_earth_and_moon)
+        )
+      end
+
+      # (apparent λ) Moon apparent longitude (A.A. p. 343)
+      # UNIT: Angle
+      def moon_apparent_ecliptic_longitude
+        @moon_apparent_ecliptic_longitude ||= moon_ecliptic_longitude + nutation_in_longitude
+      end
+
+      # (α) geocentric (apparent) right ascension of the moon (13.3 A.A. p. 93)
+      # UNIT: Angle
+      def moon_right_ascension
+        @moon_right_ascension ||= begin
+          numerator = Math.sin(moon_apparent_ecliptic_longitude.radians) *
+            Math.cos(obliquity_of_ecliptic.radians) -
+            Math.tan(moon_ecliptic_latitude.radians) *
+              Math.sin(obliquity_of_ecliptic.radians)
+          denominator = Math.cos(moon_apparent_ecliptic_longitude.radians)
+          Angle.from_radians(Math.atan2(numerator, denominator))
+        end
+      end
+
+      # (δ) geocentric (apparent) declination of the moon (13.4) A.A. p. 93
+      # UNIT: Angle
+      def moon_declination
+        @moon_declination ||= begin
+          result = Math.sin(moon_ecliptic_latitude.radians) *
+            Math.cos(obliquity_of_ecliptic.radians) +
+            Math.cos(moon_ecliptic_latitude.radians) *
+              Math.sin(obliquity_of_ecliptic.radians) *
+              Math.sin(moon_apparent_ecliptic_longitude.radians)
+          Angle.from_radians(Math.asin(result))
+        end
+      end
+    end
+  end
+end

data/lib/lunation/calculation/nutation_and_obliquity.rb

@@ -0,0 +1,121 @@
+module Lunation
+  class Calculation
+    module NutationAndObliquity
+      # rubocop:disable Layout/LineLength
+      NUTATION_IN_OBLIQUITY_PERIODIC_TERMS = YAML.load_file("config/periodic_terms_earth_nutation.yml").freeze
+      ECLIPTIC_MEAN_OBLIQUITY_CONSTANTS = [21.448, -4680.93, -1.55, 1_999.25, -51.38, -249.67, -39.05, 7.12, 27.87, 5.79, 2.45].freeze
+      MOON_MEAN_ELONGATION_FROM_SUN_CONSTANTS = [297.85036, 445_267.111480, -0.0019142, 1 / 189_474.0].freeze
+      SUN_MEAN_ANOMALY_CONSTANTS = [357.52772, 35_999.050340, -0.0001603, -1 / 300_000.0].freeze
+      MOON_MEAN_ANOMALY_CONSTANTS = [134.96298, 477_198.867398, 0.0086972, 1 / 56_250.0].freeze
+      MOON_ARGUMENT_OF_LATITUDE_CONSTANTS = [93.27191, 483_202.017538, -0.0036825, 1 / 327_270.0].freeze
+      LONGITUDE_OF_THE_ASCENDING_NODE_CONSTANTS = [125.04452, -1934.136261, 0.0020708, 1 / 450_000.0].freeze
+      # rubocop:enable Layout/LineLength
+
+      # (D) Mean elongation of the moon from the sun (A.A. p. 144)
+      # UNIT: Angle
+      def moon_mean_elongation_from_sun
+        @moon_mean_elongation_from_sun ||= begin
+          result = Horner.compute(time, MOON_MEAN_ELONGATION_FROM_SUN_CONSTANTS)
+          Angle.from_decimal_degrees(result)
+        end
+      end
+
+      # (M) Sun mean_anomaly (A.A. p. 144)
+      # UNIT: Angle
+      def sun_mean_anomaly
+        @sun_mean_anomaly ||= begin
+          result = Horner.compute(time, SUN_MEAN_ANOMALY_CONSTANTS)
+          Angle.from_decimal_degrees(result)
+        end
+      end
+
+      # (M') Moon mean_anomaly (A.A. p. 149)
+      # UNIT: Angle
+      def moon_mean_anomaly
+        @moon_mean_anomaly ||= begin
+          result = Horner.compute(time, MOON_MEAN_ANOMALY_CONSTANTS)
+          Angle.from_decimal_degrees(result)
+        end
+      end
+
+      # (F) Moon argument_of_latitude (A.A. p. 144)
+      # UNIT: Angle
+      def moon_argument_of_latitude
+        @moon_argument_of_latitude ||= begin
+          result = Horner.compute(time, MOON_ARGUMENT_OF_LATITUDE_CONSTANTS)
+          Angle.from_decimal_degrees(result)
+        end
+      end
+
+      # (Ω) Longitude of the ascending node of the Moon's mean orbit on the ecliptic,
+      #   measured from the mean equinox of the date (A.A. p. 144)
+      # UNIT: Angle
+      def longitude_of_ascending_node
+        @longitude_of_ascending_node ||= begin
+          result = Horner.compute(time, LONGITUDE_OF_THE_ASCENDING_NODE_CONSTANTS)
+          Angle.from_decimal_degrees(result)
+        end
+      end
+
+      # (Δψ) nutation in longitude (A.A. p. 144)
+      # UNIT: Angle
+      def nutation_in_longitude
+        @nutation_in_longitude ||= begin
+          result = NUTATION_IN_OBLIQUITY_PERIODIC_TERMS.inject(0.0) do |acc, elem|
+            argument = Angle.from_decimal_degrees(
+              elem["moon_mean_elongation"] * moon_mean_elongation_from_sun.decimal_degrees +
+              elem["sun_mean_anomaly"] * sun_mean_anomaly.decimal_degrees +
+              elem["moon_mean_anomaly"] * moon_mean_anomaly.decimal_degrees +
+              elem["moon_argument_of_latitude"] * moon_argument_of_latitude.decimal_degrees +
+              elem["longitude_of_ascending_node"] * longitude_of_ascending_node.decimal_degrees
+            )
+            coefficient = elem["sine_coefficient_first_term"] + elem["sine_coefficient_second_term"] * time
+            acc + coefficient * Math.sin(argument.radians)
+          end / 10_000.0
+          Angle.from_decimal_arcseconds(result)
+        end
+      end
+
+      # (Δε) nutation in obliquity (A.A. p. 144)
+      # UNIT: Angle
+      def nutation_in_obliquity
+        @nutation_in_obliquity ||= begin
+          result = NUTATION_IN_OBLIQUITY_PERIODIC_TERMS.inject(0.0) do |acc, elem|
+            argument = Angle.from_decimal_degrees(
+              elem["moon_mean_elongation"] * moon_mean_elongation_from_sun.decimal_degrees +
+              elem["sun_mean_anomaly"] * sun_mean_anomaly.decimal_degrees +
+              elem["moon_mean_anomaly"] * moon_mean_anomaly.decimal_degrees +
+              elem["moon_argument_of_latitude"] * moon_argument_of_latitude.decimal_degrees +
+              elem["longitude_of_ascending_node"] * longitude_of_ascending_node.decimal_degrees
+            )
+            coefficient = elem["cosine_coefficient_first_term"] + elem["cosine_coefficient_second_term"] * time
+            acc + coefficient * Math.cos(argument.radians)
+          end / 10_000.0
+          Angle.from_decimal_arcseconds(result)
+        end
+      end
+
+      # (ε0) mean obliquity of the ecliptic (22.3, A.A. p. 147)
+      # UNIT: Angle
+      def mean_obliquity_of_ecliptic
+        @mean_obliquity_of_ecliptic ||= begin
+          decimal_arcseconds = Horner.compute(
+            time_myriads,
+            ECLIPTIC_MEAN_OBLIQUITY_CONSTANTS
+          )
+          Angle.from_degrees(
+            degrees: 23.0,
+            arcminutes: 26.0,
+            decimal_arcseconds: decimal_arcseconds
+          )
+        end
+      end
+
+      # (ε) true obliquity of the ecliptic (A.A. p. 147)
+      # UNIT: Angle
+      def obliquity_of_ecliptic
+        @obliquity_of_ecliptic ||= mean_obliquity_of_ecliptic + nutation_in_obliquity
+      end
+    end
+  end
+end