astroscript 0.3.0

data/lib/astroscript/calculator.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class Calculator
+    attr_accessor :name, :latitude, :longitude, :altitude, :jd, :house_method, :tz, :arc, :prefix
+    attr_reader :flags, :asc, :mc, :vertex, :transformer, :equasc
+
+    def initialize *args
+      @arc = 0
+      params = args.last.is_a?(Hash) ? args.pop : {}
+      init_params(params)
+      # defaults
+      set_topo(51.476852, -0.000500) # Royal Observatory Greenwich, London, UK
+      self.datetime = DateTime.now.new_offset # Time.now.utc
+    end
+
+    def transformer=(method)
+      return unless method
+      raise ArgumentError, "must be a method or proc" unless method.respond_to?(:call)
+
+      @transformer = method
+    end
+
+    def options
+      opts = {}
+      opts[:house_method] = house_method
+      opts[:latitude] = AstroHelper.print_dms(latitude, lat: true)
+      opts[:longitude] = AstroHelper.print_dms(longitude, lon: true)
+      opts[:jd] = @jd
+      opts[:tz] = @tz.to_s
+      # date = @tz.to_local(DateTime.new(*Swe4r::swe_revjul(@jd))).to_s
+      date = DateTime.new(*Swe4r.swe_revjul(@jd)).to_s
+      opts[:date] = DateTime.parse(date).strftime("%Y-%m-%d %I:%M %p")
+      opts[:ayanamsha] = AstroHelper.print_dms ayanamsha, seconds: true
+      opts[:flags] = @flags
+      opts
+    end
+
+    def timezone
+      TZInfo::Timezone.get(@tz)
+    end
+
+    def utc
+      DateTime.new(*Swe4r.swe_revjul(@jd))
+    end
+
+    def datetime
+      @tz ? timezone.to_local(utc) : utc
+    end
+
+    def to_a
+      [@tz, @jd, @latitude, @longitude, @altitude]
+    end
+
+    def init *args
+      AstroHelper.init_calc(self, *args)
+    end
+
+    def update(params)
+      init_params(params)
+    end
+
+    def ayanamsha
+      @ayanamsha ? Swe4r.swe_get_ayanamsa_ex_ut(@jd, @flags) : 0
+    end
+
+    def svp
+      -ayanamsha
+    end
+
+    def true_node?
+      !!@true_node
+    end
+
+    def oe # obliquity of the ecliptic
+      @oe ||= Swe4r.swe_calc_ut(@jd, -1, 0).first
+    end
+
+    def datetime=(time)
+      @oe = nil
+      @ra = nil
+      @planetary_hours = nil
+      @jd = AstroHelper.datetime_to_jd(time)
+    end
+
+    def set_topo(latitude, longitude, altitude = nil)
+      @latitude = latitude
+      @longitude = longitude
+      @altitude = altitude.to_f
+      Swe4r.swe_set_topo(@longitude, @latitude, @altitude)
+    end
+
+    def calc(id, equatorial: false, heliocentric: false)
+      flags = self.flags
+      flags |= Swe4r::SEFLG_EQUATORIAL if equatorial
+      flags |= Swe4r::SEFLG_HELCTR if heliocentric
+
+      Swe4r.swe_calc_ut(jd, id, flags)
+    end
+
+    def get_body(abbr, jd = nil)
+      @jd = jd if jd
+      $logger.warn "use :NN with @true_node configuration instead of #{abbr}" if %i[MN TN].include?(abbr)
+      if abbr =~ /^C(\d+)$/
+        HouseCusp.new(::Regexp.last_match(1).to_i, self)
+      else
+        Body.new(abbr, self)
+      end
+    end
+
+    def [](abbr)
+      abbr = abbr.upcase if abbr.size == 2
+      get_body(abbr)
+    end
+
+    def ascendant
+      @asc || (get_houses && @asc)
+    end
+
+    def midheaven
+      @mc
+    end
+
+    def house_cusps(calc_method = nil)
+      case calc_method
+      when :asc
+        AstroHelper.harmonic_cusps(get_position(:asc).lon)
+      when :mc
+        AstroHelper.harmonic_cusps(get_position(:mc).lon, 10)
+      else
+        get_houses(calc_method) unless @house_cusps && calc_method.nil?
+        @house_cusps[1..12]
+      end
+    end
+
+    def get_houses(calc_method = nil)
+      if calc_method
+        @house_method = calc_method
+      else
+        @house_method ||= "P" # 'C'
+      end
+      raise "you must call set_topo with latitude and longitude before get_houses" unless @latitude && @longitude
+
+      flag = @ayanamsha ? Swe4r::SEFLG_SIDEREAL : 0
+      @house_cusps, ascmc, *, ascmc_speeds = Swe4r.swe_houses_ex2(jd, flag, @latitude, @longitude,
+                                                                  @house_method)
+      # @house_cusps.pop if @house_cusps.first.zero? # FIXME bug
+      @asc, @mc, @ramc, @vertex = *ascmc[0..3]
+      @equasc, = *ascmc[4..7]
+      # * ascmc[4] = equasc		* "equatorial ascendant" *
+      # * ascmc[5] = coasc1		* "co-ascendant" (W. Koch) *
+      # * ascmc[6] = coasc2		* "co-ascendant" (M. Munkasey) *
+      # * ascmc[7] = polasc		* "polar ascendant" (M. Munkasey) *
+      @asc_speed, @mc_speed, *, @vertex_speed = *ascmc_speeds[0..3]
+      true
+    end
+
+    def ramc
+      @ramc || (get_houses && @ramc)
+    end
+
+    def which_house(degree)
+      get_houses unless @house_cusps
+      min_cusp = house_cusps.min
+      degree += 360 if degree < min_cusp
+      # Iterate through the house cusps
+      house_cusps.each_with_index do |cusp, i|
+        # Check if the degree is within the current house
+        next_cusp = house_cusps[i + 1]
+        return 12 if next_cusp.nil?
+
+        next_cusp += 360 if next_cusp == min_cusp
+        # $logger.debug("#{degree.round(2)}.between? #{cusp},#{next_cusp}")
+        return i + 1 if degree.between?(cusp, next_cusp)
+      end
+    end
+
+    def dc
+      flip(asc)
+    end
+
+    def ic
+      flip(mc)
+    end
+
+    def av
+      flip(vertex)
+    end
+    alias avx av
+
+    def flip(d)
+      (d + 180) % 360
+    end
+
+    def before_sunrise?
+      ac = house_cusps[0] # sunrise
+      ic = house_cusps[3] # midnight
+      ic += 360 if ic < ac
+      get_body(:SO).to_f.between?(ac, ic) # before sunrise?
+    end
+
+    def solunar_phase
+      (get_body(:MO).to_f - get_body(:SO).to_f + 360) % 360
+    end
+
+    private
+
+    def init_params(params)
+      params = { ephemeris: :moshier, center: :geo, light_correction: true }.merge(params)
+      @house_method = params[:house_method] ||= "P" # Placidus as default
+      # default to true node
+      @true_node = true unless params[:true_node] == false || params[:mean_node] || params[:node] == :mean
+      # https://www.astro.com/swisseph/swephprg.htm
+      @flags = Swe4r::SEFLG_SPEED
+      if params[:astrometric]
+        @flags |= Swe4r::SEFLG_NOABERR | Swe4r::SEFLG_NOGDEFL
+      else
+        # no light time correction - return true positions, not apparent
+        @flags |= Swe4r::SEFLG_TRUEPOS unless params[:light_correction]
+      end
+      if (@ayanamsha = params[:sidereal])
+        @flags |= Swe4r::SEFLG_SIDEREAL if params[:sidereal]
+        if @ayanamsha.is_a? Array
+          Swe4r.swe_set_sid_mode(*@ayanamsha[0..2])
+        else
+          Swe4r.swe_set_sid_mode(@ayanamsha, 0, 0)
+        end
+      end
+      if params[:heliocentric]
+        @flags |= Swe4r::SEFLG_HELCTR
+      elsif params[:topocentric]
+        @flags |= Swe4r::SEFLG_TOPOCTR
+      elsif params[:center]
+        case params[:center]
+        when :helio
+          @flags |= Swe4r::SEFLG_HELCTR
+        when :topo
+          @flags |= Swe4r::SEFLG_TOPOCTR
+        when :geo
+        else
+          raise "bad option! center: #{params[:center]}"
+        end
+      end
+      case params[:ephemeris]
+      when :moshier
+        @flags |= Swe4r::SEFLG_MOSEPH
+      when :jpl
+        @flags |= Swe4r::SEFLG_JPLEPH
+      when :swiss
+        @flags |= Swe4r::SEFLG_SWIEPH
+      else
+        raise "bad option! ephemeris: #{params[:ephemeris]}"
+      end
+      @flags |= Swe4r::SEFLG_EQUATORIAL if params[:equatorial] # right ascension and declination instead of lat/lon
+    end
+  end
+end

