gentooboontoo-gphys 0.6.1.3 → 1.3.1.1

data/lib/numru/gphys/mdstorage.rb

@@ -0,0 +1,145 @@
+require "narray"
+
+module NumRu
+  class MDStorage
+    def initialize(rank=1)
+      raise(ArgumentError,"rank must be a positive integer") if !(rank>0)
+      @rank = rank
+      @shape = []
+      rank.times{@shape.push(1)}
+      @data = [nil]
+      (rank-1).times{
+        @data = [@data]
+      }
+    end
+
+    attr_reader :rank
+
+    def shape
+      @shape.dup
+    end
+
+    # add a new dimension to the last
+    def add_dim
+      @rank += 1
+      @shape.push(1)
+      @data = [@data]
+    end
+
+    # increase the length of a dimension by one
+    def extend(dim)
+      if dim<0 or dim>=rank
+        raise(ArgumentError,"invalid dim (#{dim}): not in #{0..rank-1}")
+      end
+      yield_at_depth(@data,rank-1-dim){|a| 
+        a.push( dim==0 ? nil : make_nested_array(shape[0..dim-1]) )
+      }
+      @shape[dim] += 1
+      self
+    end
+
+    # substituion at a position specified with integers (only one element)
+    def []=(*args)
+      val = args.pop
+      raise(ArgumentError,"# of args != rank (#{rank})") if args.length != rank
+      x = @data
+      (rank-1).downto(1) do |d|
+        idx = args[d]
+        raise(ArgumentError,"all args must be integers") if !idx.is_a?(Integer)
+        len = shape[d]
+        idx += len if idx<0
+        raise("Too big negative index for dim #{d}: #{idx-len}") if idx<0
+        if 0<=idx and idx<len
+          x = x[idx]
+        elsif idx >= len
+          (idx-len+1).times{extend(d)}
+          x = x[idx]
+        else
+          raise(ArgumentError,"invalid specification")
+        end
+      end
+
+      idx = args[0]
+      len = shape[0]
+      idx += len if idx<0
+      raise("Too big negative index for dim #{0}: #{idx-len}") if idx<0
+      if idx >= len
+        (idx-len+1).times{extend(0)}
+      end
+      x[idx] = val
+    end
+
+    # read from a position specified with integers (only one element)
+    def [](*args)
+      raise(ArgumentError,"# of args != rank (#{rank})") if args.length != rank
+      x = @data
+      args.reverse_each do |idx|
+        raise(ArgumentError,"all args must be integers") if !idx.is_a?(Integer)
+        x = x[idx]
+        return(x) if x.nil?
+      end
+      x
+    end
+
+    def to_na
+      NArray.to_na(@data)
+    end
+
+    #############################################
+    ## < private methods >
+    private
+=begin
+    def __rubber_expansion( args )
+      if (id = args.index(false))  # substitution into id
+        # false is incuded
+        alen = args.length
+        if args.rindex(false) != id
+          raise ArguemntError,"only one rubber dimension is permitted"
+        elsif alen > rank+1
+          raise ArgumentError, "too many args"
+        end
+        ar = ( id!=0 ? args[0..id-1] : [] )
+        args = ar + [true]*(rank-alen+1) + args[id+1..-1]
+      end
+      args
+    end
+=end
+
+    # make a neste multi-D Array filled with nil
+    def make_nested_array(shape)
+      if shape.length == 1
+        Array.new(shape[0])      # => [nil,nil,...,nil]
+      elsif shape.length > 1   # recursive construction
+        (0...shape[-1]).collect{make_nested_array(shape[0..-2])}
+      else
+        raise ArgumentError, "shape must have 1 or more elements"
+      end
+    end
+
+    # call the block at the depth in the nested array
+    def yield_at_depth(ary,depth, &blk)
+      if depth==0
+        blk.call(ary)    # call the block
+      elsif depth>0
+        ary.each{|sub| yield_at_depth(sub,depth-1,&blk)}
+      else
+        raise ArgumentError, "depth must be >= 0"
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  include NumRu
+  a = MDStorage.new(3)
+  p a
+  p a.extend(2)
+  p a.extend(2)
+  p a.extend(0)
+  a[0,0,0] = 10.9
+  a[1,0,-1] = "XX"
+  p a, a[0,0,0], a[1,0,-1]
+  a[2,0,2] = '###'
+  p a
+  p a.to_na
+end

