gphys 1.2.2.1 → 1.4.3

data/lib/numru/gphys/subsetmapping.rb

@@ -25,7 +25,6 @@ module NumRu
 	    if slicer.length == 0
 	       @maps = Array.new
 	       for i in 0...len do
-		  p  shape[i],0..-1
 		  @maps[i] = SubsetMapping1D.new(shape[i],0..-1)
 	       end
 	    else

data/lib/numru/gphys/unumeric.rb

@@ -183,6 +183,50 @@ module NumRu
       @val, @uni = val, uni
     end
       
+    ##########################
+    # Tentative class to assist basic arithmetic operations between
+    # quantities without (like Numeric) and with (like UNumeric) units.
+    # 
+    # The fundamental problem here is that the desired unit conversion
+    # to convert the Numeric is different between additional methods (+,-)
+    # and multiplicative methods (*,/). In the former, the
+    # numeric should be converted to have the same units with
+    # the other operand, and in the latter, it should be 
+    # non-dimensional.
+    #
+    class Num2Coerce
+      # * num (Numeric, NArray etc -- numeric-like object without units).
+      #   It must be KNOWN by the other operand.
+      def initialize(num)
+        @num = num
+      end
+
+      def num; @num; end
+
+      def +(o); o + num; end
+      def -(o); (-o) + num; end
+      def *(o); o * num; end
+      def /(o); o**(-1) * num;end
+
+      def >(o); o<num; end
+      def <(o); o>num; end
+      def >=(o); o<=num; end
+      def <=(o); o>=num; end
+      def ==(o); o==num; end
+      def ===(o); o===num; end
+
+      def <=>(o); c = o<=>num or -c; end
+
+      ['%','**','divmod'].each do |op|
+        eval <<-EOS
+          def #{op}(o)
+            raise("operation #{op} is unavailable between Numeric and "+o.class.to_s)
+          end
+        EOS
+      end
+    end
+    ##########################
+
     def self::[](val, uni)
       new(val, uni)
     end
@@ -368,11 +412,11 @@ module NumRu
     def coerce(other)
       case
       when Numeric
-	c_other = UNumeric.new( other, Units.new("1") )
-      when Array
-	c_other = VArray.new( NArray.to_na(other) )
-      when NArray
-	c_other = VArray.new( other )
+	c_other = Num2Coerce.new( other )
+      #when Array
+      # c_other = VArray.new( NArray.to_na(other) )
+      #when NArray
+      # c_other = VArray.new( other )
       else
 	raise "#{self.class}: cannot coerce #{other.class}"
       end
@@ -518,6 +562,7 @@ if $0 == __FILE__
   p a*7
   p -a
   p a-b, a-1000, a/100
+  p 1 + a
   p a.log, a.sin
   p UNumeric[1.0,Units['1']].atan2( UNumeric[1.0,Units['1']] )
 

data/lib/numru/gphys/varray.rb

@@ -547,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
@@ -619,22 +626,7 @@ These methods returns a NArray (not a VArray).
       end
 
       def axis_cyclic?
-	# Default setting is taken from a widely used netcdf convention.
-	# You can override it in a sub-class or using convention specific 
-	# mixins.
-	topology = attr['topology']
-	case topology
-	when /circular/i
-	  true
-	when nil     # 'topology' not defined
-	  if /degrees?_east/ =~ attr['units']
-	    true     # special treatment a common convention for the earth
-	  else
-	    nil      # not defined --> nil
-	  end
-	else
-	  false
-	end  
+        axis_modulo != nil
       end
 
       def axis_modulo
@@ -681,23 +673,16 @@ These methods returns a NArray (not a VArray).
       ## ToDo: coerce
 
       def coerce(other)
-	oattr = self.attr_copy
 	case other
 	when UNumeric
+          oattr = self.attr_copy
 	  oattr['units'] = other.units.to_s
 	  na_other, = NArray.new(self.typecode, 1).coerce(other.val)   # scalar
 	  c_other = VArray.new(na_other, oattr, self.name)
 	else
-	  oattr['units'] = self.get_att('units')     # Assume the same units
 	  case other
-	  when Numeric
-	    na_other, = NArray.new(self.typecode, 1).coerce(other)   # scalar
-	    c_other = VArray.new(na_other, oattr, self.name)
-	  when Array
-	    na = NArray.to_na(other)
-	    c_other = VArray.new(na, oattr, self.name)
-	  when NArray, NArrayMiss
-	    c_other = VArray.new(other, oattr, self.name)
+	  when Numeric, Array, NArrayMiss
+	    c_other = UNumeric::Num2Coerce.new( other )
 	  else
 	    raise "Cannot coerse #{other.class}"
 	  end
@@ -799,7 +784,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
@@ -810,7 +795,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
@@ -1072,7 +1057,7 @@ if $0 == __FILE__
    p "*3*",vt.log10
    p "*4*",(vt < vs)
    vt.name='vvvttt'
-   p "*5*",(3+vt), vt.sin, vt.cos
+   p "*5*",(3+vt).units.to_s, (3*vt).units.to_s, vt.sin, vt.cos
    vc = vt.copy
    p 'atan2'
    vv = VArray.new( NArray.sfloat(5).indgen!, nil, 'vv' )

