mathgl 0.0.3 → 0.0.4

data/lib/mathgl/libdoc_data_en.rb

@@ -1,11 +1,10 @@
 # This document is converted from data_en.texi.
-class MglDataC
+
+# MglData class
+class MglData
 
 # Public variables.
-# Gets or sets the value in by "flat" index i without border checking. Index i should be in range [0, nx*ny*nz-1].
-# @overload get_val(i)
-#  @param [long] i 
-#  @return [Float]
+# Gets or sets the value in by "flat" index i without border checking. Index i should be in range (0, nx*ny*nz-1).
 # @overload get_val(i)
 #  @param [long] i 
 #  @return [Float]
@@ -13,11 +12,7 @@ class MglDataC
 #  @param [Float] val 
 #  @param [long] i 
 #  @return [nil]
-# @overload set_val(val,i)
-#  @param [Float] val 
-#  @param [long] i 
-#  @return [nil]
-def set_val
+def get_val
 end
 
 
@@ -25,17 +20,11 @@ end
 # Gets the x-, y-, z-size of the data.
 # @overload get_nx()
 #  @return [long]
-# @overload get_nx()
-#  @return [long]
 # @overload get_ny()
 #  @return [long]
-# @overload get_ny()
-#  @return [long]
-# @overload get_nz()
-#  @return [long]
 # @overload get_nz()
 #  @return [long]
-def get_nz
+def get_nx
 end
 
 
@@ -46,11 +35,6 @@ end
 #  @param [Integer] my default=1
 #  @param [Integer] mz default=1
 #  @return [MglData]
-# @overload initialize(mx=1,my=1,mz=1)
-#  @param [Integer] mx default=1
-#  @param [Integer] my default=1
-#  @param [Integer] mz default=1
-#  @return [MglDataC]
 def initialize
 end
 
@@ -90,39 +74,6 @@ end
 #  @param [Integer] size 
 #  @param [Integer] cols 
 #  @return [MglData]
-# @overload initialize(dat2)
-#  @param [MglData] dat2 
-#  @return [MglDataC]
-# @overload initialize(dat2)
-#  @param [MglData] dat2 
-#  @return [MglDataC]
-# @overload initialize(size,dat2)
-#  @param [Integer] size 
-#  @param [float] dat2 
-#  @return [MglDataC]
-# @overload initialize(size,cols,dat2)
-#  @param [Integer] size 
-#  @param [Integer] cols 
-#  @param [float] dat2 
-#  @return [MglDataC]
-# @overload initialize(size,dat2)
-#  @param [Integer] size 
-#  @param [Float] dat2 
-#  @return [MglDataC]
-# @overload initialize(size,cols,dat2)
-#  @param [Integer] size 
-#  @param [Integer] cols 
-#  @param [Float] dat2 
-#  @return [MglDataC]
-# @overload initialize(size,dat2)
-#  @param [Integer] size 
-#  @param [dual] dat2 
-#  @return [MglDataC]
-# @overload initialize(size,cols,dat2)
-#  @param [Integer] size 
-#  @param [Integer] cols 
-#  @param [dual] dat2 
-#  @return [MglDataC]
 def initialize
 end
 
@@ -132,9 +83,6 @@ end
 # @overload initialize(fname)
 #  @param [String] fname 
 #  @return [MglData]
-# @overload initialize(fname)
-#  @param [String] fname 
-#  @return [MglDataC]
 def initialize
 end
 
@@ -146,11 +94,6 @@ end
 #  @param [Integer] my default=1
 #  @param [Integer] mz default=1
 #  @return [nil]
-# @overload create(mx,my=1,mz=1)
-#  @param [Integer] mx 
-#  @param [Integer] my default=1
-#  @param [Integer] mz default=1
-#  @return [nil]
 def create
 end
 
@@ -162,11 +105,6 @@ end
 #  @param [Integer] my default=0
 #  @param [Integer] mz default=0
 #  @return [nil]
-# @overload rearrange(mx,my=0,mz=0)
-#  @param [Integer] mx 
-#  @param [Integer] my default=0
-#  @param [Integer] mz default=0
-#  @return [nil]
 def rearrange
 end
 
@@ -176,9 +114,6 @@ end
 # @overload transpose(dim="yx")
 #  @param [String] dim default="yx"
 #  @return [nil]
-# @overload transpose(dim="yx")
-#  @param [String] dim default="yx"
-#  @return [nil]
 def transpose
 end
 
@@ -189,10 +124,6 @@ end
 #  @param [Integer] n1 
 #  @param [Integer] n2 default=0
 #  @return [nil]
-# @overload extend(n1,n2=0)
-#  @param [Integer] n1 
-#  @param [Integer] n2 default=0
-#  @return [nil]
 def extend
 end
 
@@ -205,23 +136,12 @@ end
 #  @param [Integer] rz default=1
 #  @param [bool] smooth default=false
 #  @return [nil]
-# @overload squeeze(rx,ry=1,rz=1,smooth=false)
-#  @param [Integer] rx 
-#  @param [Integer] ry default=1
-#  @param [Integer] rz default=1
-#  @param [bool] smooth default=false
-#  @return [nil]
 def squeeze
 end
 
 
 # Data resizing.
-# Cuts off edges of the data i<n1 and i>n2 if n2>0 or i>n[xyz]-n2 if n2<=0 along direction dir.
-# @overload crop(n1,n2,dir='x')
-#  @param [Integer] n1 
-#  @param [Integer] n2 
-#  @param [String] dir default='x'
-#  @return [nil]
+# Cuts off edges of the data i<n1 and i>n2 if n2>0 or i>n(xyz)-n2 if n2<=0 along direction dir.
 # @overload crop(n1,n2,dir='x')
 #  @param [Integer] n1 
 #  @param [Integer] n2 
@@ -238,11 +158,6 @@ end
 #  @param [Integer] pos default=0
 #  @param [Integer] num default=1
 #  @return [nil]
-# @overload insert(dir,pos=0,num=1)
-#  @param [String] dir 
-#  @param [Integer] pos default=0
-#  @param [Integer] num default=1
-#  @return [nil]
 def insert
 end
 
@@ -254,20 +169,31 @@ end
 #  @param [Integer] pos default=0
 #  @param [Integer] num default=1
 #  @return [nil]
-# @overload delete(dir,pos=0,num=1)
-#  @param [String] dir 
-#  @param [Integer] pos default=0
-#  @param [Integer] num default=1
-#  @return [nil]
 def delete
 end
 
 
 # Data resizing.
-# Join data cells from vdat to dat. At this, function increase dat sizes according following: z-size for 3D data arrays arrays with equal x-,y-sizes; or y-size for 2D data arrays with equal x-sizes; or x-size otherwise.
-# @overload join(vdat)
-#  @param [MglData] vdat 
+# Sort data rows (or slices in 3D case) by values of specified column idx (or cell (idx,idy) for 3D case). Note, this function is not thread safe!
+# @overload sort(idx,idy=-1)
+#  @param [lond] idx 
+#  @param [long] idy default=-1
+#  @return [nil]
+def sort
+end
+
+
+# Data resizing.
+# Delete rows which values are equal to next row for given column idx.
+# @overload clean(idx)
+#  @param [lond] idx 
 #  @return [nil]
+def clean
+end
+
+
+# Data resizing.
+# Join data cells from vdat to dat. At this, function increase dat sizes according following: z-size for 3D data arrays arrays with equal x-,y-sizes; or y-size for 2D data arrays with equal x-sizes; or x-size otherwise.
 # @overload join(vdat)
 #  @param [MglData] vdat 
 #  @return [nil]
@@ -276,7 +202,7 @@ end
 
 
 # Data filling.
-# Allocates memory and copies the data from the  float* or double* array.
+# Allocates memory and copies the data from the flat float* or double* array.
 # @overload set(a,nx,ny=1,nz=1)
 #  @param [float] a 
 #  @param [Integer] nx 
@@ -289,23 +215,37 @@ end
 #  @param [Integer] ny default=1
 #  @param [Integer] nz default=1
 #  @return [nil]
-# @overload set(a,nx,ny=1,nz=1)
+def set
+end
+
+
+# Data filling.
+# Allocates memory and copies the data from the float** or double** array with dimensions N1, N2, i.e. from array defined as mreal a(N1)(N2);.
+# @overload set(a,n1,n2)
 #  @param [float] a 
-#  @param [Integer] nx 
-#  @param [Integer] ny default=1
-#  @param [Integer] nz default=1
+#  @param [Integer] n1 
+#  @param [Integer] n2 
 #  @return [nil]
-# @overload set(a,nx,ny=1,nz=1)
+# @overload set(a,n1,n2)
 #  @param [Float] a 
-#  @param [Integer] nx 
-#  @param [Integer] ny default=1
-#  @param [Integer] nz default=1
+#  @param [Integer] n1 
+#  @param [Integer] n2 
 #  @return [nil]
-# @overload set(a,nx,ny=1,nz=1)
-#  @param [dual] a 
-#  @param [Integer] nx 
-#  @param [Integer] ny default=1
-#  @param [Integer] nz default=1
+def set
+end
+
+
+# Data filling.
+# Allocates memory and copies the data from the float*** or double*** array with dimensions N1, N2, N3, i.e. from array defined as mreal a(N1)(N2)(N3);.
+# @overload set(a,n1,n2)
+#  @param [float] a 
+#  @param [Integer] n1 
+#  @param [Integer] n2 
+#  @return [nil]
+# @overload set(a,n1,n2)
+#  @param [Float] a 
+#  @param [Integer] n1 
+#  @param [Integer] n2 
 #  @return [nil]
 def set
 end
@@ -316,9 +256,6 @@ end
 # @overload set(v)
 #  @param [gsl_vector] v 
 #  @return [nil]
-# @overload set(v)
-#  @param [gsl_vector] v 
-#  @return [nil]
 def set
 end
 
@@ -328,9 +265,6 @@ end
 # @overload set(m)
 #  @param [gsl_matrix] m 
 #  @return [nil]
-# @overload set(m)
-#  @param [gsl_matrix] m 
-#  @return [nil]
 def set
 end
 
@@ -340,19 +274,6 @@ end
 # @overload set(from)
 #  @param [MglData] from 
 #  @return [nil]
-# @overload set(from)
-#  @param [MglData] from 
-#  @return [nil]
-def set
-end
-
-
-# Data filling.
-# Copies the data from mglData instances for real and imaginary parts of complex data arrays.
-# @overload set(re,im)
-#  @param [MglData] re 
-#  @param [MglData] im 
-#  @return [nil]
 def set
 end
 
