astronoby 0.0.1 → 0.2.0

data/lib/astronoby/angle.rb

@@ -4,39 +4,175 @@ require "bigdecimal/math"
 
 module Astronoby
   class Angle
-    UNITS = [
-      DEGREES = :degrees,
-      RADIANS = :radians
-    ].freeze
+    include Comparable
 
-    UNIT_CLASS_NAMES = {
-      DEGREES => "Astronoby::Degree",
-      RADIANS => "Astronoby::Radian"
-    }
+    PRECISION = 14
+    PI = BigMath.PI(PRECISION)
+    PI_IN_DEGREES = BigDecimal("180")
 
-    PI = BigMath.PI(10)
+    FULL_CIRCLE_IN_RADIANS = (2 * PI)
+
+    RADIAN_PER_HOUR = PI / BigDecimal("12")
+    MINUTES_PER_DEGREE = BigDecimal("60")
+    MINUTES_PER_HOUR = BigDecimal("60")
+    SECONDS_PER_MINUTE = BigDecimal("60")
+    SECONDS_PER_HOUR = MINUTES_PER_HOUR * SECONDS_PER_MINUTE
+
+    FORMATS = %i[dms hms].freeze
 
     class << self
-      UNIT_CLASS_NAMES.each do |unit, class_name|
-        define_method("as_#{unit}") do |angle|
-          Kernel.const_get(class_name).new(angle)
-        end
+      def zero
+        new(0)
+      end
+
+      def as_radians(radians)
+        normalized_radians = radians.remainder(FULL_CIRCLE_IN_RADIANS)
+        new(normalized_radians)
+      end
+
+      def as_degrees(degrees)
+        radians = degrees / PI_IN_DEGREES * PI
+        as_radians(radians)
+      end
+
+      def as_hours(hours)
+        radians = hours * RADIAN_PER_HOUR
+        as_radians(radians)
+      end
+
+      def as_hms(hour, minute, second)
+        hours = hour + minute / MINUTES_PER_HOUR + second / SECONDS_PER_HOUR
+        as_hours(hours)
+      end
+
+      def as_dms(degree, minute, second)
+        sign = degree.negative? ? -1 : 1
+        degrees = degree.abs + minute / MINUTES_PER_HOUR + second / SECONDS_PER_HOUR
+        as_degrees(sign * degrees)
+      end
+
+      def asin(ratio)
+        radians = Math.asin(ratio)
+        as_radians(radians)
+      end
+
+      def acos(ratio)
+        radians = Math.acos(ratio)
+        as_radians(radians)
+      end
+
+      def atan(ratio)
+        radians = Math.atan(ratio)
+        as_radians(radians)
       end
     end
 
-    UNITS.each do |unit|
-      define_method("to_#{unit}") do
-        raise NotImplementedError, "#{self.class} must implement #to_#{unit} method."
+    attr_reader :radians
+
+    def initialize(radians)
+      @radians = if radians.is_a?(Integer) || radians.is_a?(BigDecimal)
+        BigDecimal(radians)
+      else
+        BigDecimal(radians, PRECISION)
       end
+      freeze
     end
 
-    def initialize(angle, unit:)
-      @angle = BigDecimal(angle)
-      @unit = unit
+    def degrees
+      @radians * PI_IN_DEGREES / PI
     end
 
