when_exe 0.4.2 → 0.5.0

data/lib/when_exe/tmptypes.rb

@@ -0,0 +1,1279 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2011-2016 Takashi SUGA
+
+  You may use and/or modify this file according to the license described in the LICENSE.txt file included in this archive.
+=end
+
+module When::TM
+
+  #
+  # 時間座標 - 単一の時間間隔によって定義する連続な間隔尺度を基礎とする
+  #
+  # see {http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#TimeCoordinateType gml schema}
+  #
+  class Coordinate < TemporalPosition
+
+    class << self
+      # 内部時間によるオブジェクトの生成
+      alias :universal_time :new
+
+      # 外部時間によるオブジェクトの生成
+      #
+      # @param [Numeric] dynamical_time 外部時間による時間座標値
+      #
+      # @param [Hash] options 下記の通り
+      # @option options [When::TimeStandard] :time_standard
+      #
+      # @return [When::TM::Coordinate]
+      #
+      def dynamical_time(dynamical_time, options={})
+        universal_time(When.Resource(options[:time_standard] || 'UniversalTime', '_t:').from_dynamical_time(dynamical_time), options)
+      end
+
+      # 他種の時間位置によるオブジェクトの生成
+      #
+      # @param [Numeric, When::TM::ClockTime, ::Time, ::Date, ::DateTime] time 他種の時間位置によるオブジェクト
+      #
+      # @param [Hash] options 下記の通り
+      # @option options [When::TM::Clock] :clock
+      # @option options [When::Parts::Timezone] :tz
+      #
+      # @return [When::TM::Coordinate]
+      #
+      def new(time, options={})
+        options         = options.dup
+        options[:frame] = Clock.get_clock_option(options)
+        case time
+        when Numeric
+          options[:frame] ||= When::UTC unless time.kind_of?(Integer)
+          universal_time    = (2*time - (2*JulianDate::JD19700101-1)) * Duration::DAY.to_i / 2.0
+        when ClockTime
+          options[:frame] ||= time.clock
+          universal_time    = time.clk_time[0] + time.universal_time
+        when ::Time
+          options[:frame] ||= When.Clock(time.gmtoff)
+          universal_time    = options[:frame].time_standard.from_time_object(time)
+        when TimeValue
+          options[:frame] ||= time.clock
+          universal_time    = time.universal_time
+        else
+          if ::Object.const_defined?(:Date) && ::Date.method_defined?(:+) && time.respond_to?(:ajd)
+            case time
+            when ::DateTime
+              options[:frame] ||= When.Clock((time.offset * 86400).to_i)
+              universal_time    = (2*time.ajd - (2*JulianDate::JD19700101-1)) * Duration::DAY.to_i / 2.0
+            when ::Date
+              universal_time    = JulianDate._d_to_t(time.jd)
+              if options[:frame] && options[:frame].rate_of_clock != 1.0
+                universal_time  = options[:frame].time_standard.from_dynamical_time(
+                                               When::TimeStandard.to_dynamical_time(universal_time))
+              end
+            end
+          end
+        end
+        raise TypeError, "Can't create #{self} from #{time.class}" unless universal_time
+        universal_time(universal_time, options)
+      end
+    end
+
+    # この時間位置と関連付けられた時間参照系 (relation - Reference)
+    #
+    # The time reference system associated with the temporal position being described
+    #
+    # @return [When::TM::ReferenceSystem]
+    #
+    alias :clock :frame
+
+    # 内部時間による時間座標値
+    #
+    # @return [Numeric]
+    #
+    attr_accessor :universal_time
+    alias :coordinateValue :universal_time
+    protected :universal_time=
+
+    # 内部時間(ローカル)
+    #
+    # @return [Numeric]
+    #
+    #   1970-01-01T00:00:00(ローカル) からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    def local_time
+      @universal_time
+    end
+
+    # CoordinateSystem による時間座標値
+    #
+    # @return [Numeric]
+    #
+    def coordinateValue
+      (universal_time - frame.origin.universal_time) / frame.interval.to_f
+    end
+
+    # 加算
+    #
+    # @param [Numeric, When::TM::IntervalLength] other
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    def +(other)
+      other = other.to_interval_length if other.kind_of?(PeriodDuration)
+      super(other)
+    end
+
+    # 減算
+    #
+    # @param [When::TM::TemporalPosition, Numeric, When::TM::IntervalLength] other
+    #
+    # @return [When::TM::TemporalPosition] if other is a Numeric or When::TM::IntervalLength
+    # @return [When::TM::IntervalLength]   if other is a When::TM::TemporalPosition
+    #
+    def -(other)
+      other = other.to_interval_length if other.kind_of?(PeriodDuration)
+      super(other)
+    end
+
+    # 前の時刻
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    #   分解能に対応する Duration だけ,日時を戻す
+    #
+    def prev
+      self - period
+    end
+
+    # 次の時刻
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    #   分解能に対応する Duration だけ,日時を進める
+    #
+    def succ
+      self + period
+    end
+    alias :next :succ
+
+    # オブジェクトの生成
+    #
+    # @param [Numeric] universal_time 内部時間による時間座標値
+    #
+    # @param [Hash] options 下記の通り
+    # @option options [When::TM::CoordinateSystem] :frame
+    #
+    def initialize(universal_time, options={})
+      super(options)
+      @universal_time = universal_time
+    end
+  end
+
+  #
+  # ユリウス日
+  #
+  # see {http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#JulianDateType CALENdeRsign}
+  #
+  class JulianDate < Coordinate
+
+    # Julian Day Number
+    #   19700101T120000Z
+    JD19700101 = 2440588
+
+    # Modified Julian Date
+    # 
+    # see {https://en.wikipedia.org/wiki/Julian_day#Variants MJD}
+    JDN_of_MJD = 2400000.5
+
+    # Countdown to Equinoctial Planetconjunction 
+    # 
+    # see {http://www.calendersign.com/en/cs_cep-pec.php CEP}
+    JDN_of_CEP = 2698162
+
+    class << self
+
+      JD19700100_5 = JD19700101 - 0.5
+
+      #
+      # 日時の内部表現をユリウス日に変換
+      #
+      # @param [Numeric] t
+      #
+      # @return [Numeric]
+      #
+      def _t_to_d(t)
+        t / Duration::DAY + JD19700100_5
+      end
+
+      #
+      # ユリウス日をに日時の内部表現変換
+      #
+      # @param [Numeric] d
+      #
+      # @return [Numeric]
+      #
+      def _d_to_t(d)
+        (d - JD19700100_5) * Duration::DAY
+      end
+
+      # Generation of Temporal Objetct
+      #
+      # @param [String] specification ユリウス通日を表す文字列
+      # @param [Hash] options 暦法や時法などの指定 (see {When::TM::TemporalPosition._instance})
+      #
+      # @return [When::TM::TemporalPosition, When::TM::Duration, When::Parts::GeometricComplex or Array<them>]
+      #
+      def parse(specification, options={})
+        num, *calendars = specification.split(/\^{1,2}/)
+        jdn  = num.sub!(/[.@]/, '.') ? num.to_f : num.to_i
+        case num
+        when /MJD/i ; jdn += JDN_of_MJD
+        when /CEP/i ; jdn += JDN_of_CEP
+        when /DTB/i ; jdn  = time_standard(options).from_dynamical_date(jdn)
+        end
+        frame = calendars.shift || options[:frame]
+        return self.new(jdn, options) unless frame
+        calendars.unshift(frame).inject(jdn) {|date, calendar| When.Calendar(calendar).jul_trans(date, options)}
+      end
+
+      private
+
+      #
+      # Time Standard を選択する
+      #
+      def time_standard(options)
+        ts   = options[:time_standard]
+        ts ||= options[:clock] unless options[:clock].kind_of?(When::Parts::Timezone)
+        ts ||= '_t:UniversalTime'
+        ts   = When.Resource(ts)
+        ts   = ts.time_standard if ts.kind_of?(When::TM::Clock)
+        ts
+      end
+    end
+
+    # 加算
+    #
+    # @param [Numeric, When::TM::IntervalLength] other
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    def +(other)
+      new_date = super
+      new_date.frame = new_date.frame._daylight(new_date.universal_time) if new_date.frame && new_date.frame._need_validate
+      return new_date
+    end
+
+    # 減算
+    #
+    # @param [When::TM::TemporalPosition, Numeric, When::TM::IntervalLength] other
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    def -(other)
+      new_date = super
+      new_date.frame = new_date.frame._daylight(new_date.universal_time) if new_date.kind_of?(TimeValue) && new_date.frame && new_date.frame._need_validate
+      return new_date
+    end
+
+    # ユリウス日が指定の剰余となる日
+    #
+    # @param [When::Coordinates::Residue] other
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    def &(other)
+      raise TypeError,"The right operand should be When::Coordinates::Residue" unless other.kind_of?(Residue)
+      raise ArgumentError,"The right operand should have a unit 'day'" unless other.event == 'day'
+      jdn      = to_i
+      new_date = self.dup
+      new_date.universal_time += ((other & jdn) - jdn) * Duration::DAY
+      return new_date
+    end
+
+    # ユリウス日の剰余
+    #
+    # @param [When::Coordinates::Residue] other
+    #
+    # @return [Numeric]
+    #
+    def %(other)
+      raise TypeError,"The right operand should be When::Coordinates::Residue" unless other.kind_of?(Residue)
+      raise ArgumentError,"The right operand should have a unit 'day'" unless other.event == 'day'
+      other % to_i
+    end
+
+    private
+
+    # オブジェクトの生成
+    #
+    # @param [Numeric] universal_time 内部時間による時間座標値
+    #
+    # @param [Hash] options 以下の通り
+    # @option options [When::TM::Clock] :frame
+    # @option options [Integer] :precision
+    #
+    def initialize(universal_time, options={})
+      @frame = options.delete(:frame)
+      @frame = When.Clock(@frame) if @frame.kind_of?(String)
+      @frame = @frame._daylight(universal_time) if @frame && @frame._need_validate
+      precision    = options.delete(:precision)
+      precision  ||= DAY unless @frame.kind_of?(Clock)
+      @precision   = Index.precision(precision)
+      super
+    end
+  end
+
+  #
+  # 順序時間参照系で参照する位置
+  #
+  # see {http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#TimeOrdinalPositionType gml schema}
+  #
+  class OrdinalPosition < TemporalPosition
+
+    # この順序位置と関連付けられた順序年代 (relation - Reference)
+    #
+    # The ordinal era associated with the ordinal position being described
+    #
+    # @return [When::TM::OrdinalEra]
+    #
+    attr_reader :ordinal_position
+    alias :ordinalPosition :ordinal_position
+
+    # オブジェクトの生成
+    #
+    # @param [When::TM::OrdinalEra] ordinal_position この順序位置と関連付けられた順序年代
+    # @param [Hash] options see {When::TM::TemporalPosition._instance}
+    #
+    def initialize(ordinal_position, options={})
+      super(options)
+      @ordinal_position = ordinal_position
+    end
+  end
+
+  #
+  # 時刻
+  #
+  # see {http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#ClockTimeType gml schema}
+  #
+  class ClockTime < TemporalPosition
+
+    # 時刻要素
+    #
+    # @return [Array<Numeric>]
+    #
+    # @note ISO19108 では sequence<Integer> だが、閏時・閏秒などが表現可能なよう Numeric としている。
+    #
+    attr_reader :clk_time
+    alias :clkTime :clk_time
+
+    # この時間位置と関連付けられた時間参照系 (relation - Reference)
+    #
+    # The time reference system associated with the temporal position being described
+    #
+    # @return [When::TM::ReferenceSystem]
+    #
+    alias :clock :frame
+
+    # 内部時間
+    #
+    # @param [Integer] sdn 参照事象の通し番号
+    #
+    # @return [Numeric]
+    #
+    #   T00:00:00Z からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    #   時法によっては、異なる意味を持つことがある
+    #
+    def universal_time(sdn=nil)
+      raise NameError, "Temporal Reference System is not defined" unless @frame
+      @universal_time ||= @frame.to_universal_time(@clk_time, sdn)
+    end
+
+    # 内部時間(ローカル)
+    #
+    # @param [Integer] sdn 参照事象の通し番号
+    #
+    # @return [Numeric]
+    #
+    #   T00:00:00(ローカル) からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    #   時法によっては、異なる意味を持つことがある
+    #
+    def local_time(sdn=nil)
+      raise NameError, "Temporal Reference System is not defined" unless @frame
+      @local_time ||= @frame.to_local_time(@clk_time, sdn)
+    end
+
+    # 繰り上がり
+    #
+    # @return [Numeric]
+    #
+    #   日付の境界が午前0時でない場合、clk_time の最上位桁に 0 以外が入ることがある
+    #
+    def carry
+      return @clk_time[0]
+    end
+
+    # 要素の参照
+    #
+    # @param [Integer, String] index 参照する要素の指定
+    #
+    # @return [Numeric]
+    #
+    def value(index)
+      @clk_time[_digit(index) {|digit| digit >= DAY}]
+    end
+
+    #protected
+    # 属性のコピー
+    # @private
+    def _copy(options={})
+      @clk_time = options[:time] if options.key?(:time)
+      if options.key?(:clock)
+        options.delete(:frame)
+        @frame  = options[:clock]
+      end
+      if options.key?(:tz_prop)
+        @frame  = @frame.dup
+        @frame.tz_prop = options[:tz_prop]
+      end
+      return super
+    end
+
+    # オブジェクトの生成
+    #
+    # @param [String] time ISO8601形式の時刻表現
+    # @param [Array<Numeric>] time (日, 時, 分, 秒)
+    #     
+    #
+    # @param [Hash] options 以下の通り
+    # @option options [When::TM::Clock] :frame
+    # @option options [Integer] :precision
+    #
+    def initialize(time, options={})
+      # 参照系の取得
+      @frame = options[:frame] || Clock.local_time
+      @frame = When.Clock(@frame) if (@frame.kind_of?(String))
+      options.delete(:frame)
+
+      # 時刻表現の解読 ( Time Zone の解釈 )
+      if (time.kind_of?(String))
+        case time
+        when /\A([-+])?(\d{2,}?):?(\d{2})?:?(\d{2}(\.\d+)?)?\z/
+          sign, hh, mm, ss = $~[1..4]
+          time = @frame._validate([0,0,0,0],
+                 [0,
+                  -(sign.to_s + "0" + hh.to_s).to_i,
+                  -(sign.to_s + "0" + mm.to_s).to_i,
+                  Pair._en_number(-(sign.to_s + "0" + ss.to_s).to_f)])
+          time[0] = Pair.new(0, time[0].to_i) if (time[0] != 0)
+        when /\AZ\z/
+          time = [0,0,0,0]
+        else
+          raise ArgumentError, "Invalid Time Format"
+        end
+      end
+      @clk_time = time
+
+      # 分解能
+      @precision = @frame._precision(time, options.delete(:precision))
+
+      super(options)
+    end
+
+    private
+
+    # オブジェクトの正規化
+    def _normalize(options={})
+      # strftime で使用する locale
+      @keys    |= @frame.keys
+
+      # 時刻の正規化
+      @clk_time = @frame._validate(@clk_time) unless options[:validate]
+    end
+
+    # 加減算共通処理
+    def _plus(period)
+      self.dup._copy({:time=>@frame._validate(@clk_time, @frame._arrange_length(period.time)),
+                      :events=>nil, :query=>nil, :validate=>:done})
+    end
+  end
+
+  #
+  # 暦日
+  #
+  # see {gml schema}[link:http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#CalDateType]
+  #
+  class CalDate < TemporalPosition
+
+    # 検索オプション
+    # @private
+    SearchOption = {After=>[0, -2, Before], Before=>[-2, 0, After]}
+
+    # 日付要素
+    #
+    # @return [Array<Numeric>]
+    #
+    # @note ISO19108 では sequence<Integer> だが、閏月などが表現可能なよう Numeric としている。
+    #
+    attr_reader :cal_date
+    alias :calDate :cal_date
+
+    # この時間位置と関連付けられた時間参照系 (relation - Reference)
+    #
+    # The time reference system associated with the temporal position being described
+    #
+    # @return [When::TM::ReferenceSystem]
+    #
+    alias :calendar :frame
+
+    # 暦年代
+    #
+    # @return [When::TM::CalendarEra]
+    #
+    attr_accessor :calendar_era
+    private :calendar_era=
+    alias :calendarEra :calendar_era
+
+    # 暦年代属性
+    #
+    # @return [Array] ( name, epoch, reverse, go back )
+    #   - name    [String]  暦年代名
+    #   - epoch   [Integer] 使用する When::TM::Calendar で暦元に対応する年
+    #   - reverse [Boolean] 年数が昇順(false,nil)か降順(true)か
+    #   - go back [Boolean] 参照イベントより前の暦日か(true)、否か(false,nil)
+    #
+    attr_accessor :calendar_era_props
+    private :calendar_era_props=
+
+    # 暦年代名
+    #
+    # @return [String] 暦年代名
+    #
+    def calendar_era_name
+      @calendar_era_props ? @calendar_era_props[0] : nil
+    end
+    alias :calendarEraName :calendar_era_name
+
+    # 暦年代元期
+    #
+    # @return [Integer] 使用する When::TM::Calendar で暦元に対応する年
+    #
+    def calendar_era_epoch
+      @calendar_era_props ?  @calendar_era_props[1] : 0
+    end
+
+    # 暦年代正逆
+    #
+    # @return [Boolean] 年数が昇順(false,nil)か降順(true)か
+    #
+    def calendar_era_reverse
+      @calendar_era_props ? @calendar_era_props[2] : false
+    end
+
+    # 暦年代遡及
+    #
+    # @return [Boolean] 参照イベントより前の暦日か(true)、否か(false,nil)
+    #
+    def calendar_era_go_back
+      @calendar_era_props ? @calendar_era_props[3] : false
+    end
+
+    # 時法の取得 - ダミー
+    def clock
+      nil
+    end
+
+    # 内部時間
+    #
+    # @return [Numeric]
+    #
+    #   当日正午の 1970-01-01T00:00:00Z からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    def universal_time
+      return super if [Now, Max, Min].include?(@indeterminated_position)
+      @universal_time ||= JulianDate._d_to_t(to_i)
+    end
+    alias :local_time :universal_time
+
+    # ユリウス日
+    #
+    # @return [Integer]
+    #
+    #   -4712-01-01からの経過日数に対応する通番
+    #
+    def to_i
+      @sdn ||= _to_i
+    end
+
+    #
+    # 暦法上の通日
+    #
+    def _to_i
+      void, epoch = @calendar_era_props
+      if epoch
+        date     = @cal_date.dup
+        date[0] += epoch
+      else
+        date     = @cal_date
+      end
+      @frame.to_julian_date(date)
+    end
+    private :_to_i
+
+    # 前の日時
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    #   分解能に対応する Duration だけ,日時を戻す
+    #
+    def prev
+      @precision==When::DAY ? _force_euqal_day(-1) : self-period
+    rescue RangeError
+      (When::Gregorian ^ self) - period
+    end
+
+    # 次の日時
+    #
+    # @return [When::TM::TemporalPosition]
+    #
+    #   分解能に対応する Duration だけ,日時を進める
+    #
+    def succ
+      @precision==When::DAY ? _force_euqal_day(+1) : self+period
+    rescue RangeError
+      (When::Gregorian ^ self) + period
+    end
+    alias :next :succ
+
+    # 剰余類化
+    #
+    # @param [Numeric] remainder 剰余
+    # @param [Integer] divisor   法(>0)
+    #
+    # @return [When::Coordinates::Residue] 当日、当年を基準とする剰余類
+    #
+    def to_residue(remainder, divisor)
+      When::Coordinates::Residue.new(remainder, divisor, {'day'  => least_significant_coordinate,
+                                                          'year' => most_significant_coordinate})
+    end
+
+    # 暦年代の削除
+    #
+    # @return [When::TM::CalDate] 暦年代を削除した When::TM::CalDate
+    #
+    def without_era
+      target  = dup
+      return target unless calendar_era
+      options = _attr
+      options[:era]      = nil
+      options[:era_name] = nil
+      options[:date]     = cal_date.dup
+      options[:date][0] += calendar_era_epoch
+      target._copy(options)
+    end
+
+    # 要素の参照
+    #
+    # @param [Integer, String] index 参照する要素の指定
+    #
+    # @return [Numeric]
+    #
+    def value(index)
+      @cal_date[(_digit(index) {|digit| digit <= DAY})-1]
+    end
+
+    #
+    # 最上位の要素
+    #
+    # @return [Numeric] 暦年代の epoch に関わらず暦法に従った年の通し番号を返す
+    #
+    def most_significant_coordinate
+      coordinate  = @cal_date[0]
+      coordinate += calendar_era_epoch if @calendar_era_props
+      @frame.index_of_MSC.times do |i|
+        coordinate = +coordinate * @frame.indices[i].unit + @cal_date[i+1] - @frame.indices[i].base
+      end
+      coordinate
+    end
+
+    #
+    # 最下位の要素
+    #
+    # @return [Numeric] 剰余類の演算に用いる日の通し番号を返す
+    #
+    def least_significant_coordinate
+      return to_i + @frame.indices[-1].shift
+    end
+
+    # ユリウス日または通年が指定の剰余となる日
+    #
+    # @param [When::Coordinates::Residue] other
+    #
+    # @return [When::TM::CalDate]
+    #
+    def &(other)
+      raise TypeError,"The right operand should be When::Coordinates::Residue" unless other.kind_of?(Residue)
+      case other.event
+      when 'day'
+      # 指定の剰余となる日
+        sdn      = other & to_i
+        options  = {:date=>_date_with_era(@frame.to_cal_date(sdn)), :events=>nil, :query=>@query, :validate=>:done}
+        options[:precision] = When::DAY if precision < When::DAY
+        result   = self.dup._copy(options)
+        result.send(:_force_euqal_day, sdn-result.to_i)
+
+      when 'year'
+      # 指定の剰余となる年
+        date     = @frame.send(:_decode, _date_without_era)
+        date[0]  = (other & (date[0] + @frame.diff_to_CE)) - @frame.diff_to_CE
+        options  = {:date=>_date_with_era(@frame.send(:_encode, date)), :events=>nil, :query=>@query}
+        options[:precision] = When::YEAR if precision < When::YEAR
+        return self.dup._copy(options)
+
+      else
+        raise ArgumentError,"The right operand should have a unit 'day' or 'year'"
+      end
+    end
+
+    # ユリウス日または通年の剰余
+    #
+    # @param [When::Coordinates::Residue] other
+    #
+    # @return [Numeric]
+    #
+    def %(other)
+      raise TypeError,"The right operand should be When::Coordinates::Residue" unless other.kind_of?(Residue)
+      if precision <= When::YEAR && other.units['year'] && other.event != 'year'
+        other.to('year') % (most_significant_coordinate + @frame.epoch_in_CE)
+      else
+        case other.event
+        when 'day'  ; other % least_significant_coordinate
+        when 'year' ; other % (most_significant_coordinate + @frame.epoch_in_CE)
+        else        ; raise ArgumentError,"The right operand should have a unit 'day' or 'year'"
+        end
+      end
+    end
+
+    # 下位桁の切り捨て
+    #
+    # @param [Integer] digit 切り捨てずに残す、最下位の桁
+    #
+    # @param [Integer] precision 切り捨て結果の分解能
+    #
+    # @return [When::TM::CalDate]
+    #
+    def floor(digit=DAY, precision=digit)
+      options = {:date=>@cal_date[0..(digit-1)], :events=>nil, :query=>nil}
+      options[:precision] = precision if precision
+      self.dup._copy(options)
+    end
+
+    # 下位桁の切り上げ
+    #
+    # @param [Integer] digit 切り上げずに残す、最下位の桁
+    #
+    # @param [Integer] precision 切り上げ結果の分解能
+    #
+    # @return [When::TM::CalDate]
+    #
+    def ceil(digit=DAY, precision=digit)
+      (self + PeriodDuration.new(1, digit, (-@frame.indices.length)..0)).floor(digit, precision)
+    end
+
+    # 要素数 ― 上位要素に含まれる下位要素の数
+    #
+    # @param [Integer] upper 上位要素のインデックス
+    # @param [Integer] lower 下位要素のインデックス(DAY または MONTH)
+    #
+    # @return [Integer]
+    #
+    def length(upper, lower=DAY)
+      range = [floor(upper).to_i, ceil(upper).to_i]
+      range = range.map {|d| (Residue.mod(d) {|m| frame._new_month(m)})[0]} if lower == MONTH
+      range[1] - range[0]
+    end
+
+    # 時刻情報のない When::TM::CalDate を返す
+    #
+    # @return [When::TM::CalDate]
+    #
+    alias :to_cal_date :dup
+    alias :to_CalDate  :to_cal_date
+
+    # 暦年代が末端の参照であるか?
+    #
+    # @return [Boolean]
+    #
+    def leaf?
+      ! @calendar_era.respond_to?(:_pool) || @calendar_era.leaf?
+    end
+
+    # 属性の Hash
+    # @private
+    def _attr
+      super.merge({:era_name=>@calendar_era_props, :era=>@calendar_era})
+    end
+    protected
+
+    # 属性のコピー
+    # @private
+    def _copy(options={})
+      @cal_date           = options[:date]     if options.key?(:date)
+      @calendar_era       = options[:era]      if options.key?(:era)
+      @calendar_era_props = options[:era_name] if options.key?(:era_name)
+      return super
+    end
+
+    # オブジェクトの生成
+    #
+    # @param [Array<Numeric>] date 日付表現
+    #
+    # @param [Hash] options 下記の通り (see also {When::TM::TemporalPosition._instance})
+    # @option options [When::TM::Calendar] :frame
+    # @option options [When::TM::CalendarEra, When::BasicTypes::M17n, Array<When::BasicTypes::M17n, Integer>] :era_name
+    #   (Integer は 当該年号の 0 年に相当する通年)
+    # @option options [Integer] :precision
+    #
+    def initialize(date, options={})
+      # 年号 & 日付
+      @calendar_era_props = options[:era_name]
+      @calendar_era       = options[:era]
+      @cal_date           = date
+
+      super(options)
+    end
+
+    private
+
+    # オブジェクトの正規化
+    def _normalize(options={})
+
+      # 日付配列の長さ
+      cal_date_index = @cal_date.compact.length
+
+      # 日付の正規化
+      if @calendar_era_props
+        # Calendar Era がある場合
+        trans_options = @trans || {} # TODO? 消す
+        count = trans_options[:count] || 1
+        query_options = (@query || {}).dup
+        query_options[:label] = @calendar_era_props
+        query_options[:count] = count
+        era = date  = nil
+        if @calendar_era
+          era, date = _search_era(@calendar_era, trans_options)
+        else
+          eras = CalendarEra._instance(query_options)
+          raise ArgumentError, "CalendarEraName doesn't exist: #{query_options[:label]}" if eras.empty?
+          eras.each do |e|
+            era, date = _search_era(e, trans_options)
+            next unless era
+            count -= 1
+            break unless count > 0
+          end
+        end
+        raise RangeError, "Out of CalendarEra Range" unless era
+        @calendar_era_props = date.calendar_era_props
+        @calendar_era       = era
+        @cal_date = date.cal_date
+        @frame    = date.frame
+        @query    = (@query||{}).merge(date.query)
+        @trans    = (@trans||{}).merge(date.trans)
+        @keys    |= calendar_era_name.keys | @frame.keys
+      else
+        # Calendar Era がない場合
+        @frame = When.Resource(options[:frame] || @frame || 'Gregorian', '_c:')
+        @cal_date = @frame._validate(@cal_date) unless options[:validate] == :done
+        @keys    |= @frame.keys
+      end
+
+      # 分解能
+      precision   = options.delete(:precision) || @precision
+      cal_date_index =
+        case options.delete(:_format)
+        when :century    ; CENTURY
+        when :week, :day ; DAY
+        else             ; cal_date_index - (@frame.indices.length + 1)
+        end
+      precision ||= cal_date_index      if cal_date_index < DAY
+      precision ||= @clk_time.precision if @clk_time
+      @precision  = Index.precision(precision || DAY)
+    end
+
+    # 暦年代を探す
+    def _search_era(era, trans_options)
+      cal_date     = @cal_date.dup
+      cal_date[0]  = -cal_date[0] if era.reverse?
+      cal_date[0] += era.epoch_year
+      date = era.trans(cal_date, trans_options)
+      loop do
+        case date
+        when Before, After
+          i0, i1, reverse = SearchOption[date]
+          new_era = (date == Before) ? era.prev : era.succ
+          break unless new_era
+          date = new_era.trans(cal_date, trans_options)
+          if date == reverse
+            cal_date = new_era.epoch[i0].frame.to_cal_date(era.epoch[i1].frame.to_julian_date(cal_date))
+            date = new_era.trans(cal_date, trans_options)
+            break if date == reverse
+          end
+          era  = new_era
+        when TimeValue
+         return era, date
+        else
+          break
+        end
+      end
+      return nil
+    end
+
+    # 加減算共通処理
+    def _plus(period)
+      _frame_adjust(period, self.dup._copy({:date=>_date_with_era(@frame._validate(_date_without_era,
+                                                     @frame._arrange_length(period.date))),
+                               :events=>nil, :query=>nil, :validate=>:done}))
+    end
+
+    # 年号を除外した @frame の暦法に対応する日付
+    def _date_without_era
+      date = @cal_date.dup
+      date[0] += calendar_era_epoch if @calendar_era_props
+      date
+    end
+
+    # 年号に続く日付
+    def _date_with_era(date)
+      date[0] -= calendar_era_epoch if @calendar_era_props
+      date
+    end
+
+    # 暦法が変わった場合の補正
+    def _frame_adjust(period, date)
+      return date if @frame.equal?(date.frame) || (period.to_day||0) == 0
+      diff = period.to_day - (date.to_i - to_i)
+      return date if diff == 0
+      date.send(:_force_euqal_day, diff)
+    end
+  end
+
+  #
+  # 時刻を伴った日付
+  #
+  # see {http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#DateAndTimeType gml schema}
+  #
+  class DateAndTime < CalDate
+
+    # 時刻要素
+    #
+    # @return [When::TM::ClockTime]
+    #
+    attr_reader :clk_time
+    alias :clkTime :clk_time
+
+    # 時法の取得
+    #
+    # @return [When::TM::Clock]
+    #
+    def clock
+      @clk_time.frame
+    end
+
+    # 内部時間
+    #
+    # @return [Numeric]
+    #
+    #   1970-01-01T00:00:00Z からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    #   暦法によっては、異なる意味を持つことがある
+    #
+    def universal_time
+      return super if [Now, Max, Min].include?(@indeterminated_position)
+      raise NameError, "Temporal Reference System is not defined" unless (@frame && clock)
+      @universal_time ||= (to_i - JulianDate::JD19700101) * Duration::DAY + @clk_time.universal_time(to_i)
+    end
+
+    # 内部時間(ローカル)
+    #
+    # @return [Numeric]
+    #
+    #   1970-01-01T00:00:00(ローカル) からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    #   暦法によっては、異なる意味を持つことがある
+    #
+    def local_time
+      return super if [Now, Max, Min].include?(@indeterminated_position)
+      raise NameError, "Temporal Reference System is not defined" unless (@frame && clock)
+      @local_time ||= (to_i - JulianDate::JD19700101) * Duration::DAY + @clk_time.local_time(to_i)
+    end
+
+    # 要素の参照
+    #
+    # @param [Integer] index 参照する要素の指定
+    #
+    # @return [Numeric]
+    #
+    def value(index)
+      digit = _digit(index)
+      return (digit <= DAY) ? @cal_date[digit-1] : @clk_time.clk_time[digit]
+    end
+
+    # ユリウス日または通年が指定の剰余となる日
+    #
+    # @param [When::Coordinates::Residue] other
+    #
+    # @return [When::TM::DateAndTime]
+    #
+    def &(other)
+      raise TypeError,"The right operand should be When::Coordinates::Residue" unless other.kind_of?(Residue)
+      case other.event
+      when 'day'
+        # 指定の剰余となる日
+        sdn     = other & to_i
+        options = {:date=>_date_with_era(@frame.to_cal_date(sdn)), :time=>@clk_time.clk_time.dup,
+                   :events=>nil, :query=>@query, :validate=>:done}
+        options[:precision] = When::DAY if precision < When::DAY
+        result  = self.dup._copy(options)
+        result.send(:_force_euqal_day, sdn-result.to_i)
+
+      when 'year'
+        # 指定の剰余となる年
+        date     = @frame.send(:_decode, _date_without_era)
+        date[0]  = (other & (date[0] + @frame.diff_to_CE)) - @frame.diff_to_CE
+        options  = {:date=>_date_with_era(@frame.send(:_encode, date)), :time=>@clk_time.clk_time.dup,
+                    :events=>nil, :query=>@query}
+        options[:precision] = When::YEAR if precision < When::YEAR
+        return self.dup._copy(options)
+
+      else
+        raise ArgumentError,"The right operand should have a unit 'day' or 'year'"
+      end
+    end
+
+    # 下位桁の切り捨て
+    #
+    # @param [Integer] digit 切り捨てずに残す、最下位の桁
+    #
+    # @param [Integer] precision 切り捨て結果の分解能
+    #
+    # @return [When::TM::DateAndTime]
+    #
+    def floor(digit=DAY, precision=digit)
+      count    = digit - clock.indices.length
+
+      if digit>=DAY
+        date     = @cal_date.dup
+      elsif @calendar_era_props
+        date     = @cal_date.dup
+        date[0] += calendar_era_epoch
+        date     = @frame._validate(date[0..(digit-1)])
+        date[0] -= calendar_era_epoch
+      else
+        date     = @frame._validate(@cal_date[0..(digit-1)])
+      end
+
+      time     = @clk_time.clk_time[0..((digit<=DAY) ? 0 : ((count>=0) ? -1 : digit))]
+      time[0] += to_i
+      time     = clock._validate(time)
+      time[0] -= to_i
+
+      if (count >= 0)
+        factor = 10**count
+        time[-1] = (time[-1] * factor).floor.to_f / factor
+      end
+
+      # オブジェクトの生成
+      options = {:date=>date, :validate=>:done, :events=>nil, :query=>nil,
+                 :time=>(digit<=DAY) ? time : @clk_time.dup._copy({:time=>time})}
+      options[:precision] = precision if precision
+      return self.dup._copy(options)
+    end
+
+    # 下位桁の切り上げ
+    #
+    # @param [Integer] digit 切り上げずに残す、最下位の桁
+    #
+    # @param [Integer] precision 切り上げ結果の分解能
+    #
+    # @return [When::TM::DateAndTime]
+    #
+    def ceil(digit=DAY, precision=digit)
+      length  = clock.indices.length
+      count   = digit - length
+      period  = PeriodDuration.new((count<=0) ? 1 : 0.1**count, digit, (-@frame.indices.length)..length)
+      result  = floor(digit, precision) + period
+      result += clock.tz_difference if (result.universal_time <= self.universal_time)
+      return result
+    end
+
+    # 位置情報
+    #
+    # @return [When::Coordinates::Spatial]
+    #
+    def location
+      @location ||= @clk_time.frame.location
+    end
+
+    # 時刻情報のない When::TM::CalDate を返す
+    #
+    # @return [When::TM::CalDate]
+    #
+    def to_cal_date
+      options = _attr
+      options.delete(:clock)
+      options[:precision] = [When::DAY, options[:precision]].min
+      CalDate.new(@cal_date, options)
+    end
+    alias :to_CalDate :to_cal_date
+
+    # 標準ライブラリの DateTime オブジェクトへの変換
+    #
+    alias :to_date_or_datetime :to_datetime
+
+    #protected
+
+    # 属性の Hash
+    # @private
+    def _attr
+      super.merge({:clock=>clock})
+    end
+
+    # 属性のコピー
+    # @private
+    def _copy(options={})
+      # 夏時間の調整
+      case options[:time]
+      when Array
+        if clock._need_validate
+          if @calendar_era_props
+            date     = options[:date].dup
+            date[0] += calendar_era_epoch
+          else
+            date     = options[:date]
+          end
+          new_clock = clock._daylight([@frame, date, options[:time]])
+          options[:time] = options[:time].map {|t| t * 1}
+        else
+          new_clock = clock
+        end
+        options[:time] = @clk_time.dup._copy(options.merge({:clock=>new_clock}))
+      when nil
+        options[:time] = @clk_time.dup._copy(options)
+      end
+
+      return super(options)
+    end
+
+    # オブジェクトの生成
+    #
+    # @param [Array<Numeric>] date 日付表現
+    # @param [Array<Numeric>] time 時刻表現
+    # @param [Hash] options 下記の通り (see also {When::TM::TemporalPosition._instance})
+    # @option options [When::TM::Calendar] :frame
+    # @option options [When::TM::Clock] :clock 
+    # @option options [When::TM::CalendarEra, When::BasicTypes::M17n, Array<When::BasicTypes::M17n, Integer>] :era_name
+    #   (Integer は 当該年号の 0 年に相当する通年)
+    # @option options [Integer] :precision
+    #
+    def initialize(date, time, options={})
+      options[:time] = time
+      super(date, options)
+    end
+
+    private
+
+    # オブジェクトの正規化
+    def _normalize(options={})
+
+      # Clock
+      unless options[:validate]
+        clock   = Clock.get_clock_option(options)
+        clock ||= options[:time].frame if options[:time].kind_of?(ClockTime)
+        clock ||= Clock.local_time
+      end
+      clock = When.Clock(clock) if clock.kind_of?(String)
+      clock_is_timezone = clock && !clock.kind_of?(When::TM::Clock)
+      clock = clock.daylight if clock_is_timezone
+
+      # ClockTime
+      @clk_time = 
+        case options[:time]
+        when ClockTime ; options[:time]
+        when Array     ; ClockTime.new(options[:time], {:frame=>clock, :precision=>options[:precision], :validate=>:done})
+        else           ; clock.to_clk_time(options[:time], {:precision=>options[:precision]})
+        end
+
+      super
+
+      # 日付と時刻の正規化
+      unless options[:validate]
+        time      = @clk_time.clk_time
+        precision = @clk_time.precision
+        second    = time[clock.base.length-1]
+        second   -= clock.base[-1] if second
+        if second && second != 0 && time_standard.has_leap?
+          zero    = DateAndTime.new(@cal_date, time[0..-2],
+                                   {:frame=>@frame, :clock=>clock,  :precision=>precision,
+                                    :era_name=>@calendar_era_props,  :era=>options[:era],
+                                    :time_standard=>time_standard, :location=>@location})
+        end
+
+        # 日付と時刻の関係の調整
+        @cal_date = _date_with_era(@frame._validate(_date_without_era) {|jdn|
+          time[0]    += jdn
+          time[0..-1] = clock._validate(time)
+          jdn         = time[0] * 1
+          time[0]    -= jdn
+          jdn
+        })
+
+        # 夏時間の調整
+        if clock._need_validate
+          if @calendar_era_props
+            cal_date     = @cal_date.dup
+            cal_date[0] += calendar_era_epoch
+          else
+            cal_date     = @cal_date
+          end
+          clock = clock._daylight([@frame, cal_date, time])
+        end
+        time = [time[0]] +  time[1..-1].map {|t| t * 1}
+        @clk_time = ClockTime.new(time, {:frame=>clock, :precision=>precision, :validate=>:done}) if clock_is_timezone
+
+        # 閏秒
+        if zero
+          leap = ((dynamical_time - zero.dynamical_time) * clock.second - second).to_i
+          if leap != 0 && leap.abs < clock.second
+            @cal_date = zero.cal_date
+            @clk_time = zero.clk_time
+            @clk_time.clk_time[-1] += second
+            leap                   /= clock.second
+            @universal_time = @local_time = When::Coordinates::LeapSeconds.new(@local_time-leap, leap, 1/clock.second)
+            @dynamical_time -= leap
+          end
+        end
+      end
+
+      # 後処理
+      @keys |= @clk_time.keys
+    end
+
+    # 加減算共通処理
+    def _plus(period)
+      # 日時の加算
+      time  = @clk_time.clk_time.dup
+      pdate = @frame._arrange_length(period.date)
+      ptime = clock._arrange_length(period.time)
+      date  = _date_with_era(@frame._validate(_date_without_era, pdate) {|jdn|
+        time[0] += jdn
+        time     = clock._validate(time, ptime)
+        jdn      = time[0] * 1
+        time[0] -= jdn
+        jdn
+      })
+
+      # オブジェクトの生成
+      _frame_adjust(period, self.dup._copy({:date=>date, :time=>time, :validate=>:done, :events=>nil, :query=>nil}))
+    end
+  end
+end