gphys 1.5.6 → 1.5.7

data/lib/numru/ganalysis/eof.rb

@@ -44,6 +44,7 @@ module NumRu
     #                 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.
+    #   * no_pc: do not compute primary components
     #
     # == Return values
     # +eof+:: GPhys object for array of EOF vectors.
@@ -61,10 +62,12 @@ module NumRu
         dims = args
         opts = Hash.new
       end
-      dims = dims.map{|dim| gphys.dim_index(dim) }
+      no_pc = ( opts[:no_pc] || opts["no_pc"] )
+
+      dims = dims.map{|dim| gphys.dim_index(dim) }  # dimensions to vary (~"time")
       n = 1
       n_lost = 1
-      dims1 = Array.new
+      dims1 = Array.new     # vector dimensions (~"spatial")
       shape1 = Array.new
       gphys.shape.each_with_index{|s,i|
         if dims.include?(i)
@@ -75,35 +78,41 @@ module NumRu
           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
+      new_grid_wo_modes = gphys.instance_variable_get("@grid").delete_axes(dims, "covariance matrix").copy
+      new_index = NArray.sint(*new_grid_wo_modes.shape).indgen
       index = NArray.object(gphys.rank)
       index[dims] = true
 
+      wgtun = ""
       if w = (opts[:weight] || opts["weight"])
         if GPhys === w
           w = w.val
+          wgtun = w.units
         end
         unless NArray === w
           raise "weight must be NArray of GPhys"
         end
-        unless w.shape == new_grid.shape
+        unless w.shape == new_grid_wo_modes.shape
           raise "shape of weight is invalid"
         end
-        w /= w.mean
-        w.reshape!(n)
-      elsif new_grid.rank >= 2
-        nc0 = new_grid.coord(0)
-        nc1 = new_grid.coord(1)
+        w_orgshape = w
+        w = w.reshape(n)
+      elsif new_grid_wo_modes.rank >= 2
+        nc0 = new_grid_wo_modes.coord(0)
+        nc1 = new_grid_wo_modes.coord(1)
         if !(opts[:disable_weight]||opts["disable_weight"]) &&
            ( /^lon/ =~ nc0.name || /^degree.*_east/ =~ nc0.units.to_s ) &&
            ( /^lat/ =~ nc1.name || /^degree.*_north/ =~ nc1.units.to_s )
           rad = NumRu::Units.new("radian")
           nlon = nc0.length
           lat = nc1.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)
+          w2 = NMath::cos(lat)
+          eps = 1e-10   # a value whose sqrt is negligibly small as cosine
+          w2[ w2.le(0) ] = eps
+          w = NMath.sqrt(w2)     # sqrt(cos(lat))
+          w = NArray.new(lat.typecode,nlon).fill!(1) * w.reshape(1,lat.length)
+          w_orgshape = w
+          w = w.reshape(w.length)
         else
           w = nil
         end
@@ -111,27 +120,9 @@ module NumRu
         w = nil
       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)
-        vm = val.mean
-        val -= vm unless vm.nil?
-        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
-        }
-      }
+      val = gphys.val
+      ary = val.transpose( *(dims + dims1) ).reshape!(n_lost, n)
+      ary -= ary.mean(0).newdim(0)   # remove "temporal" mean
       ary = ary.mul!(w.reshape(1,n)) if w
 
       nmodes = opts[:nmodes] || opts["nmodes"] || n
@@ -150,7 +141,7 @@ module NumRu
             nn += 1
           end
         }
-        ary = nil # for GC
+        ary = nil if no_pc # for GC
         print "start calc eigen vector\n" if $DEBUG
         val, vec = SSL2.seig2(nary,nmodes)
       when "lapack"
@@ -161,7 +152,7 @@ module NumRu
           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
+        ary = nil if no_pc  # for GC
         print "start calc eigen vector\n" if $DEBUG
         case nary.typecode
         when NArray::DFLOAT
@@ -171,8 +162,8 @@ module NumRu
 	  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]
+        val = val[0...nmodes][-1..0]
       when "gsl"
         print "start calc covariance matrix\n" if $DEBUG
         nary = NArray.new(gphys.typecode,n,n)
@@ -180,7 +171,7 @@ module NumRu
           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
+        ary = nil if no_pc  # 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)
@@ -190,15 +181,32 @@ module NumRu
         val = val[0...nmodes]
       end
 