-    def value
-      @angle
+    def hours
+      @radians / RADIAN_PER_HOUR
+    end
+
+    def +(other)
+      self.class.as_radians(radians + other.radians)
+    end
+
+    def -(other)
+      self.class.as_radians(@radians - other.radians)
+    end
+
+    def sin
+      Math.sin(radians)
+    end
+
+    def cos
+      Math.cos(radians)
+    end
+
+    def tan
+      Math.tan(radians)
+    end
+
+    def positive?
+      radians > 0
+    end
+
+    def negative?
+      radians < 0
+    end
+
+    def zero?
+      radians.zero?
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && radians == other.radians
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [radians, self.class].hash
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+
+      radians <=> other.radians
+    end
+
+    def str(format)
+      case format
+      when :dms then to_dms(degrees).format
+      when :hms then to_hms(hours).format
+      else
+        raise UnsupportedFormatError.new(
+          "Expected a format between #{FORMATS.join(", ")}, got #{format}"
+        )
+      end
+    end
+
+    def to_dms(deg)
+      sign = deg.negative? ? "-" : "+"
+      absolute_degrees = deg.abs
+      degrees = absolute_degrees.floor
+      decimal_minutes = MINUTES_PER_DEGREE * (absolute_degrees - degrees)
+      absolute_decimal_minutes = (
+        MINUTES_PER_DEGREE * (absolute_degrees - degrees)
+      ).abs
+      minutes = decimal_minutes.floor
+      seconds = SECONDS_PER_MINUTE * (
+        absolute_decimal_minutes - absolute_decimal_minutes.floor
+      )
+
+      Dms.new(sign, degrees, minutes, seconds.to_f.floor(4))
+    end
+
+    def to_hms(hrs)
+      absolute_hours = hrs.abs
+      hours = absolute_hours.floor
+      decimal_minutes = MINUTES_PER_HOUR * (absolute_hours - hours)
+      absolute_decimal_minutes = (
+        MINUTES_PER_HOUR * (absolute_hours - hours)
+      ).abs
+      minutes = decimal_minutes.floor
+      seconds = SECONDS_PER_MINUTE * (
+        absolute_decimal_minutes - absolute_decimal_minutes.floor
+      )
+
+      Hms.new(hours, minutes, seconds.to_f.floor(4))
     end
   end
 end

data/lib/astronoby/angles/dms.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Dms
+    attr_reader :sign, :degrees, :minutes, :seconds
+
+    def initialize(sign, degrees, minutes, seconds)
+      @sign = sign
+      @degrees = degrees
+      @minutes = minutes
+      @seconds = seconds
+    end
+
+    def format
+      "#{sign}#{degrees}° #{minutes}′ #{seconds}″"
+    end
+  end
+end

data/lib/astronoby/angles/hms.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Hms
+    attr_reader :hours, :minutes, :seconds
+
+    def initialize(hours, minutes, seconds)
+      @hours = hours
+      @minutes = minutes
+      @seconds = seconds
+    end
+
+    def format
+      "#{hours}h #{minutes}m #{seconds}s"
+    end
+  end
+end

