when_exe 0.3.2 → 0.3.3

data/lib/when_exe/tmobjects.rb

@@ -255,7 +255,14 @@ module When::TM
     #   処理を @position (type: When::TM::Position) に委譲する
     #
     def method_missing(name, *args, &block)
-      @position.send(name.to_sym, *args, &block)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          list = args.map {|arg| arg.kind_of?(self.class) ? arg.position : arg}
+          @position.send("#{name}", *list, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      list = args.map {|arg| arg.kind_of?(self.class) ? arg.position : arg}
+      @position.send(name, *list, &block)
     end
   end
 
@@ -385,7 +392,12 @@ module When::TM
     #   処理を @begin (type: When::TM::Instant) に委譲する
     #
     def method_missing(name, *args, &block)
-      @begin.send(name.to_sym, *args, &block)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          @begin.send("#{name}", *args, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      @begin.send(name, *args, &block)
     end
   end
 
@@ -410,6 +422,8 @@ module When::TM
 
     private
 
+    alias :_method_missing :method_missing
+
     # その他のメソッド
     #
     # @note
@@ -417,7 +431,16 @@ module When::TM
     #   処理を @geometry (type: When::TM::Instant) に委譲する
     #
     def method_missing(name, *args, &block)
-      @geometry.send(name.to_sym, *args, &block)
+      return _method_missing(name, *args, &block) if When::Parts::MethodCash::Escape.key?(name) ||
+                                                     !respond_to?(:geometry)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          list = args.map {|arg| arg.respond_to?(:geometry) ? arg.geometry : arg}
+          geometry.send("#{name}", *list, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      list = args.map {|arg| arg.respond_to?(:geometry) ? arg.geometry : arg}
+      geometry.send(name, *list, &block)
     end
   end
 
@@ -828,7 +851,12 @@ module When::TM
     #   処理を @duration (type:Numeric) に委譲する
     #
     def method_missing(name, *args, &block)
-      @duration.send(name.to_sym, *args, &block)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          @duration.send("#{name}", *args, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      @duration.send(name, *args, &block)
     end
   end
 

data/lib/when_exe/tmposition.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 =begin
-  Copyright (C) 2011-2013 Takashi SUGA
+  Copyright (C) 2011-2014 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
@@ -136,6 +136,8 @@ module When::TM
 
     private
 
+    alias :_method_missing :method_missing
+
     # その他のメソッド
     #
     # @note
@@ -145,8 +147,15 @@ module When::TM
     #   (両方ともに有効なメソッドは@any_otherを優先する)
     #
     def method_missing(name, *args, &block)
-      union = @any_other.respond_to?(name.to_sym) ? @any_other : @date_time8601
-      union.send(name.to_sym, *args, &block)
+      return _method_missing(name, *args, &block) if When::Parts::MethodCash::Escape.key?(name)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          union = @any_other.respond_to?("#{name}") ? @any_other : @date_time8601
+          union.send("#{name}", *args, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      union = @any_other.respond_to?(name) ? @any_other : @date_time8601
+      union.send(name, *args, &block)
     end
   end
 
@@ -265,6 +274,7 @@ module When::TM
       # @option options [When::TM::Clock, When::V::Timezone, When::Parts::Timezone, String] :clock 時法の指定
       # @option options [String] :tz 時法の指定(時間帯を指定する場合 :clock の替わりに用いることができる)
       # @option options [Array<Numeric>] :abbr ISO8601上位省略形式のためのデフォルト日付(省略時 指定なし)
+      # @option options [Integer] :extra_year_digits ISO8601拡大表記のための年の構成要素拡大桁数(省略時 1桁)
       # @option options [String] :wkst ISO8601週日形式のための暦週開始曜日(省略時 'MO')
       # @option options [Integer] :precision 生成するオブジェクトの分解能
       # @option options [When::TimeStandard::TimeStandard] :time_standard 時刻系の指定(省略時 When::TimeStandard::UnversalTime)
@@ -430,12 +440,13 @@ module When::TM
         clock = Clock.get_clock_option(query)
         main[:clock] = clock if clock
         [:indeterminated_position, :frame, :events, :precision,
-         :era_name, :era, :abbr, :wkst, :time_standard, :location].each do |key|
+         :era_name, :era, :abbr, :extra_year_digits, :wkst, :time_standard, :location].each do |key|
           main[key] = query.delete(key) if (query.key?(key))
         end
         long = query.delete(:long)
         lat  = query.delete(:lat)
-        main[:location] ||= "_l:long=#{long}&lat=#{lat}" if long && lat
+        alt  = query.delete(:alt)
+        main[:location] ||= "_l:long=#{long||0}&lat=#{lat||0}&alt=#{alt||0}" if long && lat
         trans = query.delete(:trans) || {}
         [:lower, :upper, :count].each do |key|
           trans[key] = query.delete(key) if (query.key?(key))
@@ -446,6 +457,13 @@ module When::TM
         return main
       end
 
+      # 比較
+      # @private
+      def _verify(source, target)
+        return source.universal_time <=> target.universal_time if source.time_standard.equal?(target.time_standard)
+        return source.dynamical_time <=> target.dynamical_time
+      end
+
       private
 
       # date_time_or_duration
@@ -503,9 +521,10 @@ module When::TM
     #
     def time_standard
       return @time_standard if @time_standard.kind_of?(When::TimeStandard)
-      @time_standard = When.Resource(@time_standard ||
-                                (frame ? frame.time_standard : nil) ||
-                                'UniversalTime', '_t:')
+      @time_standard ||= clock.time_standard if respond_to?(:clock) && clock
+      @time_standard ||= frame.time_standard if frame
+      @time_standard ||= 'UniversalTime'
+      @time_standard   = When.Resource(@time_standard, '_t:')
     end
 
     # 時間の歩度
@@ -664,7 +683,8 @@ module When::TM
       when Integer        ; self + PeriodDuration.new(other, When::DAY)
       when Numeric        ; self + IntervalLength.new(other, 'day')
       when PeriodDuration ; _plus(other)
-      when Duration       ; @frame.jul_trans(JulianDate.dynamical_time(dynamical_time + other.duration), self._attr)
+      when Duration       ; @frame.kind_of?(Calendar) ? @frame.jul_trans(JulianDate.dynamical_time(dynamical_time + other.duration), self._attr) :
+                                                                         JulianDate.dynamical_time(dynamical_time + other.duration,  self._attr)
       else                ; raise TypeError, "The right operand should be Numeric or Duration"
       end
     rescue RangeError
@@ -686,7 +706,8 @@ module When::TM
       when Integer        ; self - PeriodDuration.new(other, When::DAY)
       when Numeric        ; self - IntervalLength.new(other, 'day')
       when PeriodDuration ; _plus(-other)
-      when Duration       ; @frame.jul_trans(JulianDate.dynamical_time(dynamical_time - other.duration), self._attr)
+      when Duration       ; @frame.kind_of?(Calendar) ? @frame.jul_trans(JulianDate.dynamical_time(dynamical_time - other.duration), self._attr) :
+                                                                         JulianDate.dynamical_time(dynamical_time - other.duration,  self._attr)
       else                ; raise TypeError, "The right operand should be Numeric, Duration or TemporalPosition"
       end
     rescue RangeError
@@ -711,7 +732,7 @@ module When::TM
     #   分解能に対応する Duration だけ,日時を戻す
     #
     def prev
-    @precision==When::DAY ? _force_euqal_day(-1) : self-period
+      @precision==When::DAY ? _force_euqal_day(-1) : self-period
     rescue RangeError
       (When.Calendar('Gregorian') ^ self) - period
     end
@@ -723,7 +744,7 @@ module When::TM
     #   分解能に対応する Duration だけ,日時を進める
     #
     def succ
-    @precision==When::DAY ? _force_euqal_day(+1) : self+period
+      @precision==When::DAY ? _force_euqal_day(+1) : self+period
     rescue RangeError
       (When.Calendar('Gregorian') ^ self) + period
     end
@@ -773,8 +794,25 @@ module When::TM
       return self == date
     end
 
+    # オブジェクトの同値
+    #
+    # @param [比較先] other
+    #
+    # @return [Boolean]
+    #   [ true  - 同値   ]
+    #   [ false - 非同値 ]
+    #
+    def ==(other)
+      (self <=> other) == 0
+    rescue
+      false
+    end
+
     # 大小比較
     #
+    # @param [When::TM::TemporalPosition] other チェックされる日時
+    # @param [Numeric] other チェックされる日時の universal time(self と同じtime_standardとみなす)
+    #
     # @return [Integer] (-1, 0, 1)
     #
     #   分解能の低い方にあわせて比較を行う
@@ -782,32 +820,34 @@ module When::TM
     #     Ex. when?('2011-03') <=> when?('2011-03-10') -> 0
     #
     def <=>(other)
-      other  = other.first if other.kind_of?(When::Parts::GeometricComplex)
+      other = other.first if other.kind_of?(Range)
+      return universal_time <=> other if other.kind_of?(Numeric)
+
       [self.indeterminated_position, other.indeterminated_position].each do |position|
         prec = SYSTEM if [TimeValue::Min, TimeValue::Max].include?(position)
       end
       prec   = [self.precision, other.precision].min unless prec
+
       case prec
       when DAY    ; return self.to_i <=> other.to_i
-      when SYSTEM ; src, dst = self, other
-      else
-        if prec < DAY && respond_to?(:most_significant_coordinate) &&
-                   other.respond_to?(:most_significant_coordinate) && @frame.equal?(other.frame)
-          result = most_significant_coordinate <=> other.most_significant_coordinate
-          return result unless result == 0 && @cal_date.length + prec > 1
-          (@cal_date.length + prec - 2).times do |i|
-            result = @cal_date[i+1] <=> other.cal_date[i+1]
-            return result unless result == 0
-          end
-          return @cal_date[prec - 1] <=> other.cal_date[prec - 1]
+      when SYSTEM ; return TemporalPosition._verify(self, other)
+      end
+
+      if prec < DAY && respond_to?(:most_significant_coordinate) &&
+                 other.respond_to?(:most_significant_coordinate) && @frame.equal?(other.frame)
+        result = most_significant_coordinate <=> other.most_significant_coordinate
+        return result unless result == 0 && @cal_date.length + prec > 1
+        (@cal_date.length + prec - 2).times do |i|
+          result = @cal_date[i+1] <=> other.cal_date[i+1]
+          return result unless result == 0
         end
-        src, dst =
-          [(prec >= self.precision ) ? self  : self.floor(prec),
-           (prec >= other.precision) ? other : other.floor(prec)]
+        @cal_date[prec - 1] <=> other.cal_date[prec - 1]
+      else
+        source = (prec >= self.precision ) ? self  : self.floor(prec)
+        target = (prec >= other.precision) ? other : other.floor(prec)
+        return source.to_i <=> target.to_i if prec <= DAY
+        TemporalPosition._verify(source, target)
       end
-      return src.to_i <=> dst.to_i if prec <= DAY
-      return src.universal_time <=> dst.universal_time if src.time_standard.equal?(dst.time_standard)
-      return src.dynamical_time <=> dst.dynamical_time
     end
 
     # 条件を満たすオブジェクトの抽出
@@ -891,10 +931,12 @@ module When::TM
     # @private
     def _attr
       attributes = {}
-      ['frame', 'events', 'precision', 'options', 'trans', 'query', 'time_standard'].each do |key|
-        attributes[key.to_sym] = instance_variable_get("@#{key}")
+      [:frame, :events, :precision, :options, :trans, :query].each do |key|
+        attributes[key] = instance_variable_get("@#{key}")
       end
-      return attributes
+      attributes[:location]      = location
+      attributes[:time_standard] = time_standard
+      return attributes.delete_if {|k,v| !v}
     end
 
     protected
@@ -965,6 +1007,8 @@ module When::TM
       end
     end
 
+    alias :_method_missing :method_missing
+
     # その他のメソッド
     #
     # @note
@@ -972,7 +1016,14 @@ module When::TM
     #   処理を @frame (type: When::TM::Calendar or When::TM::Clock) に委譲する
     #
     def method_missing(name, *args, &block)
-      @frame.send(name.to_sym, self, *args, &block)
+      
+      return _method_missing(name, *args, &block) if When::Parts::MethodCash::Escape.key?(name)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          @frame.send("#{name}", self, *args, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      @frame.send(name, self, *args, &block)
     end
   end
 
@@ -1016,29 +1067,29 @@ module When::TM
         case time
         when Numeric
           options[:frame] ||= When.utc unless time.kind_of?(Integer)
-          external_time     = (2*time - (2*JulianDate::JD19700101-1)) * Duration::DAY.to_i / 2.0
+          universal_time     = (2*time - (2*JulianDate::JD19700101-1)) * Duration::DAY.to_i / 2.0
         when ClockTime
           options[:frame] ||= time.clock
-          external_time     = time.clk_time[0] + time.universal_time
+          universal_time     = time.clk_time[0] + time.universal_time
         when ::Time
           options[:frame] ||= When.Clock(time.gmtoff)
-          external_time     = When.Resource('_t:UniversalTime').from_time_object(time)
+          universal_time     = When.Resource('_t:UniversalTime').from_time_object(time)
         when TimeValue
           options[:frame] ||= time.clock
-          external_time     = time.universal_time
+          universal_time     = time.universal_time
         else
           if ::Object.const_defined?(:Date) && time.respond_to?(:ajd)
             case time
             when ::DateTime
               options[:frame] ||= When.Clock((time.offset * 86400).to_i)
-              external_time    = (2*time.ajd - (2*JulianDate::JD19700101-1)) * Duration::DAY.to_i / 2.0
+              universal_time    = (2*time.ajd - (2*JulianDate::JD19700101-1)) * Duration::DAY.to_i / 2.0
             when ::Date
-              external_time    = JulianDate._d_to_t(time.jd)
+              universal_time    = JulianDate._d_to_t(time.jd)
             end
           end
         end
-        raise TypeError, "Can't create #{self} from #{time.class}" unless external_time
-        universal_time(external_time, options)
+        raise TypeError, "Can't create #{self} from #{time.class}" unless universal_time
+        universal_time(universal_time, options)
       end
     end
 
@@ -1073,8 +1124,8 @@ module When::TM
     # @return [When::TM::TemporalPosition]
     #
     def +(other)
-      raise TypeError,"The right operand should be IntervalLength" if other.kind_of?(PeriodDuration)
-      super
+      other = other.to_interval_length if other.kind_of?(PeriodDuration)
+      super(other)
     end
 
     # 減算
@@ -1085,8 +1136,8 @@ module When::TM
     # @return [When::TM::IntervalLength]   if other is a When::TM::TemporalPosition
     #
     def -(other)
-      raise TypeError,"The right operand should be IntervalLength or (Temporal)Position" if other.kind_of?(PeriodDuration)
-      super
+      other = other.to_interval_length if other.kind_of?(PeriodDuration)
+      super(other)
     end
 
     # オブジェクトの生成
@@ -1148,9 +1199,7 @@ module When::TM
     #
     def +(other)
       new_date = super
-      if new_date.frame && new_date.frame._need_validate
-        new_date.frame = new_date.frame._daylight(self.class.dynamical_time(new_date.dynamical_time, {:frame=>When.utc}))
-      end
+      new_date.frame = new_date.frame._daylight(new_date.universal_time) if new_date.frame && new_date.frame._need_validate
       return new_date
     end
 
@@ -1194,7 +1243,7 @@ module When::TM
     def initialize(universal_time, options={})
       @frame = options.delete(:frame)
       @frame = When.Clock(@frame) if (@frame.kind_of?(String))
-      @frame = @frame._daylight(self.class.universal_time(universal_time, {:frame=>When.utc})) if @frame && @frame._need_validate
+      @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)
@@ -1311,7 +1360,7 @@ module When::TM
     #
     def initialize(time, options={})
       # 参照系の取得
-      @frame = (options[:frame] || Clock.local_time || When.utc)
+      @frame = options[:frame] || Clock.local_time
       @frame = When.Clock(@frame) if (@frame.kind_of?(String))
       options.delete(:frame)
 
@@ -1850,7 +1899,7 @@ module When::TM
       return @location if @location
       timezone = @clk_time.frame.tz_prop
       return nil unless timezone.kind_of?(When::Parts::Timezone)
-      @location = When.Resource("_l:long=#{timezone.longitude.to_f}&lat=#{timezone.latitude.to_f}")
+      @location = timezone.location
     end
 
     # 時刻情報のない When::TM::CalDate を返す
@@ -1880,7 +1929,7 @@ module When::TM
       case options[:time]
       when Array
         if clock._need_validate
-          new_clock = clock._daylight { |c| self.class.new(options[:date], options[:time], {:frame=>@frame, :clock=>c}) }
+          new_clock = clock._daylight([@frame, options[:date], options[:time]])
           options[:time] = options[:time].map {|t| t * 1}
         else
           new_clock = clock
@@ -1918,7 +1967,7 @@ module When::TM
       unless options[:validate]
         clock   = Clock.get_clock_option(options)
         clock ||= options[:time].frame if options[:time].kind_of?(ClockTime)
-        clock ||= Clock.local_time || When.utc 
+        clock ||= Clock.local_time
       end
       clock = When.Clock(clock) if (clock.kind_of?(String))
       clock_is_timezone = clock.respond_to?(:daylight)
@@ -1964,7 +2013,7 @@ module When::TM
           else
             cal_date     = @cal_date
           end
-          clock = clock._daylight {|clock| self.class.new(cal_date, time, {:frame=>@frame, :clock=>clock}) }
+          clock = clock._daylight([@frame, cal_date, time])
         end
         time = time.map {|t| t * 1}
         @clk_time = ClockTime.new(time, {:frame=>clock, :precision=>precision, :validate=>:done}) if clock_is_timezone

data/lib/when_exe/tmreference.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 =begin
-  Copyright (C) 2011-2013 Takashi SUGA
+  Copyright (C) 2011-2014 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
@@ -49,16 +49,15 @@ module When::TM
     #
     # Range of time within which the temporal reference system is use
     #
-    # @return [When::Parts::GeomerticComplex]
+    # @return [Hash<String=>When::Parts::GeomerticComplex>]
     #
     # @note
     #   マルチスレッド動作時 CalendarEra の生成で Calendar の本属性が更新される
     #   参照・更新処理は synchronize { ... } の ... の部分に書く必要がある
     #
     def domain
-      @domain ||= When::Parts::GeometricComplex.new([])
+      @domain ||= Hash.new {|hash, key| hash[key] = When::Parts::GeometricComplex.new([])}
     end
-    attr_writer :domain
 
     # 時間参照系を識別する名称
     #
@@ -99,7 +98,9 @@ module When::TM
   class Calendar < ReferenceSystem
 
     include When::Coordinates
+    include Spatial::Normalize
     include Temporal
+    include When::TimeStandard::TimeBasis
 
     # 初期化
     #
@@ -177,6 +178,7 @@ module When::TM
     # @return [When::TM::CalDateAndTime] if (options[:clock or :tz] != nil)
     #
     def jul_trans(jdt, options={})
+      options = TemporalPosition._options(options)
       unless jdt.kind_of?(When::TimeValue)
         options[:clock] ||= @time_basis unless rate_of_clock == 1.0
         jdt = JulianDate.new(jdt, options)
@@ -189,42 +191,63 @@ module When::TM
         cal_options[:clock] = @time_basis || When.utc
         jdt = JulianDate.dynamical_time(jdt.dynamical_time, {:time_standard=>time_standard})
       end
+
       cal_options.update(options)
       cal_options[:frame] = self
-      cal_date     = to_cal_date(jdt.to_i)
-      cal_date[0] -= cal_options[:era_name][1] if cal_options[:era_name]
-      clock = @time_basis || Clock.get_clock_option(cal_options) || jdt.clock
-      return CalDate.new(cal_date, cal_options) unless clock
-      clock = When.Clock(clock)    if clock.kind_of?(String)
-      clock = clock._daylight(jdt) if clock._need_validate
-      frac  = clock.universal_time
-      sdn, time = (jdt.universal_time - frac).divmod(Duration::DAY)
-      cal_options[:clock] = clock
-      return DateAndTime.new(to_cal_date(sdn.to_i + JulianDate::JD19700101), time+frac, cal_options)
+      clock = Clock.get_clock_option(cal_options) || jdt.clock
+
+      if clock
+        clock = When.Clock(clock) if clock.kind_of?(String)
+        clock = clock._daylight(jdt.universal_time) if clock._need_validate
+        frac  = clock.universal_time
+        sdn, time = (jdt.universal_time - frac).divmod(Duration::DAY)
+        cal_options[:clock] = clock
+        cal_date = to_cal_date(sdn.to_i + JulianDate::JD19700101)
+        cal_date[0] -= cal_options[:era_name][1] if cal_options[:era_name]
+        DateAndTime.new(cal_date, time+frac, cal_options)
+      else
+        cal_date     = to_cal_date(jdt.to_i)
+        cal_date[0] -= cal_options[:era_name][1] if cal_options[:era_name]
+        CalDate.new(cal_date, cal_options)
+      end
     end
     alias :julTrans :jul_trans
     alias :^ :jul_trans
 
+    # ユリウス日(Numeric)を日付に変換する
+    #
+    # @param [Integer] jdn
+    #
+    # @return [Array<Numeric>]
+    #
+    def to_cal_date(jdn)
+      _encode(_number_to_coordinates(jdn))
+    end
+
     # 日付をユリウス日(Numeric)に変換する
     #
-    # @param [Numeric] cal_date
+    # @param [Array<Numeric>] cal_date
     #
     # @return [Integer] JulianDate
     #
     def to_julian_date(cal_date)
       date    = _decode(cal_date)
       date[0] = +date[0]
-      return _coordinates_to_number(*date)
+      _coordinates_to_number(*date)
     end
 
-    # ユリウス日(Numeric)を日付に変換する
+    # 日付・時刻をUniversal Time(Numeric)に変換する
     #
-    # @param [Integer] jdn
+    # @param [Array<Numeric>] cal_date 日付
+    # @param [Array<Numeric>] clk_time 時刻
+    # @param [When::TM::Clock] clock 時法
     #
-    # @return [Numeric]
+    # @return [Numeric] Universal Time
     #
-    def to_cal_date(jdn)
-      return _encode(_number_to_coordinates(jdn))
+    def to_universal_time(cal_date, clk_time, clock=When.utc)
+      time     = clk_time.dup
+      time[0] += _coordinates_to_number(*_decode(cal_date))
+      clock.to_universal_time(time) - When::TM::JulianDate::JD19700101 * When::TM::Duration::DAY
     end
 
     # 月初の通日
@@ -264,8 +287,9 @@ module When::TM
 
     # オブジェクトの正規化
     def _normalize(args=[], options={})
-      @time_basis = When.Calendar(@time_basis) if @time_basis.kind_of?(String)
       @indices  ||= DefaultDateIndices
+      _normalize_spatial
+      _normalize_time_basis
       _normalize_temporal
       @reference_frame ||= []
     end
@@ -278,29 +302,15 @@ module When::TM
   class Clock < ReferenceSystem
 
     include When::Coordinates
+    include Spatial::Normalize
     include Temporal
 
     class << self
       include When::Parts::Resource::Pool
 
-      # 地方時
-      #
-      # @return [When::TM::Clock, When::Parts::Timezone, When::V::Timezone]
-      #
-      # @note
-      #   本変数の write access はテスト用である。
-      #   本変数は、原則、ライブラリ立ち上げ時に _setup_ で初期化する。
-      #   以降、本変数に代入を行っても、すでに生成した When::TM::TemporalPosition には反映されない。
-      #
-      # @note
-      #   マルチスレッド動作時 CalendarEra の生成で Calendar の本属性が更新される
-      #   参照・更新処理は Clock.synchronize { ... } の ... の部分に書く必要がある
-      #
-      attr_accessor :local_time
-
       # When::TM::Clock Class のグローバルな設定を行う
       #
-      # @param [When::TM::Clock, When::Parts::Timezone, When::V::Timezone] local 地方時を使用する場合、指定する
+      # @param [When::TM::Clock, When::Parts::Timezone, When::V::Timezone, String] local 地方時を使用する場合、指定する
       #
       # @return [void]
       #
@@ -314,9 +324,56 @@ module When::TM
         @local_time = local
       end
 
+      # 地方時
+      #
+      # @param [When::TM::Clock, When::Parts::Timezone, When::V::Timezone, String] local 地方時
+      #
+      # @return [When::TM::Clock, When::Parts::Timezone, When::V::Timezone, String]
+      #
+      # @note
+      #   @local_timeは、原則、ライブラリ立ち上げ時に _setup_ で初期化する。
+      #   以降、@local_timeに代入を行っても、すでに生成した When::TM::TemporalPosition 等には反映されない。
+      #
+      def local_time=(local)
+        if @_pool
+          @local_time = local
+        else
+          _setup_(local)
+        end
+      end
+
+      # When::TM::Clock のローカルタイムを読みだす
+      #
+      # @return [When::TM::Clock, When::Parts::Timezone, When::V::Timezone]
+      #
+      def local_time
+        _local_time[1]
+      end
+
+      # When::TM::Clock のローカルタイムが設定されているか?
+      #
+      # @return [true, false]
+      #
+      def is_local_time_set?
+        _local_time[0]
+      end
+
+      # 共通処理
+      def _local_time
+        case @local_time
+        when Array  ; @local_time
+        when nil    ; @local_time = [false, When.utc]
+        when String ; @local_time = [true,  When::Parts::Timezone[@local_time] ||
+                                            When::V::Timezone[@local_time]     ||
+                                            When.Clock(@local_time)]
+        else        ; @local_time = [true,  @local_time]
+        end
+      end
+      private :_local_time
+
       # @private
       def get_clock(options)
-        get_clock_option(options) || @local_time || When.utc
+        get_clock_option(options) || local_time
       end
 
       # @private
@@ -443,15 +500,17 @@ module When::TM
       @time_standard.rate_of_clock
     end
 
-    # 日の小数による参照事象の時刻
+    # 128秒単位の実数による参照事象の時刻
     #
     # Fraction time of the reference event
     #
+    # @param [Integer] sdn 参照事象の通し番号(ダミー)
+    #
     # @return [Numeric]
     #
     #   T00:00:00Z からの参照事象の経過時間 / 128秒
     #
-    def universal_time
+    def universal_time(sdn=nil)
       return @utc_reference.universal_time
     end
 
@@ -477,9 +536,9 @@ module When::TM
     end
     alias :clkTrans :clk_trans
 
-    # この時法の時刻を日の小数に変換する
+    # この時法の時刻を128秒単位の実数に変換する
     #
-    # @param [Numeric] clk_time
+    # @param [Array<Numeric>] clk_time
     #
     # @return [Numeric]
     #
@@ -487,7 +546,7 @@ module When::TM
       return _coordinates_to_number(_decode(clk_time)) / @second
     end
 
-    # 日の小数をこの時法の時刻に変換する
+    # 128秒単位の実数をこの時法の時刻に変換する
     #
     # @param [Numeric] fod
     #
@@ -544,18 +603,19 @@ module When::TM
     def ^(date, options={})
       date = Position.any_other(date, options)
       my_options = (date.options||{}).merge(options)
-      frac       = self.universal_time
+      frac       = self.universal_time(date.to_i)
       sdn, time  = (date.universal_time - frac).divmod(Duration::DAY)
       my_options[:frame] ||= date.frame if date.kind_of?(CalDate)
       my_options[:clock]   = self
       case date
       when DateAndTime
-        return DateAndTime.new(my_options[:frame].to_cal_date(sdn + JulianDate::JD19700101), time+frac, my_options)
+        time += frac unless self.kind_of?(When::CalendarTypes::LocalTime)
+        DateAndTime.new(my_options[:frame].to_cal_date(sdn + JulianDate::JD19700101), time, my_options)
       when CalDate
-        return CalDate.new(my_options[:frame].to_cal_date(date.to_i), my_options)
+        CalDate.new(my_options[:frame].to_cal_date(date.to_i), my_options)
       when JulianDate
         my_options[:frame] = my_options.delete(:clock)
-        return JulianDate.universal_time(sdn * Duration::DAY, my_options)
+        JulianDate.universal_time(sdn * Duration::DAY, my_options)
       else
         raise TypeError, "Irregal (Temporal)Position"
       end
@@ -616,14 +676,14 @@ module When::TM
 
     # 夏時間
     # @private
-    def _daylight(zdate=nil, &block)
+    def _daylight(time)
       case @tz_prop
       when nil                       ; return self
       when When::V::TimezoneProperty ; timezone = @tz_prop._pool['..']
       else                           ; timezone = @tz_prop
       end
       return self unless timezone
-      return timezone._daylight(zdate, &block)
+      return timezone._daylight(time)
     end
 
     # この時法の夏時間-標準時間変化量
@@ -653,6 +713,16 @@ module When::TM
       When::Coordinates::Index.precision(default || precision)
     end
 
+    # 丸め量 / When::TM::Duration::SYSTEM
+    # @private
+    def _round_value(precision)
+      offset = When::TM::Duration::DAY / 2
+      precision.times do |i|
+        offset /= @unit[i+1] ? @unit[i+1] : 10
+      end
+      offset
+    end
+
     private
 
     # オブジェクトの正規化
@@ -662,10 +732,14 @@ module When::TM
       # note
       @note    ||= 'JulianDayNotes'
 
+      # normalize spatial module
+      _normalize_spatial
+
+      # normalize temporal module
       _normalize_temporal
 
       # second
-      @second = (@second||128).to_f
+      @second = (@second||1/When::TM::Duration::SECOND).to_f
 
       # zone
       @zone   = Clock.to_hms(@zone || @label || @reference_event)
@@ -674,7 +748,7 @@ module When::TM
       @time_standard   = When.Resource(@time_standard||'UniversalTime', '_t:') unless @time_standard.kind_of?(When::TimeStandard)
 
       # utc_reference
-      @utc_reference ||= @zone ? ClockTime.new(@zone.to_s, {:frame=>When.utc}) : (Clock.local_time || When.utc)
+      @utc_reference ||= @zone ? ClockTime.new(@zone.to_s, {:frame=>When.utc}) : Clock.local_time
 
       # reference_time & origin_of_LSC
       case @reference_time
@@ -860,7 +934,12 @@ module When::TM
     #   処理を @begin (type: When::TM::TemporalPosition) に委譲する
     #
     def method_missing(name, *args, &block)
-      @begin.send(name.to_sym, *args, &block)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          @begin.send("#{name}", *args, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      @begin.send(name, *args, &block)
     end
   end
 
@@ -974,7 +1053,7 @@ module When::TM
         pool.delete_if {|e|
           !parents.each do |parent|
             e = e.parent
-            break false if parent != e.name
+            break false unless parent == e.name
           end
         }
       end
@@ -1311,19 +1390,32 @@ module When::TM
 
       # dating_system
       @dating_system = (@epoch.map {|e| e.frame}).compact.uniq
+      ancestors     = hierarchy.inject(['']) {|list,era|
+        list << list[-1] + '::' + era.label.to_s
+        list
+      }
 
       if @epoch.length == 1
         epoch[0].frame.synchronize {
-          epoch[0].frame.domain   |= When::Parts::GeometricComplex.new([[epoch[0],true]])
+          range = When::Parts::GeometricComplex.new([[epoch[0],true]])
+          ancestors.each do |ancestor|
+            epoch[0].frame.domain[ancestor]   |= range
+          end
         } if epoch[0].frame
       elsif reverse?
         epoch[1].frame.synchronize {
-          epoch[1].frame.domain   |= When::Parts::GeometricComplex.new([[epoch[1],true]], true)
+          range = When::Parts::GeometricComplex.new([[epoch[1],true]], true)
+          ancestors.each do |ancestor|
+            epoch[1].frame.domain[ancestor]   |= range
+          end
         } if epoch[1].frame
       else
         (epoch.length-1).times do |i|
           epoch[i].frame.synchronize {
-            epoch[i].frame.domain |= When::Parts::GeometricComplex.new([[epoch[i],true], [epoch[i+1],false]])
+            range = When::Parts::GeometricComplex.new([[epoch[i],true], [epoch[i+1],false]])
+            ancestors.each do |ancestor|
+              epoch[i].frame.domain[ancestor] |= range
+            end
           } if epoch[i].frame
         end
       end
@@ -1333,8 +1425,8 @@ module When::TM
           f.reference_frame << self
           f.reference_frame.uniq!
           f.reference_frame.sort!
-          first = f.domain.first(When::MinusInfinity)
-          last  = f.domain.last(When::PlusInfinity)
+          first = f.domain[''].first(When::MinusInfinity)
+          last  = f.domain[''].last(When::PlusInfinity)
           f.domain_of_validity = When::EX::Extent.new(
                                    When::TM::Period.new(
                                      When::TM::Instant.new(first),
@@ -1562,7 +1654,12 @@ module When::TM
     #   処理を @reference_date (type: When::TM::TemporalPosition) に委譲する
     #
     def method_missing(name, *args, &block)
-      @reference_date.send(name.to_sym, *args, &block)
+      self.class.module_eval %Q{
+        def #{name}(*args, &block)
+          @reference_date.send("#{name}", *args, &block)
+        end
+      } unless When::Parts::MethodCash.escape(name)
+      @reference_date.send(name, *args, &block)
     end
   end
 end