astronoby 0.6.0 → 0.8.0

data/lib/astronoby/cache.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "singleton"
+
+module Astronoby
+  class Cache
+    include Singleton
+
+    Entry = Struct.new(:key, :value, :prev, :next)
+
+    DEFAULT_MAX_SIZE = 10_000
+
+    attr_reader :max_size
+
+    # @param max_size [Integer] Maximum number of entries allowed in the cache
+    # @return [void]
+    def initialize(max_size = DEFAULT_MAX_SIZE)
+      @max_size = max_size
+      @hash = {}
+      @head = nil
+      @tail = nil
+      @mutex = Monitor.new
+    end
+
+    # @param key [Object] the cache key
+    # @return [Object, nil] the value, or nil if not found
+    def [](key)
+      @mutex.synchronize do
+        entry = @hash[key]
+        if entry
+          move_to_head(entry)
+          entry.value
+        end
+      end
+    end
+
+    # @param key [Object]
+    # @param value [Object]
+    # @return [Object] the value set
+    def []=(key, value)
+      @mutex.synchronize do
+        entry = @hash[key]
+        if entry
+          entry.value = value
+          move_to_head(entry)
+        else
+          entry = Entry.new(key, value)
+          add_to_head(entry)
+          @hash[key] = entry
+          evict_last_recently_used if @hash.size > @max_size
+        end
+      end
+    end
+
+    # @param key [Object]
+    # @yieldreturn [Object] Value to store if key is missing.
+    # @return [Object] Cached or computed value.
+    def fetch(key)
+      return self[key] if @mutex.synchronize { @hash.key?(key) }
+
+      value = yield
+
+      @mutex.synchronize do
+        self[key] = value unless @hash.key?(key)
+      end
+
+      value
+    end
+
+    # @return [void]
+    def clear
+      @mutex.synchronize do
+        @hash.clear
+        @head = @tail = nil
+      end
+    end
+
+    # @return [Integer]
+    def size
+      @mutex.synchronize { @hash.size }
+    end
+
+    # @param new_size [Integer] the new cache limit.
+    # @return [void]
+    def max_size=(new_size)
+      raise ArgumentError, "max_size must be positive" unless new_size > 0
+      @mutex.synchronize do
+        @max_size = new_size
+        while @hash.size > @max_size
+          evict_last_recently_used
+        end
+      end
+    end
+
+    private
+
+    def add_to_head(entry)
+      entry.prev = nil
+      entry.next = @head
+      @head.prev = entry if @head
+      @head = entry
+      @tail ||= entry
+    end
+
+    def move_to_head(entry)
+      return if @head == entry
+
+      # Unlink
+      entry.prev.next = entry.next if entry.prev
+      entry.next.prev = entry.prev if entry.next
+
+      # Update tail if needed
+      @tail = entry.prev if @tail == entry
+
+      # Insert as new head
+      entry.prev = nil
+      entry.next = @head
+      @head.prev = entry if @head
+      @head = entry
+    end
+
+    def evict_last_recently_used
+      if @tail
+        @hash.delete(@tail.key)
+        if @tail.prev
+          @tail = @tail.prev
+          @tail.next = nil
+        else
+          @head = @tail = nil
+        end
+      end
+    end
+  end
+
+  class NullCache
+    include Singleton
+
+    def [](key)
+      nil
+    end
+
+    def []=(key, value)
+      value
+    end
+
+    def fetch(key)
+      yield
+    end
+
+    def clear
+    end
+
+    def size
+      0
+    end
+
+    def max_size=(new_size)
+    end
+  end
+
+  class CacheKey
+    class << self
+      # Generate a cache key with appropriate precision
+      # @param type [Symbol] The calculation type (e.g., :geometric, :nutation)
+      # @param instant [Astronoby::Instant] The time instant
+      # @param components [Array] Additional components for the key
+      # @return [Array] The complete cache key
+      def generate(type, instant, *components)
+        return nil unless Astronoby.configuration.cache_enabled?
+
+        precision = Astronoby.configuration.cache_precision(type)
+        rounded_tt = round_terrestrial_time(instant.tt, precision)
+        [type, rounded_tt, *components]
+      end
+
+      # Round terrestrial time to specified precision
+      # @param tt [Numeric] Terrestrial time value
+      # @param precision [Numeric] Precision in seconds
+      # @return [Numeric] Rounded time value
+      def round_terrestrial_time(tt, precision)
+        return tt if precision <= 0
+
+        tt.round(precision)
+      end
+    end
+  end
+end

