zakuro 0.0.1 → 0.1.2

data/lib/zakuro/version/senmyou/senmyou.rb

@@ -3,7 +3,7 @@
 require 'date'
 require_relative '../abstract_version'
 require_relative '../../era/western'
-require_relative 'summary/gengou_data'
+require_relative 'summary/single'
 
 # :nodoc:
 module Zakuro
@@ -27,7 +27,7 @@ module Zakuro
       #
       def self.to_japan_date(western_date:)
         date = Western::Calendar.create(date: western_date)
-        GengouData.get_ancient_date(date: date)
+        Single.get(date: date)
       end
     end
   end

data/lib/zakuro/version/senmyou/specifier/single_day_specifier.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative '../../../era/western'
+require_relative '../range/full_range'
+require_relative '../base/multi_gengou_roller'
+require_relative '../base/year'
+require_relative '../../../output/response'
+require_relative '../../../output/logger'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Senmyou
+    #
+    # SingleDaySpecifier 一日検索
+    #
+    module SingleDaySpecifier
+      # @return [Logger] ロガー
+      LOGGER = Logger.new(location: 'specifier')
+
+      #
+      # 取得する
+      #
+      # @param [Array<Year>] yeas 範囲
+      # @param [Western::Calendar] date 西暦日
+      #
+      # @return [Result::Data::SingleDay] 和暦日
+      #
+      def self.get(years: [], date: Western::Calendar.new)
+        year = specify_year(years: years, date: date)
+
+        year = transfer(year: year, date: date)
+
+        month = specify_month(year: year, date: date)
+        first_date = month.western_date
+
+        Response::SingleDay.save_single_day(
+          param: Response::SingleDay::Param.new(
+            year: year, month: month,
+            date: date, days: date - first_date
+          )
+        )
+      end
+
+      #
+      # 年を特定する
+      #
+      # @param [Array<Year>] years 範囲
+      # @param [Western::Calendar] date 西暦日
+      #
+      # @return [Year] 対象年
+      #
+      def self.specify_year(years:, date:)
+        years.reverse_each do |year|
+          return year if date >= year.new_year_date
+        end
+
+        raise ArgumentError, "invalid year range. date: #{date.format}"
+      end
+      private_class_method :specify_year
+
+      #
+      # 改元する
+      #
+      # @param [Year] year 年
+      # @param [Western::Calendar] date 西暦日
+      #
+      # @return [Year] 改元後の年
+      #
+      def self.transfer(year:, date:)
+        multi_gengou = MultiGengouRoller.transfer(multi_gengou: year.multi_gengou, date: date)
+        Year.new(multi_gengou: multi_gengou, new_year_date: year.new_year_date,
+                 months: year.months, total_days: year.total_days)
+      end
+      private_class_method :transfer
+
+      # :reek:TooManyStatements { max_statements: 7 }
+
+      #
+      # 月を特定する
+      #
+      # @param [Year] year 年
+      # @param [Western::Calendar] date 西暦日
+      #
+      # @return [Month] 対象月
+      #
+      def self.specify_month(year:, date:)
+        months = year.months
+
+        current_month = months[0]
+        months.each do |month|
+          return current_month if month.western_date > date
+
+          current_month = month
+        end
+
+        current_month
+      end
+      private_class_method :specify_month
+    end
+  end
+end

data/lib/zakuro/version/senmyou/stella/lunar_orbit.rb

