ephem 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8bc9fc6e66dd3aa9d61960cb3b28d43f4c90df7a70eedc1a6460f0dde73b25a
-  data.tar.gz: a39afb7d865bf976cff25c0839557c22c8aede2ba29bb9ce5b2fa4fef9c17aef
+  metadata.gz: 87a0725b85c4ffbedd33b54f3780202c5e43aef7e7a710658df52a2e187f2dcb
+  data.tar.gz: f0d1aeccf6731b4d34344c80dd652e7cf012719728a97d3e86463fe5e98dbea7
 SHA512:
-  metadata.gz: b832de3f8565111c21e55f8040fb7b8d337cce7d569ccd67a4499949176467bc7eff3f8fa27edabb5af07019637b2f93951cbddbe36ee91e7080b1c11a045144
-  data.tar.gz: 48a6ef091dd882b9c480e50146bb4038bce15af264ad1e6b8f52a27f21c3796a6c6500a3fe6ee0229d9d534a611daf80f25cd2c0fccf00ee67202699785e033b
+  metadata.gz: 2ecffd718100afae3bb1c69e545f36c25c71aad4e9a75d766189a411afa92c1e3f77eda60a02ea17102e57a7d3a9c730b0728e5189ed9cbf2981201cff8bb3e4
+  data.tar.gz: e7ff31012dc8f1ffdf38118fc195ffc8849146c690132e9b6b48766456848cda001d11825c687fe0e58fac38a14ca93dcaee6c6ad4af75c1caf8cec9329704d1

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.4.0] - 2025-06-09
+
+### Improvements
+
+* Improve Chebyshev polynomial performance ([#33])
+* Improve download file management ([#34])
+* Validate against all kernels and date ranges ([#36])
+* Add supported Ruby versions ([#35])
+* Bump rspec from 3.13.0 to 3.13.1 by @dependabot ([#38])
+* Bump rake from 13.2.1 to 13.3.0 by @dependabot ([#39])
+* Bump csv from 3.3.4 to 3.3.5 by @dependabot ([#40])
+
+[#33]: https://github.com/rhannequin/ruby-ephem/pull/33
+[#34]: https://github.com/rhannequin/ruby-ephem/pull/34
+[#35]: https://github.com/rhannequin/ruby-ephem/pull/35
+[#36]: https://github.com/rhannequin/ruby-ephem/pull/36
+[#38]: https://github.com/rhannequin/ruby-ephem/pull/38
+[#39]: https://github.com/rhannequin/ruby-ephem/pull/39
+[#40]: https://github.com/rhannequin/ruby-ephem/pull/40
+
+**Full Changelog**: https://github.com/rhannequin/ruby-ephem/compare/v0.3.1...v0.4.0
+
 ## [0.3.1] - 2025-05-16
 
 ### Bug fixes

data/lib/ephem/computation/chebyshev_polynomial.rb

@@ -1,192 +1,89 @@
 # frozen_string_literal: true
 
-require "numo/narray"
-
 module Ephem
   module Computation
-    # Implements Chebyshev polynomial evaluation and differentiation for
-    # astronomical calculations.
-    #
-    # Chebyshev polynomials are mathematical functions that can be used to
-    # approximate other functions with high accuracy. In astronomical
-    # calculations, they are used to approximate positions and velocities of
-    # celestial bodies.
-    #
-    # The polynomial evaluation is done using the Clenshaw algorithm, which is
-    # numerically stable and efficient. For performance optimization, polynomial
-    # values are cached when they need to be used both for position and velocity
-    # calculations.
-    #
-    # @example Calculating position in 3D space
-    #   # coefficients is a 2D array where:
-    #   # - First dimension is the polynomial degree (n terms)
-    #   # - Second dimension is the spatial dimension (3 for x,y,z)
-    #   coefficients = Numo::DFloat.cast([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
-    #
-    #   # normalized_time must be between -1 and 1
-    #   polynomial = ChebyshevPolynomial.new(
-    #     coefficients: coefficients,
-    #     normalized_time: 0.5
-    #   )
-    #
-    #   position = polynomial.evaluate
+    ##
+    # High-performance, three-dimensional Clenshaw evaluation and derivative
+    # evaluation for Chebyshev polynomials, as used in SPK ephemerides.
     #
-    # @example Calculating velocity with time scaling
-    #   # radius is the time span in days
-    #   polynomial = ChebyshevPolynomial.new(
-    #     coefficients: coefficients,
-    #     normalized_time: 0.5,
-    #     radius: 32.0  # 32-day time span
-    #   )
+    # @see https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/cheby.html
+    # @see https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/FORTRAN/spicelib/spkche.html
     #
-    #   velocity = polynomial.evaluate_derivative
-    class ChebyshevPolynomial
-      include Core::Constants::Time
-
-      # Initializes a new Chebyshev polynomial calculator
-      #
-      # @param coefficients [Numo::NArray] 2D array of Chebyshev polynomial
-      #   coefficients. First dimension represents polynomial terms
-      #   (degree + 1). Second dimension represents spatial components
-      #   (usually 3 for x,y,z)
-      # @param normalized_time [Float] Time parameter normalized to [-1, 1]
-      #   interval
-      # @param radius [Float, nil] Optional scaling factor for derivative
-      #   calculations, usually represents the time span of the interval in days
-      #
-      # @raise [Ephem::InvalidInputError] if coefficients are not a 2D
-      #   Numo::NArray
-      # @raise [Ephem::InvalidInputError] if normalized_time is outside [-1, 1]
-      def initialize(coefficients:, normalized_time:, radius: nil)
-        validate_inputs(coefficients, normalized_time)
-
-        @coefficients = coefficients
-        @normalized_time = normalized_time
-        @radius = radius
-        @degree = @coefficients.shape[0]
-        @dimension = @coefficients.shape[1]
-        @two_times_normalized_time = 2.0 * @normalized_time
-        @polynomials = nil # Cache for polynomial values
-      end
-
-      # Evaluates the Chebyshev polynomial at the normalized time point
-      #
-      # Uses the Clenshaw algorithm for numerical stability. The algorithm
-      # evaluates the polynomial using a recurrence relation, which is more
-      # stable than direct power series evaluation.
-      #
-      # @return [Numo::DFloat] Evaluation result, array of size dimension
-      #   (usually 3)
-      def evaluate
-        @polynomials ||= generate_polynomials(@degree, @dimension)
-        combine_polynomials(@polynomials)
-      end
-
-      # Calculates the derivative of the Chebyshev polynomial
-      #
-      # For astronomical calculations, this typically represents velocity.
-      # For polynomials of degree < 2, returns zero array since the derivative
-      # of constants and linear terms are constant or zero.
+    module ChebyshevPolynomial
+      ##
+      # Evaluates a 3D Chebyshev polynomial at a given normalized time.
       #
-      # If radius is provided, scales the result to convert from normalized time
-      # units to physical units (usually km/sec in astronomical calculations)
-      #
-      # @return [Numo::DFloat] Derivative values, array of size dimension
-      #   (usually 3)
-      def evaluate_derivative
-        return Numo::DFloat.zeros(@dimension) if @degree < 2
-
-        derivative = calculate_derivative(@degree, @dimension)
-        scale_derivative(derivative)
-      end
-
-      private
-
-      def validate_inputs(coefficients, normalized_time)
-        unless coefficients.is_a?(Numo::NArray) && coefficients.ndim == 2
-          raise InvalidInputError, "Coefficients must be a 2D Numo::NArray"
+      # @param coeffs [Array<Array<Float>>] Array of coefficients; shape is
+      #   [n_terms][3].
+      # @param t [Float] The normalized independent variable, in [-1, 1].
+      # @return [Array<Float>] The 3-vector result at t: [x, y, z]
+      def self.evaluate(coeffs, t)
+        n = coeffs.size
+        b1x = b1y = b1z = 0.0
+        b2x = b2y = b2z = 0.0
+
+        k = n - 1
+        while k > 0
+          c = coeffs[k]
+          c0 = c[0]
+          c1 = c[1]
+          c2 = c[2]
+          t2 = 2.0 * t
+          tx = t2 * b1x - b2x + c0
+          ty = t2 * b1y - b2y + c1
+          tz = t2 * b1z - b2z + c2
+          b2x = b1x
+          b2y = b1y
+          b2z = b1z
+          b1x = tx
+          b1y = ty
+          b1z = tz
+          k -= 1
         end
 
-        unless (-1.0..1.0).cover?(normalized_time)
-          raise InvalidInputError, "Normalized time must be in range [-1, 1]"
-        end
-      end
-
-      # Generates the sequence of Chebyshev polynomials
-      # Uses the recurrence relation for Chebyshev polynomials:
-      # T₀(x) = 1
-      # T₁(x) = x
-      # Tₙ₊₁(x) = 2xTₙ(x) - Tₙ₋₁(x)
-      def generate_polynomials(degree, dimension)
-        polynomials = initialize_base_polynomials(dimension)
-        return polynomials if degree <= 2
-
-        build_polynomial_sequence(polynomials, degree)
-        polynomials
-      end
-
-      # Initializes T₀(x) = 1 and T₁(x) = x polynomials
-      def initialize_base_polynomials(dimension)
-        [
-          Numo::DFloat.ones(dimension),
-          @normalized_time * Numo::DFloat.ones(dimension)
-        ]
-      end
-
-      def build_polynomial_sequence(polynomials, degree)
-        (2...degree).each do |i|
-          polynomials << compute_next_polynomial(
-            polynomials[i - 2],
-            polynomials[i - 1]
-          )
-        end
-      end
-
-      def compute_next_polynomial(prev_prev, prev)
-        @two_times_normalized_time * prev - prev_prev
+        c0, c1, c2 = coeffs[0]
+        [t * b1x - b2x + c0, t * b1y - b2y + c1, t * b1z - b2z + c2]
       end
 
-      # Combines polynomials with their coefficients
-      # Uses vectorized operations for efficiency. The final result is:
-      # Σ(coefficients[i] * polynomials[i]) for i from 0 to degree-1
-      def combine_polynomials(polynomials)
-        (0...@degree).inject(Numo::DFloat.zeros(@dimension)) do |result, i|
-          result + @coefficients[i, true] * polynomials[i]
-        end
-      end
-
-      # Calculates derivative using the modified Clenshaw algorithm
-      # The algorithm is adapted to compute derivatives of Chebyshev polynomials
-      # while maintaining numerical stability
-      def calculate_derivative(degree, dimension)
-        @polynomials ||= generate_polynomials(degree, dimension)
-
-        derivative_prev = Numo::DFloat.zeros(dimension)
-        derivative = derivative_prev.clone
-
-        (degree - 1).downto(1) do |i|
-          derivative_next = derivative.clone
-          derivative = derivative_prev
-          derivative_prev = calculate_derivative_term(
-            i,
-            derivative,
-            derivative_next
-          )
+      ##
+      # Evaluates the time derivative of a 3D Chebyshev polynomial at a given
+      # normalized time.
+      #
+      # @param coeffs [Array<Array<Float>>] Array of coefficients; shape is
+      #   [n_terms][3].
+      # @param t [Float] The normalized independent variable (in [-1, 1]).
+      # @param radius [Float] The half-length of the time interval (days).
+      # @return [Array<Float>] The 3-vector derivative (velocity), in units per
+      #   second.
+      def self.evaluate_derivative(coeffs, t, radius)
+        n = coeffs.size
+        return [0.0, 0.0, 0.0] if n < 2
+
+        d1x = d1y = d1z = 0.0
+        d2x = d2y = d2z = 0.0
+
+        k = n - 1
+        while k > 0
+          c = coeffs[k]
+          c0 = c[0]
+          c1 = c[1]
+          c2 = c[2]
+          t2 = 2.0 * t
+          k2 = 2 * k
+          tx = t2 * d1x - d2x + k2 * c0
+          ty = t2 * d1y - d2y + k2 * c1
+          tz = t2 * d1z - d2z + k2 * c2
+          d2x = d1x
+          d2y = d1y
+          d2z = d1z
+          d1x = tx
+          d1y = ty
+          d1z = tz
+          k -= 1
         end
 
-        derivative_prev
-      end
-
-      def calculate_derivative_term(index, deriv, deriv_next)
-        @two_times_normalized_time * deriv -
-          deriv_next +
-          @coefficients[index, true] * 2 * index
-      end
-
-      def scale_derivative(derivative)
-        return derivative unless @radius
-
-        derivative * (SECONDS_PER_DAY / (2.0 * @radius))
+        scale = Ephem::Core::Constants::Time::SECONDS_PER_DAY / (2.0 * radius)
+        [d1x * scale, d1y * scale, d1z * scale]
       end
     end
   end

data/lib/ephem/download.rb

@@ -2,8 +2,10 @@
 
 require "minitar"
 require "net/http"
+require "pathname"
 require "tempfile"
 require "zlib"
+require "fileutils"
 
 module Ephem
   class Download
@@ -94,16 +96,15 @@ module Ephem
       new(name, target).call
     end
 
-    def initialize(name, local_path)
+    def initialize(name, target_path)
       @name = name
-      @local_path = local_path
+      @target_path = Pathname.new(target_path)
       validate_requested_kernel!
     end
 
     def call
-      content = jpl_kernel? ? download_from_jpl : download_from_imcce
-      File.binwrite(@local_path, content)
-
+      FileUtils.mkdir_p(@target_path.dirname)
+      jpl_kernel? ? download_jpl : download_imcce
       true
     end
 
@@ -120,28 +121,45 @@ module Ephem
       JPL_KERNELS.include?(@name)
     end
 
-    def download_from_jpl
-      uri = URI("#{JPL_BASE_URL}#{@name}")
-      Net::HTTP.get(uri)
+    def download_jpl
+      uri = URI.join(JPL_BASE_URL, @name)
+      @target_path.open("wb") do |file|
+        stream_http_to_file(uri, file)
+      end
     end
 
-    def download_from_imcce
-      temp_file = Tempfile.new(%w[archive .tar.gz])
-      uri = URI("#{IMCCE_BASE_URL}#{IMCCE_KERNELS_MATCHING[@name]}")
-      content = Net::HTTP.get(uri)
-      temp_file.write(content)
-      temp_file.rewind
-
-      Zlib::GzipReader.open(temp_file.path) do |gz|
-        Minitar::Reader.open(gz) do |tar|
-          tar.each_entry do |entry|
-            return entry.read if entry.full_name == IMCCE_KERNELS[@name]
+    def download_imcce
+      tar_gz_uri = URI.join(IMCCE_BASE_URL, IMCCE_KERNELS_MATCHING[@name])
+      Tempfile.create(%w[archive .tar.gz]) do |temp_file|
+        stream_http_to_file(tar_gz_uri, temp_file)
+        temp_file.flush
+        temp_file.rewind
+
+        Zlib::GzipReader.open(temp_file.path) do |gz|
+          Minitar::Reader.open(gz) do |tar|
+            tar.each_entry do |entry|
+              next unless entry.full_name == IMCCE_KERNELS[@name]
+
+              @target_path.open("wb") { |file| file.write(entry.read) }
+
+              break
+            end
           end
         end
       end
-    ensure
-      temp_file.close
-      temp_file.unlink
+    end
+
+    def stream_http_to_file(uri, file)
+      Net::HTTP.start(
+        uri.host,
+        uri.port,
+        use_ssl: uri.scheme == "https"
+      ) do |http|
+        request = Net::HTTP::Get.new(uri)
+        http.request(request) do |response|
+          response.read_body { |chunk| file.write(chunk) }
+        end
+      end
     end
   end
 end

data/lib/ephem/segments/segment.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "numo/narray"
+
 module Ephem
   module Segments
     # Manages data segments within SPICE kernel (SPK) files, providing methods
@@ -133,7 +135,7 @@ module Ephem
         # Synchronize access to data loading using a mutex lock
         # to prevent race conditions in multithreaded environments
         @data_lock.synchronize do
-          return if @data_loaded # Return early if data is already loaded
+          return if @data_loaded
 
           component_count = determine_component_count
           coefficients_data = load_coefficient_data
@@ -180,27 +182,27 @@ module Ephem
         coefficients = Numo::DFloat.cast(coefficients_raw)
         coefficients = coefficients.reshape(segment_count, record_size)
 
-        # Extract midpoints and radii from coefficient data
-        # midpoints: array of times at middle of each record's interval
-        # radii: array of half the interval length for each record
-        @midpoints = coefficients[0...segment_count, 0]
-        @radii = coefficients[0...segment_count, 1]
-
-        # Extract Chebyshev polynomial coefficients and reshape to 3D array
-        # dimensions: (coefficient_index, component_index, segment_index)
-        coeffs = coefficients[0...segment_count, 2..-1]
-        @coefficients = coeffs.reshape(
-          segment_count,
-          component_count,
-          coefficient_count
-        )
-          .transpose(2, 1, 0)
+        @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, Numo::NArray
+        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
@@ -228,20 +230,18 @@ module Ephem
       def generate_single(tdb_seconds)
         interval = find_interval(tdb_seconds)
         normalized_time = compute_normalized_time(tdb_seconds, interval)
-        coeffs = @coefficients[true, true, interval]
 
-        position = Computation::ChebyshevPolynomial.new(
-          coefficients: coeffs,
-          normalized_time: normalized_time
-        ).evaluate
-
-        velocity = Computation::ChebyshevPolynomial.new(
-          coefficients: coeffs,
-          normalized_time: normalized_time,
-          radius: @radii[interval]
-        ).evaluate_derivative
-
-        [position.to_a, velocity.to_a]
+        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)

data/lib/ephem/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ephem
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Rémy Hannequin
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitar
@@ -244,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Compute astronomical ephemerides from NASA/JPL DE and IMCCE INPOP
 test_files: []