astroscript 0.3.0

data/.rubocop.yml

@@ -0,0 +1,25 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+
+AllCops:
+  NewCops: enable
+
+Layout/SpaceBeforeBlockBraces:
+  EnforcedStyle: no_space
+
+Layout/SpaceInsideBlockBraces:
+  SpaceBeforeBlockParameters: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/CommentedKeyword:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.3.4

data/ARCH.md

@@ -0,0 +1,13 @@
+# Architecture notes:
+
+Chart
+- date time place
+- has array of bodies
+- has array of aspects
+- has array of formations
+
+BiChart
+- @natal Chart
+- @transit Chart
+- .bodies
+  - array of all bodies in both charts

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-11-13
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 David Löwenfels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.warning = false
+end
+
+task default: :test

data/exe/astroscript

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "astroscript"

data/lib/astro_helper.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "geocoder"
+require "tzinfo"
+require "json"
+
+module AstroHelper
+  module_function
+
+  PLANETS = %i[SO MO ME VE MA JU SA UR NE PL].freeze
+  EXTRAS = %i[AC MC NN CH VX].freeze
+  URANIAN = %i[CU HA ZE KR AN AD VU PO].freeze
+  ASTEROIDS = %i[CE PA JU VA].freeze
+  LOTS = %i[POF POS POH].freeze
+
+  LUNAR_PHASES = %i[new crescent first_quarter gibbous full disseminating last_quarter balsamic].freeze
+  PHASE_GLYPHS = %w[🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘].freeze # northern hemisphere
+
+  def print_symbol(x)
+    mp = x.to_s.split("/")
+    if mp.size > 1
+      mp.each{|p| print_symbol(p) }.join("/")
+    else
+      SwissEphemeris::BODIES[x.to_sym][:symbol]
+    end
+  end
+
+  def symbolize(s)
+    s.to_s.delete(" ").sub(".", "_").downcase.to_sym
+  end
+
+  def titleize(str)
+    str = str.to_s
+    str.split("_").map(&:capitalize).join(" ").gsub("Of", "of")
+  end
+
+  def init_calc(calc, *args)
+    case args.size
+    when 1
+      ary = args.first.dup
+      tz = ary.shift
+      tz = tz["name"] if tz.respond_to?(:[])
+      tz = tz.name if tz.respond_to?(:name)
+      calc.tz = tz
+      time = ary.shift
+      if time.respond_to?(:jd)
+        time = time.jd
+      else
+        time = datetime_to_jd(time) unless time.is_a?(Numeric)
+      end
+      calc.jd = time
+      calc.set_topo(*ary[0...3])
+      calc.datetime = DateTime.now if calc.jd.zero?
+      calc
+    else
+      year, month, day, hour, minute, location, name = *args
+      second = ((minute - minute.floor) * 60).round
+      minute = minute.floor
+      results = Geocoder.search(location)
+      calc.set_topo(results.first.latitude, results.first.longitude)
+      tz = results.first.send(:properties)["timezone"]
+      calc.tz = tz["name"]
+      calc.datetime = TZInfo::Timezone.get(tz["name"]).local_time(year, month, day, hour, minute, second, 10/600r).utc
+      calc.to_a + [location, name]
+    end
+  end
+
+  def dms(degree, zodiac = true)
+    d = degree.abs.floor
+    m = (degree.abs - d) * 60.0
+    if m.round == 60
+      m = 0
+      d += 1
+    end
+    s = (m - m.floor) * 60.0
+    if s.round == 60
+      s = 0
+      m += 1
+    end
+    d %= 30 if zodiac
+    [d, m, s]
+  end
+
+  def dms_to_deg(d, m, s)
+    d + (m * 60) + (s * 3600)
+  end
+
+  def print_dms(deg, opts = {})
+    if opts[:flavor] == :astrolog
+      opts[:zodiac] = true
+      opts[:glyph] = false
+      opts[:minutes] = ""
+    end
+    opts[:glyph] = true if opts[:glyph].nil?
+    d = deg.to_f
+    neg = d.negative?
+    d, m, s = dms(d, false)
+    if opts[:zodiac]
+      sign, d = d.divmod(30)
+      opts[:separator] = opts[:glyph] ? SwissEphemeris::ZODIAC_SYM[sign] : SwissEphemeris::SIGNS[sign][0...3].capitalize
+    end
+    opts[:separator] ||= "°"
+    if opts[:latitude] || opts[:longitude]
+      opts[:seconds] ||= false
+      opts[:separator] = neg ? "S" : "N" if opts[:latitude]
+      opts[:separator] = neg ? "E" : "W" if opts[:longitude]
+      opts[:separator] = "º#{opts[:separator]}" if opts[:degree]
+      neg = false
+      d = d.abs
+      output = if opts[:seconds] == false
+                 format("%02d%s%02d'", d, opts[:separator], m.round)
+               else
+                 format("%02d%s%02d'%02d\"", d, opts[:separator], m.floor, s.round)
+               end
+    elsif opts[:full]
+      output = format("%2d#{opts[:separator]}%2d'%7.4f", d, m.floor, s)
+    elsif opts[:seconds] || (d.zero? && m.floor.zero? && !s.round.zero?)
+      output = format("%02d#{opts[:separator]}%02d'%02d\"", d, m.floor, s.round)
+    else # default to rounded minutes
+      opts[:minutes] ||= "'"
+      output = format("%02d#{opts[:separator]}%02d#{opts[:minutes]}", d, m.round)
+    end
+    if neg
+      output = if output[0] == " "
+                 "-#{output[1..]}"
+               else
+                 "-#{output}"
+               end
+    elsif opts[:plus]
+      output = if output[0] == " "
+                 "+#{output[1..]}"
+               else
+                 "+#{output}"
+               end
+    end
+    output
+  end
+
+  def sign_to_str(sign, kind = :full)
+    output = sign.capitalize
+    case kind
+    when :glyph
+      SwissEphemeris::ZODIAC_SYM[sign_to_i(sign)]
+    when :short
+      output[0...3]
+    else
+      output
+    end
+  end
+
+  def deg_to_sign(deg)
+    SwissEphemeris::SIGNS[((deg % 360) / 30).floor]
+  end
+
+  def deg_to_gate(deg)
+    gate, line, * = HumanDesign.deg_to_gate(deg)
+    format("%2d.%1d%1s", gate, line, print_hexagram(gate))
+  end
+
+  def deg_to_s(angle, opts = {})
+    opts = opts.dup
+    opts = { padding: 12, tabs: true, angle: true, glyph: false, prefix: false, seconds: false, gate: false,
+             base: false, house: false, spectrum: false }.merge!(opts)
+    degree, minute, seconds = dms(angle, true)
+    sign = deg_to_sign(angle)
+    output = ""
+    if opts[:angle]
+      if opts[:glyph]
+        # output += sprintf("%s %2dº%2d'", sign_to_str(sign, :glyph), degree, minute.round)
+        output += format("%02d%s%02d", degree, sign_to_str(sign, :glyph), minute.round)
+      else
+        output += format("%2dº %s ", degree, sign_to_str(sign, :short))
+        output += opts[:seconds] ? format("%2d'%2d", minute.floor, seconds.round) : format("%2d'", minute.round)
+      end
+    end
+    output = format("%#{opts[:padding]}s %s", opts[:prefix], output) if opts[:prefix]
+    output += opts[:postfix].to_s if opts[:postfix]
+
+    if (val = opts[:gate] || opts[:spectrum])
+      if val.is_a?(Numeric) # adjust for ayanamsha
+        angle = (angle + val) % 360
+        # $logger.debug("adjusting ayanamsha by #{val}")
+      end
+      gate, line, color, tone, base = HumanDesign.deg_to_gate(angle)
+      if opts[:gate]
+        output += format(" %1s %2d.%1d", print_hexagram(gate), gate, line)
+        output += ".#{color}.#{tone}.#{base}" if opts[:base]
+      end
+      output += " (#{GeneKeys.gate_spectrum(gate)})" if opts[:spectrum]
+    end
+    output = output.gsub("\t", " ") unless opts[:tabs]
+    output.strip if opts[:strip]
+    output
+  end
+
+  def get_timezone_from_latlon(latitude, longitude)
+    response = HTTParty.get("https://api.geoapify.com/v1/geocode/reverse?lat=#{latitude}&lon=#{longitude}&format=json&apiKey=#{API_KEY}")
+    return JSON.parse(response.body)["results"].first["timezone"] if response.success?
+
+    puts "Request failed: #{response.code}"
+  end
+
+  def calculate_aspects(degree1, degree2, orb, max, min_orb = 0)
+    # Create an empty array to store the harmonics
+    harmonics = {}
+    delta = degree1 - degree2
+    # Iterate over the range of harmonics
+    (1..max).each do |harmonic|
+      # Calculate the difference based on the harmonic and default orb value
+      difference = delta * harmonic % 360
+      difference = 360 - difference if difference > 300
+      # Check if the difference is within the orb range
+      next unless difference <= orb && difference > min_orb
+
+      multiple = false
+      if harmonics.any?
+        first = harmonics.first[0]
+        multiple = if first > 1
+                     harmonic.gcd(first) > 1
+                   else
+                     (difference - (harmonics.first[1] * harmonic)) < 0.001
+                   end
+      end
+      # If the difference is within the orb range, add the harmonic to the array
+      harmonics[harmonic] = difference unless multiple
+    end
+    harmonics.transform_values{|v| v.round(3) }
+  end
+
+  def calc_all_aspects(planets, opts = {})
+    return if planets.size < 2
+
+    p1 = planets.pop
+    # $logger.debug( "**** Aspects for #{p1.name}" )
+    # $logger.debug( "  with #{planets.map(&:abbr)}" )
+    planets.reverse.each do |p2|
+      aspects = p1.%(p2, opts)
+      next unless aspects.any?
+
+      $logger.debug(aspects.map(&:to_s))
+      @aspects += aspects
+      # @aspects << [p1.to_sym, p2.to_sym, aspects.inject({}){|m,e| m.merge(e.to_a.last) } ]
+    end
+    calc_all_aspects(planets, opts)
+  end
+
+  def clear_aspects!
+    @aspects = nil
+  end
+
+  def aspects(planets, _opts = {})
+    opts = { clear_cache: true }.merge!(_opts)
+    if @aspects.nil? || opts[:clear_cache]
+      @aspects = []
+      # $logger.debug "Aspects: opts = #{opts.inspect}"
+      calc_all_aspects(planets.reverse, opts)
+    end
+    [%i[NN SN], %i[MC IC], %i[VX AV], %i[AC DC]].each do |anti|
+      @aspects.reject!{|a| (a.bodies.map(&:abbr) & anti) == anti }
+    end
+    # $logger.debug("DONE! (#{@aspects.count})")
+    @aspects
+  end
+
+  def print_hexagram(idx)
+    (0x4DC0 + idx - 1).to_s(16).to_i(16).chr("UTF-8")
+  end
+
+  def digital_root(num, max = 9)
+    num = num.to_s.chars.map(&:to_i).inject(:+) until num <= max
+    num
+  end
+
+  HOUSE_THEMES = %w[self possessions communication home creativity/pleasure health/service partnerships
+                    sex/death/rebirth philosophy/travel career friendships dissolution/karma].unshift(nil)
+  def print_houses(calc, calc_method = nil)
+    output = calc.house_cusps(calc_method).map.with_index do |deg, i|
+      i += 1
+      prefix = format("%-31s", "House #{SwissEphemeris::HOUSES[i]} (#{HOUSE_THEMES[i]}):")
+      ruler = calc.get_body(degree_rulership(deg))
+      tone = ruler.house - i + 1
+      tone += 12 if tone.negative?
+      postfix = " [Lord #{ruler.symbol} in #{format('%3s:%-2s', SwissEphemeris::HOUSES[ruler.house], tone)}] "
+      AstroHelper.deg_to_s(deg, gate: calc.ayanamsha, prefix: prefix, spectrum: true, postfix: postfix)
+    end
+    puts output
+  end
+
+  def name_to_sym(name)
+    name.to_s.delete(" ").sub(".", "_").downcase.to_sym
+  end
+
+  SYMBOLS = { # http://en.wikipedia.org/wiki/Astrological_symbols
+    sun: ["\u2609", "SO"], # "☉"
+    earth: ["\u2295", "EA"], # "⊕"
+    # :earth      => ["\u2641", 'EA'], #"♁"
+    moon: ["\u263d", "MO"], # "☾"
+    mercury: ["\u263f", "ME"], # "☿"
+    venus: ["\u2640", "VE"], # "♀"
+    mars: ["\u2642", "MA"], # "♂"
+    jupiter: ["\u2643", "JU"], # "♃"
+    saturn: ["\u2644", "SA"], # "♄"
+    uranus: ["\u2645", "UR"], # "♅"
+    neptune: ["\u2646", "NE"], # "♆"
+    pluto: ["\u2647", "PL"], # "♇"
+    n_node: ["\u260a", "NN"], # "☊"
+    s_node: ["\u260b", "SN"], # "☋"
+    chiron: ["\u26b7", "CH"],
+    ceres: %w[ʡ CE], # "ʡ"
+    pallas: ["\u26b4", "PA"],
+    juno: ["\u26b5", "JN"],
+    vesta: ["\u26b6", "VA"],
+    ascendant: %w[AC AC],
+    descendant: %w[DC DC],
+    midheaven: %w[MC MC],
+    nadir: %w[IC IC],
+    aries: ["♈", "AP"],
+    vertex: ["🜊", "VX"], # TODO: "We surmise that it is possible to introduce another 10 points, complementing the Vertex or Antivertex to a 12-fold division along the prime vertical" # https://web.archive.org/web/20150926042925/http://www.levante.org/svarogich/en/principia_en/part01.html
+    av: ["A🜊", "AV"],
+    retrograde: "\u211e", # "℞",
+    zodiac: ("\u2648".."\u2653").to_a # %w[♈ ♉ ♊ ♋ ♌ ♍ ♎ ♏ ♐ ♑ ♒ ♓ ]
+  }.freeze
+
+  def zodiac_symbol(sign)
+    SYMBOLS[:zodiac][sign_to_i(sign)]
+  end
+
+  def symbol(key)
+    SYMBOLS[key].first
+  end
+
+  def abbr(key)
+    SYMBOLS[key].last.to_sym
+  end
+
+  def abbr_to_key(abbr)
+    SYMBOLS.find{|_k, v| v.last == abbr.to_s }.first
+  end
+
+  # this should work for a calc or a chart
+  def converse(calc, natal_calc)
+    diff = (natal_calc.jd - calc.jd).abs
+    output = calc.dup
+    output.jd = natal_calc.jd - diff
+    output.recalc!
+    output
+  end
+
+  def datetime_to_jd(time = DateTime.now)
+    time = time.utc.to_datetime if time.is_a?(ActiveSupport::TimeWithZone)
+    Swe4r.swe_julday(time.year, time.month, time.day, time.hour + (time.min / 60.0) + (0.1 / 3600.0))
+  end
+
+  def transits(location, t = DateTime.now, **opts)
+    calc = Astroscript::Calculator.new(opts)
+    date = [t.year, t.month, t.day, t.hour, t.min]
+    calc.init(*date, location)
+  end
+end

