gphys 1.1.1a

data/lib/numru/ganalysis/covariance.rb

@@ -0,0 +1,154 @@
+require "numru/gphys"
+
+module NumRu
+  module GAnalysis
+
+    module_function
+
+    def covariance(gphys0, gphys1, *dims)
+      unless GPhys===gphys0 && GPhys===gphys1
+        raise "gphys0 and gphys1 must be GPhys"
+      end
+      unless gphys0.shape == gphys1.shape
+        raise "gphys0 and gphys1 must have the same shape"
+      end
+      units = gphys0.units*gphys1.units
+      if dims.length == 0
+        dims = Array.new
+        gphys0.rank.times{|i| dims.push i }
+      else
+        dims = dims.map{|dim| gphys0.dim_index(dim) }
+      end
+      val0 = gphys0.val
+      val1 = gphys1.val
+      if val0.is_a?(NArrayMiss)
+        if val1.is_a?(NArrayMiss)
+          mask = val0.get_mask * val1.get_mask
+          ndiv = mask.to_type(NArray::LINT).accum(*dims)
+          val0 = val0.set_mask(mask)
+          val1 = val1.set_mask(mask)
+        else
+          ndiv = val0.get_mask.to_type(NArray::LINT).accum(*dims)
+          val1 = NArrayMiss.to_nam(val1,val0.get_mask)
+        end
+      elsif val1.is_a?(NArrayMiss)
+        ndiv = val1.get_mask.to_type(NArray::LINT).accum(*dims)
+        val0 = NArrayMiss.to_nam(val0,val1.get_mask)
+      else
+        ndiv = 1
+        gphys0.shape.each_with_index{|s,i|
+          ndiv *= s if dims.include?(i)
+        }
+      end
+      val0 -= val0.accum(*dims).div!(ndiv)
+      val1 -= val1.accum(*dims).div!(ndiv)
+      nary = val0.mul_add(val1,*dims)
+      if Float === nary
+        ndiv = ndiv[0] if ndiv.is_a?(NArray)
+        nary /= (ndiv-1)
+        return UNumeric.new(nary, units), ndiv
+      else
+        nary.div!(ndiv-1)
+        vary = VArray.new(nary,
+                          {"long_name"=>"covariance","units"=>units.to_s},
+                          "covariance")
+        new_grid = gphys0.grid.delete_axes(dims, "covariance").copy
+        return GPhys.new(new_grid,vary), ndiv
+      end
+    end
+
+    def corelation(gphys0, gphys1, *dims)
+      val0 = gphys0.val
+      val1 = gphys1.val
+      if val0.is_a?(NArrayMiss)
+        mask = val0.get_mask
+      else
+        mask = NArray.byte(*(val0.shape)).fill!(1)
+      end
+      if val1.is_a?(NArrayMiss)
+        mask2 = val1.get_mask
+      else
+        mask2 = NArray.byte(*(val1.shape)).fill!(1)
+      end
+      mask.mul!(mask2)
+      val0 = NArrayMiss.to_nam(val0) unless val0.is_a?(NArrayMiss)
+      val1 = NArrayMiss.to_nam(val1) unless val1.is_a?(NArrayMiss)
+      val0 = val0.set_mask(mask)
+      val1 = val1.set_mask(mask)
+      p val0,val1 if $DEBUG
+      gphys0 = gphys0.copy.replace_val(val0)
+      gphys1 = gphys1.copy.replace_val(val1)
+
+      covariance, ndiv = gphys0.covariance(gphys1,*dims)
+      return covariance/(gphys0.stddev(*dims)*gphys1.stddev(*dims)), mask.to_type(NArray::LINT).sum(*dims)
+    end
+    alias correlation corelation
+  end
+
+  class GPhys
+    def covariance(other, *dims)
+      GAnalysis.covariance(self, other, *dims)
+    end
+
+    def corelation(other, *dims)
+      GAnalysis.corelation(self, other, *dims)
+    end
+    alias correlation corelation
+  end
+end
+
+if  $0 == __FILE__
+  require "numru/ggraph"
+  include NumRu
+
+  # TEST DATA WITHOUT MISSING VALUE
+  p x = NArray[1.0, 2.0, 4.0, 8.0, 9.0, 10.0]
+  p y = NArray[1.0, 2.0, 4.0, 8.0, 9.0, 10.0]
+
+  vx = VArray.new(x, {}, "x")
+  vy = VArray.new(y, {}, "y")
+  i  = VArray.new(NArray.int(6).indgen!, {}, "i")
+  ai = Axis.new.set_pos(i)
+  gi = Grid.new(ai)
+
+  p gx = GPhys.new(gi, vx)
+  p gy = GPhys.new(gi, vy)
+
+  corr_true, n = gx.correlation(gy)
+  covar_true, m = gx.covariance(gy)
+
+  puts "Test of GPhys::correlation"
+  puts "gx.correlation(gy) = #{corr_true.val}, num of samples = #{n}"
+
+  puts "Test of GPhys::covariance"
+  puts "gx.covariance(gy) = #{covar_true.val}, num of samples = #{m}"
+
+  # TEST DATA WITH MISSING VALUE
+  x = NArray[1.0, 2.0, 2.9, 4.0, 4.9, -99, -99, 8.0, 9.0, 10.0]
+  y = NArray[1.0, 2.0, -99, 4.0, -99, 6.1, -99, 8.0, 9.0, 10.0]
+
+  p x = NArrayMiss.to_nam_no_dup(x,x.gt(-99))
+  p y = NArrayMiss.to_nam_no_dup(y,y.gt(-99))
+
+  vx = VArray.new(x, {}, "x")
+  vy = VArray.new(y, {}, "y")
+  i  = VArray.new(NArray.int(10).indgen!, {}, "i")
+  ai = Axis.new.set_pos(i)
+  gi = Grid.new(ai)
+
+  p gx = GPhys.new(gi, vx)
+  p gy = GPhys.new(gi, vy)
+
+  corr, n2 = gx.correlation(gy)
+  covar, m2 = gx.covariance(gy)
+
+  puts "Test of GPhys::correlation"
+  puts "gx.correlation(gy) must be #{corr_true.val}"
+  puts "gx.correlation(gy) = #{corr.val}, num of samples = #{n2}"
+
+  puts "Test of GPhys::covariance"
+  puts "gx.covariance(gy) must be #{covar_true.val}"
+  puts "gx.covariance(gy) = #{covar.val}, num of smaples = #{m2}"
+
+end
+