@@ -363,23 +284,11 @@ end
 #  @param [std::vector<int>] d 
 #  @return [nil]
 # @overload set(d)
-#  @param [std::vector<int>] d 
-#  @return [nil]
-# @overload set(d)
-#  @param [std::vector<float>] d 
-#  @return [nil]
-# @overload set(d)
 #  @param [std::vector<float>] d 
 #  @return [nil]
 # @overload set(d)
 #  @param [std::vector<double>] d 
 #  @return [nil]
-# @overload set(d)
-#  @param [std::vector<double>] d 
-#  @return [nil]
-# @overload set(d)
-#  @param [std::vector<dual>] d 
-#  @return [nil]
 def set
 end
 
@@ -392,12 +301,6 @@ end
 #  @param [Integer] ny default=1
 #  @param [Integer] nz default=1
 #  @return [nil]
-# @overload set(str,nx,ny=1,nz=1)
-#  @param [String] str 
-#  @param [Integer] nx 
-#  @param [Integer] ny default=1
-#  @param [Integer] nz default=1
-#  @return [nil]
 def set
 end
 
@@ -413,37 +316,23 @@ end
 #  @param [Integer] ny default=1
 #  @param [Integer] nz default=1
 #  @return [nil]
-# @overload link(from)
-#  @param [MglData] from 
-#  @return [nil]
-# @overload link(a,nx,ny=1,nz=1)
-#  @param [dual] a 
-#  @param [Integer] nx 
-#  @param [Integer] ny default=1
-#  @param [Integer] nz default=1
-#  @return [nil]
 def link
 end
 
 
 # Data filling.
-# Equidistantly fills the data values to range [v1, v2] in direction dir=(,,).
+# Equidistantly fills the data values to range (v1, v2) in direction dir=('x','y','z').
 # @overload fill(v1,v2,dir='x')
 #  @param [Float] v1 
 #  @param [Float] v2 
 #  @param [String] dir default='x'
 #  @return [nil]
-# @overload fill(v1,v2,dir='x')
-#  @param [dual] v1 
-#  @param [dual] v2 
-#  @param [String] dir default='x'
-#  @return [nil]
 def fill
 end
 
 
 # Data filling.
-# The same as previous ones but coordinates , ,  are supposed to be normalized in range [0,1]. If dim>0 is specified then modification will be fulfilled only for slices >=dim.
+# The same as previous ones but coordinates 'x', 'y', 'z' are supposed to be normalized in range (0,1). If dim>0 is specified then modification will be fulfilled only for slices >=dim.
 # @overload modify(eq,dim=0)
 #  @param [String] eq 
 #  @param [Integer] dim default=0
@@ -457,20 +346,49 @@ end
 #  @param [MglData] v 
 #  @param [MglData] w 
 #  @return [nil]
-# @overload modify(eq,dim=0)
-#  @param [String] eq 
-#  @param [Integer] dim default=0
+def modify
+end
+
+
+# Data filling.
+# Fills data by 'x' or 'k' samples for Hankel ('h') or Fourier ('f') transform.
+# @overload fill_sample(how)
+#  @param [String] how 
 #  @return [nil]
-# @overload modify(eq,v)
-#  @param [String] eq 
-#  @param [MglData] v 
+def fill_sample
+end
+
+
+# Data filling.
+# Sets value(s) of array a(i, j, k) = val. Negative indexes i, j, k=-1 set the value val to whole range in corresponding direction(s). For example, Put(val,-1,0,-1); sets a(i,0,j)=val for i=0...(nx-1), j=0...(nz-1).
+# @overload put(val,i=-1,j=-1,k=-1)
+#  @param [Float] val 
+#  @param [Integer] i default=-1
+#  @param [Integer] j default=-1
+#  @param [Integer] k default=-1
 #  @return [nil]
-# @overload modify(eq,v,w)
-#  @param [String] eq 
+def put
+end
+
+
+# Data filling.
+# Copies value(s) from array v to the range of original array. Negative indexes i, j, k=-1 set the range in corresponding direction(s). At this minor dimensions of array v should be large than corresponding dimensions of this array. For example, Put(v,-1,0,-1); sets a(i,0,j)=v.ny>nz ? v(i,j) : v(i), where i=0...(nx-1), j=0...(nz-1) and condition v.nx>=nx is true.
+# @overload put(v,i=-1,j=-1,k=-1)
 #  @param [MglData] v 
-#  @param [MglData] w 
+#  @param [Integer] i default=-1
+#  @param [Integer] j default=-1
+#  @param [Integer] k default=-1
 #  @return [nil]
-def modify
+def put
+end
+
+
+# Data filling.
+# Sets the symbol ids for data columns. The string should contain one symbol 'a'...'z' per column. These ids are used in column.
+# @overload set_column_id(ids)
+#  @param [String] ids 
+#  @return [nil]
+def set_column_id
 end
 
 
@@ -479,9 +397,6 @@ end
 # @overload read(fname)
 #  @param [String] fname 
 #  @return [bool]
-# @overload read(fname)
-#  @param [String] fname 
-#  @return [bool]
 def read
 end
 
@@ -494,12 +409,6 @@ end
 #  @param [Integer] my default=1
 #  @param [Integer] mz default=1
 #  @return [bool]
-# @overload read(fname,mx,my=1,mz=1)
-#  @param [String] fname 
-#  @param [Integer] mx 
-#  @param [Integer] my default=1
-#  @param [Integer] mz default=1
-#  @return [bool]
 def read
 end
 
@@ -510,10 +419,6 @@ end
 #  @param [String] fname 
 #  @param [Integer] dim default=2
 #  @return [bool]
-# @overload read_mat(fname,dim=2)
-#  @param [String] fname 
-#  @param [Integer] dim default=2
-#  @return [bool]
 def read_mat
 end
 
@@ -527,13 +432,6 @@ end
 #  @param [Float] step default=1
 #  @param [bool] as_slice default=false
 #  @return [nil]
-# @overload read_range(templ,from,to,step=1,as_slice=false)
-#  @param [String] templ 
-#  @param [Float] from 
-#  @param [Float] to 
-#  @param [Float] step default=1
-#  @param [bool] as_slice default=false
-#  @return [nil]
 def read_range
 end
 
@@ -544,10 +442,6 @@ end
 #  @param [String] templ 
 #  @param [bool] as_slice default=false
 #  @return [nil]
-# @overload read_all(templ,as_slice=false)
-#  @param [String] templ 
-#  @param [bool] as_slice default=false
-#  @return [nil]
 def read_all
 end
 
@@ -558,10 +452,6 @@ end
 #  @param [String] fname 
 #  @param [Integer] ns default=-1
 #  @return [nil]
-# @overload save(fname,ns=-1)
-#  @param [String] fname 
-#  @param [Integer] ns default=-1
-#  @return [nil]
 def save
 end
 
@@ -572,10 +462,6 @@ end
 #  @param [String] fname 
 #  @param [String] dname 
 #  @return [nil]
-# @overload read_hdf(fname,dname)
-#  @param [String] fname 
-#  @param [String] dname 
-#  @return [nil]
 def read_hdf
 end
 
@@ -587,11 +473,6 @@ end
 #  @param [String] dname 
 #  @param [bool] rewrite default=false
 #  @return [nil]
-# @overload save_hdf(fname,dname,rewrite=false)
-#  @param [String] fname 
-#  @param [String] dname 
-#  @param [bool] rewrite default=false
-#  @return [nil]
 def save_hdf
 end
 
@@ -603,15 +484,35 @@ end
 #  @param [String] buf 
 #  @param [long] size 
 #  @return [Integer]
-# @overload datas_hdf(fname,buf,size)
-#  @param [String] fname 
-#  @param [String] buf 
-#  @param [long] size 
-#  @return [Integer]
 def datas_hdf
 end
 
 
+# File I/O.
+# Reads data from bitmap file (now support only PNG format). The RGB values of bitmap pixels are transformed to mreal values in range (v1, v2) using color scheme scheme (Color scheme).
+# @overload import(fname,scheme,v1=0,v2=1)
+#  @param [String] fname 
+#  @param [String] scheme 
+#  @param [Float] v1 default=0
+#  @param [Float] v2 default=1
+#  @return [nil]
+def import
+end
+
+
+# File I/O.
+# Saves data matrix (or ns-th slice for 3d data) to bitmap file (now support only PNG format). The data values are transformed from range (v1, v2) to RGB pixels of bitmap using color scheme scheme (Color scheme). If v1>=v2 then the values of v1, v2 are automatically determined as minimal and maximal value of the data array.
+# @overload export(fname,scheme,v1=0,v2=0,ns=-1)
+#  @param [String] fname 
+#  @param [String] scheme 
+#  @param [Float] v1 default=0
+#  @param [Float] v2 default=0
+#  @param [Integer] ns default=-1
+#  @return [nil]
+def export
+end
+
+
 # Make another data.
 # Extracts sub-array data from the original data array keeping fixed positive index. For example SubData(-1,2) extracts 3d row (indexes are zero based), SubData(4,-1) extracts 5th column, SubData(-1,-1,3) extracts 4th slice and so on. If argument(s) are non-integer then linear interpolation between slices is used. In MGL version this command usually is used as inline one dat(xx,yy,zz).
 # @overload sub_data(xx,yy=-1,zz=-1)
@@ -619,11 +520,6 @@ end
 #  @param [Float] yy default=-1
 #  @param [Float] zz default=-1
 #  @return [MglData]
-# @overload sub_data(xx,yy=-1,zz=-1)
-#  @param [Float] xx 
-#  @param [Float] yy default=-1
-#  @param [Float] zz default=-1
-#  @return [MglData]
 def sub_data
 end
 
@@ -635,11 +531,6 @@ end
 #  @param [MglData] yy 
 #  @param [MglData] zz 
 #  @return [MglData]
-# @overload sub_data(xx,yy,zz)
-#  @param [MglData] xx 
-#  @param [MglData] yy 
-#  @param [MglData] zz 
-#  @return [MglData]
 def sub_data
 end
 
@@ -649,26 +540,12 @@ end
 # @overload column(eq)
 #  @param [String] eq 
 #  @return [MglData]
-# @overload column(eq)
-#  @param [String] eq 
-#  @return [MglData]
 def column
 end
 
 
 # Make another data.