-      axes = new_grid.instance_variable_get('@axes')
+      axes = new_grid_wo_modes.instance_variable_get('@axes')
       axis_order = Axis.new
       axis_order.pos = VArray.new(NArray.sint(nmodes).indgen(1),
                                   {}, "mode")
-      axes << axis_order
+      axes = axes + [ axis_order ]
       new_grid = Grid.new(*axes)
+
+      unless no_pc
+        mary = NMatrix.new(ary.typecode, *ary.shape)
+        mary[true,true] = ary.to_na
+        mvec = NMatrix.new(vec.typecode, *vec.shape)
+        mvec[true,true] = vec
+        mpc = mvec * mary   # use matrix multiplication
+        pc = NArray.new(mpc.typecode, *mpc.shape)
+        pc[true,true] = mpc
+        pc /= pc.stddev(0).newdim!(0)  # normalization
+        vary = VArray.new(pc, {"long_name"=>"Primary component",
+                          "units"=>"1"}, "PC")
+        grid = Grid.new( *dims.map{|d| gphys.grid.axis(d)} + axes[-1..-1] )
+        pc = GPhys.new( grid, vary )
+      end
+
       vec /= w if w
       vec.reshape!(*new_grid.shape)
       vec *= NMath::sqrt( val.reshape( *([1]*(axes.length-1)+[nmodes]) ) )
+          # multiply a sqrt(eigen value) -> variance same as in the input data
       va_eof = VArray.new(vec,
                           {"long_name"=>"EOF vector","units"=>gphys.units.to_s },
                           "EOF")
@@ -209,7 +217,19 @@ module NumRu
                            "rate")
       rate = GPhys.new(Grid.new(axis_order), va_rate)
 
-      return [eof, rate]
+      if w
+        w = w_orgshape
+        if w.rank == new_grid_wo_modes.rank
+          v = VArray.new(w, {"long_name"=>"weight",
+                             "units"=>wgtun}, "weight" )
+          w = GPhys.new( new_grid_wo_modes,
+                         v )
+        end
+      end
+      
+      ret = [eof, rate, w]
+      ret.push(pc) unless no_pc
+      return ret
     end
 
     def eof2(gphys1, gphys2, *args)

data/lib/numru/ganalysis/fitting.rb

@@ -96,6 +96,11 @@ module NumRu
       #   this argument can be used to specify the dimensions that are
       #   not included in +grid_locs+ and are treated as independent, so
       #   the fitting is made for each of their component.
+      # * +with_offset+ (optional) if true (default), constant offset is derived.
+      #   If false, offset is not treated.
+      # * +wgt_func+ (optional) [nil (defualt) or Proc] If Proc, weighting function
+      #   to conduct the weighted least square fit. It should conform with the
+      #   fitting functions.
       # 
       # Note that the sum of the lengths of +grid_locs+, +ensemble_dims+ and
       # +indep_dims+ must be equal to the rank (# of dims) of +data+.
@@ -215,7 +220,7 @@ module NumRu
       #   number of functions (also unsolvable).
       # 
       def least_square_fit(data, grid_locs, functions, ensemble_dims=nil,
-                           indep_dims=nil, with_offset=true)
+                           indep_dims=nil, with_offset=true, wgt_func = nil)
 
         #< argument check >
 
@@ -269,12 +274,20 @@ module NumRu
           if otherdims.length != ensemble_dims.length + n_indep
             raise ArgumentError, "Overlap in ensemble_dims and indep_dims"
           end
+          sh = data.shape
+          indep_len = 1
+          indep_dims.each{|i| indep_len *= sh[i]}
+          meandims = (0...rank).collect{|d| d} - indep_dims
         end
 
         #< pre-process data >
 
-        d0 = data.mean
-        data = data - d0     # constant offset for numerical stability
+        if with_offset
+          d0 = data.mean
+          data = data - d0     # constant offset for numerical stability
+        else
+          d0 = 0.0
+        end
 
         if data.is_a?(NArrayMiss)
           mask = data.get_mask
@@ -291,33 +304,66 @@ module NumRu
           otherdims.each{|d| f.newdim!(d)}
           f
         }
-
+        if wgt_func
+          wgt = wgt_func[*grid_locs]
+          otherdims.each{|d| wgt.newdim!(d)}
+        else
+          wgt = nil
+        end
+        
         ms = fv.length    # matrix size
 
         if ( (len=data.length) < ms )
           raise "Insufficient data length (#{len}) for the # of funcs+1 (#{ms})"
         end
 