data/lib/numru/gphys/narray_ext.rb

@@ -0,0 +1,34 @@
+require "narray"
+
+class NArray
+
+  @@dump_size_limit = -1  # max len to allow dump / no limit if negative
+  def self.dump_size_limit=(lmt)
+    @@dump_size_limit = lmt
+  end
+  def self.dump_size_limit
+    @@dump_size_limit
+  end
+
+  def self.endian
+    NArray[1].to_s[1] == 1 ? :little : :big
+  end
+
+  def _dump(limit)
+    if (@@dump_size_limit <= 0) || (size <= @@dump_size_limit)
+      Marshal.dump([typecode, shape, NArray.endian, to_s])
+    else
+      raise "size of the NArray (#{size}) is too large to dump "+
+            "(limit: #{DUMP_SIZE_LIMIT})"
+    end
+  end
+
+  def self._load(str)
+    ary = Marshal.load(str)
+    typecode, shape, endian, str = ary
+    na = NArray.to_na(str, typecode, *shape)
+    na = na.swap_byte unless endian == NArray.endian
+    return na
+  end
+
+end

data/lib/numru/gphys/netcdf_convention.rb

@@ -167,7 +167,8 @@ module NumRu
 	when /^Wind Profiler/
 	  NetCDF_Convention_Wind_Profiler
 	else
-	  NetCDF_Convention_Users_Guide
+	  #NetCDF_Convention_Users_Guide
+          NetCDF_Convention_CF
 	end
       end
     end
@@ -299,8 +300,49 @@ module NumRu
       nil   # no rule for that
     end
 
+    def assoc_coord_names(data)
+      nil   # no rule for that
+    end
+
+  end
+
+  module NetCDF_Convention_CF
+    # http://cf-pcmdi.llnl.gov/
+
+    # < inherit the Users guide convention >
+
+    module Attribute_Mixin
+      include NetCDF_Convention_Users_Guide::Attribute_Mixin
+    end    # module Attribute_Mixin
+    module VArray_Mixin
+      include NetCDF_Convention_Users_Guide::VArray_Mixin
+    end    # module VArray_Mixin
+    module_function
+    extend NetCDF_Convention_Users_Guide
+    public_class_method :aux_var_names, :coord_var_names, :cell_bounds?, :cell_center?
+
+    ########### original part starts here #################
+
+    def assoc_coord_names(data)
+      if s = data.get_att("coordinates")
+        nms = s.split(/ +/)
+        case data.file
+        when NArray
+          fl = data.file[0]
+        else
+          fl = data.file
+        end
+        nms.delete_if{|nm| !fl.var(nm)}
+        nms.delete_if{|nm| fl.dim_names.include?(nm)}
+        nms
+      else
+        nil
+      end
+    end
+
   end
 
+
   module NetCDF_Convention_Wind_Profiler
     # Wind Profiler Convention
     # http://www.kurasc.kyoto-u.ac.jp/radar-group/wind_profiler_conventions/
@@ -316,7 +358,7 @@ module NumRu
     ########################
     module_function
     extend NetCDF_Convention_Users_Guide
-    public_class_method :cell_bounds?, :cell_center?
+    public_class_method :cell_bounds?, :cell_center?, :assoc_coord_names
     
     def to_s
       "Wind Profiler (http://www.kurasc.kyoto-u.ac.jp/radar-group/wind_profiler_conventions/)"

data/lib/numru/gphys/subsetmapping.rb

@@ -231,7 +231,7 @@ module NumRu
 	    idxary = @index_array[mida]
 	    if idxary.length==1
 	       fst = idxary[0]
-	       len = step = 1
+	       len = stp = 1
 	       slicer = __make_regular_slicer((scl=mapping.collapsed),fst,len,stp)
 	       SubsetMapping1D.new0.initialize_regular(slicer,scl,fst,len,stp)
 	    else

data/lib/numru/gphys/unumeric.rb

@@ -187,29 +187,88 @@ module NumRu
       new(val, uni)
     end
 