-# Resizes the data to new size mx, my, mz from box (part) [x1,x2] x [y1,y2] x [z1,z2] of original array. Initially x,y,z coordinates are supposed to be in [0,1].
-# @overload resize(mx,my=1,mz=1,x1=0,x2=1,y1=0,y2=1,z1=0,z2=1)
-#  @param [Integer] mx 
-#  @param [Integer] my default=1
-#  @param [Integer] mz default=1
-#  @param [Float] x1 default=0
-#  @param [Float] x2 default=1
-#  @param [Float] y1 default=0
-#  @param [Float] y2 default=1
-#  @param [Float] z1 default=0
-#  @param [Float] z2 default=1
-#  @return [MglData]
+# Resizes the data to new size mx, my, mz from box (part) (x1,x2) x (y1,y2) x (z1,z2) of original array. Initially x,y,z coordinates are supposed to be in (0,1).
 # @overload resize(mx,my=1,mz=1,x1=0,x2=1,y1=0,y2=1,z1=0,z2=1)
 #  @param [Integer] mx 
 #  @param [Integer] my default=1
@@ -685,7 +562,7 @@ end
 
 
 # Make another data.
-# Gets array which values is result of interpolation of original array for coordinates from other arrays. All dimensions must be the same for data idat, jdat, kdat. Coordinates from idat, jdat, kdat are supposed to be normalized in range [0,1] (if norm=true) or in ranges [0,nx], [0,ny], [0,nz] correspondingly.
+# Gets array which values is result of interpolation of original array for coordinates from other arrays. All dimensions must be the same for data idat, jdat, kdat. Coordinates from idat, jdat, kdat are supposed to be normalized in range (0,1) (if norm=true) or in ranges (0,nx), (0,ny), (0,nz) correspondingly.
 # @overload evaluate(idat,norm=true)
 #  @param [MglData] idat 
 #  @param [bool] norm default=true
@@ -701,40 +578,29 @@ end
 #  @param [MglData] kdat 
 #  @param [bool] norm default=true
 #  @return [MglData]
-# @overload evaluate(idat,norm=true)
-#  @param [MglData] idat 
-#  @param [bool] norm default=true
-#  @return [MglData]
-# @overload evaluate(idat,jdat,norm=true)
-#  @param [MglData] idat 
-#  @param [MglData] jdat 
+def evaluate
+end
+
+
+# Make another data.
+# Gets array which values is indexes (roots) along given direction dir, where interpolated values of data dat are equal to val. Output data will have the sizes of dat in directions transverse to dir. If data idat is provided then its values are used as starting points. This allows to find several branches by consequentive calls. Indexes are supposed to be normalized in range (0,1) (if norm=true) or in ranges (0,nx), (0,ny), (0,nz) correspondingly. Solve sample
+# @overload solve(val,dir,norm=true)
+#  @param [Float] val 
+#  @param [String] dir 
 #  @param [bool] norm default=true
 #  @return [MglData]
-# @overload evaluate(idat,jdat,kdat,norm=true)
+# @overload solve(val,dir,idat,norm=true)
+#  @param [Float] val 
+#  @param [String] dir 
 #  @param [MglData] idat 
-#  @param [MglData] jdat 
-#  @param [MglData] kdat 
 #  @param [bool] norm default=true
 #  @return [MglData]
-def evaluate
+def solve
 end
 
 
 # Make another data.
-# Creates n-th points distribution of the data values in range [v1, v2]. Array w specifies weights of the data elements (by default is 1). Parameter nsub define the number of additional interpolated points (for smoothness of histogram). See also Data manipulation
-# @overload hist(n,v1=0,v2=1,nsub=0)
-#  @param [Integer] n 
-#  @param [Float] v1 default=0
-#  @param [Float] v2 default=1
-#  @param [Integer] nsub default=0
-#  @return [MglData]
-# @overload hist(w,n,v1=0,v2=1,nsub=0)
-#  @param [MglData] w 
-#  @param [Integer] n 
-#  @param [Float] v1 default=0
-#  @param [Float] v2 default=1
-#  @param [Integer] nsub default=0
-#  @return [MglData]
+# Creates n-th points distribution of the data values in range (v1, v2). Array w specifies weights of the data elements (by default is 1). Parameter nsub define the number of additional interpolated points (for smoothness of histogram). See also Data manipulation
 # @overload hist(n,v1=0,v2=1,nsub=0)
 #  @param [Integer] n 
 #  @param [Float] v1 default=0
@@ -754,11 +620,7 @@ end
 
 # Make another data.
 # Gets momentum (1d-array) of the data along direction dir. String how contain kind of momentum. The momentum is defined like as
-# if dir= and so on. Coordinates , ,  are data indexes normalized in range [0,1].
-# @overload momentum(dir,how)
-#  @param [String] dir 
-#  @param [String] how 
-#  @return [MglData]
+# if dir='z' and so on. Coordinates 'x', 'y', 'z' are data indexes normalized in range (0,1).
 # @overload momentum(dir,how)
 #  @param [String] dir 
 #  @param [String] how 
@@ -772,9 +634,6 @@ end
 # @overload sum(dir)
 #  @param [String] dir 
 #  @return [MglData]
-# @overload sum(dir)
-#  @param [String] dir 
-#  @return [MglData]
 def sum
 end
 
@@ -784,9 +643,6 @@ end
 # @overload max(dir)
 #  @param [String] dir 
 #  @return [MglData]
-# @overload max(dir)
-#  @param [String] dir 
-#  @return [MglData]
 def max
 end
 
@@ -796,18 +652,12 @@ end
 # @overload min(dir)
 #  @param [String] dir 
 #  @return [MglData]
-# @overload min(dir)
-#  @param [String] dir 
-#  @return [MglData]
 def min
 end
 
 
 # Make another data.
-# Returns direct multiplication of arrays (like, res[i,j] = this[i]*a[j] and so on).
-# @overload combine(a)
-#  @param [MglData] a 
-#  @return [MglData]
+# Returns direct multiplication of arrays (like, res(i,j) = this(i)*a(j) and so on).
 # @overload combine(a)
 #  @param [MglData] a 
 #  @return [MglData]
@@ -816,9 +666,7 @@ end
 
 
 # Make another data.
-# Gets array of diagonal elements a[i,i] (for 2D case) or a[i,i,i] (for 3D case) where i=0...nx-1. Function return copy of itself for 1D case. Data array must have dimensions ny,nz >= nx or ny,nz = 1.
-# @overload trace()
-#  @return [MglData]
+# Gets array of diagonal elements a(i,i) (for 2D case) or a(i,i,i) (for 3D case) where i=0...nx-1. Function return copy of itself for 1D case. Data array must have dimensions ny,nz >= nx or ny,nz = 1.
 # @overload trace()
 #  @return [MglData]
 def trace
@@ -826,34 +674,12 @@ end
 
 
 # Make another data.
-# Gets array of real parts of the data.
-# @overload real()
-#  @return [MglData]
-def real
-end
-
-
-# Make another data.
-# Gets array of imaginary parts of the data.
-# @overload imag()
-#  @return [MglData]
-def imag
-end
-
-
-# Make another data.
-# Gets array of absolute values of the data.
-# @overload abs()
-#  @return [MglData]
-def abs
-end
-
-
-# Make another data.
-# Gets array of arguments of the data.
-# @overload arg()
+# Find roots of equation 'func'=0 for variable var with initial guess ini. Secant method is used for root finding.
+# @overload roots(func,var)
+#  @param [String] func 
+#  @param [String] var 
 #  @return [MglData]
-def arg
+def roots
 end
 
 
@@ -862,9 +688,6 @@ end
 # @overload cum_sum(dir)
 #  @param [String] dir 
 #  @return [nil]
-# @overload cum_sum(dir)
-#  @param [String] dir 
-#  @return [nil]
 def cum_sum
 end
 
@@ -874,9 +697,6 @@ end
 # @overload integral(dir)
 #  @param [String] dir 
 #  @return [nil]
-# @overload integral(dir)
-#  @param [String] dir 
-#  @return [nil]
 def integral
 end
 
@@ -886,8 +706,20 @@ end
 # @overload diff(dir)
 #  @param [String] dir 
 #  @return [nil]
-# @overload diff(dir)
-#  @param [String] dir 
+def diff
+end
+
+
+# Data changing.
+# Differentiates the data specified parametrically in direction x with y, z=constant. Parametrical differentiation uses the formula (for 2D case): da/dx = (a_j*y_i-a_i*y_j)/(x_j*y_i-x_i*y_j) where a_i=da/di, a_j=da/dj denotes usual differentiation along 1st and 2nd dimensions. The similar formula is used for 3D case. Note, that you may change the order of arguments -- for example, if you have 2D data a(i,j) which depend on coordinates (x(i,j), y(i,j)) then usual derivative along 'x' will be Diff(x,y); and usual derivative along 'y' will be Diff(y,x);.
+# @overload diff(x,y)
+#  @param [MglData] x 
+#  @param [MglData] y 
+#  @return [nil]
+# @overload diff(x,y,z)
+#  @param [MglData] x 
+#  @param [MglData] y 
+#  @param [MglData] z 
 #  @return [nil]
 def diff
 end
@@ -898,27 +730,30 @@ end
 # @overload diff2(dir)
 #  @param [String] dir 
 #  @return [nil]
-# @overload diff2(dir)
-#  @param [String] dir 
-#  @return [nil]
 def diff2
 end
 
 
 # Data changing.
-# Do Fourier transform of the data in given direction or directions. If dir contain  then inverse Fourier is used. The Fourier transform is  (see ).
-# @overload fft(dir)
+# Do Sine transform of the data in given direction or directions. The Sine transform is \sum a_j \sin(k j) (see http://en.wikipedia.org/wiki/Discrete_sine_transform#DST-I).
+# @overload sin_fft(dir)
 #  @param [String] dir 
 #  @return [nil]
-def fft
+def sin_fft
 end
 
 
 # Data changing.
-# Do Hankel transform of the data in given direction or directions. The Hankel transform is  (see ).
-# @overload hankel(dir)
+# Do Cosine transform of the data in given direction or directions. The Cosine transform is \sum a_j \cos(k j) (see http://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-I).
+# @overload cos_fft(dir)
 #  @param [String] dir 
 #  @return [nil]
+def cos_fft
+end
+
+
+# Data changing.
+# Do Hankel transform of the data in given direction or directions. The Hankel transform is \sum a_j J_0(k j) (see http://en.wikipedia.org/wiki/Hankel_transform).
 # @overload hankel(dir)
 #  @param [String] dir 
 #  @return [nil]
@@ -931,19 +766,12 @@ end
 # @overload swap(dir)
 #  @param [String] dir 
 #  @return [nil]
-# @overload swap(dir)
-#  @param [String] dir 
-#  @return [nil]
 def swap
 end
 
 
 # Data changing.