-        mat = NMatrix.float(ms,ms)   #  wil be symmetric
+        if mask && indep_dims
+          mat = (0...indep_len).map{NMatrix.float(ms,ms)}
+        else
+          mat = NMatrix.float(ms,ms)   #  wil be symmetric
+        end
 
         for i in 0...ms
           for j in 0..i
             if mask
-              fvij = NArrayMiss.to_nam( fv[i] * fv[j] * mask, mask )
-              mat[i,j] = (fvij).mean
+              unless wgt
+                fvij = NArrayMiss.to_nam( fv[i] * fv[j] * mask, mask )
+              else
+                fvij = NArrayMiss.to_nam( fv[i] * fv[j] * wgt * mask, mask )
+              end
+              if !indep_dims
+                mat[i,j] = (fvij).mean
+              else
+                x = (fvij).mean(*meandims)
+                (0...indep_len).each{|k| mat[k][i,j] = x[k]}
+              end
             else
-              mat[i,j] = (fv[i] * fv[j]).mean
+              unless wgt
+                mat[i,j] = (fv[i] * fv[j]).mean
+              else
+                mat[i,j] = (fv[i] * fv[j] * wgt).mean
+              end
             end
           end
         end
 
         for i in 0...ms
           for j in i+1...ms
-            mat[i,j] = mat[j,i]      # symmetric
+            if mask && indep_dims
+              for k in 0...indep_len
+                mat[k][i,j] = mat[k][j,i]      # symmetric
+              end
+            else
+              mat[i,j] = mat[j,i]      # symmetric
+            end
           end
         end
         #p "*** mat ***",mat
-        lu = mat.lu
+        if mask && indep_dims
+          lu = (0...indep_len).map{|k| mat[k].lu}
+        else
+          lu = mat.lu
+        end
 
         #< derive the vector, solve, and best fit >
 
@@ -325,7 +371,11 @@ module NumRu
           # derive the vector
           b = NVector.float(ms)
           for i in 0...ms
-            b[i] = (data * fv[i]).mean
+            unless wgt
+              b[i] = (data * fv[i]).mean
+            else
+              b[i] = (data * fv[i] * wgt).mean
+            end
           end
 
           # solve
@@ -355,7 +405,6 @@ module NumRu
           # derive vectors
           idshp = indep_dims.collect{|d| data.shape[d]}
           bs = NArray.float(ms,*idshp)
-          meandims = (0...rank).collect{|d| d} - indep_dims
           for i in 0...ms
             bsi = (data * fv[i]).mean(*meandims)
             if bsi.is_a?(NArrayMiss)
@@ -366,16 +415,18 @@ module NumRu
             end
             bs[i,false] = bsi
           end
-          idlen = 1
-          idshp.each{|l| idlen *= l}
 
           # solve
-          bs = bs.reshape(ms, idlen)
-          c = NArray.float(ms,idlen)
+          bs = bs.reshape(ms, indep_len)
+          c = NArray.float(ms,indep_len)
           b = NVector.float(ms)
-          for id in 0...idlen
+          for id in 0...indep_len
             b[true] = bs[true,id]
-            c[true,id] = lu.solve(b)
+            if mask
+              c[true,id] = lu[id].solve(b)
+            else
+              c[true,id] = lu.solve(b)
+            end
           end
           c[-1,true] += d0
           c = c.reshape(ms, *idshp)
@@ -453,6 +504,11 @@ module NumRu
     #   this argument can be used to specify the dimensions that are
     #   not included in +grid_locs+ and are treated as independent, so
     #   the fitting is made for each of their component.
+    # * +with_offset+ (optional) if true (default), constant offset is derived.
+    #   If false, offset is not treated.
+    # * +wgt_func+ (optional) [nil (defualt) or Proc] If Proc, weighting function
+    #   to conduct the weighted least square fit. It should conform with the
+    #   fitting functions.
     # 
     # === RETURN VALUES
     #   [ c, bf, diff ]
@@ -473,7 +529,8 @@ module NumRu
 
 
 
-    def least_square_fit(functions, ensemble_dims=nil, indep_dims=nil)
+    def least_square_fit(functions, ensemble_dims=nil, indep_dims=nil, with_offset=true,
+                         wgt_func = nil)
 
       #< preparation >
 
