ephem 0.4.1 → 0.5.0

data/lib/ephem/segments/segment.rb

@@ -1,21 +1,10 @@
 # frozen_string_literal: true
 
-require "numo/narray"
-
 module Ephem
   module Segments
-    # Manages data segments within SPICE kernel (SPK) files, providing methods
-    # to compute positions and velocities of celestial bodies using Chebyshev
-    # polynomial approximations.
-    #
-    # Each segment contains data for a specific celestial body (target) relative
-    # to another body (center) within a specific time range. The data is stored
-    # as Chebyshev polynomial coefficients that can be evaluated to obtain
-    # position and velocity vectors.
-    #
-    # The class provides thread-safe data loading and caching mechanisms to
-    # optimize performance while ensuring data consistency in multithreaded
-    # environments.
+    # SPK trajectory segment: position (type 2) and position/velocity (type 3)
+    # of a target body relative to a center body, stored as Chebyshev
+    # coefficients.
     #
     # @example Computing position at a specific time
     #   segment = Ephem::Segments::Segment.new(
@@ -27,29 +16,18 @@ module Ephem
     #
     # @example Computing position and velocity
     #   state = segment.compute_and_differentiate(time)  # returns State
-    #   position = state.position  # Vector
-    #   velocity = state.velocity  # Vector
     #
     # @see Ephem::Core::Vector
     # @see Ephem::Core::State
-    # @see Ephem::Computation::ChebyshevPolynomial
+    # @see Ephem::Segments::ChebyshevType2
     class Segment < BaseSegment
+      include ChebyshevType2
+
       COMPONENT_COUNTS = {
         2 => 3,  # Type 2: position (x, y, z)
         3 => 6   # Type 3: position (x, y, z) and velocity (vx, vy, vz)
       }.freeze
 
-      # @param daf [Ephem::IO::DAF] DAF file object containing the segment data
-      # @param source [String] Name of the source SPK file
-      # @param descriptor [Array] Array containing segment metadata:
-      #   - start_second [Float] Start time in seconds from J2000
-      #   - end_second [Float] End time in seconds from J2000
-      #   - target [Integer] NAIF ID of target body
-      #   - center [Integer] NAIF ID of center body
-      #   - frame [Integer] Reference frame ID
-      #   - data_type [Integer] Type of data (2 for position, 3 for pos/vel)
-      #   - start_i [Integer] Start index in DAF array
-      #   - end_i [Integer] End index in DAF array
       def initialize(daf:, source:, descriptor:)
         super
         @data_loaded = false
@@ -59,39 +37,35 @@ module Ephem
       # Computes the position of the target body relative to the center body at
       # the specified time.
       #
-      # Uses Chebyshev polynomial approximation to interpolate the position from
-      # stored coefficients. The computation is thread-safe and uses cached data
-      # when available.
-      #
       # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
       # @param tdb2 [Numeric] Optional fractional part of TDB date
       # @return [Ephem::Core::Vector] Position vector in kilometers
       # @raise [Ephem::OutOfRangeError] if time is outside segment coverage
-      #
-      # @example Computing Earth's position relative to Solar System Barycenter
-      #   position = segment.compute(2451545.0)  # J2000 epoch
       def compute(tdb, tdb2 = 0.0)
-        Core::Vector.new(*generate(tdb, tdb2).first)
+        load_data
+        tdb_seconds = convert_to_seconds(tdb, tdb2)
+
+        case tdb_seconds
+        when Numeric
+          position = generate_position(tdb_seconds)
+          Core::Vector.new(position[0], position[1], position[2])
+        else
+          tdb_seconds.map do |t|
+            position = generate_position(t)
+            Core::Vector.new(position[0], position[1], position[2])
+          end
+        end
       end
       alias_method :position_at, :compute
 
       # Computes both position and velocity vectors at the specified time.
       #
-      # Uses Chebyshev polynomial approximation and its derivative to compute
-      # both position and velocity. The computation is thread-safe and uses
-      # cached data when available.
-      #
       # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
       # @param tdb2 [Numeric] Optional fractional part of TDB date
       # @return [Ephem::Core::State, Array<Ephem::Core::State>] State object(s)
-      #   containing position and velocity vectors. Returns array if input is
-      #   array.
+      #   containing position (km) and velocity (km/day) vectors. Returns an
+      #   array if the input is an array.
       # @raise [Ephem::OutOfRangeError] if time is outside segment coverage
-      #
-      # @example Computing Earth's state vector
-      #   state = segment.compute_and_differentiate(2451545.0)
-      #   position = state.position  # in kilometers
-      #   velocity = state.velocity  # in kilometers/second
       def compute_and_differentiate(tdb, tdb2 = 0.0)
         load_data
         tdb_seconds = convert_to_seconds(tdb, tdb2)
