gphys 1.4.3.2 → 1.5.0

data/{multibitIO.c → ext/numru/gphys/multibitIO.c}

@@ -3,8 +3,9 @@
 #include "ruby.h"
 #include "narray.h"
 
-#ifndef HAVE_INT32_T
-typedef int int32_t;
+/* for compatibility for NArray and NArray with big memory patch */
+#ifndef NARRAY_BIGMEM
+typedef int na_shape_t;
 #endif
 
 /* for compatibility with ruby 1.6 */
@@ -128,10 +129,10 @@ multibit_read_2D(fp, pos, nbit, sh0, sh1, f0, l0, s0, f1, l1, s1, idx0, idx1,
     buf = ALLOCA_N(unsigned char, size);
     status = fseek(fp, pf, SEEK_SET);
     if (status) { rb_raise(rb_eStandardError,
-                  "Could not move to the specified position %d",pf); }
+                  "Could not move to the specified position %ld",pf); }
     sz = fread(buf,1,size,fp);
     if (sz!=size) { rb_raise(rb_eStandardError,
-                    "Could not read %d bytes from %d",size,pf); }
+                    "Could not read %ld bytes from %ld",size,pf); }
 
     // << multibit -> int32_t >>
     
@@ -194,7 +195,7 @@ ary2long(src, sh, len)
     for (i = 0; i < *len; i++) {
         x = NUM2INT(ptr[i]);
         if(x<-sh||x>=sh){rb_raise(rb_eArgError,
-                "%d-th index (%d) is not in the index range", i,x);}
+                "%ld-th index (%ld) is not in the index range", i,x);}
         if(x<0){x += sh;}
         rtn[i] = x;
     }
@@ -225,7 +226,7 @@ na2long(src, sh, len)
     for (i = 0; i < *len; i++) {
 	x = (long)ptr[i];
         if(x<-sh||x>=sh){rb_raise(rb_eArgError,
-                "%d-th index (%d) is not in the index range", i,x);}
+                "%ld-th index (%ld) is not in the index range", i,x);}
         if(x<0){x += sh;}
         rtn[i] = x;
     }
@@ -283,7 +284,7 @@ wrp_multibit_read_2D(self, pos, nbit, sh0, sh1, f0, l0, s0, f1, l1, s1,
                  // Then f0, s0, and l0 must be 0, 1 and len-1 of idx0
     long *Idx1;  // If non-NULL, index map of the subset regarding the 2nd D
                  // Then f1, s1, and l1 must be 0, 1 and len-1 of idx1
-    int lens[2];
+    na_shape_t lens[2];
     long len;
     int32_t *ival;
     float *fval;
@@ -300,11 +301,11 @@ wrp_multibit_read_2D(self, pos, nbit, sh0, sh1, f0, l0, s0, f1, l1, s1,
     if (idx0 == Qnil){
         F0 = NUM2INT(f0);
         if(F0<-Sh0||F0>=Sh0){rb_raise(rb_eArgError,
-                  "f0 (=%d) is not in the index range of the 1st dim", f0);}
+                  "f0 (=%ld) is not in the index range of the 1st dim", f0);}
         if(F0<0){F0 += Sh0;}
         L0 = NUM2INT(l0);
         if(L0<-Sh0||L0>=Sh0){rb_raise(rb_eArgError,
-                  "l0 (=%d) is not in the index range of the 1st dim", l0);}
+                  "l0 (=%ld) is not in the index range of the 1st dim", l0);}
         if(L0<0){L0 += Sh0;}
         S0 = NUM2INT(s0);
         if(S0<=0){rb_raise(rb_eArgError,"s0 (step) must be positive integer");}
