Refactor Angle as a single class

.github/workflows/main.yml

@@ -15,7 +15,9 @@ jobs:
     strategy:
       matrix:
         ruby:
-          - 3.1.4
+          - 3.2.0
+          - 3.2.1
+          - 3.2.2
           - 3.2.3
           - 3.3.0
     steps:

README.md

@@ -41,10 +41,10 @@ horizontal_coordinates = sun.horizontal_coordinates(
   longitude: longitude
 )
 
-horizontal_coordinates.altitude.value.to_f
-# => 27.50236513017543
+horizontal_coordinates.altitude.degrees.to_f
+# => 27.502365130176567
 
-horizontal_coordinates.altitude.to_dms.format
+horizontal_coordinates.altitude.str(:dms)
 # => "+27° 30′ 8.5144″"
 ```
 

astronoby.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "Ruby version of the calculations from various books like Celestial Calculations by J. L. Lawrence, Practical Astronomy with your Calculator or Spreadsheet by Peter Duffett-Smith and Jonathan Zwart, or Astronomical Algorithms by Jean Meeus"
   spec.homepage = "https://github.com/rhannequin/astronoby"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.4"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage

lib/astronoby.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 require "astronoby/angle"
-require "astronoby/angles/degree"
 require "astronoby/angles/dms"
 require "astronoby/angles/hms"
-require "astronoby/angles/hour"
-require "astronoby/angles/radian"
 require "astronoby/epoch"
 require "astronoby/body"
 require "astronoby/bodies/sun"

lib/astronoby/aberration.rb

@@ -22,27 +22,22 @@ def apply
       delta_longitude = Astronoby::Angle.as_degrees(
         -20.5 *
         Math.cos(
-          @sun_longitude.to_radians.value - @coordinates.longitude.to_radians.value
-        ) / Math.cos(@coordinates.latitude.to_radians.value) / 3600
+          @sun_longitude.radians - @coordinates.longitude.radians
+        ) / Math.cos(@coordinates.latitude.radians) / 3600
       )
 
       delta_latitude = Astronoby::Angle.as_degrees(
         -20.5 *
-        Math.sin(
-          @sun_longitude.to_radians.value -
-          @coordinates.longitude.to_radians.value
-        ) *
-        Math.sin(@coordinates.latitude.to_radians.value) / 3600
+        Math.sin(@sun_longitude.radians - @coordinates.longitude.radians) *
+        Math.sin(@coordinates.latitude.radians) / 3600
       )
 
       Astronoby::Coordinates::Ecliptic.new(
         latitude: Astronoby::Angle.as_degrees(
-          @coordinates.latitude.to_degrees.value +
-          delta_latitude.value
+          @coordinates.latitude.degrees + delta_latitude.degrees
         ),
         longitude: Astronoby::Angle.as_degrees(
-          @coordinates.longitude.to_degrees.value +
-          delta_longitude.value
+          @coordinates.longitude.degrees + delta_longitude.degrees
         )
       )
     end

lib/astronoby/angle.rb

@@ -4,57 +4,109 @@
 
 module Astronoby
   class Angle
-    UNITS = [
-      DEGREES = :degrees,
-      HOURS = :hours,
-      RADIANS = :radians
-    ].freeze
-
-    UNIT_CLASS_NAMES = {
-      DEGREES => "Astronoby::Degree",
-      HOURS => "Astronoby::Hour",
-      RADIANS => "Astronoby::Radian"
-    }
-
     PRECISION = 14
-    PI = BigMath.PI(10)
+    PI = BigMath.PI(PRECISION)
+    PI_IN_DEGREES = BigDecimal("180")
+
+    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)
+        new(radians)
+      end
+
+      def as_degrees(degrees)
+        radians = degrees / PI_IN_DEGREES * PI
+        new(radians)
+      end
+
+      def as_hours(hours)
+        radians = hours * RADIAN_PER_HOUR
+        new(radians)
       end
 
       def as_hms(hour, minute, second)
-        angle = hour + minute / 60.0 + second / 3600.0
-        Kernel.const_get(UNIT_CLASS_NAMES[HOURS]).new(angle)
+        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
-        angle = degree.abs + minute / 60.0 + second / 3600.0
-        Kernel.const_get(UNIT_CLASS_NAMES[DEGREES]).new(sign * angle)
+        degrees = degree.abs + minute / MINUTES_PER_HOUR + second / SECONDS_PER_HOUR
+        as_degrees(sign * degrees)
       end
     end
 
-    UNITS.each do |unit|
-      define_method("to_#{unit}") do
-        raise NotImplementedError, "#{self.class} must implement #to_#{unit} method."
+    def radians
+      @angle
+    end
+
+    def degrees
+      @angle * PI_IN_DEGREES / PI
+    end
+
+    def hours
+      @angle / RADIAN_PER_HOUR
+    end
+
+    def initialize(angle)
+      @angle = if angle.is_a?(Integer) || angle.is_a?(BigDecimal)
+        BigDecimal(angle)
+      else
+        BigDecimal(angle, PRECISION)
       end
     end
 
-    def initialize(angle, unit:)
-      @angle = BigDecimal(angle, PRECISION).ceil(PRECISION)
-      @unit = unit
+    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 value
-      @angle
+    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 ==(other)
-      value == other.value && self.class == other.class
+    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

lib/astronoby/bodies/sun.rb

@@ -14,9 +14,9 @@ def initialize(epoch:)
 
     def ecliptic_coordinates
       Coordinates::Ecliptic.new(
-        latitude: Angle.as_degrees(0),
+        latitude: Angle.zero,
         longitude: Angle.as_degrees(
-          (true_anomaly.value + longitude_at_perigee.to_degrees.value) % 360
+          (true_anomaly.degrees + longitude_at_perigee.degrees) % 360
         )
       )
     end
@@ -33,29 +33,24 @@ def horizontal_coordinates(latitude:, longitude:)
 
     def mean_anomaly
       Angle.as_degrees(
-        (
-          longitude_at_base_epoch.to_degrees.value -
-          longitude_at_perigee.to_degrees.value
-        ) % 360
+        (longitude_at_base_epoch.degrees - longitude_at_perigee.degrees) % 360
       )
     end
 
     def true_anomaly
       eccentric_anomaly = Astronoby::Util::Astrodynamics.eccentric_anomaly_newton_raphson(
         mean_anomaly,
-        orbital_eccentricity.to_degrees.value,
+        orbital_eccentricity.degrees,
         2e-06,
         10
       )
 
       tan = Math.sqrt(
-        (1 + orbital_eccentricity.to_degrees.value)./(
-          1 - orbital_eccentricity.to_degrees.value
-        )
-      ) * Math.tan(eccentric_anomaly.to_radians.value / 2)
+        (1 + orbital_eccentricity.degrees) / (1 - orbital_eccentricity.degrees)
+      ) * Math.tan(eccentric_anomaly.radians / 2)
 
       Astronoby::Angle.as_degrees(
-        (Astronoby::Angle.as_radians(Math.atan(tan)).to_degrees.value * 2) % 360
+        (Astronoby::Angle.as_radians(Math.atan(tan)).degrees * 2) % 360
       )
     end