@@ -114,190 +88,16 @@ module Ephem
       end
       alias_method :state_at, :compute_and_differentiate
 
-      # Clears cached coefficient data, forcing reload on next computation.
-      #
-      # This method is thread-safe and can be used to free memory or force
-      # fresh data loading if needed.
-      #
-      # @return [void]
-      def clear_data
-        @data_lock.synchronize do
-          @data_loaded = false
-          @midpoints = nil
-          @radii = nil
-          @coefficients = nil
-        end
-      end
-
       private
 
-      def load_data
-        # Synchronize access to data loading using a mutex lock
-        # to prevent race conditions in multithreaded environments
-        @data_lock.synchronize do
-          return if @data_loaded
-
-          component_count = determine_component_count
-          coefficients_data = load_coefficient_data
-          process_coefficient_data(coefficients_data, component_count)
-
-          @data_loaded = true
-        end
-      end
-
-      def determine_component_count
+      def component_count
         COMPONENT_COUNTS.fetch(@data_type) do
           raise "Unsupported data type: #{@data_type}"
         end
       end
 
-      def load_coefficient_data
-        # Read metadata from the end of the segment
-        # start_index: index of first coefficient in segment
-        # end_index: index of last coefficient in segment
-        # record_size: total size of each record (coefficients + 2)
-        # segment_count: number of records in the segment
-        metadata = @daf.read_array(@end_i - 3, @end_i)
-        _start_index, _end_index, record_size, segment_count = metadata
-
-        coefficient_count = ((record_size - 2) / determine_component_count).to_i
-        coefficients_raw = @daf.map_array(@start_i, @end_i - 4)
-
-        [
-          coefficients_raw,
-          record_size.to_i,
-          segment_count.to_i,
-          coefficient_count
-        ]
-      end
-
-      def process_coefficient_data(data, component_count)
-        coefficients_raw, record_size, segment_count, coefficient_count = data
-
-        # Convert raw coefficient data to Numo::DFloat and reshape to 2D array.
-        # Numo::NArray allows efficient numerical computations on arrays.
-        # It provides ndarray data structures and supports various arithmetic
-        # operations. Using Numo::DFloat ensures the array elements are 64-bit
-        # floating point numbers.
-        coefficients = Numo::DFloat.cast(coefficients_raw)
-        coefficients = coefficients.reshape(segment_count, record_size)
-
-        @midpoints = coefficients[0...segment_count, 0].to_a
-        @radii = coefficients[0...segment_count, 1].to_a
-        n_terms = coefficient_count
-        n_components = component_count
-
-        @coefficients = Array.new(segment_count) do |i|
-          row = coefficients[i, 2..-1].to_a
-          Array.new(n_terms) do |k|
-            Array.new(n_components) do |j|
-              row[k + j * n_terms]
-            end
-          end
-        end
-      end
-
-      def convert_to_seconds(tdb, tdb2)
-        case tdb
-        when Array
-          tdb.map { |t| time_to_seconds(t, tdb2) }
-        when Numo::NArray
-          tdb.to_a.map { |t| time_to_seconds(t, tdb2) }
-        else
-          time_to_seconds(tdb, tdb2)
-        end
-      end
-
-      def time_to_seconds(time, offset)
-        (time - Time::J2000_EPOCH) *
-          Time::SECONDS_PER_DAY +
-          offset *
-            Time::SECONDS_PER_DAY
-      end
-
-      def generate(tdb, tdb2)
-        load_data
-        tdb_seconds = convert_to_seconds(tdb, tdb2)
-
-        case tdb_seconds
-        when Numeric
-          generate_single(tdb_seconds)
-        else
-          generate_multiple(tdb_seconds)
-        end
-      end
-
-      def generate_single(tdb_seconds)
-        interval = find_interval(tdb_seconds)
-        normalized_time = compute_normalized_time(tdb_seconds, interval)
-
-        coeffs = @coefficients[interval] # already [n_terms][3]
-        position = Computation::ChebyshevPolynomial.evaluate(
-          coeffs,
-          normalized_time
-        )
-        velocity = Computation::ChebyshevPolynomial.evaluate_derivative(
-          coeffs,
-          normalized_time,
-          @radii[interval]
-        )
-        [position, velocity]
-      end
-
-      def generate_multiple(tdb_seconds)
-        positions = []
-        velocities = []
-
-        tdb_seconds.each do |time|
-          pos, vel = generate_single(time)
-          positions << pos
-          velocities << vel
-        end
-
-        [positions, velocities]
-      end
-
-      def find_interval(tdb_seconds)
-        left = 0
-        right = @midpoints.size - 1
-
-        if @last_interval && time_in_interval?(tdb_seconds, @last_interval)
-          return @last_interval
-        end
-
-        while left <= right
-          mid = (left + right) / 2
-          min_time = @midpoints[mid] - @radii[mid]
-          max_time = @midpoints[mid] + @radii[mid]
-
-          if tdb_seconds < min_time
-            right = mid - 1
-          elsif tdb_seconds > max_time
-            left = mid + 1
-          else
-            @last_interval = mid
-            return mid
-          end
-        end
-
-        raise OutOfRangeError.new(
-          "Time #{tdb_seconds} is outside the coverage of this segment",
-          tdb_seconds
-        )
-      end
-
-      def time_in_interval?(time, interval)
-        min_time = @midpoints[interval] - @radii[interval]
-        max_time = @midpoints[interval] + @radii[interval]
-        time.between?(min_time, max_time)
-      end
-
-      def compute_normalized_time(time_seconds, interval)
-        (time_seconds - @midpoints[interval]) / @radii[interval]
-      end
-
-      Registry.register(2, self)
-      Registry.register(3, self)
+      Registry.register(:spk, 2, self)
+      Registry.register(:spk, 3, self)
     end
   end
 end