data/lib/astronoby/configuration.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Configuration
+    DEFAULT_PRECISIONS = {
+      geometric: 9,        # 8.64e-5 seconds
+      nutation: 2,         # 864 seconds
+      precession: 2,       # 864 seconds
+      rise_transit_set: 5  # 0.1 seconds
+    }.freeze
+
+    attr_accessor :cache_enabled
+    attr_reader :cache_precisions
+
+    def initialize
+      @cache_enabled = false
+      @cache_precisions = DEFAULT_PRECISIONS.dup
+      @cache_instance = nil
+    end
+
+    # Configure cache precision for specific calculation types
+    # @param type [Symbol] The calculation type
+    # @param precision [Numeric] Precision in rounding of terrestrial time
+    # @return [Numeric] the precision for the given type
+    def cache_precision(type, precision = nil)
+      if precision.nil?
+        @cache_precisions[type] || DEFAULT_PRECISIONS[:geometric]
+      else
+        @cache_precisions[type] = precision
+      end
+    end
+
+    # Set all cache precisions at once
+    # @param precisions [Hash] Hash of calculation type to precision in rounding
+    #   of terrestrial time
+    # @return [void]
+    def cache_precisions=(precisions)
+      @cache_precisions = DEFAULT_PRECISIONS.merge(precisions)
+    end
+
+    # Get the cache instance (singleton or null cache)
+    # @return [Astronoby::Cache, Astronoby::NullCache] the cache instance
+    def cache
+      if cache_enabled?
+        Cache.instance
+      else
+        NullCache.instance
+      end
+    end
+
+    def cache_enabled?
+      @cache_enabled
+    end
+
+    # Reset cache instance (useful for testing or configuration changes)
+    # @return [void]
+    def reset_cache!
+      cache.clear
+    end
+  end
+
+  class << self
+    # Global configuration instance
+    # @return [Astronoby::Configuration] the global configuration instance
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configuration block for setup
+    # @example
+    #   Astronoby.configure do |config|
+    #     config.cache_enabled = false
+    #     config.cache_precision(:geometric, 9)
+    #   end
+    def configure
+      yield(configuration)
+      configuration.reset_cache!
+    end
+
+    # Quick access to cache
+    # @return [Astronoby::Cache, Astronoby::NullCache] the cache instance
+    def cache
+      configuration.cache
+    end
+
+    # Reset configuration to defaults
+    # @return [void]
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/astronoby/constants.rb

@@ -2,9 +2,12 @@
 
 module Astronoby
   class Constants
-    DAYS_PER_JULIAN_CENTURY = 36525.0
+    DAYS_PER_JULIAN_YEAR = 365.25
+    DAYS_PER_JULIAN_CENTURY = DAYS_PER_JULIAN_YEAR * 100
     DAYS_PER_JULIAN_MILLENIA = DAYS_PER_JULIAN_CENTURY * 10
 
+    TROPICAL_YEAR_AT_B1900 = 365.242198781
+
     HOURS_PER_DAY = 24.0
     DEGREES_PER_CIRCLE = 360.0
     RADIANS_PER_CIRCLE = 2 * Math::PI
@@ -15,8 +18,8 @@ module Astronoby
 
     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