data/lib/numru/gphys/varraycomposite.rb

@@ -77,24 +77,31 @@ module NumRu
 
       nvas = varrays.shape
       vrank = nvas.length
-      rank=0
       varrays.each{|va|
-	if va.is_a?(VArray)
+	if !va.nil?
 	  @first_vary = va
-	  @attr = @first_vary.attr
+	  @attr = @first_vary.attr_copy
 	  @name = @first_vary.name
-	  @rank = va.rank
+	  @crank = va.rank   # rank of the component VArrays
 	  break
 	end
       }
-      if vrank > @rank
-	raise ArgumentError, "rank of varrays > rank of the VArray"
-      elsif vrank < @rank
-	(@rank - vrank).times{
-	  varrays = varrays.newdim(vrank)
-	  nvas.push(1)
-	}
-	vrank = @rank
+      if vrank > @crank
+        @rank = vrank       #=>  @rank > @crank
+      else
+	@rank = @crank
+        if vrank < @crank
+          (@crank - vrank).times{
+            varrays = varrays.newdim(vrank)
+            nvas.push(1)
+          }
+          vrank = @crank   # rank of varrays is increased to @crank (==@rank)
+        end
+      end
+      un0 = varrays[0].units
+      for i in 1...varrays.length
+        va = varrays[i]
+        varrays[i] = va.convert_units(un0) if va && va.units != un0
       end
 
       @bound_idx = Array.new     # will be Array of Array