@@ -329,11 +330,11 @@ wrp_multibit_read_2D(self, pos, nbit, sh0, sh1, f0, l0, s0, f1, l1, s1,
     if (idx1 == Qnil){
         F1 = NUM2INT(f1);
         if(F1<-Sh1||F1>=Sh1){rb_raise(rb_eArgError,
-                  "f1 (=%d) is not in the index range of the 2nd dim", f1);}
+                  "f1 (=%ld) is not in the index range of the 2nd dim", f1);}
         if(F1<0){F1 += Sh1;}
         L1 = NUM2INT(l1);
         if(L1<-Sh1||L1>=Sh1){rb_raise(rb_eArgError,
-                  "l1 (=%d) is not in the index range of the 2nd dim", l1);}
+                  "l1 (=%ld) is not in the index range of the 2nd dim", l1);}
         if(L1<0){L1 += Sh1;}
         S1 = NUM2INT(s1);
         if(S1<=0){rb_raise(rb_eArgError,"s1 (step) must be positive integer");}
@@ -417,18 +418,21 @@ str_to_uint3(unsigned char *ptr)
 static VALUE \
 rb_str_to_uint##num(int argc, VALUE *argv, VALUE self) \
 { \
+  unsigned char *ptr; \
+  unsigned long n; \
+  uint i; \
   if (argc > 1) { \
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); \
   } \
-  unsigned char *ptr = (unsigned char*)StringValuePtr(self);	\
+  ptr = (unsigned char*)StringValuePtr(self);	\
   if (argc == 1) { \
-    unsigned long n = FIX2UINT(argv[0]); \
-    if (n >= RSTRING_LEN(self)) { \
+    n = FIX2UINT(argv[0]); \
+    if (n >= (unsigned long) RSTRING_LEN(self)) {	\
       rb_raise(rb_eArgError, "out of index"); \
     } \
     ptr += n; \
   } \
-  uint i = str_to_uint##num(ptr); \
+  i = str_to_uint##num(ptr); \
   return UINT2NUM(i); \
 }
 STR2UINT(1)

data/gphys-bigmem.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'numru/gphys/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gphys-bigmem"
+  spec.version       = NumRu::GPhys::VERSION
+  spec.authors           = ["Takeshi Horinouchi", "Ryo Mizuta",\
+    "Daisuke Tsukahara", "Seiya Nishizawa", "Shin-ichi Takehiro"]
+  spec.email         = ["horinout@ees.hokudai.ac.jp"]
+
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."
+  #end
+
+  spec.summary          = %q{A multi-purpose class to handle Gridded Physical quantities}
+  spec.description      = %q{Comprehensive library for self-descriptive gridded physical data (in NetCDF, GrADS, or on memory) with graphics. This version works with Ruby 2.0.}
+  spec.homepage         = 'http://www.gfd-dennou.org/arch/ruby/products/gphys/'
+  spec.licenses       = ["BSD-2-Clause"]
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["ext","lib"]
+  spec.test_files    = spec.files.grep(%r{^(test|test_old|sample|testdata)/})
+  spec.extensions << "ext/numru/gphys/extconf.rb"
+
+  spec.post_install_message = "Thanks for installing! You can add extra libraries (i.e., ruby-lapack, rb-grib) to enjoy powerful calculating and handling datasets."
+
+  spec.required_ruby_version = Gem::Requirement.new(">= 1.8")
+
+  spec.add_runtime_dependency(%q<narray-bigmem>)
+  spec.add_runtime_dependency(%q<narray_miss-bigmem>)
+  spec.add_runtime_dependency(%q<numru-misc-bigmem>)
+  spec.add_runtime_dependency(%q<numru-units>, [">= 1.7"])
+  spec.add_runtime_dependency(%q<ruby-netcdf-bigmem>)
+  spec.add_runtime_dependency(%q<ruby-dcl-bigmem>)
+  spec.add_runtime_dependency(%q<ruby-fftw3-bigmem>)
+  #spec.add_runtime_dependency(%q<gsl>, [">= 1.14"])
+  #spec.add_runtime_dependency(%q<rb-gsl>, [">= 1.14"])
+  #spec.add_runtime_dependency(%q<ruby-lapack>, [">= 1.5"])
+  #spec.add_development_dependency(%q<rb-grib>, [">= 0.2.0"])
+end