-# Rolls the data along direction dir. Resulting array will be out[i] = ini[(i+num)%nx] if dir='x'.
-# @overload roll(dir,error)
-#  @param [String] dir 
-#  @param [unknown] error 
-#  @return [nil]
+# Rolls the data along direction dir. Resulting array will be out(i) = ini((i+num)%nx) if dir='x'.
 # @overload roll(dir,error)
 #  @param [String] dir 
 #  @param [unknown] error 
@@ -953,10 +781,7 @@ end
 
 
 # Data changing.
-# Mirror the left-to-right part of the data in given direction. Looks like change the value index i->n-i. Note, that the similar effect in graphics you can reach by using options (), for example, surf dat; xrange 1 -1.
-# @overload mirror(dir)
-#  @param [String] dir 
-#  @return [nil]
+# Mirror the left-to-right part of the data in given direction. Looks like change the value index i->n-i. Note, that the similar effect in graphics you can reach by using options (Command options), for example, surf dat; xrange 1 -1.
 # @overload mirror(dir)
 #  @param [String] dir 
 #  @return [nil]
@@ -965,11 +790,17 @@ end
 
 
 # Data changing.
-# Smooths the data on specified direction or directions. String dirs specifies the dimensions which will be smoothed. It may contain characters:  for 1st dimension,  for 2nd dimension,  for 3d dimension. If string dir contain:  then does nothing,  -- linear averaging over 3 points,  -- linear averaging over 5 points. By default quadratic averaging over 5 points is used.
-# @overload smooth(dir="xyz",delta=0)
-#  @param [String] dir default="xyz"
-#  @param [Float] delta default=0
+# Remove value steps (like phase jumps after inverse trigonometric functions) with period da in given direction.
+# @overload sew(dir,m_pi)
+#  @param [String] dir 
+#  @param [mreal da=2] m_pi 
 #  @return [nil]
+def sew
+end
+
+
+# Data changing.
+# Smooths the data on specified direction or directions. String dirs specifies the dimensions which will be smoothed. It may contain characters: 'x' for 1st dimension, 'y' for 2nd dimension, 'z' for 3d dimension. If string dir contain: '0' then does nothing, '3' -- linear averaging over 3 points, '5' -- linear averaging over 5 points. By default quadratic averaging over 5 points is used.
 # @overload smooth(dir="xyz",delta=0)
 #  @param [String] dir default="xyz"
 #  @param [Float] delta default=0
@@ -978,70 +809,128 @@ def smooth
 end
 
 
-# Interpolation.
-# Interpolates data by linear function to the given point x in [0...nx-1], y in [0...ny-1], z in [0...nz-1].
-# @overload linear(x,y=0,z=0)
-#  @param [Float] x 
-#  @param [Float] y default=0
-#  @param [Float] z default=0
-#  @return [Float]
-# @overload linear(x,y=0,z=0)
-#  @param [Float] x 
-#  @param [Float] y default=0
-#  @param [Float] z default=0
-#  @return [dual]
-def linear
+# Data changing.
+# Find envelop for data values along direction dir.
+# @overload envelop(dir='x')
+#  @param [String] dir default='x'
+#  @return [nil]
+def envelop
 end
 
 
-# Interpolation.
-# Interpolates data by linear function to the given point x, y, z which assumed to be normalized in range [0, 1].
-# @overload linear1(x,y=0,z=0)
-#  @param [Float] x 
-#  @param [Float] y default=0
-#  @param [Float] z default=0
-#  @return [Float]
-# @overload linear1(x,y=0,z=0)
-#  @param [Float] x 
-#  @param [Float] y default=0
-#  @param [Float] z default=0
-#  @return [dual]
-def linear1
+# Data changing.
+# Normalizes the data to range (v1,v2). If flag sym=true then symmetrical interval (-max(|v1|,|v2|), max(|v1|,|v2|)) is used. Modification will be applied only for slices >=dim.
+# @overload norm(v1=0,v2=1,sym=false,dim=0)
+#  @param [Float] v1 default=0
+#  @param [Float] v2 default=1
+#  @param [bool] sym default=false
+#  @param [Integer] dim default=0
+#  @return [nil]
+def norm
+end
+
+
+# Data changing.
+# Normalizes data slice-by-slice along direction dir the data in slices to range (v1,v2). If flag sym=true then symmetrical interval (-max(|v1|,|v2|), max(|v1|,|v2|)) is used. If keep_en is set then maximal value of k-th slice will be limited by
+# @overload norm_sl(v1=0,v2=1,dir='z',keep_en=true,sym=false)
+#  @param [Float] v1 default=0
+#  @param [Float] v2 default=1
+#  @param [String] dir default='z'
+#  @param [bool] keep_en default=true
+#  @param [bool] sym default=false
+#  @return [nil]
+def norm_sl
 end
 
 
 # Interpolation.
-# Interpolates data by linear function to the given point x in [0...nx-1], y in [0...ny-1], z in [0...nz-1]. The values of derivatives at the point are saved in dif.
-# @overload linear(dif,x,y=0,z=0)
+# Interpolates data by cubic spline to the given point x in (0...nx-1), y in (0...ny-1), z in (0...nz-1).
+# @overload spline(x,y=0,z=0)
+#  @param [Float] x 
+#  @param [Float] y default=0
+#  @param [Float] z default=0
+#  @return [Float]
+def spline
+end
+
+
+# Interpolation.
+# Interpolates data by cubic spline to the given point x, y, z which assumed to be normalized in range (0, 1).
+# @overload spline1(x,y=0,z=0)
+#  @param [Float] x 
+#  @param [Float] y default=0
+#  @param [Float] z default=0
+#  @return [Float]
+def spline1
+end
+
+
+# Interpolation.
+# Interpolates data by cubic spline to the given point x in (0...nx-1), y in (0...ny-1), z in (0...nz-1). The values of derivatives at the point are saved in dif.
+# @overload spline(dif,x,y=0,z=0)
 #  @param [MglPoint] dif 
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
 #  @return [Float]
-# @overload linear(dif,x,y=0,z=0)
+def spline
+end
+
+
+# Interpolation.
+# Interpolates data by cubic spline to the given point x, y, z which assumed to be normalized in range (0, 1). The values of derivatives at the point are saved in dif.
+# @overload spline1(dif,x,y=0,z=0)
 #  @param [MglPoint] dif 
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
-#  @return [dual]
+#  @return [Float]
+def spline1
+end
+
+
+# Interpolation.
+# Interpolates data by linear function to the given point x in (0...nx-1), y in (0...ny-1), z in (0...nz-1).
+# @overload linear(x,y=0,z=0)
+#  @param [Float] x 
+#  @param [Float] y default=0
+#  @param [Float] z default=0
+#  @return [Float]
 def linear
 end
 
 
 # Interpolation.
-# Interpolates data by linear function to the given point x, y, z which assumed to be normalized in range [0, 1]. The values of derivatives at the point are saved in dif.
-# @overload linear1(dif,x,y=0,z=0)
+# Interpolates data by linear function to the given point x, y, z which assumed to be normalized in range (0, 1).
+# @overload linear1(x,y=0,z=0)
+#  @param [Float] x 
+#  @param [Float] y default=0
+#  @param [Float] z default=0
+#  @return [Float]
+def linear1
+end
+
+
+# Interpolation.
+# Interpolates data by linear function to the given point x in (0...nx-1), y in (0...ny-1), z in (0...nz-1). The values of derivatives at the point are saved in dif.
+# @overload linear(dif,x,y=0,z=0)
 #  @param [MglPoint] dif 
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
 #  @return [Float]
+def linear
+end
+
+
+# Interpolation.
+# Interpolates data by linear function to the given point x, y, z which assumed to be normalized in range (0, 1). The values of derivatives at the point are saved in dif.
 # @overload linear1(dif,x,y=0,z=0)
 #  @param [MglPoint] dif 
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
-#  @return [dual]
+#  @return [Float]
 def linear1
 end
 
@@ -1053,11 +942,6 @@ end
 # @overload print_info(fp)
 #  @param [FILE] fp 
 #  @return [nil]
-# @overload print_info()
-#  @return [String]
-# @overload print_info(fp)
-#  @param [FILE] fp 
-#  @return [nil]
 def print_info
 end
 
@@ -1070,13 +954,7 @@ end
 #  @return [long]
 # @overload get_nz()
 #  @return [long]
-# @overload get_nx()
-#  @return [long]
-# @overload get_ny()
-#  @return [long]
-# @overload get_nz()
-#  @return [long]
-def get_nz
+def get_nx
 end
 
 
@@ -1084,8 +962,6 @@ end
 # Gets maximal value of the data.
 # @overload maximal()
 #  @return [Float]
-# @overload maximal()
-#  @return [Float]
 def maximal
 end
 
@@ -1094,8 +970,6 @@ end
 # Gets minimal value of the data.
 # @overload minimal()
 #  @return [Float]
-# @overload minimal()
-#  @return [Float]
 def minimal
 end
 
@@ -1107,11 +981,6 @@ end
 #  @param [Integer] j 
 #  @param [Integer] k 
 #  @return [Float]
-# @overload minimal(i,j,k)
-#  @param [Integer] i 
-#  @param [Integer] j 
-#  @param [Integer] k 
-#  @return [Float]
 def minimal
 end
 
@@ -1123,11 +992,6 @@ end
 #  @param [Integer] j 
 #  @param [Integer] k 
 #  @return [Float]
-# @overload maximal(i,j,k)
-#  @param [Integer] i 
-#  @param [Integer] j 
-#  @param [Integer] k 
-#  @return [Float]
 def maximal
 end
 
@@ -1139,11 +1003,6 @@ end
 #  @param [Float] y 
 #  @param [Float] z 
 #  @return [Float]
-# @overload minimal(x,y,z)
-#  @param [Float] x 
-#  @param [Float] y 
-#  @param [Float] z 
-#  @return [Float]
 def minimal
 end
 
@@ -1155,424 +1014,949 @@ end
 #  @param [Float] y 
 #  @param [Float] z 
 #  @return [Float]
-# @overload maximal(x,y,z)
-#  @param [Float] x 
-#  @param [Float] y 
-#  @param [Float] z 
-#  @return [Float]
 def maximal
 end
 
 