@@ -106,14 +113,24 @@ module NumRu
 	  len=0
 	  varrays[*idx].each{|va|
 	    if !set && va
-	      if !va.is_a?(VArray)
-		raise ArgumentError,"Not a VArray: #{va.inspect}"
-	      end
-	      len = va.shape_current[dim]
+              ### commented out for the duck typing:
+	      #if !va.is_a?(VArray)
+              #  raise ArgumentError,"Not a VArray: #{va.inspect}"
+	      #end
+              if dim < @crank
+                len = va.shape_current[dim]
+              else
+                len = 1
+              end
 	      @bound_idx[dim][i+1] = @bound_idx[dim][i] + len
 	      set=true
 	    elsif va
-	      if va.shape_current[dim] != len
+              if dim < @crank
+                lc = va.shape_current[dim]
+              else
+                lc = 1
+              end
+	      if lc != len
 		raise ArgumentError,"Non-uniformity in the #{i}th element"+
                    " of the #{dim}th dimension (#{va.shape_current[dim]} for #{len})"
 	      end
@@ -165,9 +182,18 @@ module NumRu
       loop_multi_dim_index( @varrays.shape ){|index|
 	vidx = Array.new
 	for d in 0...@rank
-	  vidx[d] = (@bound_idx[d][index[d]])..(@bound_idx[d][index[d]+1]-1)
+          if d < @crank
+            vidx[d] = (@bound_idx[d][index[d]])..(@bound_idx[d][index[d]+1]-1)
+          else
+            vidx[d] = @bound_idx[d][index[d]]
+          end
 	end
-	v = @varrays[*index].val
+        units = @attr["units"]
+        if units
+          v = @varrays[*index].convert_units(units).val
+        else
+          v = @varrays[*index].val
+        end
 	if !val
 	  if NArray===v
 	    val = NArray.new(v.typecode,*@shape)
@@ -177,7 +203,7 @@ module NumRu
 	    raise TypeError, "Unexpected type #{v.class}"
 	  end
 	end
-	val[*vidx] = @varrays[*index].val
+	val[*vidx] = v
       }
       val
     end
@@ -190,7 +216,11 @@ module NumRu
 	  __check_ary_class(narray)
 	  vidx = Array.new
 	  for d in 0...@rank
-	    vidx[d] = (@bound_idx[d][index[d]])..(@bound_idx[d][index[d]+1]-1)
+            if d < @crank
+              vidx[d] = (@bound_idx[d][index[d]])..(@bound_idx[d][index[d]+1]-1)
+            else
+              vidx[d] = @bound_idx[d][index[d]]
+            end
 	  end
 	  sub=narray[*vidx]
 	end
@@ -286,12 +316,12 @@ module NumRu
       idx.each_with_index{ |ix, dim|
 	size = @bound_idx[dim][-1]
 	imask[dim] = Array.new
-	isub[dim] = Array.new
+	isub[dim] = Array.new if dim < @crank
 	for j in 0...(@bound_idx[dim].length)
 	  match, isb = _imatch( size, ix, @bound_idx[dim][j..j+1] )
 	  if match
 	    imask[dim].push(j)
-	    isub[dim].push(isb) 
+	    isub[dim].push(isb) if dim < @crank
 	  end
 	end
       }
@@ -334,6 +364,11 @@ module NumRu
 	  stp = 1
 	else # Hash
 	  range, stp = index.to_a[0]
+          if stp<=0
+            raise(ArgumentError,"Currently only positive step is supported")
+            # development note: current handling of fst and lst assumes a
+            # positive step
+          end
 	  range = 0..-1 if range==true
 	  fst = range.first
 	  fst += size if fst < 0
@@ -349,11 +384,28 @@ module NumRu
 	  if stp==1
 	    return [true, a..b ]
 	  else
-	    return [true, {(a..b)  => stp} ]
+            len = last-first+1
+            if a<len
+              return [true, {(a..b)  => stp} ]
+            else
+              return [false, nil]
+            end
 	  end
 	else
 	  return [false, nil]
 	end
+      when Array
+        match = false
+        isb = []
+        index.each{ |idx|
+          idx += size if idx < 0
+          if first <= idx && idx <= last
+            match = true
+            isb.push(idx-first)
+          end
+        }
+        isb = nil if isb == []
+        return [match, isb]
       else
 	raise "Unsupported type for indexing: #{index.class}"
       end
@@ -412,4 +464,35 @@ if __FILE__ == $0
   p vac.get_att('long_name')
   p va01.get_att('long_name')
   p vac.typecode,vac.ntype
+
+  puts "testing rank extension.."
+  va0 = VArray.new( NArray.float(3,2).indgen!,     {"units"=>"m/s"}, 'V' )
+  va1 = VArray.new( NArray.float(3,2).indgen!+100, {"units"=>"m/s"}, 'V' )
+  va2 = VArray.new( NArray.float(3,2).indgen!+200, {"units"=>"m/s"}, 'V' )
+  va3 = VArray.new( NArray.float(3,2).indgen!+300, {"units"=>"m/s"}, 'V' )
+  varrays = NArray.to_na([ [[va0]], [[va1]], [[va2]], [[va3]] ])
+  vac = VArrayComposite.new(varrays)
+  p vac, vac.val
+  if vac[1,1,1].val == 104.0
+    puts "test OK"
+  else
+    raise "test failed"
+  end
+
+  v = vac[0..1,0,{1..-1=>2}].val
+  ans = NArray.to_na( [ [100.0,101.0], [300.0, 301.0] ] )
+  if v==ans
+    puts "test OK"
+  else
+    raise "test failed"
+  end
+
+  vac[-1,true,1..2] = -999.0
+  if vac[-1,true,1..2].val.to_a.flatten.uniq == [-999.0 ] 
+    puts "test OK"
+  else
+    raise "test failed"
+  end
+  #vac.val = NArray.float(3,2,4).random!
+  #p vac.val
 end

data/lib/numru/gphys/varraynetcdf.rb

@@ -55,7 +55,7 @@ module NumRu
 	 end
       end
       def close
-	 enddef
+	 enddef rescue nil
 	 super
       end
    end        # module NetCDFDeferred
@@ -216,9 +216,15 @@ module NumRu
       ## < redefined instance methods > ##
 
       def val
-	 mode_switched = @ary.file.enddef
+         begin
+           mode_switched = @ary.file.enddef
+         rescue
+         end
 	 v = @ary.get
-	 if mode_switched; @ary.file.redef; end
+         begin
+           if mode_switched; @ary.file.redef; end
+         rescue
+         end
 	 v
       end
 

data/lib/numru/gphys/version.rb

@@ -0,0 +1,5 @@
+module NumRu
+  class GPhys
+    VERSION = "1.4.3"
+  end
+end

data/sample/druby_cli1.rb

@@ -4,6 +4,8 @@
 #   See ./druby_serv1.rb
 
 require "drb/drb"
+require "numru/gphys"
+include NumRu
 
 DRb.start_service
 uri = ARGV.shift || raise("Usage: % #{$0} uri")

data/sample/druby_cli2.rb

@@ -17,10 +17,6 @@ p gp.grid.axis(0).pos.name
 gpmean = gp.mean(0)
 p gpmean.class, gpmean.name, gpmean.rank
 
-class NArray
-  def self._load(o) to_na(*Marshal::load(o)).ntoh end
-end
-
 p ( gpmean_copy = gpmean.copy )
 DCL.gropn(1)
 DCL.sgpset('lfull',true)
@@ -30,5 +26,3 @@ GGraph.set_fig('viewport'=>[0.25,0.7,0.15,0.6], 'itr'=>2 )
 GGraph.contour( gpmean_copy )
 DCL.grcls
 
-print "\nThe following will be a DRbObject rather than GPhys since the size is too large\n(see druby_serv2.rb):\n"
-p ( gpcopy = gp.copy )

data/sample/druby_serv2.rb

@@ -41,19 +41,6 @@ port = ARGV.shift
 usage if port && port.to_i.to_s != port
 usage if ARGV.length > 0
 
-class NArray
-  DUMP_SIZE_LIMIT = 5000
-  def self._load(o) to_na(*Marshal::load(o)).ntoh end
-  def _dump(limit) 
-    if size <= DUMP_SIZE_LIMIT
-      Marshal::dump([hton.to_s, typecode, *shape]) 
-    else
-      raise "size of the NArray (#{size}) is too large to dump "+
-            "(limit: #{DUMP_SIZE_LIMIT})"
-    end
-  end
-end
-
 file = NetCDF.open("../testdata/T.jan.nc")
 gp = GPhys::NetCDF_IO.open(file,"T")