astronoby 0.6.0 → 0.7.0

data/lib/astronoby/reference_frames/topocentric.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Topocentric < ReferenceFrame
+    def self.build_from_apparent(
+      apparent:,
+      observer:,
+      instant:,
+      target_body:
+    )
+      matrix = observer.earth_fixed_rotation_matrix_for(instant)
+
+      observer_position = Distance.vector_from_meters(
+        matrix * observer.geocentric_position.map(&:m)
+      )
+      observer_velocity = Velocity.vector_from_mps(
+        matrix * observer.geocentric_velocity.map(&:kmps)
+      )
+
+      position = apparent.position - observer_position
+      velocity = apparent.velocity - observer_velocity
+
+      new(
+        position: position,
+        velocity: velocity,
+        instant: instant,
+        center_identifier: [observer.longitude, observer.latitude],
+        target_body: target_body,
+        observer: observer
+      )
+    end
+
+    def initialize(
+      position:,
+      velocity:,
+      instant:,
+      center_identifier:,
+      target_body:,
+      observer:
+    )
+      super(
+        position: position,
+        velocity: velocity,
+        instant: instant,
+        center_identifier: center_identifier,
+        target_body: target_body
+      )
+      @observer = observer
+    end
+
+    def angular_diameter
+      @angular_radius ||= begin
+        return Angle.zero if @position.zero?
+
+        Angle.from_radians(
+          Math.atan(@target_body.class::EQUATORIAL_RADIUS.m / distance.m) * 2
+        )
+      end
+    end
+
+    def ecliptic
+      @ecliptic ||= begin
+        return Coordinates::Ecliptic.zero if distance.zero?
+
+        equatorial.to_ecliptic(epoch: @instant.tdb)
+      end
+    end
+
+    def horizontal(refraction: false)
+      horizontal = equatorial.to_horizontal(
+        time: @instant.to_time,
+        observer: @observer
+      )
+
+      if refraction
+        Refraction.correct_horizontal_coordinates(coordinates: horizontal)
+      else
+        horizontal
+      end
+    end
+  end
+end

data/lib/astronoby/true_obliquity.rb

@@ -3,8 +3,9 @@
 module Astronoby
   class TrueObliquity
     def self.for_epoch(epoch)
+      instant = Instant.from_utc_julian_date(epoch)
       mean_obliquity = MeanObliquity.for_epoch(epoch)
-      nutation = Nutation.for_obliquity_of_the_ecliptic(epoch: epoch)
+      nutation = Nutation.new(instant: instant).nutation_in_obliquity
 
       mean_obliquity + nutation
     end

data/lib/astronoby/util/maths.rb

@@ -3,91 +3,88 @@
 module Astronoby
   module Util
     module Maths
-      class << self
-        # Source:
-        #  Title: Astronomical Algorithms
-        #  Author: Jean Meeus
-        #  Edition: 2nd edition
-        #  Chapter: 3 - Interpolation
+      module_function
 
-        # @param values [Array<Numeric>] First term
-        # @param factor [Numeric] Interpolation factor
-        # @return [Float] Interpolated value
-        def interpolate(values, factor)
-          unless factor.between?(0, 1)
-            raise IncompatibleArgumentsError,
-              "Interpolation factor must be between 0 and 1, got #{factor}"
-          end
+      def dot_product(a, b)
+        a.zip(b).sum { |x, y| x * y }
+      end
 
-          if values.length == 3
-            return interpolate_3_terms(values, factor)
-          elsif values.length == 5
-            return interpolate_5_terms(values, factor)
-          end
+      # Find maximum altitude using quadratic interpolation
+      # @param t1, t2, t3 [Time] Three consecutive times
+      # @param alt1, alt2, alt3 [Float] Corresponding altitudes
+      # @return [::Time] Time of maximum altitude
+      def quadratic_maximum(t1, t2, t3, alt1, alt2, alt3)
+        # Convert to float seconds for arithmetic
+        x1, x2, x3 = t1.to_f, t2.to_f, t3.to_f
+        y1, y2, y3 = alt1, alt2, alt3
+
+        # Quadratic interpolation formula
+        denom = (x1 - x2) * (x1 - x3) * (x2 - x3)
+        a = (x3 * (y2 - y1) + x2 * (y1 - y3) + x1 * (y3 - y2)) / denom
+        b = (x3 * x3 * (y1 - y2) +
+          x2 * x2 * (y3 - y1) +
+          x1 * x1 * (y2 - y3)) / denom
+
+        # Maximum is at -b/2a
+        max_t = -b / (2 * a)
+
+        ::Time.at(max_t)
+      end
 