+    @@supported_calendars = [nil,"gregorian", "standard", "proleptic_gregorian", 
+                            "noleap", "365_day", "360_day"]
+
+    def self::supported_calendar?(cal)
+      @@supported_calendars.include?(cal)
+    end
+
+    def self::supported_calendars
+      @@supported_calendars.dup
+    end
+
     # * date (Date or DateTime)
     # * units (Units or String) : units of the UNumeric to be created
-    def self::from_date(date, units)
+    def self::from_date(date, units, calendar=nil)
       sunits = units.to_s
       /(.*) *since *(.*)/ =~ sunits
       if (!$1 or !$2)
         raise("Units mismatch. Requires time units that includes 'since'")
       end
       tun = Units[$1]
-      since = DateTime.parse($2)
+      since = DateTime.parse(UNumeric::before_date_parse($2))
       if( tun =~ Units['months since 0001-01-01'] )
         year0,mon0 = since.year,since.mon
         year,mon = date.year,date.mon
         time = Units['months'].convert((year*12+mon)-(year0*12+mon0), tun)
       elsif( tun =~ Units['days since 0001-01-01'] )
-        time = Units['days'].convert( date-since, tun )
+        case calendar
+        when nil, "gregorian", "standard"
+          time = Units['days'].convert( date-since, tun )
+        when "proleptic_gregorian"
+          since = DateTime.parse(UNumeric::before_date_parse($2),false,Date::GREGORIAN)
+          time = Units['days'].convert( date-since, tun )
+        when "noleap", "365_day"
+          since_yday = since - DateTime.new(since.year,1,1) # day number of year (0..364)
+          since_yday = since_yday - 1 if( since.leap? && since.mon > 2 )
+          date_yday = date - DateTime.new(date.year,1,1)
+          if( date.leap? )
+            if date_yday >= 60.0 # after Mar1
+              date_yday = date_yday - 1
+            elsif date_yday >= 59.0 # Feb29
+              raise("Feb.29 is specified, but calendar is #{calendar}.")
+            end
+          end
+          days = (date.year - since.year)*365 + (date_yday - since_yday)
+          time = Units['days'].convert( days, tun )
+        when "360_day" # does not work perfectly
+          if date.day == 31
+            raise("day=31 is specified, but calendar is #{calendar}.")
+          end
+          if date.is_a?(DateTime)
+            date_hour,date_min,date_sec = date.hour,date.min,date.sec
+          else
+            date_hour,date_min,date_sec = 0,0,0
+          end
+          days = (date.year-since.year)*360 + (date.mon-since.mon)*30 + 
+                 (date.day-since.day) + Rational(date_hour-since.hour,24) + 
+                 Rational(date_min-since.min,1440) + Rational(date_sec-since.sec,86400)
+          time = Units['days'].convert( days.to_f, tun )
+        else
+          #raise("Unrecognized calendar: #{calendar}")
+          return nil
+        end
       else
-        raise("Unrecognized time units #{tun.to_s} -- may be a BUG?")
+        #raise("Unrecognized time units #{tun.to_s}")
+        return nil
       end
       time = time.to_f
       UNumeric[time, units]
     end
 
+
+    # Always interpret y \d\d as 00\d\d and y \d as 000\d
+    # (Date in Ruby 1.9 interprets them as 20\d\d etc.)
+    def self::before_date_parse(str)
+      if /^\d\d-\d/ =~ str
+        str = "00"+str
+      elsif /^\d-\d/ =~ str
+        str = "00"+str
+      end
+      str
+    end
+
     def val; @val; end
 
     def units; @uni; end
@@ -250,7 +309,7 @@ module NumRu
 
     # * eps_sec : Magic epsilon to prevent the round-off of DateTime [seconds].
     #             Recommended value is 0.1.
-    def to_datetime(eps_sec=0.0)
+    def to_datetime(eps_sec=0.0,calendar=nil)
       time = self.val
       sunits = self.units.to_s
       /(.*) *since *(.*)/ =~ sunits
@@ -258,13 +317,47 @@ module NumRu
   	raise("Units mismatch. Requires time units that includes 'since'")
       end
       tun = Units[$1]