data/gphys.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = NumRu::GPhys::VERSION
   spec.authors           = ["Takeshi Horinouchi", "Ryo Mizuta",\
     "Daisuke Tsukahara", "Seiya Nishizawa", "Shin-ichi Takehiro"]
-  spec.email         = ["eriko@gfd-dennou.org"]
+  spec.email         = ["horinout@ees.hokudai.ac.jp"]
 
   #if spec.respond_to?(:metadata)
   #  spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."
@@ -17,14 +17,14 @@ Gem::Specification.new do |spec|
   spec.summary          = %q{A multi-purpose class to handle Gridded Physical quantities}
   spec.description      = %q{Comprehensive library for self-descriptive gridded physical data (in NetCDF, GrADS, or on memory) with graphics. This version works with Ruby 2.0.}
   spec.homepage         = 'http://www.gfd-dennou.org/arch/ruby/products/gphys/'
-  spec.licenses       = ["GFD Dennou Club"]
+  spec.licenses       = ["BSD-2-Clause"]
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.bindir        = "bin"
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ["ext","lib"]
   spec.test_files    = spec.files.grep(%r{^(test|test_old|sample|testdata)/})
-  spec.extensions << "extconf.rb"
+  spec.extensions << "ext/numru/gphys/extconf.rb"
 
   spec.post_install_message = "Thanks for installing! You can add extra libraries (i.e., ruby-lapack, rb-grib) to enjoy powerful calculating and handling datasets."
 

data/lib/numru/dclext.rb

@@ -39,6 +39,11 @@ MATH1
 * ((<glpack>))
   * ((<gl_set_params>))
     Calls (({DCL.glpset})) multiple times (for each key and val of (({hash}))).
+MATH2
+* ((<shtlib>))
+  * ((<sht_get_n>)) calculate n (total wavenum)
+  * ((<sht_get_m>)) calcurate m (zonal wavenum)
+
 GRPH1
 * ((<sgpack>))
   * ((<sg_set_params>))
@@ -115,6 +120,26 @@ GRPH2
         ....
         DCLExt.gl_set_params(before)     # reset the change
 
+===shtlib
+---sht_get_n(mm)
+    calcurate n (total wavenum)
+
+    ARGUMENT
+    * mm (Integer) : truncation wavenumber
+
+    RETURN VALUE
+    * n (NArray) : an integer NArray contianing n's
+
+---sht_get_m(mm)
+
+    calcurate m (zonal wavenum)
+
+    ARGUMENT
+    * mm (Integer) : truncation wavenumber
+
+    RETURN VALUE
+    * m (NArray) : an integer NArray contianing m's
+
 ===sgpack
 ---sg_set_params(hash)
     Calls (({DCL.sgpset})) multiple times (for each key and val of (({hash}))).
@@ -668,6 +693,36 @@ module NumRu
 
     @@empty_hash = Hash.new
 
+    #<<< MATH2: shtlib >>>
+
+    # calcurate n (total wavenum)
+    def sht_get_n(mm)
+      ns = NArray.int((mm+1)**2)
+      mi = NArray.int(mm+1).indgen!
+      ns[0..mm] = mi  # for m=0
+      i = mm+1
+      for m in 1..mm
+        ns[i..(i+mm-m)] = mi[m..mm]
+        i += mm-m+1
+        ns[i..(i+mm-m)] = mi[m..mm]
+        i += mm-m+1
+      end
+      ns
+    end
+
+    # calcurate m (zonal wavenum)
+    def sht_get_m(mm)
+      ns = NArray.int((mm+1)**2)
+      i = mm+1
+      for m in 1..mm
+        ns[i..(i+mm-m)] = m
+        i += mm-m+1
+        ns[i..(i+mm-m)] = m
+        i += mm-m+1
+      end
+      ns
+    end
+
     #<<< udpack >>>
 
     def ud_coloring(clr_min=13, clr_max=99)

