astroscript 0.3.0

data/lib/astroscript/body/house_cusp.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class HouseCusp < Body
+    attr_reader :house
+
+    def initialize(house, calc)
+      @house = house
+      @abbr = :"c#{@house}"
+      super(@abbr, calc)
+    end
+
+    def calculate!
+      @lon = calc.house_cusps[@house - 1]
+      update!
+      @lon = calc.flip(@lon) if antipode
+      self
+    end
+
+    def symbol
+      @symbol = "C#{house}"
+    end
+
+    def name
+      "House Cusp #{numeral}"
+    end
+
+    private
+
+    def numeral
+      HOUSES[@house]
+    end
+  end
+end

data/lib/astroscript/body/method_body.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class MethodBody < Body
+    attr_accessor :symbol, :name, :chart
+
+    def initialize(deg, name, symbol = nil, _abbr = nil, chart:)
+      @lon = deg
+      @name = name
+      @chart = chart
+      @calc = chart.calc
+      @harmonic = 1
+      body = SwissEphemeris::BODIES.select{|_k, v| v[:name] == name }
+      if body.empty?
+        $logger.warn "Unknown body: #{name}"
+      else
+        @abbr = body.keys.first
+        @symbol = body[@abbr][:symbol] || symbol
+      end
+      update!
+    end
+
+    def calculate! # name should equal method
+      @lon = @chart.send name
+    end
+  end
+end

data/lib/astroscript/body/midpoint.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class Midpoint < Body
+    attr_reader :bodies
+
+    def initialize(b1, b2, opts = {})
+      @harmonic = opts[:harmonic] || 1
+      @bodies = [b1, b2]
+      @name = abbr.sub(operator, "_")
+      @symbol = @bodies.map(&:symbol).join(operator)
+      @lon = @bodies.map(&:lon).avg
+      if ((@lon - b1.lon).abs % 360) > 90
+        @lon = (@lon + 180) % 360 # flip!
+      end
+      update!
+    end
+
+    def calculate!
+      bodies.each(&:calculate!)
+    end
+
+    def abbr
+      bodies.map(&:abbr).join(operator)
+    end
+
+    def symbol
+      bodies.map(&:symbol).join(operator)
+    end
+
+    def to_sym
+      abbr.to_sym
+    end
+
+    def inspect
+      return super unless defined?(IRB)
+
+      "#{bodies.first.abbr}/#{bodies.last.abbr}\t#{AstroHelper.deg_to_s(lon)}"
+    end
+
+    protected
+
+    def operator
+      "/"
+    end
+  end
+end

data/lib/astroscript/body.rb