@@ -492,7 +549,8 @@ module NumRu
 
       #< fitting >
       c, bf, diff = GAnalysis::Fitting.least_square_fit(data, grid_locs, 
-                                          functions, ensemble_dims, indep_dims)
+                           functions, ensemble_dims, indep_dims,
+                           with_offset, wgt_func)
 
       #< make a GPhys of the best fit >
 
@@ -557,12 +615,17 @@ if $0 == __FILE__
   data = x + x*x*0.1
   c, bf, diff = GAnalysis::Fitting.least_square_fit(data, [x], 
                                               [GAnalysis::Fitting::X])
-  p "data:", data, "c:", c, "bf:", bf
-exit
+  p "*1* data:", data, "c:", c, "bf:", bf, "diff:", diff
 
   c, bf, diff = GAnalysis::Fitting.least_square_fit(data, [x], 
                              [GAnalysis::Fitting::X,GAnalysis::Fitting::XX])
-  p c
+  p "*2* data:", data, "c:", c, "bf:", bf, "diff:", diff
+
+  wgt = Proc.new{|x| 1.0 + x**2}
+  c, bf, diff = GAnalysis::Fitting.least_square_fit(data, [x], 
+                             [GAnalysis::Fitting::X,GAnalysis::Fitting::XX],
+                             nil, nil, true, wgt)
+  p "*3* data:", data, "x:", x, "c:", c, "bf:", bf, "diff:", diff
 
   xx = x.newdim(-1)
   data = xx + 2*yy + 100

data/lib/numru/ganalysis/histogram.rb

@@ -43,9 +43,9 @@ module NumRu
       val = gphys0.val
       val = val.get_array![val.get_mask!] if NArrayMiss === val
       val = NMath.log10(val) if log_bins
-      hist.increment(val)
+      val.each{|v| hist.increment(v)}
 
-      bounds = hist.range.to_na
+      bounds =  NArray.to_na(hist.range.to_a)
       bounds = 10 ** bounds if log_bins
       center = (bounds[0..-2]+bounds[1..-1])/2
       cell_width = (bounds[1..-1] - bounds[0..-2]) / 2
@@ -57,7 +57,7 @@ module NumRu
       axis.set_cell(center, bounds, name)
       axis.set_pos_to_center
 