data/lib/numru/derivative.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require "narray"
 
 ############################################################
@@ -42,7 +43,7 @@ Module functions of Derivative Operater for NArray.
     * x (NArray): a NArray represents the dimension which derivative respect to.
       z.rank must be 1.
     * dim (Numeric): a Numeric represents the dimention which derivative respect to. 
-      you can give number count backward (((<dim>))<0), but ((<z.rank ��dim>)) must be > 0. 
+      you can give number count backward (((<dim>))<0), but ((<z.rank ＋dim>)) must be > 0. 
     * bc (Numeric) : a Numeric to represent boundary condition.
       Supported conditions are expressed in terms of boundary extension
       applied before differentiation:
@@ -69,7 +70,7 @@ Module functions of Derivative Operater for NArray.
       to. z.rank must be 1.
     * dim (Numeric): a Numeric represents the dimention which derivative 
       respect to. you can give number count backward (((<dim>))<0), but 
-      ((<z.rank ��dim>)) must be > 0. 
+      ((<z.rank ＋dim>)) must be > 0. 
     * bc (Numeric) : a Numeric to represent boundary condition.
       See ((<threepoint_O2nd_deriv>)) for supported conditions.
 
@@ -89,7 +90,7 @@ Module functions of Derivative Operater for NArray.
       to. z.rank must be 1.
     * dim (Numeric): a Numeric represents the dimention which derivative 
       respect to. you can give number count backward (((<dim>))<0), but 
-      ((<z.rank ��dim>)) must be > 0. 
+      ((<z.rank ＋dim>)) must be > 0. 
     * bc (Numeric) : a Numeric to represent boundary condition.
       See ((<threepoint_O2nd_deriv>)) for supported conditions.
 
@@ -109,7 +110,7 @@ Module functions of Derivative Operater for NArray.
     * z (NArray): a NArray which you want to expand boundary.
     * dim (Numeric): a Numeric represents the dimention which derivative 
       respect to. you can give number count backward (((<dim>))<0), but 
-      ((<z.rank ��dim>)) must be > 0. 
+      ((<z.rank ＋dim>)) must be > 0. 
 
     RETURN VALUE
     * expand_data (NArray): 
@@ -124,7 +125,7 @@ Module functions of Derivative Operater for NArray.
     * x (NArray): a NArray which you want to get difference.
     * dim (Numeric): a Numeric representing the dimention which derivative 
       respect to. you can give number count backward (((<dim>))<0), but 
-      ((<z.rank ��dim>)) must be > 0. 
+      ((<z.rank ＋dim>)) must be > 0. 
 
     RETURN VALUE
     * cdiff_data (NArray): (x_{i+1} - x_{i-1})

data/lib/numru/ganalysis/met.rb

@@ -191,26 +191,33 @@ module NumRu
       end
       private :del_ngp
 
-      # Derive geostrophic wind from geopotential hight (spherical but fixed f)
+      # Derive geostrophic wind from geopotential hight (spherical)
       # 
       # ARGUMENTS
       # * z [GPhys] : geopotential height on the pressure (or log-pressure)
       #   coordinate
-      # * f [nil or Numeric of UNumeric] : the constant f value 
-      #   (Coriolis parameter).
-      #   If nil, the value at the north pole is assumed.
-      #   If Numeric, units are assumed to be "s-1".
+      # * f [nil or GPhys or Numeric or UNumeric] : Coriolis parameter
+      #   If nil, local Corioris parameter is used.
+      #   If Numeric or UNumeric, f is a constant as a matter of course
+      #   (if Numeric, units are assumed to be "s-1").
       #
       def z2geostrophic_wind(z, f=nil)
         if f.nil?