data/lib/astronoby/bodies/sun.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Sun
+    SEMI_MAJOR_AXIS_IN_METERS = 149_598_500_000
+    ANGULAR_DIAMETER = Angle.as_degrees(0.533128)
+    INTERPOLATION_FACTOR = BigDecimal("24.07")
+
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 51 - The equation of time
+
+    # @param date [Date] Requested date
+    # @return [Integer] Equation of time in seconds
+    def self.equation_of_time(date:)
+      noon = Time.utc(date.year, date.month, date.day, 12)
+      epoch_at_noon = Epoch.from_time(noon)
+      sun_at_noon = new(epoch: epoch_at_noon)
+      equatorial_hours = sun_at_noon
+        .ecliptic_coordinates
+        .to_equatorial(epoch: epoch_at_noon)
+        .right_ascension
+        .hours
+      gst = GreenwichSiderealTime
+        .new(date: date, time: equatorial_hours)
+        .to_utc
+
+      (noon - gst).to_i
+    end
+
+    # Source:
+    #  Title: Celestial Calculations
+    #  Author: J. L. Lawrence
+    #  Edition: MIT Press
+    #  Chapter: 6 - The Sun
+
+    # @param epoch [Numeric] Considered epoch, in Julian days
+    def initialize(epoch:)
+      @epoch = epoch
+    end
+
+    # @return [Astronoby::Coordinates::Ecliptic] Sun's ecliptic coordinates
+    def ecliptic_coordinates
+      Coordinates::Ecliptic.new(
+        latitude: Angle.zero,
+        longitude: Angle.as_degrees(
+          (true_anomaly + longitude_at_perigee).degrees % 360
+        )
+      )
+    end
+
+    # Computes the Sun's horizontal coordinates
+    #
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param longitude [Astronoby::Angle] Longitude of the observer
+    # @return [Astronoby::Coordinates::Horizontal] Sun's horizontal coordinates
+    def horizontal_coordinates(latitude:, longitude:)
+      time = Epoch.to_utc(@epoch)
+
+      ecliptic_coordinates
+        .to_equatorial(epoch: @epoch)
+        .to_horizontal(time: time, latitude: latitude, longitude: longitude)
+    end
+
+    # @param observer [Astronoby::Observer] Observer of the event
+    # @return [Time] Time of sunrise
+    def rising_time(observer:)
+      event_date = Epoch.to_utc(@epoch).to_date
+      lst1 = event_local_sidereal_time_for_date(event_date, observer, :rising)
+      next_day = event_date.next_day(1)
+      lst2 = event_local_sidereal_time_for_date(next_day, observer, :rising)
+      time = (INTERPOLATION_FACTOR * lst1) / (INTERPOLATION_FACTOR + lst1 - lst2)
+
+      LocalSiderealTime.new(
+        date: event_date,
+        time: time,
+        longitude: observer.longitude
+      ).to_gst.to_utc
+    end
+
+    # @param observer [Astronoby::Observer] Observer of the event
+    # @return [Astronoby::Angle, nil] Azimuth of sunrise
+    def rising_azimuth(observer:)
+      equatorial_coordinates = ecliptic_coordinates.to_equatorial(epoch: @epoch)
+      Body.new(equatorial_coordinates).rising_azimuth(
+        latitude: observer.latitude,
+        vertical_shift: vertical_shift
+      )
+    end
+
+    # @param observer [Astronoby::Observer] Observer of the event
+    # @return [Time] Time of sunset
+    def setting_time(observer:)
+      event_date = Epoch.to_utc(@epoch).to_date
+      lst1 = event_local_sidereal_time_for_date(event_date, observer, :setting)
+      next_day = event_date.next_day(1)
+      lst2 = event_local_sidereal_time_for_date(next_day, observer, :setting)
+      time = (INTERPOLATION_FACTOR * lst1) / (INTERPOLATION_FACTOR + lst1 - lst2)
+
+      LocalSiderealTime.new(
+        date: event_date,
+        time: time,
+        longitude: observer.longitude
+      ).to_gst.to_utc
+    end
+
+    # @param observer [Astronoby::Observer] Observer of the event
+    # @return [Astronoby::Angle, nil] Azimuth of sunset
+    def setting_azimuth(observer:)
+      equatorial_coordinates = ecliptic_coordinates.to_equatorial(epoch: @epoch)
+      Body.new(equatorial_coordinates).setting_azimuth(
+        latitude: observer.latitude,
+        vertical_shift: vertical_shift
+      )
+    end
+
+    # @return [Numeric] Earth-Sun distance in meters
+    def earth_distance
+      SEMI_MAJOR_AXIS_IN_METERS / distance_angular_size_factor
+    end
+
+    # @return [Astronoby::Angle] Apparent Sun's angular size
+    def angular_size
+      Angle.as_degrees(ANGULAR_DIAMETER.degrees * distance_angular_size_factor)
+    end
+
+    # @return [Astronoby::Angle] Sun's true anomaly
+    def true_anomaly
+      eccentric_anomaly = Util::Astrodynamics.eccentric_anomaly_newton_raphson(
+        mean_anomaly,
+        orbital_eccentricity.degrees,
+        2e-06,
+        10
+      )
+
+      tan = Math.sqrt(
+        (1 + orbital_eccentricity.degrees) / (1 - orbital_eccentricity.degrees)
+      ) * Math.tan(eccentric_anomaly.radians / 2)
+
+      Angle.as_degrees((Angle.atan(tan).degrees * 2) % 360)
+    end
+
+    # @return [Astronoby::Angle] Sun's longitude at perigee
+    def longitude_at_perigee
+      Angle.as_degrees(
+        (281.2208444 + 1.719175 * centuries + 0.000452778 * centuries**2) % 360
+      )
+    end
+
+    # @return [Astronoby::Angle] Sun's orbital eccentricity
+    def orbital_eccentricity
+      Angle.as_degrees(
+        (0.01675104 - 0.0000418 * centuries - 0.000000126 * centuries**2) % 360
+      )
+    end
+
+    private
+
+    def mean_anomaly
+      Angle.as_degrees(
+        (longitude_at_base_epoch - longitude_at_perigee).degrees % 360
+      )
+    end
+
+    def days_since_epoch
+      Epoch::DEFAULT_EPOCH - @epoch
+    end
+
+    def centuries
+      @centuries ||= (@epoch - Epoch::J1900) / Epoch::DAYS_PER_JULIAN_CENTURY
+    end
+
+    def longitude_at_base_epoch
+      Angle.as_degrees(
+        (279.6966778 + 36000.76892 * centuries + 0.0003025 * centuries**2) % 360
+      )
+    end
+
+    def distance_angular_size_factor
+      term1 = 1 + orbital_eccentricity.degrees * true_anomaly.cos
+      term2 = 1 - orbital_eccentricity.degrees**2
+
+      term1 / term2
+    end
+
+    def event_local_sidereal_time_for_date(date, observer, event)
+      midnight_utc = Time.utc(date.year, date.month, date.day)
+      epoch = Epoch.from_time(midnight_utc)
+      sun_at_midnight = self.class.new(epoch: epoch)
+      shift = Body::DEFAULT_REFRACTION_VERTICAL_SHIFT +
+        GeocentricParallax.angle(distance: sun_at_midnight.earth_distance) +
+        Angle.as_degrees(sun_at_midnight.angular_size.degrees / 2)
+      ecliptic_coordinates = sun_at_midnight.ecliptic_coordinates
+      equatorial_coordinates = ecliptic_coordinates.to_equatorial(epoch: epoch)
+
+      event_time = if event == :rising
+        Body.new(equatorial_coordinates).rising_time(
+          latitude: observer.latitude,
+          longitude: observer.longitude,
+          date: midnight_utc.to_date,
+          vertical_shift: shift
+        )
+      else
+        Body.new(equatorial_coordinates).setting_time(
+          latitude: observer.latitude,
+          longitude: observer.longitude,
+          date: midnight_utc.to_date,
+          vertical_shift: shift
+        )
+      end
+
+      GreenwichSiderealTime
+        .from_utc(event_time.utc)
+        .to_lst(longitude: observer.longitude)
+        .time
+    end
+
+    def vertical_shift
+      Astronoby::Body::DEFAULT_REFRACTION_VERTICAL_SHIFT +
+        Astronoby::GeocentricParallax.angle(distance: earth_distance) +
+        Astronoby::Angle.as_degrees(angular_size.degrees / 2)
+    end
+  end
+end