@@ -0,0 +1,495 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class Body
+    attr_reader :abbr, :lat, :distance, :velocity, :decl, :ra, :azimuth, :altitude, :calc, :harmonic, :hlat, :hlon,
+                :hdist, :hvel
+    attr_accessor :antipode
+
+    def initialize(abbr, calc)
+      @abbr = abbr
+      @calc = calc
+      @abbr = @abbr.upcase if @abbr.size == 2
+      @harmonic = 1
+      calculate!
+    end
+
+    def inspect
+      return super unless defined?(IRB)
+
+      "#{abbr}\t#{AstroHelper.deg_to_s(lon)}"
+    end
+
+    def radix
+      harmonize(1)
+    end
+
+    def ==(other)
+      lon == other.lon
+    end
+
+    def self.phase(b1, b2, opts = {})
+      opts[:method] ||= :lon
+      # $logger.debug("#{b1}, #{b2} #{opts[:method]}")
+      bb1 = b1.send(opts[:method])
+      bb2 = b2.send(opts[:method])
+      (bb2 - bb1) % 360
+      # if b1.speed_order > b2.speed_order
+      #   (bb2-bb1)%360
+      # else
+      #   (bb1-bb2)%360
+      # end
+      # rescue => e
+      #   raise e, "#{b1.abbr} - #{b2.abbr} => #{opts[:method]} == nil!"
+    end
+
+    def transit?
+      @transit
+    end
+
+    def transit!
+      @transit = true
+    end
+
+    def flip
+      @lon += 180
+      @lon % 360
+    end
+
+    def flip!
+      self.antipode = !antipode
+      calculate!
+    end
+
+    def lon
+      output = @lon # @calc.in_mundo? ? prime_degree : @lon
+      output *= @harmonic
+      output %= 360
+      output += @calc.arc if @calc
+      # TODO: make harmonic charts a calc transformer?
+      if (t = calc&.transformer)
+        t.call(self, output)
+      else
+        output
+      end
+    end
+
+    alias degree lon
+    alias to_f lon
+
+    def to_dms(opts = {})
+      lon.to_dms(opts)
+    end
+
+    def prefix
+      @calc&.prefix
+    end
+
+    def handle
+      "#{prefix}#{abbr}"
+    end
+
+    def name
+      return unless (body = SwissEphemeris::BODIES[abbr])
+
+      body[:name].capitalize
+    end
+
+    def symbol
+      return unless (body = SwissEphemeris::BODIES[abbr])
+
+      body[:symbol]
+    end
+
+    def calculate!
+      # $logger.debug "calculating #{abbr}"
+      if @abbr == :SVP
+        @lon = -@calc.ayanamsha
+        @lat = 0
+        @distance = nil
+        @velocity = 0
+      end
+      raise ArgumentError, "unknown Body #{@abbr}!" unless (body = SwissEphemeris::BODIES[@abbr])
+
+      if (id = body[:id])
+        results = @calc.calc(id)
+        @lon, @lat, @distance, @velocity = results[0..4]
+        results = @calc.calc(id, equatorial: true)
+        # right ascension and declination
+        @ra, @decl = results[0..2]
+        @azimuth, @altitude, * = Swe4r.swe_azalt(calc.jd, Swe4r::SE_ECL2HOR, calc.longitude, calc.latitude,
+                                                 calc.altitude, 1013.25, 15.0, @lon + calc.ayanamsha, @lat.to_f, @distance.to_f)
+        @azimuth = (@azimuth + 180) % 360 # adjusts to measure clockwise from north
+        # heliocentric
+        id = Swe4r::SE_EARTH if abbr == :EA
+        results = @calc.calc(id, heliocentric: true)
+        @hlon, @hlat, @hdist, @hvel = results[0..4]
+      else # virtual body - angles and nodes
+        method = if (a = body[:antipode])
+                   SwissEphemeris::BODIES[a][:name]
+                 else
+                   body[:name]
+                 end
+        @calc.get_houses
+        method = AstroHelper.symbolize(method)
+        # $logger.debug "sending #{method} to @calc"
+        if %i[NN SN].include?(@abbr)
+          node = @calc.true_node? ? Swe4r::SE_TRUE_NODE : Swe4r::SE_MEAN_NODE
+          @lon, @lat, @distance, @velocity = @calc.calc(node)
+          # @lon = calc.flip(@lon) if @abbr == :SN # TODO flip after harmonic
+        else
+          @lon = @calc.send(method)
+        end
+        # TODO: get values from sun at this degree
+      end
+      @lon = calc.flip(@lon) if body[:antipode] || antipode
+      update!
+    end
+
+    # https://www.timeanddate.com/astronomy/planets/distance
+
+    # According to BPHS the victor is the Graha who is further north.
+    # Surya Siddhanta adds that the brighter will win even if in the south.
+    # By brighter is meant an unusually brighter planet. To determine this we need to know the natural
+    # order of brightness from least bright to most bright which is:
+    # Saturn, Mars, Mercury, Jupiter, Venus. On very rare occasions when a planet in its oval shaped
+    # revolution is much closer to Earth and the other much further away, one planet can gain a lot of
+    # brightness while the other loses brightness. On these occasions a planet that is normally darker
+    # than another may appear brighter – in which case it wins the war. To determine the victor in a war,
+    # therefore, requires first that elaborate calculations are done based on the diameter of the planet
+    # and its proximity to Earth in order to determine the brightness. If the brightness of the two
+    # planets follows the regular order, then the Graha with the most northern declination wins the war.
+    # If, on the other hand, the planet that is regularly less bright is brighter, than it wins the war
+    # and no check for most northern position need be made. Venus, regardless, always wins the war, due
+    # to her much greater brilliance she is considered to never be defeated.
+    # https://astrology-videos.com/CourseMaterials/PlanetaryWar.pdf
+    def prime_degree
+      # lon, decl = Swe4r::swe_cotrans( 90, @azimuth+calc.ayanamsha, @altitude)
+      (Swe4r.swe_house_pos(calc.ramc, calc.latitude, calc.oe, "C".ord, @lon + calc.ayanamsha, @lat.to_f) * 30) - 30
+    end
+    alias pvl prime_degree
+
+    def meridian_degree # longitude
+      azimuth, altitude, * = Swe4r.swe_azalt(calc.jd, Swe4r::SE_ECL2HOR, calc.longitude, calc.latitude, calc.altitude,
+                                             0, 0, @lon, @lat.to_f, @distance.to_f)
+      azimuth = (azimuth + 90) % 360
+      lon, decl, * = Swe4r.swe_cotrans(90, azimuth, altitude)
+      output = [((lon + 180) % 360).round(4), decl.round(4)]
+      output[0]
+    end
+
+    # def /(body)
+    #   Midpoint.new(self, body)
+    # end
+
+    ORBS = { tight: 2.0, close: 6.0, max: 12.0 }.freeze # Hamblin
+    # ORBS = {tight: 2.0, close: 4.0, max: 16.0} # Cochrane
+
+    def sign_i
+      sign
+    end
+
+    def sign
+      (lon / 30).floor
+    end
+
+    def sign_sym
+      SwissEphemeris::SIGNS[sign]
+    end
+
+    def to_s(_opts = {})
+      opts = { angle: true, symbol: true }.merge!(_opts)
+      postfix = " "
+      if opts[:angle]
+        postfix = "r" if retrograde?
+        postfix = "s" if stationary?
+        dignity = nil
+        # dignity = SYMBOLS[:exalted] if in_exaltation? # TODO
+        # dignity = SYMBOLS[:detriment] if in_detriment?
+      end
+      if opts[:symbol]
+        opts[:prefix] = format("%4s", symbol) if opts[:symbol]
+        opts[:padding] = 2
+      end
+      opts[:prefix] = "#{opts[:symbol] ? symbol : name}#{dignity}" if opts[:prefix]
+      if opts[:house]
+        opts[:postfix] = "#{postfix} #{format('%-5s', HOUSES[house])}"
+        opts[:postfix] += " (#{AstroHelper::HOUSE_THEMES[house]})" if opts[:theme]
+      end
+      AstroHelper.deg_to_s(lon, { postfix: postfix }.merge!(opts)) # .strip
+    end
+
+    def gate
+      AstroHelper.deg_to_gate(lon)
+    end
+
+    def print(opts = {})
+      puts to_s({ prefix: true, gate: true, spectrum: true, house: true, theme: true, symbol: true }.merge(opts))
+    end
+
+    def distance_to_sun
+      SwissEphemeris::BODIES.keys.index(abbr) || -1
+    end
+
+    # this assumes the that BODIES hash is defined in proper order
+    def closer_to_sun?(b2)
+      i1 = distance_to_sun
+      i2 = b2.distance_to_sun
+      i1 && i2 && i1 < i2
+    end
+
+    ANGLES = %i[AC MC DC IC VX POF POS POH].freeze
+    def is_angle?
+      ANGLES.include?(abbr)
+    end
+
+    def personal_angle?
+      (ANGLES + %i[VX POF POS POH]).include?(abbr)
+    end
+
+    def speed_order
+      a = abbr
+      a = :NN if %i[MN SN].include?(a)
+      return -1 * ANGLES.reverse.index(a) if is_angle?
+
+      # https://groups.io/g/SpiritusMundi/topic/speed_of_ascendant_and/83787680
+      SPEED_ORDER.index(a)
+    end
+
+    #################
+    ### RULERSHIP ###
+    #################
+
+    def ruler(chart = nil)
+      ruler = RULERSHIPS.find{|_k, v| v.include? sign_sym }.first
+      if chart
+        chart.get_body(ruler)
+      else
+        ruler
+      end
+    end
+    alias dispositor ruler
+
+    def in_domicile?
+      RULERSHIPS[abbr].include?(sign_sym)
+    rescue NoMethodError
+      false
+    end
+
+    def in_fall? # opposite to rulership
+      RULERSHIPS[abbr].include?(rotate_sign(6))
+    rescue NoMethodError
+      false
+    end
+
+    def in_exaltation?
+      EXALTATION[abbr].first == sign_sym
+    rescue NoMethodError
+      false
+    end
+
+    def in_detriment?
+      EXALTATION[abbr].first == rotate_sign(6)
+    rescue NoMethodError
+      false
+    end
+
+    def retrograde?
+      @velocity&.negative?
+    end
+
+    # RETROGRADE = { # days
+    #   ME: 24, VE: 42, MA: 80, JU: 120, SA: 140, UR: 150, NE: 160, PL: 160, CE: 60
+    # }
+    STATIONARY_VELOCITY = { # seconds/day from https://www.astro.com/astrowiki/en/Stationary_Phase
+      ME: 300, VE: 180, MA: 90, JU: 60, SA: 60, UR: 20, NE: 10, PL: 10, CE: 7
+    }.freeze
+    MAX_VELOCITY = { # in minutes from https://en.wikipedia.org/wiki/Planets_in_astrology
+      ME: (2 * 60) + 25, VE: (1 * 60) + 25, MA: 52, CE: 30, JU: 14 + (40 / 60.0), SA: 8 + (48 / 60.0),
+      UR: 4, NE: 2 + (25 / 60.0), PL: 2 + (30 / 60.0), PA: 40 + (30 / 60.0), JN: 39, VA: 36, CH: 10
+    }.freeze
+    AVG_VELOCITY = { # in minutes
+      SO: 59 + (8 / 60.0), MO: (13 * 60) + 11 + (36 / 60.0), ME: (1 * 60) + 23, VE: (1 * 60) + 12, MA: 31 + (27 / 60.0), CE: 12 + (40 / 60.0),
+      JU: 4 + (59 / 60.0), SA: 2 + (1 / 60.0), UR: 42 / 60.0, NE: 24 / 60.0, PL: 15 / 60.0, CH: 2,
+      PA: 12 + (20 / 60.0), JN: 14 + (15 / 60.0), VA: 16 + (15 / 60.0), SD: 0.289, ER: 6.307,
+      NN: 3.177
+    }.freeze
+    SPEED_ORDER = AVG_VELOCITY.sort_by{|_k, v| v }.reverse.map(&:first)
+
+    # Here is a snippet of the Python code I use for the speeds:
+    # # Adjust the speeds to be compatible with the old standalone version
+    # # of Haydn's Jyotish.  {    # Haydn Huntley haydn@hjyotish.com }
+    # daysPerEarthYear = 365.242199
+    # x = 360.0 / daysPerEarthYear ** 2
+    # self.speed[MOON]    *=     0.09706    # Magic constant.
+    # self.speed[MARS]    *=   686.971  * x # Orbital period in days,
+    # self.speed[JUPITER] *=  4332.59   * x # according to Wikipedia.
+    # self.speed[SATURN]  *= 10759.22   * x
+    # self.speed[URANUS]  *= 30799.095  * x
+    # self.speed[NEPTUNE] *= 60190.03   * x
+    # self.speed[PLUTO]   *= 89865.65   * x
+    # self.speed[RAHU]    *=  6585.3213 * x # Saros cycle in days.
+    # self.speed[KETU]    *=  6585.3213 * x
+
+    def stationary?
+      return nil unless (minutes = MAX_VELOCITY[abbr])
+
+      velocity.abs <= (0.05 * minutes / 60.0) # 5% of velocity in degrees/day
+    end
+
+    def relative_velocity
+      return nil unless (minutes = AVG_VELOCITY[abbr])
+
+      begin
+        velocity / (minutes / 60.0)
+      rescue StandardError
+        1.0
+      end
+    end
+
+    def house
+      @calc.which_house(lon)
+    end
+
+    def yin?
+      sign.odd?
+    end
+
+    def yang?
+      sign.even?
+    end
+
+    def modality
+      %i[c f m][sign % 3]
+    end
+
+    def element
+      %i[F E A W][sign % 4]
+    end
+
+    def element_sym
+      %w[🜂 🜃 🜁 🜄][sign % 4]
+    end
+
+    # qualities for interpretations
+    def feminine?
+      %i[MO VE NE].include?(abbr)
+    end
+
+    def masculine?
+      %i[SO MA JU UR PL].include?(abbr)
+    end
+
+    def outer?
+      %i[SA UR NE PL].include?(abbr)
+    end
+
+    def inner?
+      luminary? || %i[ME VE MA].include?(abbr)
+    end
+
+    def luminary?
+      %i[SO MO].include?(abbr)
+    end
+
+    def decan
+      ((to_f % 30) / 10).floor + 1
+    end
+
+    #######################
+    # Harmonic Divisions
+    #######################
+
+    def harmonic_sign(h) # always use 1st harmonic longitude
+      SwissEphemeris::SIGNS[varga_sign(h)]
+    end
+
+    def triple_harmonic_signs(h)
+      harmonic_signs(1, h, h * h)
+    end
+
+    def harmonic_signs *args
+      args.map{|h| harmonic_sign(h) }
+    end
+
+    def harmonize!(h)
+      @harmonic = h
+      calculate!
+      self
+    end
+
+    def harmonize(h)
+      dup.harmonize!(h)
+    end
+
+    def *(other)
+      harmonize(other)
+    end
+
+    def pentan
+      harmonic_sign(6)
+    end
+
+    def subpentan
+      harmonic_sign(36)
+    end
+
+    def duad
+      SwissEphemeris::SIGNS[(varga_sign(12) - sign) % 12]
+    end
+
+    def subduad # is this correct
+      SwissEphemeris::SIGNS[(varga_sign(144) - sign) % 12]
+    end
+
+    def navamsha
+      harmonic_sign(9)
+    end
+
+    def dwad
+      harmonic_sign(12)
+    end
+
+    def subdwad
+      harmonic_sign(144)
+    end
+
+    def sign_and_house
+      "#{sign_sym.capitalize} in #{house.ordinalize}"
+    end
+
+    def midpoint?
+      is_a?(Astroscript::Midpoint)
+    end
+
+    def to_json(*_args)
+      d, m, * = AstroHelper.dms(lon)
+      key = "#{name.downcase} in #{SwissEphemeris::SIGNS[sign]}"
+      {
+        house: house,
+        name: name,
+        sign_degrees: d,
+        sign_minutes: m.round,
+        sign_name: SwissEphemeris::SIGNS[sign],
+        total_angle: @lon.round(2),
+        description: key.titleize,
+        key: key
+      }
+    end
+
+    private
+
+    def update!
+      @sign, @degree = (@lon * @harmonic).divmod(360)
+      @degree, m, s = AstroHelper.dms(@degree)
+      @minute = m.round
+      @minute_ = m.floor
+      @seconds = s.round
+      self
+    end
+
+    def varga_sign(h)
+      (harmonized_degree(h) / 30).floor
+    end
+  end
+end