@@ -193,7 +193,7 @@ module Zakuro
           { |key, _| key.match(/^#{prefix}_#{format('%<day>02d', day: day)}_.*/) }
 
         targets.each do |key, value|
-          # NOTE 境界値は上から順に引き当てた方を返す（7日の境界値7465は上のキーで返す）
+          # NOTE: 境界値は上から順に引き当てた方を返す（7日の境界値7465は上のキーで返す）
           matched, diff = \
             extract_data_from_moon_adjustment_key(key, minute)
           # 小余の下げ幅
@@ -255,7 +255,7 @@ module Zakuro
       #
       # 天正冬至（入暦前回未計算）を求める
       #
-      # @param [Remainder] winter_solstice_age 昨年冬至
+      # @param [Remainder] winter_solstice_age 天正閏余
       # @param [Integer] western_year 西暦年
       #
       # @return [LunarRemainder] 入暦

data/lib/zakuro/version/senmyou/stella/solar_average.rb

@@ -7,186 +7,163 @@ module Zakuro
     #
     # SolarAverage 常気（太陽軌道平均）
     #
-    module SolarAverage
+    class SolarAverage
       # @return [Remainder] 気策（24分の1年）
       SOLAR_TERM_AVERAGE = Remainder.new(day: 15, minute: 1835, second: 5)
 
-      # :reek:TooManyStatements { max_statements: 6 }
-
       #
-      # 冬至から数えた1年データの月ごとに二十四節気を割り当てる
+      # 初期化
       #
       # @param [Integer] western_year 西暦年
-      # @param [Array<Month>] annual_data 1年データ
-      #
-      # @return [Array<Month>] 1年データ
       #
-      def self.set_solar_terms_into_annual_data(western_year:, annual_data:)
-        # 天正冬至
-        winter_solstice = WinterSolstice.calc(western_year: western_year)
-
-        # 前年冬至からの二十四節気
-        solar_terms = collect_solar_terms_from_last_winter_solstice(
-          winter_solstice: winter_solstice
-        )
-
-        apply_solar_terms_from_last_winter_solstice(annual_data: annual_data,
-                                                    solar_terms: solar_terms)
-
-        # 前後の二十四節気
-        rest_solar_terms = \
-          collect_solar_terms_before_and_after(solar_terms: solar_terms)
-
-        apply_solar_terms_before_and_after(annual_data: annual_data,
-                                           rest_solar_terms: rest_solar_terms)
-
-        annual_data
+      def initialize(western_year:)
+        @solar_term = SolarAverage.first_solar_term(western_year: western_year)
       end
 
-      # :reek:TooManyStatements { max_statements: 6 }
-
       #
-      # 前年冬至から当年大雪までの二十四節気を計算する
+      # 冬至から数えた1年データの月ごとに二十四節気を割り当てる
       #
-      # @param [Remainder] winter_solstice 冬至
+      # @param [Array<Month>] annual_range 1年データ
       #
-      # @return [Array<Remainder>] 二十四節気
+      # @return [Array<Month>] 1年データ
       #
-      def self.collect_solar_terms_from_last_winter_solstice(winter_solstice:)
-        result = []
-        term = winter_solstice
-        (0...24).each do |_i|
-          result.push(term)
-          term = term.add(SOLAR_TERM_AVERAGE)
+      def set(annual_range:)
+        # 次月と比較しながら当月の二十四節気を決める
+        # NOTE: 最後の月は処理できない（=計算外の余分な月が最後に必要である）
+        annual_range.each_cons(2) do |(current_month, next_month)|
+          set_solar_term(
+            current_month: current_month,
+            next_month: next_month
+          )
         end
 
-        result
+        annual_range
       end
-      private_class_method :collect_solar_terms_from_last_winter_solstice
-
-      # :reek:TooManyStatements { max_statements: 9 }
 
       #
-      # 各月の二十四節気を設定する
+      # 計算開始する二十四節気を求める
       #
-      # @param [Array<Month>] annual_data 1年データ
-      # @param [Array<Remainder>] solar_terms 1年データ内の全二十四節気
+      # @param [Integer] western_year 西暦年
+      #
+      # @return [SolarTerm] 二十四節気
       #
-      def self.apply_solar_terms_from_last_winter_solstice(annual_data:,
-                                                           solar_terms:)
-        c_idx = 0
-        st_idx = 0
-        while c_idx < annual_data.size && st_idx < solar_terms.size
-          current_month = annual_data[c_idx]
-          next_month = annual_data[c_idx + 1]
-          solar_term = solar_terms[st_idx]
+      def self.first_solar_term(western_year:)
+        # 天正冬至
+        winter_solstice = WinterSolstice.calc(western_year: western_year)
 
-          if in_range_solar_term?(target: solar_term, min: current_month.remainder,
-                                  max: next_month.remainder)
-            set_solar_term(month: current_month,
-                           solar_term: solar_term, solar_term_index: st_idx)
-            st_idx += 1
-            next
-          end
-          c_idx += 1
-        end
+        # 二十四節気（冬至）
+        solar_term = SolarTerm.new(index: 0, remainder: winter_solstice)
+
+        first_solar_term_index = SolarAverage.calc_fist_solar_term_index(western_year: western_year)
+
+        # 対象の二十四節気まで戻す
+        solar_term.prev_by_index(first_solar_term_index)
+
+        solar_term
       end
-      private_class_method :apply_solar_terms_from_last_winter_solstice
 
       #
-      # 1年データ内の二十四節気の前後を収集する
+      # 計算開始する二十四節気番号を求める
+      #
+      # * 前提として入定気は冬至の手前にある
+      # * 例えば、定気が大雪であれば入定気は大雪の範囲内にある
+      # * 入定気は、定気の開始位置に重複しない限り、常に定気より後にある
+      # * 基本的に定気の一つ前から起算すれば、当時から求めた11月(閏10/閏11月)に二十四節気を割り当てられる
       #
-      # @param [Array<Remainder>] solar_terms 1年データ内の全二十四節気
+      # @param [Integer] western_year 西暦年
       #
-      # @return [Hash<Integer, Hash<Symbol, Integer>>, Hash<Integer, Hash<Symbol, Remainder>>] 前後
+      # @return [Integer] 二十四節気番号
       #
-      def self.collect_solar_terms_before_and_after(solar_terms:)
-        raise ArgumentError, 'parameter must be 24 solar terms' unless solar_terms.size == 24
+      def self.calc_fist_solar_term_index(western_year:)
+        # 天正閏余
+        winter_solstice_age = \
+          WinterSolstice.calc_moon_age(western_year: western_year)
 
-        touji = solar_terms[-1].add(SOLAR_TERM_AVERAGE)
-        {
-          # 前年大雪
-          23 => { index: 0, solar_term: solar_terms[0].sub(SOLAR_TERM_AVERAGE) },
-          # 当年冬至
-          0 => { index: -2, solar_term: touji },
-          # 当年小寒
-          1 => { index: -2, solar_term: touji.add(SOLAR_TERM_AVERAGE) }
-        }
-      end
-      private_class_method :collect_solar_terms_before_and_after
+        # 入定気を求める
+        solar_location = SolarLocation.get(
+          solar_term: SolarTerm.new(remainder: winter_solstice_age)
+        )
 
-      # :reek:TooManyStatements { max_statements: 6 }
+        solar_term_index = solar_location.index
 
-      #
-      # 1年データ前後の二十四節気を適用する
-      #
-      # @param [Array<Month>] annual_data 1年データ
-      # @param [Hash<Integer, Hash<Symbol, Integer>>, Hash<Integer, Hash<Symbol, Remainder>>]
-      #   rest_solar_terms 前後
-      #
-      def self.apply_solar_terms_before_and_after(annual_data:, rest_solar_terms:)
-        rest_solar_terms.each do |key, value|
-          index = value[:index]
-          solar_term = value[:solar_term]
-          data = annual_data[index]
-          next unless in_range_solar_term?(
-            target: solar_term,
-            min: data.remainder, max: annual_data[index + 1].remainder
-          )
+        # 入定気の一つ後の二十四節気まで戻す（ただし11月経朔が二十四節気上にある場合は戻さない）
+        solar_term_index += 1 unless solar_location.remainder == Remainder.new(total: 0)
 
-          set_solar_term(month: data,
-                         solar_term: solar_term, solar_term_index: key)
-        end
+        solar_term_index
       end
-      private_class_method :apply_solar_terms_before_and_after
 
       # :reek:TooManyStatements { max_statements: 7 }
 
       #
-      # 月内（currentからnextの間）に二十四節気があるか
+      # 月内（当月朔日から当月末日（来月朔日の前日）の間）に二十四節気があるか
       # @note 大余60で一巡するため 以下2パターンがある
-      #   * current(min) <= next(max) : (二十四節気) >= current && (二十四節気) < next
-      #   * current(min) > next(max)  : (二十四節気) >= current || (二十四節気) < next
+      #   * current_month <= next_month : (二十四節気) >= current_month && (二十四節気) < next_month
+      #   * current_month > next_month  : (二十四節気) >= current_month || (二十四節気) < next_month
       #
-      # @param [Remainder] target 対象の二十四節気
-      # @param [Remainder] min 月初
-      # @param [Remainder] max 月末
+      # @param [Remainder] solar_term 二十四節気
+      # @param [Remainder] current_month 月初
+      # @param [Remainder] next_month 月末
       #
       # @return [True] 対象の二十四節気がある
       # @return [False] 対象の二十四節気がない
       #
-      def self.in_range_solar_term?(target:, min:, max:)
+      def self.in_solar_term?(solar_term:, current_month:, next_month:)
         # 大余で比較する
-        target_time = target.day
-        min_time = min.day
-        max_time = max.day
-        min_over = (target_time >= min_time)
-        max_under = (target_time < max_time)
+        target_time = solar_term.day
+        current_month_time = current_month.day
+        next_month_time = next_month.day
+        current_month_over = (target_time >= current_month_time)
+        next_month_under = (target_time < next_month_time)
+
+        return current_month_over && next_month_under if current_month_time <= next_month_time
 
-        (min_time <= max_time ? min_over && max_under : min_over || max_under)
+        current_month_over || next_month_under
       end
-      private_class_method :in_range_solar_term?
+
+      private
+
+      # :reek:TooManyStatements { max_statements: 8 }
 
       #
       # 二十四節気を設定する
       #
-      # @param [Month] month 月
-      # @param [Remainder] solar_term 二十四節気
-      # @param [Integer] solar_term_index 連番（二十四節気）
-      #
-      def self.set_solar_term(month:, solar_term:, solar_term_index:)
-        term = SolarTerm.new(remainder: solar_term, index: solar_term_index)
-        if solar_term_index.even?
-          # 中気
-          month.even_term = term
-        else
-          # 節気
-          month.odd_term = term
+      # @param [Month] current_month 当月
+      # @param [Month] next_month 次月
+      #
+      def set_solar_term(current_month:, next_month:)
+        # 安全策として無限ループは回避する
+        # * 最大試行回数：4回（設定なし => 設定あり => 設定あり => 設定なし）
+        # * 閏月は1回しか設定しない
+        # * 最大2回設定する（中気・節気）
+        (0..3).each do |_index|
+          in_range = SolarAverage.in_solar_term?(
+            solar_term: @solar_term.remainder, current_month: current_month.remainder,
+            next_month: next_month.remainder
+          )
+
+          # 範囲外
+          unless in_range
+            # 1つ以上設定されていれば切り上げる（一つ飛ばしで二十四節気を設定することはない）
+            break unless current_month.empty_solar_term?
+
+            next_solar_term
+            next
+          end
+
+          current_month.add_term(term: @solar_term.clone)
+          next_solar_term
+
+          # 宣明暦は最大2つまで
+          break if current_month.solar_term_size == 2
         end
+      end
 
-        nil
+      #
+      # 次の二十四節気に移る
+      #
+      def next_solar_term
+        @solar_term.next!
       end
-      private_class_method :set_solar_term
     end
   end
 end

data/lib/zakuro/version/senmyou/stella/solar_location.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Senmyou
+    #
+    # SolarLocation 入定気演算
+    #
+    # 入定気とは、太陽がどの二十四節気に属するか、またその二十四節気の開始点からどれだけ離れているかを示す
+    #
+    module SolarLocation
+      #
+      # Interval 入気定日加減数（二十四節気の間隔）
+      #
+      module Interval
+        # @return [Hash<Symbol, Remainder>] 一覧
+        LIST = {
+          # 冬至（とうじ）・大雪（たいせつ）
+          touji: Remainder.new(day: 14, minute: 4235, second: 5),
+          taisetsu: Remainder.new(day: 14, minute: 4235, second: 5),
+          # 小寒（しょうかん）・小雪（しょうせつ）
+          shoukan: Remainder.new(day: 14, minute: 5235, second: 5),
+          shousetsu: Remainder.new(day: 14, minute: 5235, second: 5),
+          # 大寒（だいかん）・立冬（りっとう）
+          daikan: Remainder.new(day: 14, minute: 6235, second: 5),
+          rittou: Remainder.new(day: 14, minute: 6235, second: 5),
+          # 立春（りっしゅん）・霜降（そうこう）
+          risshun: Remainder.new(day: 14, minute: 7235, second: 5),
+          soukou: Remainder.new(day: 14, minute: 7235, second: 5),
+          # 雨水（うすい）・寒露（かんろ）
+          usui: Remainder.new(day: 15, minute: 35, second: 5),
+          kanro: Remainder.new(day: 15, minute: 35, second: 5),
+          # 啓蟄（けいちつ）・秋分（しゅうぶん）
+          keichitsu: Remainder.new(day: 15, minute: 1235, second: 5),
+          shuubun: Remainder.new(day: 15, minute: 1235, second: 5),
+          # 春分（しゅんぶん）・白露（はくろ）
+          shunbun: Remainder.new(day: 15, minute: 2435, second: 5),
+          hakuro: Remainder.new(day: 15, minute: 2435, second: 5),
+          # 清明（せいめい）・処暑（しょしょ）
+          seimei: Remainder.new(day: 15, minute: 3635, second: 5),
+          shosho: Remainder.new(day: 15, minute: 3635, second: 5),
+          # 穀雨（こくう）・立秋（りっしゅう）
+          kokuu: Remainder.new(day: 15, minute: 4835, second: 5),
+          risshuu: Remainder.new(day: 15, minute: 4835, second: 5),
+          # 立夏（りっか）・大暑（たいしょ）
+          rikka: Remainder.new(day: 15, minute: 5835, second: 5),
+          taisho: Remainder.new(day: 15, minute: 5835, second: 5),
+          # 小満（しょうまん）・小暑（しょうしょ）
+          shouman: Remainder.new(day: 15, minute: 6835, second: 5),
+          shousho: Remainder.new(day: 15, minute: 6835, second: 5),
+          # 芒種（ぼうしゅ）・夏至（げし）
+          boushu: Remainder.new(day: 15, minute: 7835, second: 5),
+          geshi: Remainder.new(day: 15, minute: 7835, second: 5)
+        }.freeze
+
+        # @return [Array<Remainder>] 索引
+        INDEXES = [
+          LIST[:touji],      #  0
+          LIST[:shoukan],    #  1
+          LIST[:daikan],     #  2
+          LIST[:risshun],    #  3
+          LIST[:usui],       #  4
+          LIST[:keichitsu],  #  5
+          LIST[:shunbun],    #  6
+          LIST[:seimei],     #  7
+          LIST[:kokuu],      #  8
+          LIST[:rikka],      #  9
+          LIST[:shouman],    # 10
+          LIST[:boushu],     # 11
+          LIST[:geshi],      # 12
+          LIST[:shousho],    # 13
+          LIST[:taisho],     # 14
+          LIST[:risshuu],    # 15
+          LIST[:shosho],     # 16
+          LIST[:hakuro],     # 17
+          LIST[:shuubun],    # 18
+          LIST[:kanro],      # 19
+          LIST[:soukou],     # 20
+          LIST[:rittou],     # 21
+          LIST[:shousetsu],  # 22
+          LIST[:taisetsu]    # 23
+        ].freeze
+      end
+
+      #
+      # 入定気を計算する
+      #
+      # * 定気（index）の指定がない場合は、11月の入定気を求める
+      # * 定気（index）の指定がある場合は、大余小余から適切な入定気を再計算する
+      #
+      # @param [SolarTerm] solar_term 入定気
+      #
+      # @return [SolarTerm] 入定気
+      #
+      def self.get(solar_term:)
+        if solar_term.invalid?
+          return calc_first_solar_term(
+            winter_solstice_age: solar_term.remainder
+          )
+        end
+
+        calc_next_solar_term_recursively(
+          solar_term: solar_term
+        )
+      end
+
+      # :reek:TooManyStatements { max_statements: 7 }
+
+      #
+      # 入定気（定気の開始点からの日時）と属する定気を計算する
+      #
+      # @param [Remainder] winter_solstice_age 天正冬至
+      #
+      # @return [SolarTerm] 二十四節気
+      #   SolarTerm.remainder : 入定気（定気の開始点からの日時）
+      #   SolarTerm.index : 定気
+      #
+      def self.calc_first_solar_term(winter_solstice_age:)
+        # 入定気の起算方法
+        # 概要:
+        #  * 太陽の運行による補正値は、二十四節気の気ごとに定められる
+        #  * 11月経朔の前にある気を求め、それから11月経朔との間隔を求める
+        #  * 気ごとの補正値と、気から11月経朔までにかかる補正値を求める
+        # 前提:
+        #  * 11月経朔に関わる二十四節気は、時系列から順に、小雪・大雪・冬至である
+        #  * 小雪〜大雪の間隔は小雪定数で、大雪〜冬至の間隔は大雪定数で決められている（24気損益眺朒（ちょうじく）数のこと）
+        #  * 11月経朔は、この小雪〜冬至の間のいずれかにある
+        # 計算:
+        # 2パターンある
+        #  (a) 大雪〜冬至にある場合
+        #   *「大雪定数 >= 天正閏余」の場合を指す
+        #   * * NOTE 資料では「より大きい（>）」とされるが、大雪そのものの場合は大雪から起算すべき
+        #   * この場合は、大雪〜経朔の間隔を求める
+        #  (b) 小雪〜大雪にある場合
+        #   *「大雪定数 < 天正閏余」の場合を指す
+        #   * この場合は、小雪〜経朔の間隔を求める
+
+        # NOTE: 上記パターンとは別に、稀だが立冬のパターンも存在する
+        # この場合は比較方法はそのままに立冬〜経朔の間隔を求める
+
+        rest = winter_solstice_age.clone
+        # 大雪（23）/小雪（22）/立冬（21）
+        [23, 22, 21].each do |index|
+          solar_term = prev_solar_term(winter_solstice_age: rest, index: index)
+
+          if solar_term.invalid?
+            rest = solar_term.remainder
+            next
+          end
+
+          return solar_term
+        end
+
+        # 立冬（21）を超える天正閏余は成立し得ない（1朔望月をはるかに超えることになる）
+        raise ArgumentError.new, 'invalid winster solstice age'
+      end
+      private_class_method :calc_first_solar_term
+
+      #
+      # 入気定日加減数で入定気を遡る
+      #
+      # @param [Remainder] winter_solstice_age 天正冬至
+      # @param [Integer] index 二十四節気の連番
+      #
+      # @return [SolarTerm] 二十四節気
+      #   SolarTerm.remainder : 入定気（定気の開始点からの日時）
+      #   SolarTerm.index : 定気（範囲外であれば-1とする）
+      #
+      def self.prev_solar_term(winter_solstice_age:, index:)
+        interval = Interval::INDEXES[index]
+        if winter_solstice_age > interval
+          # 入定気が確定しない（さらに前の定気まで遡れる）
+          return SolarTerm.new(
+            remainder: winter_solstice_age.sub(interval),
+            index: -1
+          )
+        end
+
+        # 入定気が確定する
+        SolarTerm.new(
+          remainder: interval.sub(winter_solstice_age),
+          index: index
+        )
+      end
+      private_class_method :prev_solar_term
+
+      # :reek:TooManyStatements { max_statements: 8 }
+
+      #
+      # 次の二十四節気を計算する
+      #
+      # @param [SolarTerm] solar_term 今回の二十四節気
+      #
+      # @return [SolarTerm] 次回の二十四節気
+      #
+      def self.calc_next_solar_term_recursively(solar_term:)
+        remainder = solar_term.remainder
+        index = solar_term.index
+        interval = Interval::INDEXES[index]
+        return solar_term if remainder < interval
+
+        remainder.sub!(interval)
+        index += 1
+        index = 0 if index >= Interval::INDEXES.size
+        calc_next_solar_term_recursively(
+          solar_term: SolarTerm.new(remainder: remainder, index: index)
+        )
+      end
+      private_class_method :calc_next_solar_term_recursively
+    end
+  end
+end