-end # MglDataC
-
-class MglData
-
-# Data resizing.
-# Sort data rows (or slices in 3D case) by values of specified column idx (or cell (idx,idy) for 3D case). Note, this function is not thread safe!
-# @overload sort(idx,idy=-1)
-#  @param [lond] idx 
-#  @param [long] idy default=-1
-#  @return [nil]
-def sort
+# Data information.
+# Gets zero-momentum (energy, I=\sum dat_i) and write first momentum (median, a = \sum \xi_i dat_i/I), second momentum (width, w^2 = \sum (\xi_i-a)^2 dat_i/I), third momentum (skewness, s = \sum (\xi_i-a)^3 dat_i/ I w^3) and fourth momentum (kurtosis, k = \sum (\xi_i-a)^4 dat_i / 3 I w^4) to variables. Here \xi is corresponding coordinate if dir is ''x'', ''y'' or ''z''. Otherwise median is a = \sum dat_i/N, width is w^2 = \sum (dat_i-a)^2/N and so on.
+# @overload momentum(dir,a,w)
+#  @param [String] dir 
+#  @param [Float] a 
+#  @param [Float] w 
+#  @return [Float]
+# @overload momentum(dir,m,w,s,k)
+#  @param [String] dir 
+#  @param [Float] m 
+#  @param [Float] w 
+#  @param [Float] s 
+#  @param [Float] k 
+#  @return [Float]
+def momentum
 end
 
 
-# Data resizing.
-# Delete rows which values are equal to next row for given column idx.
-# @overload clean(idx)
-#  @param [lond] idx 
-#  @return [nil]
-def clean
+# Data information.
+# Find position (after specified in i, j, k) of first nonzero value of formula cond. Function return the data value at found position.
+# @overload find(cond,i,j,k)
+#  @param [String] cond 
+#  @param [Integer] i 
+#  @param [Integer] j 
+#  @param [Integer] k 
+#  @return [Float]
+def find
 end
 
 
-# Data filling.
-# Allocates memory and copies the data from the float** or double** array with dimensions N1, N2, i.e. from array defined as mreal a[N1][N2];.
-# @overload set(a,n1,n2)
-#  @param [float] a 
-#  @param [Integer] n1 
-#  @param [Integer] n2 
-#  @return [nil]
-# @overload set(a,n1,n2)
-#  @param [Float] a 
-#  @param [Integer] n1 
-#  @param [Integer] n2 
-#  @return [nil]
-def set
+# Data information.
+# Find position (before specified in i, j, k) of last nonzero value of formula cond. Function return the data value at found position.
+# @overload last(cond,i,j,k)
+#  @param [String] cond 
+#  @param [Integer] i 
+#  @param [Integer] j 
+#  @param [Integer] k 
+#  @return [Float]
+def last
 end
 
 
-# Data filling.
-# Allocates memory and copies the data from the float*** or double*** array with dimensions N1, N2, N3, i.e. from array defined as mreal a[N1][N2][N3];.
-# @overload set(a,n1,n2)
-#  @param [float] a 
-#  @param [Integer] n1 
-#  @param [Integer] n2 
-#  @return [nil]
-# @overload set(a,n1,n2)
-#  @param [Float] a 
-#  @param [Integer] n1 
-#  @param [Integer] n2 
-#  @return [nil]
-def set
+# Data information.
+# Return position of first in direction dir nonzero value of formula cond. The search is started from point (i,j,k).
+# @overload find(cond,dir,i=0,j=0,k=0)
+#  @param [String] cond 
+#  @param [String] dir 
+#  @param [Integer] i default=0
+#  @param [Integer] j default=0
+#  @param [Integer] k default=0
+#  @return [Integer]
+def find
 end
 
 
-# Data filling.
-# Fills data by 'x' or 'k' samples for Hankel ('h') or Fourier ('f') transform.
-# @overload fill_sample(how)
-#  @param [String] how 
-#  @return [nil]
-# @overload mgl_data_fill_sample(a,how)
-#  @param [HMDT] a 
-#  @param [String] how 
-#  @return [nil]
-def mgl_data_fill_sample
+# Data information.
+# Determines if any nonzero value of formula in the data array.
+# @overload find_any(cond)
+#  @param [String] cond 
+#  @return [bool]
+def find_any
 end
 
 
-# Data filling.
-# Sets value(s) of array a[i, j, k] = val. Negative indexes i, j, k=-1 set the value val to whole range in corresponding direction(s). For example, Put(val,-1,0,-1); sets a[i,0,j]=val for i=0...(nx-1), j=0...(nz-1).
-# @overload put(val,i=-1,j=-1,k=-1)
-#  @param [Float] val 
-#  @param [Integer] i default=-1
-#  @param [Integer] j default=-1
-#  @param [Integer] k default=-1
-#  @return [nil]
-# @overload mgl_data_put_val(a,val,i,j,k)
-#  @param [HMDT] a 
-#  @param [Float] val 
-#  @param [Integer] i 
-#  @param [Integer] j 
-#  @param [Integer] k 
-#  @return [nil]
-def mgl_data_put_val
+# Operators.
+# Adds the other data or the number.
+# @overload +(b)
+#  @param [MglData] b 
+#  @return [MglData]
+# @overload +(b)
+#  @param [Float] b 
+#  @return [MglData]
+def +
 end
 
 
-# Data filling.
-# Copies value(s) from array v to the range of original array. Negative indexes i, j, k=-1 set the range in corresponding direction(s). At this minor dimensions of array v should be large than corresponding dimensions of this array. For example, Put(v,-1,0,-1); sets a[i,0,j]=v.ny>nz ? v[i,j] : v[i], where i=0...(nx-1), j=0...(nz-1) and condition v.nx>=nx is true.
-# @overload put(v,i=-1,j=-1,k=-1)
-#  @param [MglData] v 
-#  @param [Integer] i default=-1
-#  @param [Integer] j default=-1
-#  @param [Integer] k default=-1
-#  @return [nil]
-def put
+# Operators.
+# Subtracts the other data or the number.
+# @overload -(b)
+#  @param [MglData] b 
+#  @return [MglData]
+# @overload -(b)
+#  @param [Float] b 
+#  @return [MglData]
+def -
 end
 
 
