zakuro 0.0.3 → 0.1.4

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative '../../../output/logger'
+require_relative '../cycle/remainder'
+require_relative '../cycle/solar_term'
+require_relative '../../../calculation/monthly/initialized_month'
+require_relative '../monthly/lunar_phase'
+require_relative '../stella/solar_orbit'
+require_relative '../stella/solar_average'
+require_relative '../stella/solar_location'
+require_relative '../stella/lunar_orbit'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Senmyou
+    # :nodoc:
+    module Range
+      #
+      # AnnualRange 年間範囲
+      #
+      module AnnualRange
+        # @return [Output::Logger] ロガー
+        LOGGER = Output::Logger.new(location: 'annual_range')
+
+        # :reek:TooManyStatements { max_statements: 6 }
+
+        #
+        # 11月定朔（冬至が含まれる月の1日：補正済）を求める
+        #
+        # @param [Integer] western_year 西暦年
+        #
+        # @return [Remainder] 11月定朔
+        #
+        def self.calc_last_november_1st(western_year:)
+          # 天正閏余
+          winter_solstice_age = \
+            WinterSolstice.calc_moon_age(western_year: western_year)
+          # 11月経朔
+          november_1st = \
+            WinterSolstice.calc_averaged_last_november_1st(western_year: western_year)
+          # 11月定朔
+
+          # 補正
+          correction_value = correction_value_on_last_november_1st(
+            winter_solstice_age: winter_solstice_age,
+            western_year: western_year
+          )
+
+          result = november_1st.add(Cycle::Remainder.new(day: 0, minute: correction_value,
+                                                         second: 0))
+          # 進朔
+          result.up_on_new_moon!
+          result
+        end
+
+        # :reek:TooManyStatements { max_statements: 6 }
+
+        #
+        # 一覧取得する
+        #
+        #   * 対象年に対して、前年11月-当年11月までを出力する
+        #   * 対象年（西暦）と計算年（元号x年）の紐付けは行わない
+        #
+        # @param [Context] context 暦コンテキスト
+        # @param [Integer] western_year 西暦年
+        #
+        # @return [Array<Month>] 1年データ
+        #
+        def self.collect_annual_range_after_last_november_1st(context:, western_year:)
+          annual_range = initialized_annual_range(context: context, western_year: western_year)
+
+          apply_big_and_small_of_the_month(annual_range: annual_range)
+
+          solar_average = SolarAverage.new(western_year: western_year)
+          solar_average.set(annual_range: annual_range)
+
+          # 月間隔を取得するためだけの末尾要素を削除
+          annual_range.pop
+
+          initialize_month_label(annual_range: annual_range)
+        end
+
+        #
+        # 11月定朔の補正値を求める
+        #
+        # @param [Remainder] winter_solstice_age 天正閏余
+        # @param [Integer] western_year 西暦年
+        #
+        # @return [Integer] 補正値
+        #
+        def self.correction_value_on_last_november_1st(winter_solstice_age:, western_year:)
+          # 補正
+          solar_term = Cycle::SolarTerm.new(
+            remainder: winter_solstice_age
+          )
+          solar_term = \
+            SolarLocation.get(
+              solar_term: solar_term
+            )
+
+          moon_remainder, is_forward = LunarOrbit.calc_moon_point(
+            remainder: winter_solstice_age, western_year: western_year
+          )
+
+          SolarOrbit.calc_sun_orbit_value(solar_term: solar_term) +
+            LunarOrbit.calc_moon_orbit_value(remainder_month: moon_remainder,
+                                             is_forward: is_forward)
+        end
+        private_class_method :correction_value_on_last_november_1st
+
+        #
+        # 1年データを取得する
+        #
+        # @param [Context] context 暦コンテキスト
+        # @param [Integer] western_year 西暦年
+        #
+        # @return [Array<Month>] 1年データ
+        #
+        def self.initialized_annual_range(context:, western_year:)
+          result = []
+          lunar_phase = Monthly::LunarPhase.new(western_year: western_year)
+
+          # 14ヶ月分を生成する（閏年で最大13ヶ月 + 末月の大小/二十四節気を求めるために必要な月）
+          (0..13).each do |_index|
+            adjusted = lunar_phase.next_month
+
+            result.push(
+              Calculation::Monthly::InitializedMonth.new(
+                context: context,
+                month_label: Calculation::Monthly::MonthLabel.new,
+                first_day: Calculation::Monthly::FirstDay.new(remainder: adjusted),
+                phase_index: 0
+              )
+            )
+          end
+
+          result
+        end
+        private_class_method :initialized_annual_range
+
+        #
+        # 1年データの各月に月の大小を設定する
+        #
+        # @param [Array<Month>] annual_range 1年データ
+        #
+        def self.apply_big_and_small_of_the_month(annual_range:)
+          # NOTE: 最後の月は処理できない（=計算外の余分な月が最後に必要である）
+          annual_range.each_cons(2) do |(current_month, next_month)|
+            current_month.eval_many_days(next_month_day: next_month.remainder.day)
+          end
+        end
+        private_class_method :apply_big_and_small_of_the_month
+
+        #
+        # 月表示情報を更新する
+        #
+        # @param [Array<Month>] annual_range 1年データ
+        #
+        def self.initialize_month_label(annual_range:)
+          annual_range.each(&:rename_month_label_by_solar_term)
+        end
+        private_class_method :initialize_month_label
+      end
+    end
+  end
+end

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'date'
-require_relative '../abstract_version'
 require_relative '../../era/western'