-          raise IncompatibleArgumentsError,
-            "Only 3 or 5 terms are supported for interpolation"
+      # Linear interpolation between two points
+      # @param x1 [Numeric] First x value
+      # @param x2 [Numeric] Second x value
+      # @param y1 [Numeric] First y value
+      # @param y2 [Numeric] Second y value
+      # @param target_y [Numeric] Target y value (default: 0)
+      # @return [Numeric] Interpolated x value where y=target_y
+      def self.linear_interpolate(x1, x2, y1, y2, target_y = 0)
+        # Handle horizontal line case (avoid division by zero)
+        if (y2 - y1).abs < 1e-10
+          # If target_y matches the line's y-value (within precision), return
+          # midpoint. Otherwise, return one of the endpoints (no unique solution
+          # exists)
+          return ((target_y - y1).abs < 1e-10) ? (x1 + x2) / 2.0 : x1
         end
 
-        # Fixes angles forced to be in range [0, 360] or other angle range, for
-        # interpolation use
-        # @param angles [Array<Integer|Float>] Angles values
-        # @param full_circle [Integer] Full circle value
-        # @return [Array<Interger|Float>] Normalized values
-        def normalize_angles_for_interpolation(angles, full_circle: 360)
-          normalized = angles.dup
-
-          (1...normalized.size).each do |i|
-            prev_angle = normalized[i - 1]
-
-            while normalized[i] - prev_angle > full_circle / 2
-              normalized[i] -= full_circle
-            end
-            while normalized[i] - prev_angle < -full_circle / 2
-              normalized[i] += full_circle
-            end
-          end
-
-          normalized
+        # Handle vertical line case
+        if (x2 - x1).abs < 1e-10
+          # For a vertical line, there's only one x-value possible
+          return x1
         end
 
-        private
-
-        # @return [Float] Interpolated value
-        def interpolate_3_terms(terms, factor)
-          y1, y2, y3 = terms
-
-          a = y2 - y1
-          b = y3 - y2
-          c = b - a
+        # Standard linear interpolation formula
+        x1 + (target_y - y1) * (x2 - x1) / (y2 - y1)
+      end
 
-          y2 + (factor / 2.0) * (a + b + factor * c)
+      # Creates an array of evenly spaced values between start and stop.
+      # @param start [Numeric] The starting value of the sequence
+      # @param stop [Numeric] The end value of the sequence
+      # @param num [Integer] Number of samples to generate. Default is 50
+      # @param endpoint [Boolean] If true, stop is the last sample. Otherwise,
+      #   it is not included. Default is true
+      # @return [Array<Numeric>] Array of evenly spaced values
+      # @raise [ArgumentError] If num is less than 1
+      def linspace(start, stop, num = 50, endpoint = true)
+        raise ArgumentError, "Number of samples must be at least 1" if num < 1
+        return [start] if num == 1
+
+        step = if endpoint
+          (stop - start) / (num - 1).to_f
+        else
+          (stop - start) / num.to_f
         end
 
-        # @return [Float] Interpolated value
-        def interpolate_5_terms(terms, factor)
-          y1, y2, y3, y4, y5 = terms
-
-          a = y2 - y1
-          b = y3 - y2
-          c = y4 - y3
-          d = y5 - y4
-
-          e = b - a
-          f = c - b
-          g = d - c
+        result = Array.new(num)
+        current = start
 
-          h = f - e
-          j = g - f
-
-          k = j - h
-
-          y3 +
-            factor * ((b + c) / 2.0 - (h + j) / 12.0) +
-            factor**2 * (f / 2.0 - k / 24.0) +
-            factor**3 * (h + j) / 12.0 +
-            factor**4 * k / 24.0
+        (num - 1).times do |i|
+          result[i] = current
+          current += step
         end
+
+        result[num - 1] = endpoint ? stop : current
+        result
       end
     end
   end