data/lib/numru/ganalysis/eof.rb

@@ -0,0 +1,298 @@
+require "numru/gphys"
+
+module NumRu
+  module GAnalysis
+
+    begin
+      require "numru/ssl2"
+      @@EOF_engin = "ssl2"
+    rescue LoadError
+      begin
+        require "numru/lapack"
+        @@EOF_engin = "lapack"
+      rescue LoadError
+        begin
+          require "gsl"
+          @@EOF_engin = "gsl"
+        rescue LoadError
+        end
+      end
+    end
+
+    print "EOF engin is #{@@EOF_engin}\n" if $DEBUG
+
+    module_function
+
+    # = Calculate EOF vectors and contribution rate
+    # call-seq:
+    #  NumRu::GAnalysis.eof(gphys, dim0[, dim1, ..., dimN[, opts]]) => [eof, rate]
+    #
+    # == Arguments
+    # +gphys+:: GPhys object to be calculated its EOF
+    # +dim0+, ..., +dimN+:: dimension name (String) or number (Ingeter) to calculate variance or covariance, and those dimensions are not contained in the result EOF vectors.
+    # +opts+:: a Hash object whose key is String or Symbol. The following options are available:
+    #   * nmodes: Integer, number of EOF modes to be calculate (default all EOF modes)
+    #   * weight: GPhys or NArray, weight vector
+    #              +gphys+ is multiplied by the weight vector before calculation of variance covariance matrix
+    #              and the result eigen vectors are divided by the vector.
+    #              If weight vector is not set,
+    #                 it is cosine of latitude when the first two axes of the +gphys+ are "lon" and "lat" and +disable_weight+ option is not +true+,
+    #                 else 1.
+    #   * disable_weight: See weight option.
+    #
+    # == Return values
+    # +eof+:: GPhys object for array of EOF vectors.
+    # +rate+:: GPhys object for array of contribution rate correspoinding to the EOF vectors.
+    def eof(gphys, *args)
+
+      unless defined?(@@EOF_engin)
+        raise "SSL2 (Ruby-SSL2) or LAPACK (Ruby-LAPACK) or GSL (Ruby/GSL) must have been installed. (SSL2 or LAPACK is recommended for large computation)"
+      end
+
+      if Hash === args[-1]
+        dims = args[0..-2]
+        opts = args[-1]
+      else
+        dims = args
+        opts = Hash.new
+      end
+      dims = dims.map{|dim| gphys.dim_index(dim) }
+      n = 1
+      n_lost = 1
+      dims1 = Array.new
+      shape1 = Array.new
+      gphys.shape.each_with_index{|s,i|
+        if dims.include?(i)
+          n_lost *= s
+        else
+          n *= s
+          dims1.push i
+          shape1.push s
+        end
+      }
+      new_grid = gphys.instance_variable_get("@grid").delete_axes(dims, "covariance matrix").copy
+      new_index = NArray.sint(*new_grid.shape).indgen
+      index = NArray.object(gphys.rank)
+      index[dims] = true
+
+      if w = (opts[:weight] || opts["weight"])
+        if GPhys === w
+          w = w.val
+        end
+        unless NArray === w
+          raise "weight must be NArray of GPhys"
+        end
+        unless w.shape == new_grid.shape
+          raise "shape of weight is invalid"
+        end
+        w /= w.mean
+        w.reshape!(n)
+      else
+        if !(opts[:disable_weight]||opts["disable_weight"]) && /^lon/ =~ new_grid.coord(0).name && /^lat/ =~ new_grid.coord(1).name
+          rad = NumRu::Units.new("radian")
+          nlon = new_grid.coord(0).length
+          lat = new_grid.coord(1).convert_units(rad).val
+          w = NArray.new(lat.typecode,nlon).fill!(1) * NMath::cos(lat).reshape(1,lat.length)
+          w /= w.mean
+          w.reshape!(n)
+        else
+          w = nil
+        end
+      end
+
+      ary = NArrayMiss.new(gphys.typecode, n_lost, n)
+      ind_rank = dims1.length
+      ind = Array.new(ind_rank,0)
+      n.times{|n1|
+        index[dims1] = ind
+        val = gphys[*index].val
+        val.reshape!(n_lost)
+        val -= val.mean
+        ary[true,n1] = val
+        break if n1==n-1
+        ind[0] += 1
+        ind_rank.times{|i|
+          if ind[i] == shape1[i]
+            ind[i] = 0
+            ind[i+1] += 1
+          else
+            break
+          end
+        }
+      }
+      ary.mul!(w.reshape(1,n)) if w
+
+
+      nmodes = opts[:nmodes] || opts["nmodes"] || n
+      case @@EOF_engin
+      when "ssl2"
+        print "start calc covariance matrix\n" if $DEBUG
+        nary = NArray.new(gphys.typecode,n*(n+1)/2)
+        nn = 0
+        total_var = 0
+        n.times{|n0|
+          for n1 in n0...n
+            nary[nn] = ary[n0].mul_add(ary[n1],0)/(n_lost-1)
+            if n1==n0
+              total_var += nary[nn]
+            end
+            nn += 1
+          end
+        }
+        ary = nil # for GC
+        print "start calc eigen vector\n" if $DEBUG
+        val, vec = SSL2.seig2(nary,nmodes)
+      when "lapack"
+        print "start calc covariance matrix\n" if $DEBUG
+        nary = NArray.new(gphys.typecode,n,n)
+        total_var = 0.0
+        n.times{|n0|
+          nary[n0...n,n0] = (ary[true,n0...n].mul_add(ary[true,n0],0)/(n_lost-1)).get_array!
+          total_var += nary[n0,n0]
+        }
+        ary = nil # for GC
+        print "start calc eigen vector\n" if $DEBUG
+        case nary.typecode
+        when NArray::DFLOAT
+	  m, val, vec, isuppz, work, iwork, info, = NumRu::Lapack.dsyevr("V", "I", "L", nary, 0, 0, n-nmodes+1, n, 0.0, -1, -1)
+	  m, val, vec, = NumRu::Lapack.dsyevr("V", "I", "L", nary, 0, 0, n-nmodes+1, n, 0.0, work[0], iwork[0])
+        when NArray::SFLOAT
+	  m, val, vec, isuppz, work, iwork, info, = NumRu::Lapack.ssyevr("V", "I", "L", nary, 0, 0, n-nmodes+1, n, 0.0, -1, -1)
+	  m, val, vec, = NumRu::Lapack.ssyevr("V", "I", "L", nary, 0, 0, n-nmodes+1, n, 0.0, work[0], iwork[0])
+        end
+        val = val[-1..0]
+        vec = vec[true,-1..0]
+      when "gsl"
+        print "start calc covariance matrix\n" if $DEBUG
+        nary = NArray.new(gphys.typecode,n,n)
+        n.times{|n0|
+          nary[n0...n,n0] = (ary[true,n0...n].mul_add(ary[true,n0],0)/(n_lost-1)).get_array!
+          nary[n0,n0...n] = nary[n0...n,n0]
+        }
+        ary = nil # for GC
+        print "start calc eigen vector\n" if $DEBUG
+        val, vec = GSL::Eigen::symmv(nary.to_gm)
+        GSL::Eigen.symmv_sort(val, vec, GSL::Eigen::SORT_VAL_DESC)
+        vec = vec.to_na[0...nmodes,true].transpose(1,0)
+        val = val.to_na
+        total_var = val.sum
+        val = val[0...nmodes]
+      end
+
+      axes = new_grid.instance_variable_get('@axes')
+      axis_order = Axis.new
+      axis_order.pos = VArray.new(NArray.sint(nmodes).indgen(1),
+                                  {}, "mode")
+      axes << axis_order
+      new_grid = Grid.new(*axes)
+      vec /= w if w
+      vec.reshape!(*new_grid.shape)
+      vec *= NMath::sqrt( val.reshape( *([1]*(axes.length-1)+[nmodes]) ) )
+      va_eof = VArray.new(vec,
+                          {"long_name"=>"EOF vector","units"=>gphys.units.to_s },
+                          "EOF")
+      eof = GPhys.new(new_grid, va_eof)
+
+      va_rate = VArray.new(val.div!(total_var),
+                           {"long_name"=>"EOF contribution rate", "units"=>"1" },
+                           "rate")
+      rate = GPhys.new(Grid.new(axis_order), va_rate)
+
+      return [eof, rate]
+    end
+
+    def eof2(gphys1, gphys2, *args)
+      if Hash === args[-1]
+        opts = args[-1]
+      else
+        opts = Hash.new
+      end
+      raise ArgumentError, "The 1st arg must be a GPhys of rank 1: arg1 = #{gphys1.inspect}" unless gphys1.rank==1
+      raise ArgumentError, "The 2nd arg must be a GPhys of rank 1: arg2 = #{gphys2.inspect}" unless gphys2.rank==1
+      raise ArgumentError, "The 1st and 2nd args must have the same length: #{gphys1.length}!=#{gphys2.length}" unless gphys2.rank==1
+      nam = NArrayMiss.new(gphys1.typecode, 2, gphys1.length)
+      nam[0,true] = gphys1.val
+      nam[1,true] = gphys2.val
+      gphys = GPhys.new(Grid.new(Axis.new.set_pos(VArray.new(NArray[0,1],{},"var")),
+                                 gphys1.axis(0)),
+                        VArray.new(nam,gphys1.data.attr_copy,gphys1.name))
+      eof(gphys, 1, opts)
+    end
+  end
+
+  class GPhys
+    def eof(*args)
+      GAnalysis.eof(self, *args)
+    end
+  end
+
+end
+
+
+#:enddoc
+
+if  $0 == __FILE__
+  require "numru/ggraph"
+  include NumRu
+  N = 10000
+  x = NArray.float(N).randomn!*2
+  y = NArray.float(N).randomn!*1
+  ary = NArray.float(2,N)
+  theta = Math::PI/6
+  ary[0,true] = x*Math::cos(theta)-y*Math::sin(theta)
+  ary[1,true] = x*Math::sin(theta)+y*Math::cos(theta)
+  vary = VArray.new(ary, { }, "test")
+  axis0 = Axis.new
+  axis0.pos = VArray.new(NArray[0,1], {}, "dimensions")
+  axis1 = Axis.new
+  axis1.pos = VArray.new(NArray.sint(N).indgen, {}, "t")
+  gphys = GPhys.new(Grid.new(axis0,axis1), vary)
+
+  eof,rate = gphys.eof("t")
+
+  max = 5
+  DCL::gropn(4)
+  DCL::grfrm
+  DCL::grsvpt(0.1,0.9,0.1,0.9)
+  DCL::grswnd(-max,max,-max,max)
+  DCL::grstrn(1)
+  DCL::grstrf
+
+  DCL::sgpmzu(ary[0,true],ary[1,true],1,1,0.01)
+
+  eof1 = eof[true,0].val
+  eof2 = eof[true,1].val
+  DCL::sgplzu([eof1[0],-eof1[0]],[eof1[1],-eof1[1]], 1, 23)
+  DCL::sgplzu([eof2[0],-eof2[0]],[eof2[1],-eof2[1]], 1, 43)
+
+  DCL::usdaxs
+  DCL::uxsttl("T","test of GAnalysis::eof",0)
+
+  # TEST OF GAnalysis::eof2
+
+  vary1 = VArray.new(ary[0,true], { }, "test")
+  gphys1 = GPhys.new(Grid.new(axis1), vary1)
+  vary2 = VArray.new(ary[1,true], { }, "test")
+  gphys2 = GPhys.new(Grid.new(axis1), vary2)
+
+  eof,rate = GAnalysis.eof2(gphys1,gphys2)
+
+  max = 5
+  DCL::grfrm
+  DCL::grsvpt(0.1,0.9,0.1,0.9)
+  DCL::grswnd(-max,max,-max,max)
+  DCL::grstrn(1)
+  DCL::grstrf
+
+  DCL::sgpmzu(ary[0,true],ary[1,true],1,1,0.01)
+
+  eof1 = eof[true,0].val
+  eof2 = eof[true,1].val
+  DCL::sgplzu([eof1[0],-eof1[0]],[eof1[1],-eof1[1]], 1, 23)
+  DCL::sgplzu([eof2[0],-eof2[0]],[eof2[1],-eof2[1]], 1, 43)
+
+  DCL::usdaxs
+  DCL::uxsttl("T","test of GAnalysis::eof2",0)
+
+  DCL::grcls
+end

