when_exe 0.3.5 → 0.3.6

data/lib/when_exe/calendartypes.rb

@@ -58,7 +58,7 @@ module When::CalendarTypes
     def _normalize(args=[], options={})
       @label   ||= m17n('Z')
       @indices ||= When::Coordinates::DefaultTimeIndices
-      @note    ||= 'JulianDayNotes'
+      @note    ||= 'JulianDay'
       _normalize_spatial
       _normalize_temporal
       @second    = (@second||1/When::TM::Duration::SECOND).to_f
@@ -144,6 +144,197 @@ module When::CalendarTypes
     end
   end
 
+  # 
+  # 太陰(太陽)暦の朔閏パターンを扱うモジュール
+  #
+  module Lunar
+
+    # @private
+    Pattern = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+    # 朔閏表を生成する
+    #
+    # @param  [Range] range 生成範囲(西暦年)
+    # @param  [Integer] length 大の月の日数
+    # @param  [When::TM::Duration] duration チェックする月の間隔
+    #
+    # @return [Hash] 朔閏表
+    #
+    def lunar_table(range, length=30, duration=When::P1M)
+      date  = When.TemporalPosition(range.first, {:frame=>self}).floor
+      table = []
+      hash  = {
+        'origin_of_MSC' => range.first,
+        'origin_of_LSC' => date.to_i,
+        'rule_table'    => table
+      }
+      list  = ''
+      while range.include?(date[YEAR])
+        month = date[MONTH] * 1
+        char  = Pattern[month..month]
+        char  = char.downcase unless date.length(MONTH) == length
+        list += char
+        succ  = date + duration
+        unless date[YEAR] == succ[YEAR]
+          table << list
+          list = ''
+        end
+        date = succ
+      end
+      hash
+    end
+
+    # 朔閏表を比較する
+    #
+    # @param  [When::TM::Calendar] base 基準とする暦法
+    # @param  [Range] range 比較範囲(西暦年)
+    # @param  [Integer] length 大の月の日数
+    # @param  [When::TM::Duration] duration チェックする月の間隔
+    #
+    # @return [Hash] 朔閏表の差分
+    #
+    def verify(base, range=base.range, length=30, duration=When::P1M)
+      range = When::Parts::GeometricComplex.new(range) & When::Parts::GeometricComplex.new(self.range) if respond_to?(:range)
+      base_table = base.lunar_table(range, length, duration)
+      self_table = self.lunar_table(range, length, duration)
+      hash = {}
+      range.each do |year|
+        difference = _verify(base_table['rule_table'][year-range.first],
+                             self_table['rule_table'][year-range.first])
+        hash[year] = difference if difference
+      end
+      hash
+    end
+
+    # @private
+    def _verify(source, target)
+      return nil if source == target
+      return {source => target} unless source.length == target.length
+      indices = []
+      index   = []
+      source.length.times do |i|
+        if source[i..i] == target[i..i]
+          unless index.empty?
+            indices << index
+            index = []
+          end
+        else
+          index << i
+        end
+      end
+      indices << index unless index.empty?
+      ranges = []
+      indices.each do |index|
+        if ranges.empty? || index.first > ranges.last.last + 2
+          ranges << index
+        else
+          ranges[-1] = [ranges.last.first,index.last]
+        end
+      end
+      hash = {}
+      ranges.each do |index|
+        range = index.first..index.last
+        hash[source[range]] = target[range]
+      end
+      test = source.dup
+      hash.each_pair do |key, value|
+        test.sub!(key, value)
+      end
+    # raise ArgumentError, "can't replace '#{source}'=>'#{target}' by #{hash}." unless test == target
+      return hash if test == target
+      {source => target}
+    end
+  end
+
+  # 
+  # 朔閏パターンの表の拡張
+  #
+  module TableExtend
+
+    # 年月日 -> 通日
+    #
+    # @param  [Numeric] y 年
+    # @param  [Integer] m 月 (0 始まり)
+    # @param  [Integer] d 日 (0 始まり)
+    #
+    # @return [Integer] 通日
+    #
+    def _coordinates_to_number(y, m, d)
+      if @after && y >= @rule_table[@entry_key]['Years']
+        _normalize_after
+        return @after._coordinates_to_number(y + @_after_offset, m, d)
+      end
+      if @before && y < 0
+        _normalize_before
+        return @before._coordinates_to_number(y + @_before_offset, m, d)
+      end
+      super
+    end
+
+    # 通日 - > 年月日
+    #
+    # @param  [Integer] sdn 通日
+    #
+    # @return [Array<Integer>] [ y, m, d ]
+    #   y 年
+    #   m 月 (0 始まり)
+    #   d 日 (0 始まり)
+    #
+    def _number_to_coordinates(sdn)
+      if @after && sdn >= @origin_of_LSC + @rule_table[@entry_key]['Days']
+        _normalize_after
+        y, m, d = @after._number_to_coordinates(sdn)
+        return [y - @_after_offset, m, d]
+      end
+      if @before && sdn < @origin_of_LSC
+        _normalize_before
+        y, m, d = @before._number_to_coordinates(sdn)
+        return [y - @_before_offset, m, d]
+      end
+      super
+    end
+
+    #
+    # その他のテーブル参照
+    #
+    %w(ids_ length).each do |method|
+      module_eval %Q{
+        def _#{method}(date)
+          if @after && +date[0] >= @rule_table[@entry_key]['Years']
+            _normalize_after
+            date[0] += @_after_offset
+            return @after.send(:_#{method}, date)
+          end
+          if @before && +date[0] < 0
+            _normalize_before
+            date[0] += @_before_offset
+            return @before.send(:_#{method}, date)
+          end
+          super
+        end
+      }
+    end
+
+    private
+
+    def _normalize_after
+      raise RangeError, "Out of range: #{iri}" if @after.kind_of?(Symbol)
+      @after = When.Calendar(@after)
+      @_after_offset = @origin_of_MSC - @after.origin_of_MSC
+      class << self; alias :_normalize_after :_normalize_non end
+    end
+
+    def _normalize_before
+      raise RangeError, "Out of range: #{iri}" if @before.kind_of?(Symbol)
+      @before = When.Calendar(@before)
+      @_before_offset = @origin_of_MSC - @before.origin_of_MSC
+      class << self; alias :_normalize_before :_normalize_non end
+    end
+
+    def _normalize_non
+    end
+  end
+
   # 月日の配当パターンの種類が限定されている暦の抽象基底クラス
   #
   #   Calendar which has some fixed arrangement rules for under year
@@ -245,6 +436,9 @@ module When::CalendarTypes
         @mean_month = Rational(@rule_table[@entry_key]['Days'], @rule_table[@entry_key]['Months'])
         @mean_year  = Rational(@rule_table[@entry_key]['Days'], @rule_table[@entry_key]['Years' ])
       end
+
+      # range extension
+      extend(TableExtend) if @before || @after
     end
 
     # rule の正規化
@@ -349,20 +543,16 @@ module When::CalendarTypes
       rule = {
         'Years'  => 1,
         'Months' => key.length,
-        'Days'   => key.length * 29 + key.gsub(/[a-z]/,'').length,
+        'Days'   => _year_length(key),
         'IDs'    => [],
         'Length' => [],
         'Offset' => []
       }
 
-      key.length.times do |k|
-        rule['Length'] << (key[k,1] =~ /[a-z]/ ? 29 : 30)
-        rule['Offset'] << (k == 0 ? 0 : rule['Offset'][k-1]+rule['Length'][k-1])
-        trunk  = key.upcase[k]
-        branch = (trunk == key.upcase[k-1]) ? 1 : 0
-        trunk  = trunk.ord if trunk.kind_of?(String)
-        trunk -= 64
-        rule['IDs'] << ((branch==0) ? trunk : When::Coordinates::Pair.new(trunk, branch))
+      key.length.times do |m|
+        rule['Length'] << _month_length(key, m)
+        rule['Offset'] << (m == 0 ? 0 : rule['Offset'][m-1]+rule['Length'][m-1])
+        rule['IDs'] << _month_id(key, m)
       end
       return rule
     end
@@ -374,6 +564,115 @@ module When::CalendarTypes
   #
   class PatternTableBasedLuniSolar < TableBased
 
+    include Lunar
+
+    class << self
+      #
+      # ひとつのひな型朔閏表からの差分で朔閏表を生成する
+      #
+      # @param [Array] definition ひな型朔閏表
+      # @param [Range] range 生成する朔閏表の年代範囲
+      # @param [Hash{Integer=>(String or Hash{String or Regexp=>String})}] difference 差分情報
+      #
+      # @return [Array] 生成された朔閏表定義
+      #
+      def patch(definition, range=nil, difference={})
+        When.Calendar(definition)
+        base    = When::CalendarTypes.const_get(definition)
+        hash    = base[-1].dup
+        range ||= hash['origin_of_MSC']...(hash['origin_of_MSC']+hash['rule_table'].size)
+        range   = range.to_a
+        hash['origin_of_LSC'] += hash['rule_table'][range[0]-hash['origin_of_MSC']][1]
+        hash['rule_table']     = range.map {|year|
+          original = hash['rule_table'][year-hash['origin_of_MSC']][0]
+          case difference[year]
+          when String ; next difference[year]
+          when nil    ; next original
+          end
+          original = original.dup
+          difference[year].each_pair {|key,value|
+            raise ArgumentError, "Can't patch \"#{original}\" by {#{key}=>#{value}} at #{year}" unless original.sub!(key,value)
+          }
+          original
+        }
+        hash['origin_of_MSC']  = range[0]
+        base[0..-2] + [hash]
+      end
+
+      #
+      # 複数のひな型朔閏表からの差分で朔閏表を生成する
+      #
+      # @param [[Array<Array<String, Range>>]] definitions ひな型朔閏表
+      #     - String - もとにする太陰太陽暦のIRI文字列
+      #     - Range  - 朔閏表の年代範囲(デフォルトはもとにする太陰太陽暦の年代範囲)
+      # @param [Hash{Integer=>(String or Hash{String or Regexp=>String})}] difference 差分情報
+      #
+      # @return [Array] 生成された朔閏表定義
+      #
+      def join(definitions, difference={})
+        if definitions.first.kind_of?(Array)
+          base = When::CalendarTypes.const_get(definitions.first[0]).dup
+        else
+          base = []
+          base << definitions.shift until definitions.first.kind_of?(Array)
+        end
+        tables = definitions.map {|definition|
+          When.Calendar(definition[0]).lunar_table(definition[1])
+        }
+        hash   = base.pop.merge({
+          'origin_of_MSC' => tables.first['origin_of_MSC'],
+          'origin_of_LSC' => tables.first['origin_of_LSC'],
+          'rule_table'    => tables.inject([]) {|rules, table| rules += table['rule_table']}
+        })
+        difference.each_pair do |year, pattern|
+          offset = year - hash['origin_of_MSC']
+          hash['rule_table'][offset] =
+           if pattern.kind_of?(Hash)
+              rule = hash['rule_table'][offset].dup
+              pattern.each_pair do |key,value|
+                raise ArgumentError, "Can't patch \"#{rule}\" by {#{key}=>#{value}} at #{year}" unless rule.sub!(key,value)
+              end
+              rule
+            else
+              pattern
+            end
+        end
+        base << hash
+      end
+    end
+
+    # 朔閏表を生成する
+    #
+    # @param  [Range] sub_range 生成範囲(西暦年) デフォルトは self.range
+    # @param  [Integer] length 大の月の日数(ダミー)
+    # @param  [When::TM::Duration] duration チェックする月の間隔(ダミー)
+    #
+    # @return [Hash] 朔閏表
+    #
+    def lunar_table(sub_range=nil, length=nil, duration=nil)
+      sub_range ||= range
+      last  = sub_range.last
+      last -= 1 if sub_range.exclude_end?
+      [sub_range.first, last].each do |edge|
+        raise RangeError, 'Range exceeded: ' + sub_range.to_s unless range.include?(edge)
+      end
+      {
+        'origin_of_MSC' => sub_range.first,
+        'origin_of_LSC' => @origin_of_LSC + @rule_table['T']['Rule'][sub_range.first-@origin_of_MSC][1],
+        'rule_table'    => sub_range.to_a.map {|year|
+          @rule_table['T']['Rule'][year-@origin_of_MSC][0]
+        }
+      }
+    end
+
+    # 朔閏表の有効範囲
+    #
+    # @return [Range] 有効範囲(西暦年)
+    #
+    def range
+       @origin_of_MSC...(@origin_of_MSC+@rule_table['T']['Rule'].length)
+    end
+
     private
 
     #  new で指定された月日配当規則をプログラムで利用可能にします。
@@ -408,8 +707,8 @@ module When::CalendarTypes
 
     # オフセットの更新
     def _increment_offsets(offsets, subkey)
-      offsets[1] += subkey.length                                       # 月のオフセットを月数分進める
-      offsets[0] += subkey.length * 29 + subkey.gsub(/[a-z]/,'').length # 日のオフセットを日数分進める
+      offsets[1] += subkey.length        # 月のオフセットを月数分進める
+      offsets[0] += _year_length(subkey) # 日のオフセットを日数分進める
     end
 
     # 年初の通日によるセットアップ
@@ -453,12 +752,48 @@ module When::CalendarTypes
       return rule['Rule'][year][0]
     end
 
+    # 朔閏パターン -> 日数/年
+    #
+    # @param [String] key 朔閏パターン
+    #
+    # @return [Integer] 日数/年
+    #
+    def _year_length(key)
+      key.length * 29 + key.gsub(/[a-z]/,'').length
+    end
+
+    # 朔閏パターン -> 日数/年
+    #
+    # @param [String] key 朔閏パターン
+    # @param [Integer] m 月番号(0始まり)
+    #
+    # @return [Integer] 日数/月
+    #
+    def _month_length(key, m)
+      key[m,1] =~ /[a-z]/ ? 29 : 30
+    end
+
+    # 朔閏パターン -> 月のID
+    #
+    # @param [String] key 朔閏パターン
+    # @param [Integer] m 月番号(0始まり)
+    #
+    # @return [Integer] 月のID
+    #
+    def _month_id(key, m)
+      trunk  = key.upcase[m]
+      branch = trunk == key.upcase[m-1] ? 1 : 0
+      trunk  = trunk.ord if trunk.kind_of?(String)
+      trunk -= 64
+      branch == 0 ? trunk : When::Coordinates::Pair.new(trunk, branch)
+    end
+
     # オブジェクトの正規化
     #
     # @note インスタンス変数 @note は to_a でデフォルトとして用いる暦注
     #
     def _normalize(args=[], options={})
-      @note ||= When.CalendarNote('ChineseNotes') # See when.rb
+      @note ||= When.CalendarNote('Chinese') # See when.rb
       super
     end
   end
@@ -484,6 +819,58 @@ module When::CalendarTypes
     end
   end
 
+  # 表引きにより実現する太陽暦(閏月なし, 5,6,27～34日の月に対応)
+  #
+  #   Solar calendar which uses year / month /day table
+  #
+  class PatternTableBasedSolar < PatternTableBasedLuniSolar
+
+    private
+
+    # 朔閏パターン -> 日数/年
+    #
+    # @param [String] key 朔閏パターン
+    #
+    # @return [Integer] 日数/年
+    #
+    def _year_length(key)
+      length = 0
+      key.length.times do |m|
+        length += _month_length(key, m)
+      end
+      length
+    end
+
+    # 朔閏パターン -> 日数/年
+    #
+    # @param [String] key 朔閏パターン
+    # @param [Integer] m 月番号(0始まり)
+    #
+    # @return [Integer] 日数/月
+    #
+    def _month_length(key, m)
+      trunk  = key.upcase[m]
+      trunk  = trunk.ord if trunk.kind_of?(String)
+      trunk -= 48
+      case trunk
+      when 5, 6 ; trunk
+      when 7..9 ; trunk + 20
+      else      ; trunk + 30
+      end
+    end
+
+    # 朔閏パターン -> 月のID
+    #
+    # @param [String] key 朔閏パターン
+    # @param [Integer] m 月番号(0始まり)
+    #
+    # @return [Integer] 月のID
+    #
+    def _month_id(key, m)
+      m + 1
+    end
+  end
+
   # 年の配当パターンが限定されている暦
   #
   #   Calendar which has some fixed arrangement rules of year pattern
@@ -788,8 +1175,8 @@ module When::CalendarTypes
     private
 
     # オブジェクトの正規化
-    # @cycle_offset   = 位相のオフセット / １か月分の角度
-    # @formula        = 位相の計算に用いる太陽の Formula
+    # cycle_offset   = 位相のオフセット / １か月分の角度
+    # formula        = 位相の計算に用いる太陽の Formula
     #
     def _normalize(args=[], options={})
       @cycle_offset   ||= -1.5
@@ -804,6 +1191,8 @@ module When::CalendarTypes
   #
   class EphemerisBasedLunar < EphemerisBased
 
+    include Lunar
+
     #protected
 
     # 月初の通日
@@ -819,13 +1208,13 @@ module When::CalendarTypes
     private
 
     # オブジェクトの正規化
-    # @cycle_offset   = Goldstein Number に対する暦元の補正
+    # cycle_offset   = Goldstein Number に対する暦元の補正
     #
     def _normalize(args=[], options={})
       @cycle_offset ||= 1671 * 12 + 4
       super
     end
- end
+  end
 
   # 月日の配当が太陽および月の位置によって決定される太陰太陽暦
   #
@@ -833,6 +1222,8 @@ module When::CalendarTypes
   #
   class EphemerisBasedLuniSolar < EphemerisBasedSolar
 
+    include Lunar
+
     # 計算方法
     # @return [Array<When::Ephemeris::Formula>]
     attr_reader :formula
@@ -847,7 +1238,7 @@ module When::CalendarTypes
     #
     # @return [Integer] 通日
     #
-    def _coordinates_to_number(yy, mm=0, dd=0)
+    def _coordinates_to_number(yy, mm, dd)
       _new_month(_new_year_month(+yy) + mm) + dd
     end
 
@@ -931,9 +1322,9 @@ module When::CalendarTypes
 
     # オブジェクトの正規化
     #
-    # @cycle_offset = 雨水の場合 -1
-    # @formula      = 位相の計算に用いる太陽と月の Formula
-    # @notes        = to_a でデフォルトとして用いる暦注
+    # cycle_offset = 雨水の場合 -1
+    # formula      = 位相の計算に用いる太陽と月の Formula
+    # notes        = to_a でデフォルトとして用いる暦注
     #
     def _normalize(args=[], options={})
       @formula ||= ['Formula?formula=12S', 'Formula?formula=1L']
@@ -1095,7 +1486,7 @@ module When::CalendarTypes
     #
     # @note 属性 @event によって境界を計算する (see {When::Ephemeris::Formula#day_event})
     #
-    def border(date=[], clock=When.utc)
+    def border(date=[], clock=When::UTC)
       return @border unless date[0] && clock.formula
 
       clock._encode(