+    MICROSECOND_IN_DAYS = 1.0 / SECONDS_PER_DAY / 1e6
 
     PI_IN_DEGREES = 180.0
 
@@ -26,6 +29,18 @@ module Astronoby
     ASTRONOMICAL_UNIT_IN_METERS = 149_597_870_700
     EARTH_EQUATORIAL_RADIUS_IN_METERS = 6378140
 
+    # WGS84 Earth Constants
+    WGS84_EARTH_EQUATORIAL_RADIUS_IN_METERS = 6378137
+    WGS84_INVERSE_FLATTENING = 298.257223563
+    WGS84_FLATTENING = 1.0 / WGS84_INVERSE_FLATTENING
+    WGS84_ECCENTICITY_SQUARED = 2.0 * WGS84_FLATTENING - WGS84_FLATTENING * WGS84_FLATTENING
+
+    LIGHT_SPEED_M_PER_S = 299_792_458
+
     EARTH_FLATTENING_CORRECTION = 0.996647
+
+    EARTH_ANGULAR_VELOCITY_RAD_PER_S = 7.2921159e-5
+
+    TAI_TT_OFFSET = 32.184
   end
 end

data/lib/astronoby/constellation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Constellation
+    attr_reader :name, :abbreviation
+
+    def initialize(name, abbreviation)
+      @name = name
+      @abbreviation = abbreviation
+    end
+  end
+end

data/lib/astronoby/constellations/data.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Constellations
+    class Data
+      def self.sorted_right_ascensions
+        @sorted_right_ascensions ||=
+          read_file("sorted_right_ascensions.dat").map(&:to_f)
+      end
+
+      def self.sorted_declinations
+        @sorted_declinations ||=
+          read_file("sorted_declinations.dat").map(&:to_f)
+      end
+
+      def self.radec_to_index
+        @radec_to_index ||=
+          read_file("radec_to_index.dat").map do |line|
+            line.split.map(&:to_i)
+          end
+      end
+
+      def self.indexed_abbreviations
+        @indexed_abbreviations ||=
+          read_file("indexed_abbreviations.dat")
+      end
+
+      def self.constellation_names
+        @constellation_names ||=
+          read_file("constellation_names.dat").map(&:split)
+      end
+
+      def self.read_file(filename)
+        File.readlines(data_path(filename)).map(&:strip)
+      end
+
+      def self.data_path(filename)
+        File.join(__dir__, "..", "data", "constellations", filename)
+      end
+    end
+  end
+end

data/lib/astronoby/constellations/finder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Constellations
+    class Finder
+      # Finds the constellation that contains the given B1875 equatorial
+      #   coordinates.
+      # @param equatorial_coordinates [Astronoby::Coordinates::Equatorial] The
+      #   B1875 coordinates to search for.
+      # @return [Astronoby::Constellation, nil] The constellation that contains
+      #   the coordinates, or nil if none is found.
+      def self.find(equatorial_coordinates)
+        ra_hours = equatorial_coordinates.right_ascension.hours
+        dec_degrees = equatorial_coordinates.declination.degrees
+        ra_index = Data
+          .sorted_right_ascensions
+          .bsearch_index { _1 >= ra_hours }
+        dec_index = Data
+          .sorted_declinations
+          .bsearch_index { _1 > dec_degrees }
+
+        return if ra_index.nil? || dec_index.nil?
+
+        abbreviation_index = Data.radec_to_index.dig(ra_index, dec_index)
+
+        return if abbreviation_index.nil?
+
+        constellation_abbreviation =
+          Data.indexed_abbreviations[abbreviation_index]
+
+        Repository.get(constellation_abbreviation)
+      end
+    end
+  end
+end