data/lib/astroscript/chart.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Astroscript
+  class Chart
+    attr_reader :calc
+    attr_accessor :harmonic, :location
+
+    DEFAULT_BODIES = AstroHelper::PLANETS + AstroHelper::EXTRAS - [:VX]
+
+    # TODO: consider renaming opts to calc(_opts) ?
+    def initialize(birth_data, bodies: DEFAULT_BODIES, opts: {})
+      @opts = opts || {}
+      @opts[:true_node] ||= true
+      case birth_data
+      when Astroscript::Chart, Astroscript::Calculator
+        @calc = birth_data.dup
+        @calc.house_method = opts[:house_method]
+        @calc = @calc.calc if @calc.is_a?(Chart)
+      when Array
+        @calc = Astroscript::Calculator.new(opts).init(birth_data)
+        @location, name = birth_data[5..6]
+      when nil
+        raise ArgumentError, "no birth data provided!"
+      end
+      self.transformer = opts[:transformer]
+      @chart = {}
+      @harmonic = opts[:harmonic] || 1
+      @calc.arc = opts[:arc] if opts[:arc]
+      @calc.name = name || opts[:name] || ""
+      @calc.prefix = opts[:prefix]
+      get_bodies! bodies
+    end
+
+    def initialize_copy(orig)
+      super
+      # puts "duplicating @calc"
+      @calc = @calc.dup # attempt to prevent weirdness with transformers
+      self
+    end
+
+    # def dup
+    #   Chart.new( @calc.dup, @chart.values.map(&:abbr), @opts)
+    # end
+
+    def transformer=(method)
+      @calc.transformer = method
+    end
+
+    def bodies
+      @chart.values
+    end
+
+    def recalc!(opts = {})
+      @calc.update(opts) unless opts.empty?
+      bodies.each(&:calculate!)
+      self
+    end
+
+    def asc=(deg)
+      @asc = deg.to_f
+    end
+
+    def asc
+      return @asc if @asc
+
+      if (a = find_body(:AC) || find_body(:C1))
+        a.degree
+      else
+        @calc.asc
+      end
+    end
+
+    def deg(body, method = :to_f)
+      body.send(method)
+    end
+
+    def degree(body, asc = nil) # helper for drawing chart
+      ((asc || self.asc) - 180 - deg(body)) % 360
+    end
+
+    def get_bodies!(planets)
+      planets.each do |abbr|
+        body = find_body!(abbr)
+        body.harmonize!(@harmonic) if body.is_a?(Astroscript::Body)
+      end
+    end
+
+    def find_body!(abbr)
+      case abbr
+      when *SwissEphemeris::BODIES.keys
+        key = AstroHelper.symbolize(SwissEphemeris::BODIES[abbr][:name])
+        self[key] = get_body(abbr)
+      else
+        raise ArgumentError, "unknown body: #{abbr}"
+      end
+    end
+
+    def phase_angle(b1, b2)
+      b1 = find_body(b1) if b1.is_a?(Symbol) && SwissEphemeris::BODIES.keys.include?(b1)
+      b2 = find_body(b2) if b2.is_a?(Symbol) && SwissEphemeris::BODIES.keys.include?(b2)
+      # (b1.lon - b2.lon) % 360
+      b1 - b2
+    end
+
+    def []=(key, body)
+      @chart[key] = body
+      # body.chart = self
+    end
+
+    def [](abbr)
+      abbr = abbr.upcase if abbr.size == 2
+      get_body(abbr)
+    end
+
+    def find_body(abbr)
+      if (result = @chart.find{|_k, v| v.abbr == abbr })
+        result[1]
+      else
+        # calc.get_body(abbr)
+      end
+    end
+
+    def get_body(abbr)
+      body = SwissEphemeris::BODIES[abbr]
+      if (method = body[:method])
+        method = body[:name] if method == true
+        output = MethodBody.new(send(method), method, chart: self)
+      else
+        output = find_body(abbr) || calc.get_body(abbr)
+      end
+      output.harmonize(@harmonic)
+    end
+
+    def find_bodies(ary)
+      ary.map{|a| find_body(a) }
+    end
+
+    def aries_point
+      # ConstBody.new( 0, 'AP' )
+      0
+    end
+
+    def method_missing(method_name, ...)
+      if @calc.respond_to?(method_name)
+        @calc.send(method_name, ...)
+      elsif @chart.respond_to?(method_name)
+        @chart.send(method_name, ...)
+      else
+        raise "unknown method! :#{method_name}"
+      end
+    end
+
+    def night_birth?
+      sun = get_body(:SO).lon
+      desc = asc + 180
+      if desc > 360
+        sun.between?(desc % 360, asc)
+      else
+        sun.between?(asc, asc + 180)
+      end
+    end
+
+    def harmonic?
+      @harmonic > 1
+    end
+
+    def harmonize(h)
+      # output = Marshal.load( Marshal.dump(self) ) # deep copy
+      output = initialize_copy(self)
+      output.harmonize!(h)
+    end
+
+    def harmonize!(h)
+      @harmonic = h
+      bodies.each{|b| b.harmonize!(h) }
+      self
+    end
+
+    alias * harmonize
+
+    def print **opts # prefix: true, seconds: true, gate: true, house: true, spectrum: true
+      opts[:seconds] ||= true
+      puts @chart.map{|_k, v| v.to_s(opts) }.join("\n")
+    end
+
+    def to_a
+      calc.to_a << location
+    end
+
+    def to_json(*_args)
+      {
+        bodies: bodies.map(&:to_json)
+      }.to_json
+    end
+
+    def aspects(opts = {})
+      _bodies = bodies + opts[:with].to_a
+      if (orbs = opts[:orbs])
+        orbs.map do |flavor, orb|
+          _bodies.combination(2).map do |b1, b2|
+            Aspect.new(b1, b2, orb: orb, ratio: Aspect::FLAVORS.key(flavor))
+          end
+        end.flatten.uniq
+      else
+        _bodies.combination(2).map do |b1, b2|
+          Aspect.new(b1, b2, opts)
+        end.reject(&:invalid?)
+      end
+    end
+
+    def conjunctions(orb: 8)
+      aspects(orb: orb, harmonic: 1)
+    end
+
+    def trines(orb: 8)
+      aspects(orb: orb, harmonic: 3)
+    end
+
+    def midpoints
+      bodies.combination(2).map do |b1, b2|
+        Midpoint.new(b1, b2)
+      end
+    end
+
+    def midpoint_aspects(opts = {})
+      opts[:max_harmonic] ||= 2
+      opts[:orb] ||= 1.5
+      aspects(opts.merge(with: midpoints))
+        .select(&:midpoint?)
+        .reject(&:overlap?).reject(&:isotrap?)
+        .sort_by(&:orb)
+    end
+
+    # def isotraps( opts={} )
+    #   opts[:orb] ||= 1.5
+    #   aspects( opts.merge( with: midpoints ) ).select(&:isotrap?).reject(&:conjunction)
+    # end
+  end
+end