-          f = 2 * GAnalysis::Planet.omega
+          f = get_f(z)
         elsif f.is_a?(Numeric)
           f = UNumeric[f,"s-1"]
         end
-        z = z.convert_units("m")
-        gx, gy = GAnalysis::Planet.grad_s( z * (g/f) )
-        u = -gy
-        v = gx
+        #z = z.convert_units("m")
+        gx, gy = GAnalysis::Planet.grad_s( z * g )
+        u = -gy/f
+        v = gx/f
+        if f.respond_to? :val   # supposedly a GPhys
+          if0 = f.val.eq(0).where
+          if if0.length > 0
+            u[true,if0,false] = 0   # replace Inf with 0
+            v[true,if0,false] = 0   # replace Inf with 0
+          end
+        end
         u.name = "u"
         u.long_name = "geostrophic U"
         u.put_att("assumed_f",f.to_s)
@@ -220,6 +227,16 @@ module NumRu
         [u, v]
       end
 
+      # Get the Coriolis parameter
+      def get_f(gp)
+        lam, phi, = GAnalysis::Planet.get_lambda_phi(gp)
+        sin_phi = phi.sin
+        f = 2 * GAnalysis::Planet.omega * sin_phi
+        f.name = "f"
+        f.long_name = "Coriolis parameter"
+        f
+      end
+
       # Adiabatic frontogenesis function over the sphere. --
       # D/Dt(|gradH theta|) or D/Dt(|gradH theta|^2), where gradH express
       # the horizontal component of gradient. 

data/lib/numru/ganalysis/qg.rb

@@ -10,7 +10,7 @@ require 'numru/ganalysis/beta_plane'
 module NumRu
   module GAnalysis
 
-    # QG_common: correction of common methods for QG, QG_sphere, and QG_sphere_div.
+    # QG_common: collection of common methods for QG, QG_sphere, and QG_sphere_div.
     module QG_common
       ## module_function  # disabled: module functions are specified one-by-one
 
@@ -218,7 +218,7 @@ module NumRu
 
     ######################################################
 
-    # Correction of common methods for QG_sphere and QG_sphere_div
+    # Collection of common methods for QG_sphere and QG_sphere_div
     module QG_sphere_common
 
       # Coriolis parameter f
@@ -248,6 +248,7 @@ module NumRu
       module_function
       extend QG_common
 
+      # This class is for internal use only
       class Uninitialized
         def method_missing(method_name)
           raise("Reference latitude has not been set. Call QG::set_lat0 to use the module QG.")
@@ -389,7 +390,7 @@ module NumRu
             p = p.convert2("Pa")
           end
         else
-          p = LogP.get_p(psi).convert_units("Pa")
+          p = Met.get_prs(psi).convert_units("Pa")
         end
         psi_xy = psi.threepoint_O2nd_deriv(0,bc,x).threepoint_O2nd_deriv(1,bc,y)
         psi_xx = psi.deriv2nd(0,bc,x)

data/lib/numru/ganalysis/sph_harmonic_iso_g.rb