-require_relative 'summary/specifier'
+require_relative '../abstract_version'
+require_relative '../context'
+require_relative '../../calculation/summary/single'
 
 # :nodoc:
 module Zakuro
@@ -18,16 +19,21 @@ module Zakuro
       # @return [True] リリースあり
       RELEASE = true
 
+      # @return [String] 暦クラス名
+      VERSION_NAME = 'Senmyou'
+
       #
       # 西暦日から和暦日に変換する
       #
       # @param [Date] western_date 西暦日
       #
-      # @return [Result::SingleDay] 和暦日
+      # @return [Result::Single] 和暦日
       #
       def self.to_japan_date(western_date:)
         date = Western::Calendar.create(date: western_date)
-        SingleDaySpecifier.get(date: date)
+
+        context = Context.new(version_name: VERSION_NAME)
+        Calculation::Summary::Single.get(context: context, date: date)
       end
     end
   end

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

@@ -13,7 +13,7 @@ module Zakuro
       # @return [Integer] 暦中日
       # @note ANOMALISTIC_MONTH の半分に相当する
       HALF_ANOMALISTIC_MONTH = \
-        LunarRemainder.new(day: 13, minute: 6529, second: 9.5)
+        Cycle::LunarRemainder.new(day: 13, minute: 6529, second: 9.5)
 
       #
       # Adjustment 補正値情報
@@ -122,7 +122,7 @@ module Zakuro
       # @return [True] 正しくない
       #
       def self.valid?(remainder:)
-        return if remainder.is_a?(LunarRemainder)
+        return if remainder.is_a?(Cycle::LunarRemainder)
 
         raise ArgumentError, "unmatch parameter type: #{remainder.class}"
       end
@@ -255,7 +255,7 @@ module Zakuro
       #
       # 天正冬至（入暦前回未計算）を求める
       #
-      # @param [Remainder] winter_solstice_age 昨年冬至
+      # @param [Remainder] winter_solstice_age 天正閏余
       # @param [Integer] western_year 西暦年
       #
       # @return [LunarRemainder] 入暦
@@ -272,14 +272,14 @@ module Zakuro
           total_year * WinterSolstice::YEAR - winter_solstice_age.to_minute
 
         remainder_month = \
-          LunarRemainder.new(total: (total_day % ANOMALISTIC_MONTH))
+          Cycle::LunarRemainder.new(total: (total_day % ANOMALISTIC_MONTH))
 
         remainder_month, is_forward = decrease_moon_point(
           remainder_month: remainder_month,
           remainder_limit: HALF_ANOMALISTIC_MONTH, is_forward: true
         )
 
-        remainder_month.add!(Remainder.new(day: 1, minute: 0, second: 0))
+        remainder_month.add!(Cycle::Remainder.new(day: 1, minute: 0, second: 0))
 
         [remainder_month, is_forward]
       end
@@ -302,7 +302,7 @@ module Zakuro
         remainder_month, is_forward = \
           decrease_moon_point(
             remainder_month: remainder,
-            remainder_limit: Remainder.new(day: 14, minute: 6529, second: 0),
+            remainder_limit: Cycle::Remainder.new(day: 14, minute: 6529, second: 0),
             is_forward: is_forward
           )
 

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