data/lib/numru/ganalysis/histogram.rb

@@ -0,0 +1,252 @@
+require "numru/gphys"
+require "numru/ggraph"
+module NumRu
+  module GAnalysis
+
+    begin
+      require "gsl"
+      HistogramGSL = true
+    rescue LoadError
+      HistogramGSL = false
+    end
+
+    module_function
+
+    def histogram(gphys0,opts=Hash.new)
+      unless HistogramGSL
+        raise "gsl is necessary to use this method"
+      end
+      unless GPhys === gphys0
+        raise "gphys0 (1st arg) must be GPhys"
+      end
+      unless Hash === opts
+        raise "opts (2nd arg) must be Hash"
+      end
+      if opts["bins"]
+        bins = opts["bins"]
+        unless (bins.is_a?(NArray) || bins.is_a?(Array))
+          raise(TypeError, "option 'bins' must be Array or NArray")
+        end
+        bins = bins.to_gslv if bins.is_a?(NArray)
+        hist = GSL::Histogram.alloc(bins)
+      else
+        nbins = opts["nbins"] || gphys0.total/500
+        nbins = 10 if nbins < 10
+        min = opts["min"] || gphys0.min.val
+        max = opts["max"] || gphys0.max.val
+        hist = GSL::Histogram.alloc(nbins,[min,max])
+      end
+      val = gphys0.val
+      val = val.get_array![val.get_mask!] if NArrayMiss === val
+      hist.increment(val)
+
+      bounds = hist.range.to_na
+      center = (bounds[0..-2]+bounds[1..-1])/2
+      name = gphys0.name
+      attr = gphys0.data.attr_copy
+      bounds = VArray.new(bounds, attr, name)
+      center = VArray.new(center, attr, name)
+      axis = Axis.new(true)
+      axis.set_cell(center, bounds, name)
+      axis.set_pos_to_center
+
+      bin = hist.bin.to_na
+      bin = VArray.new(bin,
+                       {"long_name"=>"number in bins", "units"=>"1"},
+                       "bin")
+      new_gphys = GPhys.new(Grid.new(axis), bin)
+      new_gphys.set_att("mean",[hist.mean])
+      new_gphys.set_att("standard_deviation",[hist.sigma])
+      return new_gphys
+    end
+    alias :histogram1D :histogram
+
+    def histogram2D(gphys0, gphys1, opts=Hash.new)
+      unless HistogramGSL
+        raise "gsl is necessary to use this method"
+      end
+      unless GPhys === gphys0
+        raise "gphys0 (1st arg) must be GPhys"
+      end
+      unless GPhys === gphys1
+        raise "gphys1 (2nd arg) must be GPhys"
+      end
+      unless Hash === opts
+        raise "opts (3nd arg) must be Hash"
+      end
+
+      nbins0 = opts["nbins0"] || gphys0.total/500
+      nbins0 = 10 if nbins0 < 10
+      nbins1 = opts["nbins1"] || gphys1.total/500
+      nbins1 = 10 if nbins1 < 10
+
+      min0 = opts["min0"] || gphys0.min.val
+      max0 = opts["max0"] || gphys0.max.val
+      min1 = opts["min1"] || gphys1.min.val
+      max1 = opts["max1"] || gphys1.max.val
+
+      hist = GSL::Histogram2d.alloc(nbins0,[min0,max0],nbins1,[min1,max1])
+      val0 = gphys0.val
+      val1 = gphys1.val
+      mask = nil
+      if NArrayMiss === val0
+        mask = val0.get_mask!
+        val0 = val0.get_array!
+      end
+      if NArrayMiss === val1
+        if mask
+          mask = mask & val1.get_mask!
+        else
+          mask = val1.get_mask!
+        end
+        val1 = val1.get_array!
+      end
+      if mask
+        val0 = val0[mask]
+        val1 = val1[mask]
+      end
+      hist.increment(val0.to_gslv, val1.to_gslv)
+
+      bounds0 = hist.xrange.to_na
+      center0 = (bounds0[0..-2]+bounds0[1..-1])/2
+      name = gphys0.name
+      attr = gphys0.data.attr_copy
+      bounds0 = VArray.new(bounds0, attr, name)
+      center0 = VArray.new(center0, attr, name)
+      axis0 = Axis.new(true)
+      axis0.set_cell(center0, bounds0, name)
+      axis0.set_pos_to_center
+
+      bounds1 = hist.yrange.to_na
+      center1 = (bounds1[0..-2]+bounds1[1..-1])/2
+      name = gphys1.name
+      attr = gphys1.data.attr_copy
+      bounds1 = VArray.new(bounds1, attr, name)
+      center1 = VArray.new(center1, attr, name)
+      axis1 = Axis.new(true)
+      axis1.set_cell(center1, bounds1, name)
+      axis1.set_pos_to_center
+
+      bin = hist.bin.to_na.reshape!(nbins1,nbins0).transpose(1,0)
+      bin = VArray.new(bin,
+                       {"long_name"=>"number in bins", "units"=>"1"},
+                       "bin")
+      new_gphys = GPhys.new(Grid.new(axis0,axis1), bin)
+      new_gphys.set_att("mean0",[hist.xmean])
+      new_gphys.set_att("standard_deviation0",[hist.xsigma])
+      new_gphys.set_att("mean1",[hist.ymean])
+      new_gphys.set_att("standard_deviation1",[hist.ysigma])
+      new_gphys.set_att("covariance",[hist.cov])
+      return new_gphys
+    end
+
+
+  end
+
+  class GPhys
+    def histogram(opts=Hash.new)
+      GAnalysis.histogram(self, opts)
+    end
+    alias :histogram1D :histogram
+  end
+
+  module GGraph
+    module_function
+
+    @@histogram_options = Misc::KeywordOptAutoHelp.new(
+            ['window', [nil,nil,0,nil], "window bounds"],
+            ['title', "histogram", "window title"],
+            ['exchange', false, "exchange x and y"],
+            ['fill', false, "fill bars"]
+                                                       )
+    def histogram(gphys, newframe=true, options=nil)
+      gropn_1_if_not_yet
+      if newframe!=true && newframe!=false
+        raise ArgumentError, "2nd arg (newframe) must be true of false"
+      end
+      unless gphys.rank == 1
+        raise ArgumentError, "rank of gphys must be 1"
+      end
+      unless gphys.axis(0).cell?
+        raise ArgumentError, "axis must be cell type"
+      end
+      opts = @@histogram_options.interpret(options)
+      exchange = opts["exchange"]
+      unless exchange
+        x = gphys.axis(0).cell_bounds
+        y = gphys
+      else
+        y = gphys.axis(0).cell_bounds
+        x = gphys
+      end
+      if newframe
+        fig(x, y, "window"=>opts["window"])
+        axes(x, y, "title"=>opts["title"])
+      end
+      unless exchange
+        if opts["fill"]
+          DCL::uvbxa(x.val, [0]*y.length, y.val)
+        end
+        DCL::uvbxf(x.val, [0]*y.length, y.val)
+      else
+        if opts["fill"]
+          DCL::uhbxa([0]*x.length, x.val, y.val)
+        end
+        DCL::uhbxf([0]*x.length, x.val, y.val)
+      end
+      return nil
+    end
+    alias :histogram1D :histogram
+
+  end
+
+end
+
+
+
+if $0 == __FILE__
+  include NumRu
+
+  npoints = 10000
+  rng = GSL::Rng.alloc
+
+  vary = VArray.new(rng.weibull(1,2,npoints).to_na,
+                    {"long_name"=>"wind speed", "units"=>"m/s"},
+                    "u")
+  axis = Axis.new
+  axis.pos = VArray.new(NArray.sint(npoints),
+                        {"long_name"=>"points"},
+                        "points")
+  gphys1D = GPhys.new(Grid.new(axis), vary)
+
+  npoints = 100000
+  na0 = rng.weibull(1,2,npoints).to_na
+  na1 = rng.gaussian(0.5,npoints).to_na
+  theta = Math::PI/6
+  vary0 = VArray.new(na0*Math.cos(theta)-na1*Math.sin(theta),
+                    {"long_name"=>"zonal wind speed", "units"=>"m/s"},
+                    "u")
+  vary1 = VArray.new(na0*Math.sin(theta)+na1*Math.cos(theta),
+                    {"long_name"=>"meridional wind speed", "units"=>"m/s"},
+                    "v")
+  axis = Axis.new
+  axis.pos = VArray.new(NArray.sint(npoints),
+                        {"long_name"=>"points"},
+                        "points")
+  gphys2D_0 = GPhys.new(Grid.new(axis), vary0)
+  gphys2D_1 = GPhys.new(Grid.new(axis), vary1)
+
+  DCL::gropn(4)
+
+  hist = GAnalysis.histogram(gphys1D)
+  GGraph.histogram(hist)
+
+  hist = gphys1D.histogram("nbins"=>10)
+  GGraph.histogram(hist, true, "title"=>"histogram 1D")
+
+  hist = GAnalysis.histogram2D(gphys2D_0, gphys2D_1, "nbins0"=>50)
+  GGraph.tone(hist, true, "tonc"=>true)
+
+
+  DCL::grcls
+end