@@ -0,0 +1,290 @@
+require "numru/gphys"
+require "numru/dclext"  # for SHTLIB and its extensions (sht_get_n, sht_get_m)
+
+module NumRu
+  module GAnalysis
+    
+    # Spherical harmonics library for equally spaced lon-lat grids using SHTLIB in DCL
+    # 
+    # REQUIREMENT
+    # * This module can handle grid data that satisfy the following
+    #   * dimension 0 (first dim) is longitude, dimension 1 is latitude.
+    #   * must be equally spaced and cover the globe
+    #     such as lon = 0, 2,.., 358 [,360], or -180, -170,..,170 [,180].
+    #     etc (in increasing order; cyclic extension is applied internally) 
+    #     and lat = -90,-88,..,90. (or 90, 98,..,-90; pole to pole)
+    # * Data missig is not allowed
+    # 
+    module SphHarmonicIsoG
+      @@work = @@im = @@jm = @@mm = nil
+
+      module_function
+
+      # Check the valdity of the lon-lat grid. 
+      # 
+      # This method raises an exception if the data is not acceptable
+      # 
+      # ARGUMENTS
+      # * gp [GPhys] : data to check its grid
+      # * mm [Integer] : truncation wavenumber
+      #   
+      # RETURN VALUE
+      # * gphys [GPhys] : same as input, but for the 1st dim is cyclically 
+      #   extended if needed.
+      # * np2sp [true or false] : true if data is N.pole to S.pole,
+      #   false if data is S.pole to N.pole
+      def check_and_init(gphys, mm)
+
+        raise(ArgumentError, "Invalid rank (#{gphys.rank})") if gphys.rank < 2
+
+        lon = gphys.coord(0).val
+        if lon[0] > lon[-1]
+          raise ArgumentError, "Longitude must be in the increasing order."
+        end
+        gphys = gphys.cyclic_ext(0)
+
+        lat = gphys.coord(1).convert_units("degrees").val
+        eps = 0.1
+        if (lat[0]-90.0).abs < eps &&  (lat[-1]+90.0).abs < eps
+          # N.pole to S.pole
+          np2sp = true
+        elsif (lat[0]+90.0).abs > eps ||  (lat[-1]-90.0).abs > eps
+          raise ArgumentError, "Not pole to pole: #{lat[0]..lat[-1]}."
+        else
+          np2sp = false
+        end
+
+        nx, ny, = gphys.shape
+        im = (nx-1)/2
+        jm = (ny-1)/2
+
+        if (mm+1)/2 > jm || mm+1 > im
+          raise(ArgumentError,"mm=#{mm} is too big for im=#{im} & jm=#{jm}")
+        end
+        if @@work.nil? || @@mm != mm || @@jm != jm || @@im != im
+          @@work = DCL.shtint(mm,jm,im)
+          @@mm = mm
+          @@jm = jm
+          @@im = im
+        end
+        [gphys, np2sp]
+      end
+
+      # Spherical harmonics filter
+      #
+      # ARGUMENTS
+      # * gp [GPhys] : grid data to filter (lon,lat,...: rank >= 2)
+      # * mm [Integer] : truncation wavenumber
+      # * deriv (optional) [nil(default) or Symbol]
+      #   (let \lambda be longitude and \phi be latitude)
+      #   if :xgrad (or :xdiv), applies del / cos\phi del\lambda,
+      #   if :ygrad, applies del / del\phi,
+      #   if :ydiv, applies del cos\phi / cos\phi del\phi.
+      # * lap (optional) [nil(default) or Integer] If 1, laplacian
+      #   is taken; if -1 inverserser laplacian is taken -- note
+      #   that you can also explitly take laplacian by
+      #   using the factor_n_m block (see below).
+      #
+      # * factor_n_m (optional block)
+      #   spectral filter in the form of {|n,m|  } that
+      #   returns the factor if n and m are integers.
+      #   Example {|n,m| -n*(n+1)} to take laplacian. 
+      def filt( gp, mm, deriv=nil, lap=nil, &factor_n_m )
+        iswg2s = isws2g = 0
+        case deriv
+        when :xgrad, :xdiv
+          isws2g = -1
+        #when :xderiv
+        ##(horinout, developpers memo: just multiply with cos\phi afterward)
+        #  iswg2s = -1   # don't know if isws2g is better
+        #  raise("Under development: need cos_phi factor")
+        when :ygrad
+          isws2g = 1
+        when :ydiv
+          iswg2s = 1
+        when nil
+          # do nothing
+        else
+          raise ArgumentError,"Unsupported operation #{deriv}"
+        end
+        nlon = gp.shape[0]
+        gp, np2sp = check_and_init(gp, mm)   # sets @@work, @@mm, @@im & @@jm
+        na = gp.val
+        na = na.to_na if na.respond_to?(:to_na)   # for NArrayMiss
+        shape = na.shape
+        naf = NArray.float( *shape )  # output variable (filtered NArray)
+        f = __factor_n_m( &factor_n_m ) if factor_n_m
+        loop_for_3rd_or_greater_dim(shape){|sel|
+          w,s = DCL.shtg2s(@@mm,iswg2s,na[*sel],@@work)
+          s = DCL.shtlap(@@mm,lap,s) if lap
+          s = s * f if factor_n_m
+          s = -s if np2sp && (isws2g==1 || iswg2s==1 )  # y-reversed --> *(-1)
+          w,g =  DCL.shts2g(@@mm,@@jm,@@im,isws2g,s,@@work)
+          naf[*sel] = g
+        }
+        vaf = VArray.new(naf, gp.data, gp.name)
+        gp = GPhys.new( gp.grid, vaf)
+        if gp.shape[0] != nlon
+          # cyclically extended --> trim it to the original shape
+          gp = gp[0...nlon,false]
+        end
+        gp
+      end
+
+      def xgrad( gp, mm, &factor_n_m )
+        filt( gp, mm, :xgrad, &factor_n_m )
+      end
+      alias :xdiv :xgrad
+      module_function :xdiv
+
+      def ygrad( gp, mm, &factor_n_m )
+        filt( gp, mm, :ygrad, &factor_n_m )
+      end
+      def ydiv( gp, mm, &factor_n_m )
+        filt( gp, mm, :ydiv, &factor_n_m )
+      end
+
+      # Horizontal Laplacian on the sphere
+      # 
+      # * gp [GPhys] : grid data (lon,lat,...: rank >= 2)
+      # * mm [Integer] : truncation wavenumber
+      # * radius (optional; defaut=1.0) [Numeric(if non-dim) or UNumeric]
+      #   radius of the sphere
+      def lapla_h( gp, mm, radius=1.0, order=1 )
+        if order==-1 || order==1
+          gp = filt( gp, mm, nil, order )
+        elsif order > 0
+          gp = filt( gp, mm ){|n,m| (-n*(n+1))**order }
+        else
+          # negative --> avoid zero division
+          gp = filt( gp, mm ){|n,m| n==0 ? 0 : (-n*(n+1))**order }
+        end
+        gp *= radius**(-2) if radius != 1.0
+        gp
+      end
+
+      # Horizontal divergence on the sphere
+      # 
+      # ARGUMENTS
+      # * u,v [GPhys] : the x and y components to take divergence
+      # * mm [Integer] : truncation wavenumber
+      # * radius (optional; defaut=1.0) [Numeric(if non-dim) or UNumeric]
+      #   radius of the sphere
+      def div_h(u,v, mm, radius=1.0, &factor_n_m )
+        gp = xdiv(u, mm, &factor_n_m) + ydiv(v, mm, &factor_n_m)
+        gp *= radius**(-1) if radius != 1.0
+        gp.long_name = "div_h(#{u.name},#{v.name})"
+        gp.name = "div_h"
+        gp
+      end
+
+      # Horizontal rotation on the sphere
+      # 
+      # * u,v [GPhys] : the x and y components to take rotation
+      # * mm [Integer] : truncation wavenumber
+      # * radius (optional; defaut=1.0) [Numeric(if non-dim) or UNumeric]
+      #   radius of the sphere
+      def rot_h(u,v, mm, radius=1.0, &factor_n_m )
+        gp = xdiv(v, mm, &factor_n_m) - ydiv(u, mm, &factor_n_m)
+        gp *= radius**(-1) if radius != 1.0
+        gp.long_name = "rot_h(#{u.name},#{v.name})"
+        gp.name = "rot_h"
+        gp
+      end
+
+      def __factor_n_m( &factor_n_m )
+        ms = DCLExt.sht_get_m(@@mm)
+        ns = DCLExt.sht_get_n(@@mm)
+        len = ms.length
+        f = NArray.float(len)
+        for i in 0...len
+          f[i] = factor_n_m.call(ns[i],ms[i])
+        end
+        f
+      end
+
+      def loop_for_3rd_or_greater_dim(shape,&block)
+        raise(ArgumentError, "block not given") if !block
+        sh3 = shape[2..-1]
+        rank3 = sh3.length
+        csh3 = [1]
+        (1...rank3).each{|d| csh3[d] = sh3[d-1]*csh3[d-1]}
+        len = 1
+        sh3.each{|n| len *= n}
+        for i in 0...len
+          sel = [true,true]
+          (0...rank3).each do |d|
+            sel.push( (i/csh3[d]) % sh3[d] )
+          end
+          block.call(sel)
+        end
+      end
+
+    end
+
+  end
+end
+
+#######################################################
+# test / demo part
+#######################################################
+if __FILE__ == $0
+  require "numru/ggraph"
+  include NumRu
+  include GAnalysis
+  include NMath
+  gp = GPhys::IO.open("../../../testdata/T.jan.nc","T").copy
+  x = gp.coord(0).val.newdim(1) * (PI/180.0)
+  y = gp.coord(1).val.newdim(0) * (PI/180.0)
+  #gp[false,-1] = sin(x)*cos(y)
+  gp[false,-1] = sin(x)*cos(y)**2
+  #gp[false,-1] = (x*0+1)*cos(y) # + 1
+  mm = 17
+  c = 1.0 / ( mm*mm*(mm+1)*(mm+1) )
+  gpf = SphHarmonicIsoG.filt(gp,mm)
+  p gpf
+
+  gpf2 = SphHarmonicIsoG.filt(gp,mm){|n,m| 
+    [0.0, 1.0 - c*n*n*(n+1)*(n+1)].max
+  }
+
+  gpfxg = SphHarmonicIsoG.xgrad(gp,mm)
+  gpfyg = SphHarmonicIsoG.ygrad(gp,mm)
+  gpfyd = SphHarmonicIsoG.ydiv(gp,mm)
+
+  gpflap = SphHarmonicIsoG.lapla_h(gp,mm)
+
+  DCL.swpset('iwidth',960)
+  DCL.swpset('iheight',720)
+  DCL.sgscmn(10)
+  DCL.gropn(1)
+  DCL.sldiv("t",2,3)
+  DCL.sgpset("lfull",true)
+  DCL.sgpset('isub', 96)      # control character of subscription: '_' --> '`'
+  DCL.glpset('lmiss',true)
+  GGraph.set_fig "itr"=>10,"viewport"=>[0.15,0.85,0.07,0.4]
+  GGraph.set_tone "color_bar"=>true
+  GGraph.tone gp
+  GGraph.tone gpf, true, "keep"=>true
+  GGraph.tone gpf2, true, "keep"=>true
+
+  GGraph.tone gpfxg[false,1], true
+  k=-1
+  GGraph.tone gpf[false,k], true
+  GGraph.tone gpfxg[false,k], true
+  #GGraph.tone gpfx[false,k]-gpfxg[false,k], true
+
+  GGraph.tone gpfyg[false,0], true
+  k=-1
+  GGraph.tone gpf[false,k], true
+  GGraph.tone gpfyg[false,k], true, "min"=>-1,"max"=>1
+  GGraph.tone gpfyd[false,k], true, "min"=>-1.5,"max"=>1.5
+  GGraph.tone gpfyg[false,k]*1.5-gpfyd[false,k], true, "log"=>true
+
+  GGraph.tone gpflap[false,k]
+
+  GGraph.set_fig "itr"=>1
+  GGraph.line gpf.cut(true,40,false), true
+  GGraph.line gpfxg.cut(true,40,false), true
+  DCL.grcls
+end