@@ -7,212 +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 }
+      SOLAR_TERM_AVERAGE = Cycle::Remainder.new(day: 15, minute: 1835, second: 5)
 
       #
-      # 冬至から数えた1年データの月ごとに二十四節気を割り当てる
+      # 初期化
       #
       # @param [Integer] western_year 西暦年
-      # @param [Array<Month>] annual_range 1年データ
-      #
-      # @return [Array<Month>] 1年データ
       #
-      def self.set_solar_terms_into_annual_range(western_year:, annual_range:)
-        # 天正冬至
-        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_range: annual_range,
-                                                    solar_terms: solar_terms)
-
-        # 前後の二十四節気
-        rest_solar_terms = \
-          collect_solar_terms_before_and_after(solar_terms: solar_terms)
-
-        apply_solar_terms_before_and_after(annual_range: annual_range,
-                                           rest_solar_terms: rest_solar_terms)
-
-        annual_range
+      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_range 1年データ
-      # @param [Array<Remainder>] solar_terms 1年データ内の全二十四節気
+      # @param [Integer] western_year 西暦年
       #
-      def self.apply_solar_terms_from_last_winter_solstice(annual_range:, solar_terms:)
-        month_index = 0
-        solar_term_index = 0
-        month_size = annual_range.size
-
-        while month_index < month_size && solar_term_index < solar_terms.size
-          raise StandardError, "month is over. idx: #{month_index}" if month_index >= month_size
-
-          if set_solar_term_on_current_month(current_month: annual_range[month_index],
-                                             next_month: annual_range[month_index + 1],
-                                             solar_term: solar_terms[solar_term_index],
-                                             solar_term_index: solar_term_index)
-            solar_term_index += 1
-            next
-          end
+      # @return [SolarTerm] 二十四節気
+      #
+      def self.first_solar_term(western_year:)
+        # 天正冬至
+        winter_solstice = WinterSolstice.calc(western_year: western_year)
 
-          month_index += 1
-        end
-      end
-      private_class_method :apply_solar_terms_from_last_winter_solstice
+        # 二十四節気（冬至）
+        solar_term = Cycle::SolarTerm.new(index: 0, remainder: winter_solstice)
 
-      #
-      # 当月に二十四節気を設定する
-      #
-      # @param [Remainder] current_month 当月
-      # @param [Month] next_month 次月
-      # @param [Month] solar_term 二十四節気
-      # @param [Integer] solar_term_index 二十四節気位置
-      #
-      # @return [True] 設定済
-      # @return [False] 未設定
-      #
-      def self.set_solar_term_on_current_month(current_month:,
-                                               next_month:, solar_term:, solar_term_index:)
-        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: solar_term_index)
-          return true
-        end
+        first_solar_term_index = SolarAverage.calc_fist_solar_term_index(western_year: western_year)
 
-        # 一度も割り当てがない場合は設定済みとして次の二十四節気を進める
-        return true if current_month.empty_solar_term?
+        # 対象の二十四節気まで戻す
+        solar_term.prev_by_index(first_solar_term_index)
 
-        false
+        solar_term
       end
 
       #
-      # 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: Cycle::SolarTerm.new(remainder: winter_solstice_age)
+        )
 
-      # :reek:TooManyStatements { max_statements: 6 }
+        solar_term_index = solar_location.index
 
-      #
-      # 1年データ前後の二十四節気を適用する
-      #
-      # @param [Array<Month>] annual_range 1年データ
-      # @param [Hash<Integer, Hash<Symbol, Integer>>, Hash<Integer, Hash<Symbol, Remainder>>]
-      #   rest_solar_terms 前後
-      #
-      def self.apply_solar_terms_before_and_after(annual_range:, rest_solar_terms:)
-        rest_solar_terms.each do |key, value|
-          index = value[:index]
-          solar_term = value[:solar_term]
-          data = annual_range[index]
-          next unless in_range_solar_term?(
-            target: solar_term,
-            min: data.remainder, max: annual_range[index + 1].remainder
-          )
+        # 入定気の一つ後の二十四節気まで戻す（ただし11月経朔が二十四節気上にある場合は戻さない）
+        solar_term_index += 1 unless solar_location.remainder == Cycle::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_term!
       end
-      private_class_method :set_solar_term
     end
   end
 end