data/lib/astronoby/constellations/repository.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Constellations
+    class Repository
+      # Returns a constellation object for the given abbreviation.
+      # @param abbreviation [String] The abbreviation of the constellation.
+      # @return [Astronoby::Constellation, nil] The constellation object or nil
+      #   if not found.
+      def self.get(abbreviation)
+        @constellations ||= Data.constellation_names.map do |abbr, name|
+          constellation = Constellation.new(name, abbr)
+          [abbr, constellation]
+        end.to_h
+
+        @constellations[abbreviation]
+      end
+    end
+  end
+end

data/lib/astronoby/coordinates/ecliptic.rb

@@ -10,43 +10,8 @@ module Astronoby
         @longitude = longitude
       end
 
-      # Source:
-      #  Title: Celestial Calculations
-      #  Author: J. L. Lawrence
-      #  Edition: MIT Press
-      #  Chapter: 4 - Orbits and Coordinate Systems
-
-      def to_true_equatorial(epoch:)
-        mean_obliquity = MeanObliquity.for_epoch(epoch)
-        to_equatorial(obliquity: mean_obliquity, epoch: epoch)
-      end
-
-      def to_apparent_equatorial(epoch:)
-        apparent_obliquity = TrueObliquity.for_epoch(epoch)
-        to_equatorial(obliquity: apparent_obliquity, epoch: epoch)
-      end
-
-      private
-
-      def to_equatorial(obliquity:, epoch:)
-        y = Angle.from_radians(
-          @longitude.sin * obliquity.cos -
-            @latitude.tan * obliquity.sin
-        )
-        x = Angle.from_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 * obliquity.cos +
-            @latitude.cos * obliquity.sin * @longitude.sin
-        )
-
-        Equatorial.new(
-          right_ascension: right_ascension,
-          declination: declination,
-          epoch: epoch
-        )
+      def self.zero
+        new(latitude: Angle.zero, longitude: Angle.zero)
       end
     end
   end

data/lib/astronoby/coordinates/equatorial.rb

@@ -9,7 +9,7 @@ module Astronoby
         declination:,
         right_ascension:,
         hour_angle: nil,
-        epoch: Epoch::DEFAULT_EPOCH
+        epoch: JulianDate::DEFAULT_EPOCH
       )
         @right_ascension = right_ascension
         @declination = declination
@@ -17,6 +17,30 @@ module Astronoby
         @epoch = epoch
       end
 
+      def self.zero
+        new(declination: Angle.zero, right_ascension: Angle.zero)
+      end
+
+      def self.from_position_vector(position)
+        return zero if position.zero?
+
+        term1 = position.z.m
+        term2 = position.magnitude.m
+        declination = Angle.asin(term1 / term2)
+
+        term1 = position.y.m
+        term2 = position.x.m
+        angle = Angle.atan(term1 / term2)
+        right_ascension =
+          Astronoby::Util::Trigonometry.adjustement_for_arctangent(
+            term1,
+            term2,
+            angle
+          )
+
+        new(declination: declination, right_ascension: right_ascension)
+      end
+
       def compute_hour_angle(time:, longitude:)
         lst = GreenwichSiderealTime
           .from_utc(time.utc)
@@ -38,6 +62,7 @@ module Astronoby
 
         t1 = @declination.sin - latitude.sin * altitude.sin
         t2 = t1 / (latitude.cos * altitude.cos)
+        t2 = t2.clamp(-1, 1)
         azimuth = Angle.acos(t2)
 
         if ha.sin.positive?
@@ -57,8 +82,8 @@ module Astronoby
       #  Author: J. L. Lawrence
       #  Edition: MIT Press
       #  Chapter: 4 - Orbits and Coordinate Systems
-      def to_ecliptic(epoch:)
-        mean_obliquity = MeanObliquity.for_epoch(epoch)
+      def to_ecliptic(instant:)
+        mean_obliquity = MeanObliquity.at(instant)
 
         y = Angle.from_radians(
           @right_ascension.sin * mean_obliquity.cos +
@@ -78,13 +103,6 @@ module Astronoby
           longitude: longitude
         )
       end