-      bin = hist.bin.to_na
+      bin = NArray.to_na(hist.bin.to_a)
       bin /= cell_width if opts["log_bins"]
       bin = VArray.new(bin,
                        {"long_name" => (log_bins ? "number per unit bin width" : "number in bins"), "units"=>"1"},

data/lib/numru/ganalysis/log_p.rb

@@ -74,6 +74,26 @@ module NumRu
         pi_dz_p_p_dz
       end
 
+      def gph2n2(gph)
+        phi = gph*Met.g
+        phi.units = Units[ phi.units.to_s.sub(/gpm/i,'m') ]
+        phi_zz = pcdata_dz2(phi)
+        phi_z = pcdata_dz(phi)
+        n2 = phi_zz + phi_z * (Met::Kappa/h)
+        n2 = n2.convert_units(Units["s-2"])
+        n2.name = "N2"
+        n2.long_name = "squared log-p buoyancy freq"
+        n2
+      end
+
+      def gph2n(gph)
+        n2 = gph2n2(gph)
+        n = n2.sqrt
+        n.name = "N"
+        n.long_name = "log-p buoyancy freq"
+        n
+      end
+
     end
   end
 

data/lib/numru/ganalysis/lomb_scargle.rb

@@ -0,0 +1,205 @@
+# coding: utf-8
+=begin
+= Lomb-Scargle periodgram
+=end
+
+require "numru/gphys"
+
+module NumRu
+  module GAnalysis
+    module LombScargle
+      module_function
+
+      # = Lomb-Scargle periodgram
+      # 
+      # ARGUMENTS
+      # * y [NArray or NArrayMiss] : data
+      # * dim [Integer] : the dimension to apply LS
+      # * t [1D NArray] : "time" (the coordinate values along dim)
+      # * f [Numric or 1D NArray] : frequency. If 1D NArray, the frequency
+      #   dimension is added to the end of outputs
+      # 
+      # OUTPUTS
+      # * a : coef of cos
+      # * b : coef of sin  (sqrt(a**2+b**2) is the amplitude)
+      # * reconst : reconstructed y (fitting result)
+      # * cos [NArray or NArrayMiss]: cos(2*pi*f*t + ph)
+      #   (useful if you want to reconstruct for a part of f)
+      # * sin [NArray or NArrayMiss]: sin(2*pi*f*t + ph)
+      #   (useful if you want to reconstruct for a part of f)
+      # * cc [NArray or NArrayMiss]: normarization factor sum(cos**2)
+      #   (needed to derive power spectrum)
+      # * ss [NArray or NArrayMiss]: normarization factor sum(sin**2)
+      #   (needed to derive power spectrum)
+      # * ph [NArray or NArrayMiss]: phase (for each f and,
+      #   if with miss, for each grid point)
+      def lomb_scargle(y, dim, t, f)
+        rank = y.rank
+        if y.respond_to?(:get_mask)
+          mask = y.get_mask
+        else
+          mask = nil
+        end
+        ph, ot_ph = derive_phase(t,f,dim,rank,mask)
+        cos = Misc::EMath.cos( ot_ph )
+        sin = Misc::EMath.sin( ot_ph )
+        cc = (cos*cos).sum(dim)
+        ss = (sin*sin).sum(dim)
+        #p "%%%", (cos*sin).sum(dim), cc, ss
+        if !f.is_a?(Numeric)
+          y = y.newdim(-1)
+        end
+        a = (y*cos).sum(dim) / cc
+        b = (y*sin).sum(dim) / ss
+        reconst = (a.newdim(-2)*cos).sum(-1) + (b.newdim(-2)*sin).sum(-1)
+        [a,b,reconst,cos,sin,cc,ss,ph]
+      end
+
+      def derive_phase(t,f,dim,rank,mask=nil)
+        multiple_f = !f.is_a?(Numeric)
+        if multiple_f
+          o2t = 4*Math::PI * f.newdim(0) * t.newdim(-1)  # 2 omega t
+          mask = mask.newdim(-1) if mask
+          nf = f.length
+        else
+          o2t = 4*Math::PI * f * t  # 2 omega t
+        end
+        with_miss = (mask && mask.count_false > 0)
+        if dim >= 1
+          o2t = o2t.newdim!( *([0]*dim) )
+        end
+        if dim < rank-1
+          o2t = o2t.newdim!( *([dim+1]*(rank-1-dim)) )
+        end
+        if with_miss
+          # sampling is not common for all grid points
+          expander = NArray.float( *mask.shape )
+          o2t += expander    # duplicates o2t for all grid points
+          if multiple_f
+            expander = NArray.byte(*([1]*rank+[nf])) # duplicates mask for all f
+            mask += expander
+          end
+          o2t = NArrayMiss.to_nam(o2t,mask)
+        end
+        ph = 0.5* Misc::EMath::atan2( Misc::EMath.sin(o2t).sum(dim),
+                                     -Misc::EMath.cos(o2t).sum(dim)).newdim(dim)
+        ot_ph = o2t*0.5 + ph  # omega*t + ph
+        [ph, ot_ph]
+      end
+    end
+  end
+
+  class GPhys
+    # = Lomb-Scargle periodgram
+    # 
+    # The direct outputs are the amplitude of each wave components,
+    # ga as the coefficties for cos and gb as the coefficties for sin.
+    # 
+    # LS power spectrum can be derived as
+    #   pw = ga**2 * cc/(ntlen*df) + gb**2 * ss/(ntlen*df)
+    #      = ga**2 * cc/(2*fmax) + gb**2 * ss/(2*fmax)
+    # Here, ntlen=2*f.length (equivalent data length from frequency sampling).
+    #
+    # ARGUMENTS
+    # * dim [Integer or String] : dimension to apply fitting
+    # * fmax [Numeric]: max frequency (sampling frequencies [df, 2*df,...,fmax])
+    #   fmax should be a multiple of df
+    # * df [Numeric/nil]: frequency increment (If nil, set to fmax: single freq)
+    # * f_long_name, f_name : long_name and name of the "frequency" axis.
+    #   You may want to specify them if the dimension is not time.
+    # 
+    # OUTPUTS
+    # * ga [GPhys]: coef of cos
+    # * gb [GPhys]: coef of sin  (sqrt(a**2+b**2) is the amplitude)
+    # * greconst [GPhys]: reconstructed y (fitting result)
+    # * cos [NArray or NArrayMiss]: cos(2*pi*f*t + ph)
+    #   (useful if you want to reconstruct for a part of f)
+    # * sin [NArray or NArrayMiss]: sin(2*pi*f*t + ph)
+    #   (useful if you want to reconstruct for a part of f)
+    # * cc [NArray or NArrayMiss]: normarization factor sum(cos**2)
+    #   (needed to derive power spectrum)
+    # * ss [NArray or NArrayMiss]: normarization factor sum(sin**2)
+    #   (needed to derive power spectrum)
+    # * ph [NArray or NArrayMiss]: phase (for each f and,
+    #   if with miss, for each grid point)
+    # * f [1D NArray]: frequencies derived from df and fmax
+
+    def lomb_scargle(dim, fmax, df=nil, f_long_name="frequency", f_name="f")
+
+      #< prep >
+      df = fmax if df.nil?
+      dim = dim_index( dim )
+      ct = coord(dim)
+      t = ct.val
+      nf = (fmax/df).round
+      f = df * (NArray.float(nf).indgen!+1.0)
+      y = val
+
+      #< do it >
+      a, b, reconst, cos, sin, cc, ss, ph =
+                   GAnalysis::LombScargle::lomb_scargle(y, dim, t, f)
+
+      #< to gphys >
+      tun = Units.new( coord(dim).units.to_s.sub(/ *since.*$/,'') )
+      fun = (tun**(-1)).to_s
+      fax = Axis.new.set_pos(
+            VArray.new(f, {"long_name"=>f_long_name,"units"=>fun}, f_name) )
+      oaxes = (0...rank).map{|d| axis(d)}
+      caxes = oaxes.dup
+      caxes[dim] = fax
+      cgrid = Grid.new(*caxes)  # grid of fitting (~Fourier) coefficients
+      un = units.to_s
+      ga = GPhys.new( cgrid,
+                      VArray.new(a,{"long_name"=>"coef a","units"=>un},"a") )
+      gb = GPhys.new( cgrid,
+                      VArray.new(b,{"long_name"=>"coef b","units"=>un},"b") )
+      greconst = GPhys.new( grid, VArray.new(reconst,data,name) )
+      [ga, gb, greconst, cos, sin, cc, ss, ph, f]
+    end
+  end
+
+end
+
+################################################
+##### test part ######
+if $0 == __FILE__
+  require "numru/ggraph"
+  include NumRu
+  include Misc::EMath
+
+  cx = VArray.new(NArray.float(2).indgen!, {"units"=>"1","long_name"=>"x"}, "x")
+
+  ## unequal spacing : fitting
+  #t = NArray.to_na( [0.0, 0.1, 1, 1.5, 3, 3.3, 3.8, 6, 6.3, 7, 7,5, 8, 9] )
+
+  ## equal spacing with missing
+  #t = NArray.to_na( [0.0, 2, 3, 4, 5, 6, 7, 8, 9] )
+
+  # equal spacing: equal to DFT if f is multiples of 1/10
+  t = NArray.float(10).indgen!
+
+  ct = VArray.new(t, {"units"=>"days","long_name"=>"time"},"t")
+  grid = Grid.new( Axis.new.set_pos(cx), Axis.new.set_pos(ct) )
+  nt = t.length
+
+  v = NArrayMiss.float(2,nt)
+  f = 1.0/10.0  # base frequency
+  o = 2*PI*f
+  v[0,true] = sin(o*t) + 0.4*sin(2*o*t) + 0.2*cos(2*o*t) + 0.3*cos(3*o*t)
+  v[1,true] = cos(o*t) + 0.2*sin(2*o*t) + 0.2*cos(2*o*t) + 2*sin(3*o*t)
+
+  v.invalidation(1,1)  # then, v[1,true] fitting will be different from DFT
+  
+  y = VArray.new(v, {"units"=>"m/s","long_name"=>"y"}, "y")
+  gp = GPhys.new(grid, y)
+
+  df = f
+  fmax = 4*df
+  #df = f / 2
+  #fmax = 8*df
+  ga, gb, greconst, cos, sin, ph = gp.lomb_scargle("t",fmax,df)
+  p "**", ga, ph
+  ampsp = ga**2 + gb**2
+  amp = Misc::EMath.sqrt(ampsp.val)
+  p "&&", amp, ampsp.val.sum(-1)/2, ((greconst.val - v)**2).mean(-1)
+end