-      since = DateTime.parse($2)
+      sincestr = $2.sub(/(^\d{1,2}-\d+-\d)/,'00\1') 
+              #^ correction for Ruby 1.9 to prevent 1- or 2-digit years
+              #  (e.g. 1, 02) to be interpreted as in 2000's (e.g., 2001, 2002)
+      since = DateTime.parse(UNumeric::before_date_parse(sincestr))
       if( tun =~ Units['months since 0001-01-01'] )
         datetime = since >> tun.convert( time, Units['months'] )
       elsif( tun =~ Units['days since 0001-01-01'] )
-        datetime = since + tun.convert( time, Units['days'] )
+        case calendar
+        when nil, "gregorian", "standard"
+          # default: Julian calendar before 1582-10-15, Gregorian calendar afterward
+          datetime = since + tun.convert( time, Units['days'] )
+        when "proleptic_gregorian"
+          # Gregorian calendar extended to the past
+          since = DateTime.parse(UNumeric::before_date_parse(sincestr),false,Date::GREGORIAN)
+          datetime = since + tun.convert( time, Units['days'] )
+        when "noleap", "365_day"
+          since_yday = since - DateTime.new(since.year,1,1) # day number of year (0..364)
+          since_yday = since_yday - 1 if( since.leap? && since.mon > 2 )
+          days = since_yday + tun.convert( time, Units['days'] )
+          year = since.year + (days/365).to_i
+          date_yday = days%365 # day number of year (0..364)
+          datetime = DateTime.new(year,1,1) + date_yday
+          datetime = datetime + 1 if( datetime.leap? && date_yday >= 59 )
+        when "360_day" # does not work perfectly
+          since_day = since - DateTime.new(since.year,since.mon,1)
+          days = (since.mon-1)*30 + since_day + tun.convert( time, Units['days'] )
+          year = since.year + (days/360).to_i
+          mon = ((days%360)/30).to_i + 1
+          datetime = DateTime.new(year,mon,1) + days%30 # Feb29->Mar1,Feb30->Mar2
+          #datetime = DateTime.new(year,mon,days%30 + 1) # stops if Feb29,Feb30
+          if datetime.mon != mon # Feb29,Feb30
+            $stderr.print("cannot convert #{year}-#{mon}-#{(days%30+1).to_i} to DateTime instance\n")
+            return nil
+          end
+        else
+          #raise("Unrecognized calendar: #{calendar}")
+          return nil
+        end
       else
-        raise("Unrecognized time units #{tun.to_s} -- may be a BUG?")
+        #raise("Unrecognized time units #{tun.to_s}")
+        return nil
       end
       if eps_sec != 0.0
         datetime = datetime + eps_sec/8.64e4  

data/lib/numru/gphys/varray.rb

@@ -263,6 +263,12 @@ NOMENCLATURE
       * Float if the modulo is defined
       * nil if modulo is not found
 
+---axis_cyclic_extendible?
+    (meaningful only if self is a coordinate variable.) 
+    Returns true if self is cyclic and it is suitable to exend
+    cyclically (having the distance between both ends 
+    equal to (modulo - dx), where dx is the mean increment).
+
 ---coerce(other)
     For Numeric operators. (If you do not know it, see a manual or book of Ruby)
 
@@ -325,7 +331,7 @@ These methods returns a NArray (not a VArray).
 	 when nil
 	    @attr = NumRu::Attribute.new
 	 else
-	   raise TypeErroor, "#{attr.class} is unsupported for the 2nd arg"
+	   raise TypeError, "#{attr.class} is unsupported for the 2nd arg"
 	 end
       end
 
@@ -409,11 +415,7 @@ These methods returns a NArray (not a VArray).
       end
 
       def ntype
-	 if !@mapping
-	    __ntype(@ary)
-	 else
-	    __ntype(@varray.ary)
-	 end
+        __ntype(typecode)
       end
 
       def name=(nm)
@@ -446,7 +448,7 @@ These methods returns a NArray (not a VArray).
 	if @mapping
 	  @varray.file
 	else
-	  raise nil
+	  return nil
 	end
       end
 
@@ -545,7 +547,14 @@ These methods returns a NArray (not a VArray).
 	end
 	myunits = self.units
 	if myunits != to