-# Data filling.
-# Sets the symbol ids for data columns. The string should contain one symbol 'a'...'z' per column. These ids are used in column.
-# @overload set_column_id(ids)
-#  @param [String] ids 
-#  @return [nil]
-# @overload mgl_data_set_id(a,ids)
-#  @param [HMDT] a 
-#  @param [String] ids 
+# Operators.
+# Multiplies by the other data or the number.
+# @overload *(b)
+#  @param [MglData] b 
+#  @return [MglData]
+# @overload *(b)
+#  @param [Float] b 
+#  @return [MglData]
+def *
+end
+
+
+# Operators.
+# Divides by the other data or the number.
+# @overload /(b)
+#  @param [MglData] b 
+#  @return [MglData]
+# @overload /(b)
+#  @param [Float] b 
+#  @return [MglData]
+def /
+end
+
+
+end # MglData
+
+
+# MglDataC class
+class MglDataC
+
+# Public variables.
+# Gets or sets the value in by "flat" index i without border checking. Index i should be in range (0, nx*ny*nz-1).
+# @overload get_val(i)
+#  @param [long] i 
+#  @return [Float]
+# @overload set_val(val,i)
+#  @param [Float] val 
+#  @param [long] i 
+#  @return [nil]
+def get_val
+end
+
+
+# Public variables.
+# Gets the x-, y-, z-size of the data.
+# @overload get_nx()
+#  @return [long]
+# @overload get_ny()
+#  @return [long]
+# @overload get_nz()
+#  @return [long]
+def get_nx
+end
+
+
+# Data constructor.
+# Default constructor. Allocates the memory for data array and initializes it by zero. If string eq is specified then data will be filled by corresponding formula as in fill.
+# @overload initialize(mx=1,my=1,mz=1)
+#  @param [Integer] mx default=1
+#  @param [Integer] my default=1
+#  @param [Integer] mz default=1
+#  @return [MglDataC]
+def initialize
+end
+
+
+# Data constructor.
+# Copy constructor. Allocates the memory for data array and copy values from other array. At this, if parameter eq is specified then the data will be modified by corresponding formula similarly to fill.
+# @overload initialize(dat2)
+#  @param [MglData] dat2 
+#  @return [MglDataC]
+# @overload initialize(dat2)
+#  @param [MglData] dat2 
+#  @return [MglDataC]
+# @overload initialize(size,dat2)
+#  @param [Integer] size 
+#  @param [float] dat2 
+#  @return [MglDataC]
+# @overload initialize(size,cols,dat2)
+#  @param [Integer] size 
+#  @param [Integer] cols 
+#  @param [float] dat2 
+#  @return [MglDataC]
+# @overload initialize(size,dat2)
+#  @param [Integer] size 
+#  @param [Float] dat2 
+#  @return [MglDataC]
+# @overload initialize(size,cols,dat2)
+#  @param [Integer] size 
+#  @param [Integer] cols 
+#  @param [Float] dat2 
+#  @return [MglDataC]
+# @overload initialize(size,dat2)
+#  @param [Integer] size 
+#  @param [dual] dat2 
+#  @return [MglDataC]
+# @overload initialize(size,cols,dat2)
+#  @param [Integer] size 
+#  @param [Integer] cols 
+#  @param [dual] dat2 
+#  @return [MglDataC]
+def initialize
+end
+
+
+# Data constructor.
+# Reads data from tab-separated text file with auto determining sizes of the data.
+# @overload initialize(fname)
+#  @param [String] fname 
+#  @return [MglDataC]
+def initialize
+end
+
+
+# Data resizing.
+# Creates or recreates the array with specified size and fills it by zero. This function does nothing if one of parameters mx, my, mz is zero or negative.
+# @overload create(mx,my=1,mz=1)
+#  @param [Integer] mx 
+#  @param [Integer] my default=1
+#  @param [Integer] mz default=1
+#  @return [nil]
+def create
+end
+
+
+# Data resizing.
+# Rearrange dimensions without changing data array so that resulting sizes should  be mx*my*mz < nx*ny*nz. If some of parameter my or mz are zero then it will be selected to optimal fill of data array. For example, if my=0 then it will be change to my=nx*ny*nz/mx and mz=1.
+# @overload rearrange(mx,my=0,mz=0)
+#  @param [Integer] mx 
+#  @param [Integer] my default=0
+#  @param [Integer] mz default=0
+#  @return [nil]
+def rearrange
+end
+
+
+# Data resizing.
+# Transposes (shift order of) dimensions of the data. New order of dimensions is specified in string dim. This function can be useful also after reading of one-dimensional data.
+# @overload transpose(dim="yx")
+#  @param [String] dim default="yx"
+#  @return [nil]
+def transpose
+end
+
+
+# Data resizing.
+# Increase the dimensions of the data by inserting new (|n1|+1)-th slices after (for n1>0) or before (for n1<0) of existed one. It is possible to insert 2 dimensions simultaneously for 1d data by using parameter n2. Data to new slices is copy from existed one. For example, for n1>0 new array will be
+# @overload extend(n1,n2=0)
+#  @param [Integer] n1 
+#  @param [Integer] n2 default=0
+#  @return [nil]
+def extend
+end
+
+
+# Data resizing.
+# Reduces the data size by excluding data elements which indexes are not divisible by rx, ry, rz correspondingly. Parameter smooth set to use smoothing
+# @overload squeeze(rx,ry=1,rz=1,smooth=false)
+#  @param [Integer] rx 
+#  @param [Integer] ry default=1
+#  @param [Integer] rz default=1
+#  @param [bool] smooth default=false
+#  @return [nil]
+def squeeze
+end
+
+
+# Data resizing.
+# Cuts off edges of the data i<n1 and i>n2 if n2>0 or i>n(xyz)-n2 if n2<=0 along direction dir.
+# @overload crop(n1,n2,dir='x')
+#  @param [Integer] n1 
+#  @param [Integer] n2 
+#  @param [String] dir default='x'
+#  @return [nil]
+def crop
+end
+
+
+# Data resizing.
+# Insert num slices along dir-direction at position pos and fill it by zeros.
+# @overload insert(dir,pos=0,num=1)
+#  @param [String] dir 
+#  @param [Integer] pos default=0
+#  @param [Integer] num default=1
+#  @return [nil]
+def insert
+end
+
+
+# Data resizing.
+# Delete num slices along dir-direction at position pos.
+# @overload delete(dir,pos=0,num=1)
+#  @param [String] dir 
+#  @param [Integer] pos default=0
+#  @param [Integer] num default=1
+#  @return [nil]
+def delete
+end
+
+
+# Data resizing.
+# Join data cells from vdat to dat. At this, function increase dat sizes according following: z-size for 3D data arrays arrays with equal x-,y-sizes; or y-size for 2D data arrays with equal x-sizes; or x-size otherwise.
+# @overload join(vdat)
+#  @param [MglData] vdat 
+#  @return [nil]
+def join
+end
+
+
+# Data filling.
+# Allocates memory and copies the data from the flat float* or double* array.
+# @overload set(a,nx,ny=1,nz=1)
+#  @param [float] a 
+#  @param [Integer] nx 
+#  @param [Integer] ny default=1
+#  @param [Integer] nz default=1
+#  @return [nil]
+# @overload set(a,nx,ny=1,nz=1)
+#  @param [Float] a 
+#  @param [Integer] nx 
+#  @param [Integer] ny default=1
+#  @param [Integer] nz default=1
+#  @return [nil]
+# @overload set(a,nx,ny=1,nz=1)
+#  @param [dual] a 
+#  @param [Integer] nx 
+#  @param [Integer] ny default=1
+#  @param [Integer] nz default=1
+#  @return [nil]
+def set
+end
+
+
+# Data filling.
+# Allocates memory and copies the data from the gsl_vector * structure.
+# @overload set(v)
+#  @param [gsl_vector] v 
+#  @return [nil]
+def set
+end
+
+
+# Data filling.
+# Allocates memory and copies the data from the gsl_matrix * structure.
+# @overload set(m)
+#  @param [gsl_matrix] m 
+#  @return [nil]
+def set
+end
+
+
+# Data filling.
+# Copies the data from mglData (or mglDataA) instance from.
+# @overload set(from)
+#  @param [MglData] from 
+#  @return [nil]
+def set
+end
+
+
+# Data filling.
+# Copies the data from mglData instances for real and imaginary parts of complex data arrays.
+# @overload set(re,im)
+#  @param [MglData] re 
+#  @param [MglData] im 
+#  @return [nil]
+def set
+end
+
+
+# Data filling.
+# Allocates memory and copies the data from the std::vector<T> array.
+# @overload set(d)
+#  @param [std::vector<int>] d 
+#  @return [nil]
+# @overload set(d)
+#  @param [std::vector<float>] d 
+#  @return [nil]
+# @overload set(d)
+#  @param [std::vector<double>] d 
+#  @return [nil]
+# @overload set(d)
+#  @param [std::vector<dual>] d 
+#  @return [nil]
+def set
+end
+
+
+# Data filling.
+# Allocates memory and scanf the data from the string.
+# @overload set(str,nx,ny=1,nz=1)
+#  @param [String] str 
+#  @param [Integer] nx 
+#  @param [Integer] ny default=1
+#  @param [Integer] nz default=1
+#  @return [nil]
+def set
+end
+
+
+# Data filling.
+# Links external data array, i.e. don't delete this array at exit.
+# @overload link(from)
+#  @param [MglDataC] from 
+#  @return [nil]
+# @overload link(a,nx,ny=1,nz=1)
+#  @param [dual] a 
+#  @param [Integer] nx 
+#  @param [Integer] ny default=1
+#  @param [Integer] nz default=1
+#  @return [nil]
+def link
+end
+
+
+# Data filling.
+# Equidistantly fills the data values to range (v1, v2) in direction dir=('x','y','z').
+# @overload fill(v1,v2,dir='x')
+#  @param [dual] v1 
+#  @param [dual] v2 
+#  @param [String] dir default='x'
+#  @return [nil]
+def fill
+end
+
+
+# Data filling.
+# The same as previous ones but coordinates 'x', 'y', 'z' are supposed to be normalized in range (0,1). If dim>0 is specified then modification will be fulfilled only for slices >=dim.
+# @overload modify(eq,dim=0)
+#  @param [String] eq 
+#  @param [Integer] dim default=0
+#  @return [nil]
+# @overload modify(eq,v)
+#  @param [String] eq 
+#  @param [MglData] v 
+#  @return [nil]
+# @overload modify(eq,v,w)
+#  @param [String] eq 
+#  @param [MglData] v 
+#  @param [MglData] w 
+#  @return [nil]
+def modify
+end
+
+
+# Data filling.
+# Sets the symbol ids for data columns. The string should contain one symbol 'a'...'z' per column. These ids are used in column.
+# @overload set_column_id(ids)
+#  @param [String] ids 
+#  @return [nil]
+def set_column_id
+end
+
+
+# File I/O.
+# Reads data from tab-separated text file with auto determining sizes of the data. Double newline means the beginning of new z-slice.
+# @overload read(fname)
+#  @param [String] fname 
+#  @return [bool]
+def read
+end
+
+
+# File I/O.
+# Reads data from text file with specified data sizes. This function does nothing if one of parameters mx, my or mz is zero or negative.
+# @overload read(fname,mx,my=1,mz=1)
+#  @param [String] fname 
+#  @param [Integer] mx 
+#  @param [Integer] my default=1
+#  @param [Integer] mz default=1
+#  @return [bool]
+def read
+end
+
+
+# File I/O.
+# Read data from text file with size specified at beginning of the file by first dim numbers. At this, variable dim set data dimensions.
+# @overload read_mat(fname,dim=2)
+#  @param [String] fname 
+#  @param [Integer] dim default=2
+#  @return [bool]
+def read_mat
+end
+
+
+# File I/O.
+# Join data arrays from several text files. The file names are determined by function call sprintf(fname,templ,val);, where val changes from from to to with step step. The data load one-by-one in the same slice if as_slice=false or as slice-by-slice if as_slice=true.
+# @overload read_range(templ,from,to,step=1,as_slice=false)
+#  @param [String] templ 
+#  @param [Float] from 
+#  @param [Float] to 
+#  @param [Float] step default=1
+#  @param [bool] as_slice default=false
 #  @return [nil]
-# @overload set_column_id(ids)
-#  @param [String] ids 
+def read_range
+end
+
+
+# File I/O.
+# Join data arrays from several text files which filenames satisfied the template templ (for example, templ="t_*.dat"). The data load one-by-one in the same slice if as_slice=false or as slice-by-slice if as_slice=true.
+# @overload read_all(templ,as_slice=false)
+#  @param [String] templ 
+#  @param [bool] as_slice default=false
 #  @return [nil]
-# @overload mgl_datac_set_id(a,ids)
-#  @param [HADT] a 
-#  @param [String] ids 
+def read_all
+end
+
+
+# File I/O.
+# Saves the whole data array (for ns=-1) or only ns-th slice to text file.
+# @overload save(fname,ns=-1)
+#  @param [String] fname 
+#  @param [Integer] ns default=-1
 #  @return [nil]
-def mgl_datac_set_id
+def save
 end
 
 
 # File I/O.
-# Reads data from bitmap file (now support only PNG format). The RGB values of bitmap pixels are transformed to mreal values in range [v1, v2] using color scheme scheme ().
-# @overload import(fname,scheme,v1=0,v2=1)
+# Reads data array named dname from HDF5 or HDF4 file. This function does nothing if HDF5|HDF4 was disabled during library compilation.
+# @overload read_hdf(fname,dname)
 #  @param [String] fname 
-#  @param [String] scheme 
-#  @param [Float] v1 default=0
-#  @param [Float] v2 default=1
+#  @param [String] dname 
 #  @return [nil]
-def import
+def read_hdf
 end
 
 
 # File I/O.
-# Saves data matrix (or ns-th slice for 3d data) to bitmap file (now support only PNG format). The data values are transformed from range [v1, v2] to RGB pixels of bitmap using color scheme scheme (). If v1>=v2 then the values of v1, v2 are automatically determined as minimal and maximal value of the data array.
-# @overload export(fname,scheme,v1=0,v2=0,ns=-1)
+# Saves data array named dname to HDF5 file. This function does nothing if HDF5 was disabled during library compilation.
+# @overload save_hdf(fname,dname,rewrite=false)
 #  @param [String] fname 
-#  @param [String] scheme 
-#  @param [Float] v1 default=0
-#  @param [Float] v2 default=0
-#  @param [Integer] ns default=-1
+#  @param [String] dname 
+#  @param [bool] rewrite default=false
 #  @return [nil]
-def export
+def save_hdf
+end
+
+
+# File I/O.
+# Put data names from HDF5 file fname into buf as '\t' separated fields. In MGL version the list of data names will be printed as message. This function does nothing if HDF5 was disabled during library compilation.
+# @overload datas_hdf(fname,buf,size)
+#  @param [String] fname 
+#  @param [String] buf 
+#  @param [long] size 
+#  @return [Integer]
+def datas_hdf
 end
 
 
 # Make another data.