data/lib/astronoby/body.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Body
+    DEFAULT_REFRACTION_VERTICAL_SHIFT = Angle.as_dms(0, 34, 0)
+    RISING_SETTING_HOUR_ANGLE_RATIO_RANGE = (-1..1)
+
+    def initialize(equatorial_coordinates)
+      @equatorial_coordinates = equatorial_coordinates
+    end
+
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param longitude [Astronoby::Angle] Longitude of the observer
+    # @param date [Date] Date of the event
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Time, nil] Sunrise time
+    def rising_time(
+      latitude:,
+      longitude:,
+      date:,
+      apparent: true,
+      vertical_shift: nil
+    )
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      hour_angle = Angle.acos(time_ratio)
+      local_sidereal_time = LocalSiderealTime.new(
+        date: date,
+        time: right_ascension.hours - hour_angle.hours,
+        longitude: longitude
+      )
+
+      local_sidereal_time.to_gst.to_utc
+    end
+
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Astronoby::Angle, nil] Sunrise azimuth
+    def rising_azimuth(latitude:, apparent: true, vertical_shift: nil)
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      azimuth_ratio = azimuth_ratio(latitude, apparent, vertical_shift)
+
+      Angle.acos(azimuth_ratio)
+    end
+
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param longitude [Astronoby::Angle] Longitude of the observer
+    # @param date [Date] Date of the event
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Time, nil] Sunset time
+    def setting_time(
+      latitude:,
+      longitude:,
+      date:,
+      apparent: true,
+      vertical_shift: nil
+    )
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      hour_angle = Angle.acos(time_ratio)
+      local_sidereal_time = LocalSiderealTime.new(
+        date: date,
+        time: right_ascension.hours + hour_angle.hours,
+        longitude: longitude
+      )
+
+      local_sidereal_time.to_gst.to_utc
+    end
+
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Astronoby::Angle, nil] Sunset azimuth
+    def setting_azimuth(latitude:, apparent: true, vertical_shift: nil)
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      azimuth_ratio = azimuth_ratio(latitude, apparent, vertical_shift)
+
+      Angle.as_degrees(360 - Angle.acos(azimuth_ratio).degrees)
+    end
+
+    private
+
+    def time_ratio(latitude, apparent, vertical_shift)
+      shift = if vertical_shift
+        vertical_shift
+      elsif apparent
+        DEFAULT_REFRACTION_VERTICAL_SHIFT
+      else
+        Angle.zero
+      end
+
+      term1 = shift.sin + latitude.sin * declination.sin
+      term2 = latitude.cos * declination.cos
+
+      -term1 / term2
+    end
+
+    def azimuth_ratio(latitude, apparent, vertical_shift)
+      shift = if vertical_shift
+        vertical_shift
+      elsif apparent
+        DEFAULT_REFRACTION_VERTICAL_SHIFT
+      else
+        Angle.zero
+      end
+
+      (declination.sin + shift.sin * latitude.cos) / (shift.cos * latitude.cos)
+    end
+
+    def azimuth_component(latitude)
+      declination.sin / latitude.cos
+    end
+
+    def right_ascension
+      @equatorial_coordinates.right_ascension
+    end
+
+    def declination
+      @equatorial_coordinates.declination
+    end
+  end
+end

data/lib/astronoby/coordinates/ecliptic.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Coordinates
+    class Ecliptic
+      attr_reader :latitude, :longitude
+
+      def initialize(latitude:, longitude:)
+        @latitude = latitude
+        @longitude = longitude
+      end
+
+      # Source:
+      #  Title: Celestial Calculations
+      #  Author: J. L. Lawrence
+      #  Edition: MIT Press
+      #  Chapter: 4 - Orbits and Coordinate Systems
+      def to_equatorial(epoch:)
+        mean_obliquity = MeanObliquity.for_epoch(epoch)
+
+        y = Angle.as_radians(
+          @longitude.sin * mean_obliquity.cos -
+          @latitude.tan * mean_obliquity.sin
+        )
+        x = Angle.as_radians(@longitude.cos)
+        r = Angle.atan(y.radians / x.radians)
+        right_ascension = Util::Trigonometry.adjustement_for_arctangent(y, x, r)
+
+        declination = Angle.asin(
+          @latitude.sin * mean_obliquity.cos +
+          @latitude.cos * mean_obliquity.sin * @longitude.sin
+        )
+
+        Equatorial.new(
+          right_ascension: right_ascension,
+          declination: declination,
+          epoch: epoch
+        )
+      end
+    end
+  end
+end