-	  gp = myunits.convert2(self, to)
+	  if calendar = self.get_att("calendar")
+	    date0 = UNumeric.new(0,myunits).to_datetime
+	    un0 = UNumeric.from_date(date0,to,calendar)
+	    offset = un0.to_f
+	    gp = self + offset
+	  else
+	    gp = myunits.convert2(self, to)
+	  end
 	  gp.units = to
 	  gp
 	else
@@ -625,7 +634,7 @@ These methods returns a NArray (not a VArray).
 	when /circular/i
 	  true
 	when nil     # 'topology' not defined
-	  if attr['units'] == 'degrees_east'
+	  if /degrees?_east/ =~ attr['units']
 	    true     # special treatment a common convention for the earth
 	  else
 	    nil      # not defined --> nil
@@ -645,15 +654,34 @@ These methods returns a NArray (not a VArray).
 	  else
 	    attval[0]
 	  end
-	else
-	  if attr['units'] == 'degrees_east'
-	    360.0     # special treatment a common convention for the earth
-	  else
-	    nil      # not defined --> nil
-	  end
+	elsif /degrees?_east/ =~ attr['units']
+          360.0     # special treatment: a common convention for the earth
+        elsif (tp = attr['topology']) and (/circular/i =~ tp)
+          un = Units[attr['units']]
+          if un == Units['degrees']
+	    360.0
+          elsif un == Units['radian']
+            2*Math::PI
+          else
+            nil    # cannot guess --> nil
+          end
+        else
+          nil      # not defined --> nil
 	end
       end
 
+      def axis_cyclic_extendible?
+        modulo = axis_modulo
+        return false if !modulo
+        v = val
+        width = (v[-1] - v[0]).abs
+	dx = width / (length-1)
+	eps = 1e-4
+	modulo = modulo.abs
+	extendible = ( ((width+dx) - modulo).abs < eps*modulo )
+        return extendible
+      end
+
       ### < NArray methods > ###
 
       ## ToDo: implement units handling
@@ -778,7 +806,7 @@ These methods returns a NArray (not a VArray).
 		 ary = NArrayMiss.to_nam(vl)#{f}(vr)
 	       end
 	       va = VArray.new( ary, self.attr_copy, self.name )
-	       va.units= self.units#{f}(other.units)
+	       va.units= self.units#{f}(other.units) if "#{f}" != "**" 
                va
 	    when Numeric, NArray, NArrayMiss, Array
 	       vl = self.val
@@ -789,7 +817,7 @@ These methods returns a NArray (not a VArray).
 		 ary = NArrayMiss.to_nam(vl)#{f}(vr)
 	       end
 	       va = VArray.new( ary, self.attr_copy, self.name )
-	       if "#{f}" == "**" 
+	       if "#{f}" == "**" && other.is_a?(Numeric)
 		 va.units= self.units#{f}(other)
                end
                va
@@ -966,6 +994,15 @@ These methods returns a NArray (not a VArray).
 
       alias shape_current shape
 
+      ## < marshal dump/load >
+      def marshal_dump
+        [@name, @mapping, @varray, @ary, @attr]
+      end
+       
+      def marshal_load(ary)
+        @name, @mapping, @varray, @ary, @attr = *ary
+      end
+
       ## < private methods >
       private
       def __rubber_expansion( args )
@@ -998,8 +1035,8 @@ These methods returns a NArray (not a VArray).
 	 end
 	 narray
       end
-      def __ntype(na)
-	 case na.typecode
+      def __ntype(typecode)
+	 case typecode
 	 when NArray::BYTE
 	    "byte"
 	 when NArray::SINT
@@ -1072,8 +1109,17 @@ if $0 == __FILE__
 
    p '*axis conventions*'
    p vx = VArray.new( NArray.int(6).indgen!, nil, 'x' )
-   vx.set_att('topology','circular')
+
+   vx.put_att("topology","circular")
    vx.set_att('modulo',[360.0])
    vx.set_att('positive','down')
    p vx.axis_draw_positive, vx.axis_cyclic?, vx.axis_modulo
+
+   p '   cyclic extendible:'
+   p vx.axis_cyclic_extendible?
+   vx.set_att('modulo',[6.0])
+   p vx.axis_cyclic_extendible?
+
+   p '*typecode*'
+   p vx.typecode, vx[0..1].typecode
 end