-# Gets array which values is indexes (roots) along given direction dir, where interpolated values of data dat are equal to val. Output data will have the sizes of dat in directions transverse to dir. If data idat is provided then its values are used as starting points. This allows to find several branches by consequentive calls. Indexes are supposed to be normalized in range [0,1] (if norm=true) or in ranges [0,nx], [0,ny], [0,nz] correspondingly. 
-# @overload solve(val,dir,norm=true)
-#  @param [Float] val 
-#  @param [String] dir 
+# Extracts sub-array data from the original data array keeping fixed positive index. For example SubData(-1,2) extracts 3d row (indexes are zero based), SubData(4,-1) extracts 5th column, SubData(-1,-1,3) extracts 4th slice and so on. If argument(s) are non-integer then linear interpolation between slices is used. In MGL version this command usually is used as inline one dat(xx,yy,zz).
+# @overload sub_data(xx,yy=-1,zz=-1)
+#  @param [Float] xx 
+#  @param [Float] yy default=-1
+#  @param [Float] zz default=-1
+#  @return [MglData]
+def sub_data
+end
+
+
+# Make another data.
+# Extracts sub-array data from the original data array for indexes specified by arrays xx, yy, zz (indirect access). This function work like previous one for 1D arguments or numbers, and resulting array dimensions are equal dimensions of 1D arrays for corresponding direction. For 2D and 3D arrays in arguments, the resulting array have the same dimensions as input arrays. The dimensions of all argument must be the same (or to be scalar 1*1*1) if they are 2D or 3D arrays. In MGL version this command usually is used as inline one dat(xx,yy,zz).
+# @overload sub_data(xx,yy,zz)
+#  @param [MglData] xx 
+#  @param [MglData] yy 
+#  @param [MglData] zz 
+#  @return [MglData]
+def sub_data
+end
+
+
+# Make another data.
+# Get column (or slice) of the data filled by formula eq on column ids. For example, Column("n*w^2/exp(t)");. The column ids must be defined first by idset function or read from files. In MGL version this command usually is used as inline one dat('eq').
+# @overload column(eq)
+#  @param [String] eq 
+#  @return [MglData]
+def column
+end
+
+
+# Make another data.
+# Resizes the data to new size mx, my, mz from box (part) (x1,x2) x (y1,y2) x (z1,z2) of original array. Initially x,y,z coordinates are supposed to be in (0,1).
+# @overload resize(mx,my=1,mz=1,x1=0,x2=1,y1=0,y2=1,z1=0,z2=1)
+#  @param [Integer] mx 
+#  @param [Integer] my default=1
+#  @param [Integer] mz default=1
+#  @param [Float] x1 default=0
+#  @param [Float] x2 default=1
+#  @param [Float] y1 default=0
+#  @param [Float] y2 default=1
+#  @param [Float] z1 default=0
+#  @param [Float] z2 default=1
+#  @return [MglData]
+def resize
+end
+
+
+# Make another data.
+# Gets array which values is result of interpolation of original array for coordinates from other arrays. All dimensions must be the same for data idat, jdat, kdat. Coordinates from idat, jdat, kdat are supposed to be normalized in range (0,1) (if norm=true) or in ranges (0,nx), (0,ny), (0,nz) correspondingly.
+# @overload evaluate(idat,norm=true)
+#  @param [MglData] idat 
 #  @param [bool] norm default=true
 #  @return [MglData]
-# @overload solve(val,dir,idat,norm=true)
-#  @param [Float] val 
-#  @param [String] dir 
+# @overload evaluate(idat,jdat,norm=true)
+#  @param [MglData] idat 
+#  @param [MglData] jdat 
+#  @param [bool] norm default=true
+#  @return [MglData]
+# @overload evaluate(idat,jdat,kdat,norm=true)
 #  @param [MglData] idat 
+#  @param [MglData] jdat 
+#  @param [MglData] kdat 
 #  @param [bool] norm default=true
 #  @return [MglData]
-def solve
+def evaluate
 end
 
 
 # Make another data.
-# Find roots of equation 'func'=0 for variable var with initial guess ini. Secant method is used for root finding.
-# @overload roots(func,var)
-#  @param [String] func 
-#  @param [String] var 
+# Creates n-th points distribution of the data values in range (v1, v2). Array w specifies weights of the data elements (by default is 1). Parameter nsub define the number of additional interpolated points (for smoothness of histogram). See also Data manipulation
+# @overload hist(n,v1=0,v2=1,nsub=0)
+#  @param [Integer] n 
+#  @param [Float] v1 default=0
+#  @param [Float] v2 default=1
+#  @param [Integer] nsub default=0
 #  @return [MglData]
-def roots
+# @overload hist(w,n,v1=0,v2=1,nsub=0)
+#  @param [MglData] w 
+#  @param [Integer] n 
+#  @param [Float] v1 default=0
+#  @param [Float] v2 default=1
+#  @param [Integer] nsub default=0
+#  @return [MglData]
+def hist
+end
+
+
+# Make another data.
+# Gets momentum (1d-array) of the data along direction dir. String how contain kind of momentum. The momentum is defined like as
+# if dir='z' and so on. Coordinates 'x', 'y', 'z' are data indexes normalized in range (0,1).
+# @overload momentum(dir,how)
+#  @param [String] dir 
+#  @param [String] how 
+#  @return [MglData]
+def momentum
+end
+
+
+# Make another data.
+# Gets array which is the result of summation in given direction or direction(s).
+# @overload sum(dir)
+#  @param [String] dir 
+#  @return [MglData]
+def sum
+end
+
+
+# Make another data.
+# Gets array which is the maximal data values in given direction or direction(s).
+# @overload max(dir)
+#  @param [String] dir 
+#  @return [MglData]
+def max
+end
+
+
+# Make another data.
+# Gets array which is the maximal data values in given direction or direction(s).
+# @overload min(dir)
+#  @param [String] dir 
+#  @return [MglData]
+def min
+end
+
+
+# Make another data.
+# Returns direct multiplication of arrays (like, res(i,j) = this(i)*a(j) and so on).
+# @overload combine(a)
+#  @param [MglData] a 
+#  @return [MglData]
+def combine
+end
+
+
+# Make another data.
+# Gets array of diagonal elements a(i,i) (for 2D case) or a(i,i,i) (for 3D case) where i=0...nx-1. Function return copy of itself for 1D case. Data array must have dimensions ny,nz >= nx or ny,nz = 1.
+# @overload trace()
+#  @return [MglData]
+def trace
+end
+
+
+# Make another data.
+# Gets array of real parts of the data.
+# @overload real()
+#  @return [MglData]
+def real
+end
+
+
+# Make another data.
+# Gets array of imaginary parts of the data.
+# @overload imag()
+#  @return [MglData]
+def imag
+end
+
+
+# Make another data.
+# Gets array of absolute values of the data.
+# @overload abs()
+#  @return [MglData]
+def abs
+end
+
+
+# Make another data.
+# Gets array of arguments of the data.
+# @overload arg()
+#  @return [MglData]
+def arg
+end
+
+
+# Data changing.
+# Cumulative summation of the data in given direction or directions.
+# @overload cum_sum(dir)
+#  @param [String] dir 
+#  @return [nil]
+def cum_sum
+end
+
+
+# Data changing.
+# Integrates (like cumulative summation) the data in given direction or directions.
+# @overload integral(dir)
+#  @param [String] dir 
+#  @return [nil]
+def integral
+end
+
+
+# Data changing.
+# Differentiates the data in given direction or directions.
+# @overload diff(dir)
+#  @param [String] dir 
+#  @return [nil]
+def diff
 end
 
 
 # Data changing.
-# Differentiates the data specified parametrically in direction x with y, z=constant. Parametrical differentiation uses the formula (for 2D case):  where  denotes usual differentiation along 1st and 2nd dimensions. The similar formula is used for 3D case. Note, that you may change the order of arguments -- for example, if you have 2D data a(i,j) which depend on coordinates (x(i,j), y(i,j)) then usual derivative along  will be Diff(x,y); and usual derivative along  will be Diff(y,x);.
-# @overload diff(x,y)
-#  @param [MglData] x 
-#  @param [MglData] y 
-#  @return [nil]
-# @overload diff(x,y,z)
-#  @param [MglData] x 
-#  @param [MglData] y 
-#  @param [MglData] z 
+# Double-differentiates (like Laplace operator) the data in given direction.
+# @overload diff2(dir)
+#  @param [String] dir 
 #  @return [nil]
-def diff
+def diff2
 end
 
 
 # Data changing.
-# Do Sine transform of the data in given direction or directions. The Sine transform is  (see ).
-# @overload sin_fft(dir)
+# Do Fourier transform of the data in given direction or directions. If dir contain 'i' then inverse Fourier is used. The Fourier transform is \sum a_j \exp(i k j) (see http://en.wikipedia.org/wiki/Discrete_Fourier_transform).
+# @overload fft(dir)
 #  @param [String] dir 
 #  @return [nil]
-def sin_fft
+def fft
 end
 
 
 # Data changing.
-# Do Cosine transform of the data in given direction or directions. The Cosine transform is  (see ).
-# @overload cos_fft(dir)
+# Do Hankel transform of the data in given direction or directions. The Hankel transform is \sum a_j J_0(k j) (see http://en.wikipedia.org/wiki/Hankel_transform).
+# @overload hankel(dir)
 #  @param [String] dir 
 #  @return [nil]
-def cos_fft
+def hankel
 end
 
 
 # Data changing.
-# Remove value steps (like phase jumps after inverse trigonometric functions) with period da in given direction.
-# @overload sew(dir,m_pi)
+# Swaps the left and right part of the data in given direction (useful for Fourier spectrum).
+# @overload swap(dir)
 #  @param [String] dir 
-#  @param [mreal da=2] m_pi 
 #  @return [nil]
-def sew
+def swap
 end
 
 
 # Data changing.
-# Find envelop for data values along direction dir.
-# @overload envelop(dir='x')
-#  @param [String] dir default='x'
+# Rolls the data along direction dir. Resulting array will be out(i) = ini((i+num)%nx) if dir='x'.
+# @overload roll(dir,error)
+#  @param [String] dir 
+#  @param [unknown] error 
 #  @return [nil]
-def envelop
+def roll
 end
 
 
 # Data changing.
-# Normalizes the data to range [v1,v2]. If flag sym=true then symmetrical interval [-max(|v1|,|v2|), max(|v1|,|v2|)] is used. Modification will be applied only for slices >=dim.
-# @overload norm(v1=0,v2=1,sym=false,dim=0)
-#  @param [Float] v1 default=0
-#  @param [Float] v2 default=1
-#  @param [bool] sym default=false
-#  @param [Integer] dim default=0
+# Mirror the left-to-right part of the data in given direction. Looks like change the value index i->n-i. Note, that the similar effect in graphics you can reach by using options (Command options), for example, surf dat; xrange 1 -1.
+# @overload mirror(dir)
+#  @param [String] dir 
 #  @return [nil]