-
-      def to_epoch(epoch)
-        Precession.for_equatorial_coordinates(
-          coordinates: self,
-          epoch: epoch
-        )
-      end
     end
   end
 end

data/lib/astronoby/coordinates/horizontal.rb

@@ -14,52 +14,6 @@ module Astronoby
         @altitude = altitude
         @observer = observer
       end
-
-      def to_equatorial(time:)
-        t0 = @altitude.sin * latitude.sin +
-          @altitude.cos * latitude.cos * @azimuth.cos
-
-        declination = Angle.asin(t0)
-
-        t1 = @altitude.sin - latitude.sin * declination.sin
-
-        hour_angle_degrees = Angle
-          .acos(t1 / (latitude.cos * declination.cos))
-          .degrees
-
-        if @azimuth.sin.positive?
-          hour_angle_degrees = Angle
-            .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)
-        right_ascension_decimal = lst.time - hour_angle_hours
-
-        if right_ascension_decimal.negative?
-          right_ascension_decimal += Constants::HOURS_PER_DAY
-        end
-
-        right_ascension = Angle.from_hours(right_ascension_decimal)
-
-        Equatorial.new(
-          right_ascension: right_ascension,
-          declination: declination
-        )
-      end
-
-      private
-
-      def latitude
-        @observer.latitude
-      end
-
-      def longitude
-        @observer.longitude
-      end
     end
   end
 end

data/lib/astronoby/corrections/light_time_delay.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Correction
+    class LightTimeDelay
+      LIGHT_SPEED_CORRECTION_MAXIMUM_ITERATIONS = 10
+      LIGHT_SPEED_CORRECTION_PRECISION = 1e-12
+
+      def self.compute(center:, target:, ephem:)
+        new(center: center, target: target, ephem: ephem).compute
+      end
+
+      def initialize(center:, target:, ephem:)
+        @center = center
+        @target = target
+        @ephem = ephem
+      end
+
+      def delay
+        @_delay ||= begin
+          compute
+          @delay
+        end
+      end
+
+      def compute
+        @corrected_position ||= begin
+          corrected_position = Vector[
+            Distance.zero,
+            Distance.zero,
+            Distance.zero
+          ]
+          corrected_velocity = Vector[
+            Velocity.zero,
+            Velocity.zero,
+            Velocity.zero
+          ]
+          @delay = initial_delta_in_seconds
+
+          LIGHT_SPEED_CORRECTION_MAXIMUM_ITERATIONS.times do
+            new_instant = Instant.from_terrestrial_time(
+              instant.tt - @delay / Constants::SECONDS_PER_DAY
+            )
+            corrected = @target
+              .target_body
+              .geometric(ephem: @ephem, instant: new_instant)
+            corrected_position = corrected.position
+            corrected_velocity = corrected.velocity
+
+            corrected_distance_in_km = Math.sqrt(
+              (corrected_position.x.km - position.x.km)**2 +
+                (corrected_position.y.km - position.y.km)**2 +
+                (corrected_position.z.km - position.z.km)**2
+            )
+
+            new_delay = corrected_distance_in_km / Velocity.light_speed.kmps
+
+            break if (new_delay - @delay).abs < LIGHT_SPEED_CORRECTION_PRECISION
+
+            @delay = new_delay
+          end
+
+          [corrected_position, corrected_velocity]
+        end
+      end
+
+      private
+
+      def position
+        @position ||= @center.position
+      end
+
+      def instant
+        @center.instant
+      end
+
+      def initial_delta_in_seconds
+        distance_between_bodies_in_km / Velocity.light_speed.kmps
+      end
+
+      def distance_between_bodies_in_km
+        Math.sqrt(
+          (@target.position.x.km - position.x.km)**2 +
+            (@target.position.y.km - position.y.km)**2 +
+            (@target.position.z.km - position.z.km)**2
+        )
+      end
+    end
+  end
+end