data/lib/ephem/segments/segment_group.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ephem
+  module Segments
+    # Several segments that share the same key (an SPK center/target pair, or a
+    # PCK body) but cover different, contiguous time intervals. Each query is
+    # routed to the segment covering the requested time, so a body that a kernel
+    # splits across several intervals behaves as a single, continuous source.
+    #
+    # SPK and PCK only build a group when a key actually has more than one
+    # segment; the common single-segment case returns the bare segment, so this
+    # routing never sits in the hot path for it.
+    #
+    # Subclasses ({PositionGroup}, {OrientationGroup}) add the query methods
+    # appropriate to the segments they hold.
+    class SegmentGroup
+      # Wraps segments that share a key. A single segment is returned as-is, so
+      # the common case carries no routing overhead; only a key spanning several
+      # time intervals becomes a group.
+      #
+      # @param segments [Array<BaseSegment>] segments sharing the same key
+      # @return [BaseSegment, SegmentGroup]
+      def self.wrap(segments)
+        segments.one? ? segments.first : new(segments)
+      end
+
+      # @return [Array<BaseSegment>] the underlying segments
+      attr_reader :segments
+
+      # @param segments [Array<BaseSegment>] segments sharing the same key
+      def initialize(segments)
+        @segments = segments
+      end
+
+      # Clears cached data for every segment in the group.
+      #
+      # @return [void]
+      def clear_data
+        @segments.each(&:clear_data)
+      end
+
+      def to_s
+        @segments.join("\n")
+      end
+
+      private
+
+      # Routes a query to the covering segment(s) and assembles the result. For
+      # a scalar time the block is called once with that segment and time; for
+      # an array, times are grouped by covering segment so each is queried in a
+      # single batched call, then results are reassembled in input order.
+      def query(tdb, tdb2)
+        if tdb.is_a?(Array)
+          query_many(tdb, tdb2) { |segment, times| yield segment, times, tdb2 }
+        else
+          yield segment_for(tdb, tdb2), tdb, tdb2
+        end
+      end
+
+      def query_many(times, tdb2)
+        results = Array.new(times.size)
+        indices_by_segment = times.each_index.group_by do |index|
+          segment_for(times[index], tdb2)
+        end
+
+        indices_by_segment.each do |segment, indices|
+          segment_results = yield(segment, indices.map { |index| times[index] })
+          indices.each_with_index do |original_index, position|
+            results[original_index] = segment_results[position]
+          end
+        end
+
+        results
+      end
+
+      def segment_for(tdb, tdb2)
+        @segments.reverse_each.find { |segment| segment.covers?(tdb, tdb2) } ||
+          raise(OutOfRangeError.new(
+            "Time #{tdb} is outside the coverage of this group", tdb
+          ))
+      end
+    end
+  end
+end

data/lib/ephem/spk.rb

@@ -25,9 +25,8 @@ module Ephem
     DE_FILENAME = "NIO2SPK"
 
     DATA_TYPE_IDENTIFIER = 5
-    SEGMENT_CLASSES = {}
 
-    attr_reader :segments, :pairs
+    attr_reader :daf, :segments, :pairs
 
     # Creates a new SPK instance with the given DAF.
     #
@@ -49,9 +48,16 @@ module Ephem
     # @raise [ArgumentError] If the file cannot be accessed due to permissions
     def self.open(path)
       daf = IO::DAF.new(File.open(path, "rb"))
+      if daf.file_type == :pck
+        raise ArgumentError, "#{path} is a binary PCK file, use Ephem::PCK.open"
+      end
+
       new(daf: daf)
     rescue Errno::EACCES => e
       raise ArgumentError, "File permission denied: #{path} (#{e.message})"