data/lib/astroscript/aspect.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class Aspect
+    attr_reader :orb, :aspect, :bodies, :phase
+
+    extend Forwardable
+    def_delegators :@aspect, :numerator, :denominator
+    def_delegators :denominator, :hph
+
+    FLAVORS = {
+      1r => "conjunct", 1/2r => "opposite", 1/4r => "square",
+      1/8r => "octile", 3/8r => "trioctile",
+      1/3r => "trine", 1/6r => "sextile", # 1/9r => 'novile',
+      1/12r => "semisextile", 5/12r => "quincunx",
+      1/5r => "quintile", 2/5r => "biquintile"
+      # 1/7r => 'septile', 2/7r => 'biseptile', 3/7r => 'triseptile'
+      # 1/10r => 'decile', 1/11r => 'undecile',
+    }.freeze
+
+    FLAVORS.each do |r, flavor|
+      define_method "#{flavor}?" do
+        aspect == r
+      end
+    end
+
+    def initialize(b1, b2, opts = {})
+      opts[:max_harmonic] ||= 12
+      opts[:harmonic_orb] ||= 16.0
+      if opts[:ratio] # isolate flavor, e.g. 5/12
+        opts[:harmonic] = opts[:ratio].denominator
+        opts[:numerator] = opts[:ratio].numerator
+      end
+      @bodies = [b1, b2]
+      sort!
+      @phase = @bodies.map(&:lon).diff.first.abs
+
+      ary = if (h = opts[:harmonic]) # isolate single flavor
+              [h]
+            else
+              1..opts[:max_harmonic]
+            end
+
+      ary.each do |harmonic|
+        mod = 360
+        orb = (@phase * harmonic) % mod
+        orb = mod - orb if orb > mod / 2 # this is the "flip" for oppositions
+
+        # check for conjunction in nth harmonic "flavor"
+        next unless orb <= (opts[:orb] || opts[:harmonic_orb])
+
+        if harmonic == 1
+          @aspect = 1r # 1/1 = conjunction
+        else
+          num = (@phase.abs * harmonic / mod).round
+          num = harmonic - num if num > harmonic / 2 # flip e.g. 7/12 to 5/12
+          @aspect = Rational(num, harmonic)
+        end
+        @orb = orb / harmonic
+        isolated_harmonic = opts[:harmonic] && @aspect.denominator != opts[:harmonic]
+        isolated_numerator = opts[:numerator] && @aspect.numerator != opts[:numerator]
+        return self unless isolated_harmonic || isolated_numerator
+      end
+      @aspect = 0r
+      @orb = nil
+    end
+
+    def ==(other)
+      bodies.map(&:abbr).sort == other.bodies.map(&:abbr).sort && phase == other.phase
+    end
+    alias eql? ==
+
+    def overlap?
+      abbrs = @bodies.map{|b| b.abbr.to_s.split("/").flatten }
+      (abbrs.first & abbrs.last).any?
+    end
+
+    def sort!
+      @bodies.sort_by!{|x| x.is_a?(Midpoint) ? x.bodies.first.speed_order.to_i : x.speed_order.to_i }
+      b1 = @bodies.first
+      b2 = @bodies.last
+      if b1.is_a?(Midpoint)
+        if b2.is_a?(Midpoint)
+          if b1.bodies.first == b2.bodies.first && b1.bodies.last.speed_order.to_i < (b2.bodies.last.speed_order.to_i)
+            @bodies.reverse!
+          end
+        else
+          @bodies.reverse!
+        end
+      end
+      @bodies.reverse! if @bodies.last.prefix
+      self
+    end
+
+    def applying?
+      return @applying if @applying
+
+      @orb1 = @bodies.map(&:degree).inject(:-).abs
+      body = @bodies.first
+      if body.is_a?(Midpoint)
+        body = @bodies.last
+        return nil if body.is_a?(Midpoint)
+      end
+      body.calc.jd += 1       # move forward
+      @bodies.each(&:calculate!)
+      @orb2 = @bodies.map(&:degree).inject(:-).abs
+      body.calc.jd -= 1       # put back
+      @bodies.each(&:calculate!)
+      return nil if @orb1 == @orb2
+
+      @applying = @orb1 > @orb2
+    end
+
+    def separating?
+      applying? # calculate stuff
+      return nil if @orb1 == @orb2
+
+      @orb1 < @orb2
+    end
+
+    def ratio
+      "#{numerator}/#{denominator}"
+    end
+
+    def valid?
+      !invalid?
+    end
+
+    def invalid?
+      numerator.zero? || !FLAVORS.keys.include?(aspect)
+    end
+
+    def to_a
+      @bodies.map(&:to_sym) << { harmonic => orb.round(3) }
+    end
+
+    def to_s(opts = {})
+      opts[:symbol] = true unless opts.key?(:symbol)
+      opts[:orb] = true unless opts.key?(:orb)
+      return "invalid: #{inspect}" unless valid?
+
+      flavor = FLAVORS[aspect]
+      flavor = SwissEphemeris::SYMBOLS[flavor.to_sym] if opts[:symbol]
+      output = "#{@bodies.first.handle} #{flavor} #{@bodies.last.handle}"
+      output += " [#{@orb.to_dms(separator: applying? ? 'a' : 's')}]" if opts[:orb]
+      output
+    end
+
+    def antiphase
+      -@phase % 360
+    end
+
+    def sum
+      [b1, b2].map{|b| b.send(@method) }.sum % 360
+    end
+
+    def direct_midpoint?
+      return unless midpoint?
+
+      @bodies.map(&:lon).diff.first.abs < 90
+    end
+
+    def midpoint?
+      @bodies.any?{|b| b.is_a?(Midpoint) }
+    end
+
+    def isotrap?
+      @bodies.all?{|b| b.is_a?(Midpoint) }
+    end
+
+    def opposite_midpoint?
+      !direct?
+    end
+
+    def midpoint_aspect
+      return unless midpoint?
+
+      direct_midpoint? ? SwissEphemeris::SYMBOLS[:conjunct] : SwissEphemeris::SYMBOLS[:opposite]
+    end
+
+    def print_midpoint
+      return unless midpoint?
+
+      movement = applying? ? "a" : "s"
+      "#{@bodies.map(&:symbol).join(" #{midpoint_aspect} ")}\t[#{AstroHelper.print_dms(orb)}#{movement}]"
+    end
+  end
+end

data/lib/astroscript/body/const_body.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class ConstBody < Body
+    attr_accessor :symbol, :name, :lon
+    alias degree lon
+    def initialize(deg, name, symbol = nil, abbr = nil)
+      @lon = deg
+      @name = name
+      @harmonic = 1
+      @abbr = abbr || name[0..1].upcase.to_sym
+      @symbol = symbol || @abbr
+      @calc = NullCalc.new(@lon)
+    end
+
+    def to_sym
+      @abbr
+    end
+
+    def calculate!
+      nil
+    end
+
+    class NullCalc # Silently ignores any method call
+      def initialize(lon)
+        @lon = lon
+      end
+
+      def get_body **_args
+        @lon
+      end
+
+      def method_missing(method_name, *_args)
+        case method_name
+        when %i[to_f]
+          0.0
+        when %i[to_i + - / * %]
+          0
+        when :prefix
+          ""
+        else
+          self
+        end
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+
+      def coerce(_other)
+        [0, 0] # or [other, 0] depending on your needs
+      end
+    end
+  end
+end