data/lib/astroscript/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Astroscript
+  VERSION = "0.3.0"
+end

data/lib/astroscript.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# $LOAD_PATH.unshift File.expand_path(".", __dir__)
+
+require "dotenv/load" if Gem.loaded_specs.key?("dotenv") # do this first
+require "byebug" if Gem.loaded_specs.key?("byebug")
+
+require "active_support"
+require "active_support/core_ext/string"
+require "forwardable"
+require "geocoder"
+require "logger"
+require "ostruct"
+
+require_relative "ruby_extensions"
+require_relative "swiss_ephemeris"
+
+require_relative "astroscript/version"
+require_relative "astro_helper"
+require_relative "astroscript/calculator"
+require_relative "astroscript/body"
+require_relative "astroscript/body/midpoint"
+require_relative "astroscript/body/const_body"
+require_relative "astroscript/body/method_body"
+# require_relative './astro/body/house_cusp'
+require_relative "astroscript/chart"
+require_relative "astroscript/aspect"
+
+$logger = Logger.new($stdout)
+$logger.level = Logger::WARN
+# $logger.level = Logger::DEBUG
+
+require 'dotenv/load'
+Geocoder.configure(lookup: :geoapify, api_key: ENV.fetch("GEOCODER_API_KEY", nil))
+SwissEphemeris.path = ENV.fetch("SE_EPHE_PATH", File.expand_path("../vendor/swe_data", __dir__))
+
+module Astroscript
+  class Error < StandardError; end
+end