+    rescue
+      daf&.close
+      raise
     end
 
     # Closes the SPK file and cleans up resources.
@@ -69,7 +75,7 @@ module Ephem
     def to_s
       <<~DESCRIPTION
         SPK file with #{@segments.size} segments:
-        #{@segments.map(&:to_s).join("\n")}
+        #{@segments.join("\n")}
       DESCRIPTION
     end
 
@@ -77,8 +83,9 @@ module Ephem
     #
     # @param center [Integer] NAIF ID of the center body
     # @param target [Integer] NAIF ID of the target body
-    # @return [Segments::BaseSegment] The segment containing data for the
-    #   specified bodies
+    # @return [Segments::Segment, Segments::PositionGroup] the position source
+    #   for the pair: a single segment, or a group routing each query to the
+    #   covering segment when the pair spans several time intervals
     # @raise [KeyError] If no segment is found for the given center-target pair
     def [](center, target)
       @pairs.fetch([center, target]) do
@@ -139,14 +146,18 @@ module Ephem
     end
 
     def build_pairs
-      @segments.to_h do |segment|
-        [[segment.center, segment.target], segment]
-      end
+      @segments
+        .group_by { |segment| [segment.center, segment.target] }
+        .transform_values { |segments| Segments::PositionGroup.wrap(segments) }
     end
 
     def build_segment(source:, descriptor:)
       data_type = descriptor[DATA_TYPE_IDENTIFIER]
-      segment_class = SEGMENT_CLASSES.fetch(data_type, Segments::BaseSegment)
+      segment_class = Segments::Registry.lookup(
+        :spk,
+        data_type,
+        Segments::BaseSegment
+      )
       segment_class.new(daf: @daf, source: source, descriptor: descriptor)
     end
   end

data/lib/ephem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ephem
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/ephem.rb

@@ -6,6 +6,8 @@ require_relative "ephem/computation/chebyshev_polynomial"
 require_relative "ephem/core/calendar_calculations"
 require_relative "ephem/core/state"
 require_relative "ephem/core/vector"
+require_relative "ephem/core/orientation"
+require_relative "ephem/core/rotation"
 require_relative "ephem/error"
 require_relative "ephem/io/binary_reader"
 require_relative "ephem/io/daf"
@@ -15,9 +17,16 @@ require_relative "ephem/io/record_data"
 require_relative "ephem/io/record_parser"
 require_relative "ephem/io/summary_manager"
 require_relative "ephem/spk"
+require_relative "ephem/pck"
 require_relative "ephem/segments/base_segment"
 require_relative "ephem/segments/registry"
+require_relative "ephem/segments/chebyshev_type2"
+require_relative "ephem/segments/orientation_source"
 require_relative "ephem/segments/segment"
+require_relative "ephem/segments/orientation_segment"
+require_relative "ephem/segments/segment_group"
+require_relative "ephem/segments/position_group"
+require_relative "ephem/segments/orientation_group"
 require_relative "ephem/excerpt"
 require_relative "ephem/cli"
 require_relative "ephem/version"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ephem
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Rémy Hannequin
 bindir: bin
 cert_chain: []
-date: 2025-08-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitar
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
-- !ruby/object:Gem::Dependency
-  name: numo-narray
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.2.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.2.1
 - !ruby/object:Gem::Dependency
   name: zlib
   requirement: !ruby/object:Gem::Requirement
@@ -121,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -152,6 +152,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/run.rb
 - bin/console
 - bin/ruby-ephem
 - bin/setup
@@ -161,6 +162,8 @@ files:
 - lib/ephem/core/calendar_calculations.rb
 - lib/ephem/core/constants/bodies.rb
 - lib/ephem/core/constants/time.rb
+- lib/ephem/core/orientation.rb
+- lib/ephem/core/rotation.rb
 - lib/ephem/core/state.rb
 - lib/ephem/core/vector.rb
 - lib/ephem/download.rb
@@ -172,9 +175,16 @@ files:
 - lib/ephem/io/record_data.rb
 - lib/ephem/io/record_parser.rb
 - lib/ephem/io/summary_manager.rb
+- lib/ephem/pck.rb
 - lib/ephem/segments/base_segment.rb
+- lib/ephem/segments/chebyshev_type2.rb
+- lib/ephem/segments/orientation_group.rb
+- lib/ephem/segments/orientation_segment.rb
+- lib/ephem/segments/orientation_source.rb
+- lib/ephem/segments/position_group.rb
 - lib/ephem/segments/registry.rb
 - lib/ephem/segments/segment.rb
+- lib/ephem/segments/segment_group.rb
 - lib/ephem/spk.rb
 - lib/ephem/version.rb
 - lib/tasks/validate_accuracy.rake
@@ -199,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Compute astronomical ephemerides from NASA/JPL DE and IMCCE INPOP
 test_files: []