-def norm
+def mirror
 end
 
 
 # Data changing.
-# Normalizes data slice-by-slice along direction dir the data in slices to range [v1,v2]. If flag sym=true then symmetrical interval [-max(|v1|,|v2|), max(|v1|,|v2|)] is used. If keep_en is set then maximal value of k-th slice will be limited by
-# @overload norm_sl(v1=0,v2=1,dir='z',keep_en=true,sym=false)
-#  @param [Float] v1 default=0
-#  @param [Float] v2 default=1
-#  @param [String] dir default='z'
-#  @param [bool] keep_en default=true
-#  @param [bool] sym default=false
+# Smooths the data on specified direction or directions. String dirs specifies the dimensions which will be smoothed. It may contain characters: 'x' for 1st dimension, 'y' for 2nd dimension, 'z' for 3d dimension. If string dir contain: '0' then does nothing, '3' -- linear averaging over 3 points, '5' -- linear averaging over 5 points. By default quadratic averaging over 5 points is used.
+# @overload smooth(dir="xyz",delta=0)
+#  @param [String] dir default="xyz"
+#  @param [Float] delta default=0
 #  @return [nil]
-def norm_sl
+def smooth
 end
 
 
 # Interpolation.
-# Interpolates data by cubic spline to the given point x in [0...nx-1], y in [0...ny-1], z in [0...nz-1].
-# @overload spline(x,y=0,z=0)
+# Interpolates data by linear function to the given point x in (0...nx-1), y in (0...ny-1), z in (0...nz-1).
+# @overload linear(x,y=0,z=0)
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
-#  @return [Float]
-def spline
+#  @return [dual]
+def linear
 end
 
 
 # Interpolation.
-# Interpolates data by cubic spline to the given point x, y, z which assumed to be normalized in range [0, 1].
-# @overload spline1(x,y=0,z=0)
+# Interpolates data by linear function to the given point x, y, z which assumed to be normalized in range (0, 1).
+# @overload linear1(x,y=0,z=0)
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
-#  @return [Float]
-def spline1
+#  @return [dual]
+def linear1
 end
 
 
 # Interpolation.
-# Interpolates data by cubic spline to the given point x in [0...nx-1], y in [0...ny-1], z in [0...nz-1]. The values of derivatives at the point are saved in dif.
-# @overload spline(dif,x,y=0,z=0)
+# Interpolates data by linear function to the given point x in (0...nx-1), y in (0...ny-1), z in (0...nz-1). The values of derivatives at the point are saved in dif.
+# @overload linear(dif,x,y=0,z=0)
 #  @param [MglPoint] dif 
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
-#  @return [Float]
-def spline
+#  @return [dual]
+def linear
 end
 
 
 # Interpolation.
-# Interpolates data by cubic spline to the given point x, y, z which assumed to be normalized in range [0, 1]. The values of derivatives at the point are saved in dif.
-# @overload spline1(dif,x,y=0,z=0)
+# Interpolates data by linear function to the given point x, y, z which assumed to be normalized in range (0, 1). The values of derivatives at the point are saved in dif.
+# @overload linear1(dif,x,y=0,z=0)
 #  @param [MglPoint] dif 
 #  @param [Float] x 
 #  @param [Float] y default=0
 #  @param [Float] z default=0
-#  @return [Float]
-def spline1
+#  @return [dual]
+def linear1
 end
 
 
 # Data information.
-# Gets zero-momentum (energy, ) and write first momentum (median, ), second momentum (width, ), third momentum (skewness, ) and fourth momentum (kurtosis, ) to variables. Here  is corresponding coordinate if dir is ,  or . Otherwise median is , width is  and so on.
-# @overload momentum(dir,a,w)
-#  @param [String] dir 
-#  @param [Float] a 
-#  @param [Float] w 
-#  @return [Float]
-# @overload momentum(dir,m,w,s,k)
-#  @param [String] dir 
-#  @param [Float] m 
-#  @param [Float] w 
-#  @param [Float] s 
-#  @param [Float] k 
-#  @return [Float]
-def momentum
+# Gets or prints to file fp or as message (in MGL) information about the data (sizes, maximum/minimum, momentums and so on).
+# @overload print_info()
+#  @return [String]
+# @overload print_info(fp)
+#  @param [FILE] fp 
+#  @return [nil]
+def print_info
 end
 
 
 # Data information.
-# Find position (after specified in i, j, k) of first nonzero value of formula cond. Function return the data value at found position.
-# @overload find(cond,i,j,k)
-#  @param [String] cond 
-#  @param [Integer] i 
-#  @param [Integer] j 
-#  @param [Integer] k 
-#  @return [Float]
-def find
+# Gets the x-, y-, z-size of the data.
+# @overload get_nx()
+#  @return [long]
+# @overload get_ny()
+#  @return [long]
+# @overload get_nz()
+#  @return [long]
+def get_nx
 end
 
 
 # Data information.
-# Find position (before specified in i, j, k) of last nonzero value of formula cond. Function return the data value at found position.
-# @overload last(cond,i,j,k)
-#  @param [String] cond 
-#  @param [Integer] i 
-#  @param [Integer] j 
-#  @param [Integer] k 
+# Gets maximal value of the data.
+# @overload maximal()
 #  @return [Float]
-def last
+def maximal
 end
 
 
 # Data information.
-# Return position of first in direction dir nonzero value of formula cond. The search is started from point (i,j,k).
-# @overload find(cond,dir,i=0,j=0,k=0)
-#  @param [String] cond 
-#  @param [String] dir 
-#  @param [Integer] i default=0
-#  @param [Integer] j default=0
-#  @param [Integer] k default=0
-#  @return [Integer]
-def find
+# Gets minimal value of the data.
+# @overload minimal()
+#  @return [Float]
+def minimal
 end
 
 
 # Data information.
-# Determines if any nonzero value of formula in the data array.
-# @overload find_any(cond)
-#  @param [String] cond 
-#  @return [bool]
-def find_any
+# Gets position of minimum to variables i, j, k and returns the minimal value.
+# @overload minimal(i,j,k)
+#  @param [Integer] i 
+#  @param [Integer] j 
+#  @param [Integer] k 
+#  @return [Float]
+def minimal
 end
 
 
-# Operators.
-# Adds the other data or the number.
-# @overload +(b)
-#  @param [MglData] b 
-#  @return [MglData]
-# @overload +(b)
-#  @param [Float] b 
-#  @return [MglData]
-def +
+# Data information.
+# Gets position of maximum to variables i, j, k and returns the maximal value.
+# @overload maximal(i,j,k)
+#  @param [Integer] i 
+#  @param [Integer] j 
+#  @param [Integer] k 
+#  @return [Float]
+def maximal
 end
 
 
-# Operators.
-# Subtracts the other data or the number.
-# @overload -(b)
-#  @param [MglData] b 
-#  @return [MglData]
-# @overload -(b)
-#  @param [Float] b 
-#  @return [MglData]
-def -
+# Data information.
+# Gets approximated (interpolated) position of minimum to variables x, y, z and returns the minimal value.
+# @overload minimal(x,y,z)
+#  @param [Float] x 
+#  @param [Float] y 
+#  @param [Float] z 
+#  @return [Float]
+def minimal
 end
 
 
-# Operators.
-# Multiplies by the other data or the number.
-# @overload *(b)
-#  @param [MglData] b 
-#  @return [MglData]
-# @overload *(b)
-#  @param [Float] b 
-#  @return [MglData]
-def *
+# Data information.
+# Gets approximated (interpolated) position of maximum to variables x, y, z and returns the maximal value.
+# @overload maximal(x,y,z)
+#  @param [Float] x 
+#  @param [Float] y 
+#  @param [Float] z 
+#  @return [Float]
+def maximal
 end
 
 
-# Operators.
-# Divides by the other data or the number.
-# @overload /(b)
-#  @param [MglData] b 
-#  @return [MglData]
-# @overload /(b)
-#  @param [Float] b 
-#  @return [MglData]
-def /
-end
-
+end # MglDataC
 
-end # MglData
 
-class MglExprC
+# MglExpr class
+class MglExpr
 
 # Evaluate expression.
 # Evaluates the formula for 'x','r'=x, 'y','n'=y, 'z','t'=z, 'a','u'=u.
@@ -1581,31 +1965,19 @@ class MglExprC
 #  @param [Float] y 
 #  @param [Float] z 
 #  @return [Float]
-# @overload eval(x,y,z)
-#  @param [dual] x 
-#  @param [dual] y 
-#  @param [dual] z 
-#  @return [dual]
 def eval
 end
 
 
 # Evaluate expression.
-# Evaluates the formula for variables in array var[0,...,'z'-'a'].
-# @overload eval(var)
-#  @param [Float] var 
-#  @return [Float]
-# @overload eval(var)
-#  @param [dual] var 
-#  @return [dual]
-def eval
+# Evaluates the formula for variables in array var(0,...,'z'-'a').
+# @overload var(error)
+#  @param [unknown] error 
+#  @return [mreal Eval (mreal]
+def var
 end
 
 
-end # MglExprC
-
-class MglExpr
-
 # Evaluate expression.
 # Evaluates the formula derivation respect to dir for 'x','r'=x, 'y','n'=y, 'z','t'=z, 'a','u'=u.
 # @overload diff(dir,x,y,z)
@@ -1619,17 +1991,44 @@ end
 
 
 # Evaluate expression.
-# Evaluates the formula derivation respect to dir for variables in array var[0,...,'z'-'a'].
-# @overload diff(dir,var)
-#  @param [String] dir 
-#  @param [Float] var 
-#  @return [Float]
-def diff
+# Evaluates the formula derivation respect to dir for variables in array var(0,...,'z'-'a').
+# @overload var(error)
+#  @param [unknown] error 
+#  @return [mreal Diff (char dir, mreal]
+def var
 end
 
 
 end # MglExpr
 
+
+# MglExprC class
+class MglExprC
+
+# Evaluate expression.
+# Evaluates the formula for 'x','r'=x, 'y','n'=y, 'z','t'=z, 'a','u'=u.
+# @overload eval(x,y,z)
+#  @param [dual] x 
+#  @param [dual] y 
+#  @param [dual] z 
+#  @return [dual]
+def eval
+end
+
+
+# Evaluate expression.
+# Evaluates the formula for variables in array var(0,...,'z'-'a').
+# @overload var(error)
+#  @param [unknown] error 
+#  @return [dual Eval (dual]
+def var
+end
+
+
+end # MglExprC
+
+
+# MglVar class
 class MglVar
 
 # MGL variables.