data/lib/ruby_extensions.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "date"
+
+module ArrayExtensions
+  def diff
+    diffop{|x, y| y - x }
+  end
+
+  def diffop
+    d1 = dup.unshift(0)
+    d2 = dup.push(0)
+    (0..size).map{|i| yield(d1[i], d2[i]) }[1...-1]
+  end
+
+  def avg
+    sum / size.to_f
+  end
+
+  def gmean
+    reduce(:*).to_f**(1.0 / size)
+  end
+
+  def **(other)
+    map{|x| x * other }
+  end
+
+  # harmonic operator
+  def >>(other)
+    map{|x| (x * other) % 360.0 }
+  end
+end
+Array.include ArrayExtensions
+
+module NumericExtensions
+  def sgn
+    negative? ? -1 : 1
+  end
+
+  def mod360
+    self % 360
+  end
+end
+Numeric.include NumericExtensions
+
+module IntegerExtensions
+  def ordinalize
+    n = self
+    return "#{n}th" if (11..13).include?(n % 100)
+
+    case n % 10
+    when 1 then "#{n}st"
+    when 2 then "#{n}nd"
+    when 3 then "#{n}rd"
+    else "#{n}th"
+    end
+  end
+
+  PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103,
+            107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349].freeze
+
+  def hph
+    n = self
+    return 1 if n == 1
+
+    PRIMES.reverse.find{|p| n.gcd(p) != 1 }
+  end
+end
+Integer.include IntegerExtensions
+
+module DateTimeExtensions
+  def round(granularity = 1.hour)
+    Time.at((to_time.to_i / granularity).round * granularity).to_datetime
+  end
+end
+DateTime.include DateTimeExtensions
+
+module FloatExtensions
+  def to_dms(opts = {})
+    AstroHelper.print_dms(self, opts)
+  end
+end
+Float.include FloatExtensions