Next: , Previous: , Up: Data processing   [Contents][Index]


7.4 Data filling

MGL command: list DAT v1 ...

Creates new variable with name dat and fills it by numeric values of command arguments v1 .... Command can create one-dimensional and two-dimensional arrays with arbitrary values. For creating 2d array the user should use delimiter ‘|’ which means that the following values lie in next row. Array sizes are [maximal of row sizes * number of rows]. For example, command list 1 | 2 3 creates the array [1 0; 2 3]. Note, that the maximal number of arguments is 1000.

MGL command: list DAT d1 ...

Creates new variable with name dat and fills it by data values of arrays of command arguments d1 .... Command can create two-dimensional or three-dimensional (if arrays in arguments are 2d arrays) arrays with arbitrary values. Minor dimensions of all arrays in arguments should be equal to dimensions of first array d1. In the opposite case the argument will be ignored. Note, that the maximal number of arguments is 1000.

Method on mglData: void Set (const float *A, int NX, int NY=1, int NZ=1)
Method on mglData: void Set (const double *A, int NX, int NY=1, int NZ=1)
C function: void mgl_data_set_float (HMDT dat, const mreal *A, int NX, int NY, int NZ)
C function: void mgl_data_set_double (HMDT dat, const double *A, int NX, int NY, int NZ)
Method on mglDataC: void Set (const float *A, int NX, int NY=1, int NZ=1)
Method on mglDataC: void Set (const double *A, int NX, int NY=1, int NZ=1)
Method on mglDataC: void Set (const dual *A, int NX, int NY=1, int NZ=1)
C function: void mgl_datac_set_float (HADT dat, const mreal *A, int NX, int NY, int NZ)
C function: void mgl_datac_set_double (HADT dat, const double *A, int NX, int NY, int NZ)
C function: void mgl_datac_set_complex (HADT dat, const dual *A, int NX, int NY, int NZ)

Allocates memory and copies the data from the flat float* or double* array.

Method on mglData: void Set (const float **A, int N1, int N2)
Method on mglData: void Set (const double **A, int N1, int N2)
C function: void mgl_data_set_mreal2 (HMDT dat, const mreal **A, int N1, int N2)
C function: void mgl_data_set_double2 (HMDT dat, const double **A, int N1, int N2)

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];.

Method on mglData: void Set (const float ***A, int N1, int N2)
Method on mglData: void Set (const double ***A, int N1, int N2)
C function: void mgl_data_set_mreal3 (HMDT dat, const mreal ***A, int N1, int N2)
C function: void mgl_data_set_double3 (HMDT dat, const double ***A, int N1, int N2)

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];.

Method on mglData: void Set (gsl_vector *v)
Method on mglDataC: void Set (gsl_vector *v)
C function: void mgl_data_set_vector (HMDT dat, gsl_vector *v)
C function: void mgl_datac_set_vector (HADT dat, gsl_vector *v)

Allocates memory and copies the data from the gsl_vector * structure.

Method on mglData: void Set (gsl_matrix *m)
Method on mglDataC: void Set (gsl_matrix *m)
C function: void mgl_data_set_matrix (HMDT dat, gsl_matrix *m)
C function: void mgl_datac_set_matrix (HADT dat, gsl_matrix *m)

Allocates memory and copies the data from the gsl_matrix * structure.

Method on mglData: void Set (const mglDataA &from)
Method on mglData: void Set (HCDT from)
C function: void mgl_data_set (HMDT dat, HCDT from)
Method on mglDataC: void Set (const mglDataA &from)
Method on mglDataC: void Set (HCDT from)
C function: void mgl_datac_set (HADT dat, HCDT from)

Copies the data from mglData (or mglDataA) instance from.

Method on mglDataC: void Set (const mglDataA &re, const mglDataA &im)
Method on mglDataC: void Set (HCDT re, HCDT im)
Method on mglDataC: void SetAmpl (HCDT ampl, const mglDataA &phase)
C function: void mgl_datac_set_ri (HADT dat, HCDT re, HCDT im)
C function: void mgl_datac_set_ap (HADT dat, HCDT ampl, HCDT phase)

Copies the data from mglData instances for real and imaginary parts of complex data arrays.

Method on mglData: void Set (const std::vector<int> &d)
Method on mglDataC: void Set (const std::vector<int> &d)
Method on mglData: void Set (const std::vector<float> &d)
Method on mglDataC: void Set (const std::vector<float> &d)
Method on mglData: void Set (const std::vector<double> &d)
Method on mglDataC: void Set (const std::vector<double> &d)
Method on mglDataC: void Set (const std::vector<dual> &d)

Allocates memory and copies the data from the std::vector<T> array.

Method on mglData: void Set (const char *str, int NX, int NY=1, int NZ=1)
C function: void mgl_data_set_values (const char *str, int NX, int NY, int NZ)
Method on mglDataC: void Set (const char *str, int NX, int NY=1, int NZ=1)
C function: void mgl_datac_set_values (const char *str, int NX, int NY, int NZ)

Allocates memory and scanf the data from the string.

Method on mglData: void SetList (long n, ...)

Allocate memory and set data from variable argument list of double values. Note, you need to specify decimal point ‘.’ for integer values! For example, the code SetList(2,0.,1.); is correct, but the code SetList(2,0,1); is incorrect.

Method on mglData: void Link (mglData &from)
Method on mglData: void Link (mreal *A, int NX, int NY=1, int NZ=1)
C function: void mgl_data_link (HMDT dat, mreal *A, int NX, int NY, int NZ)
Method on mglDataC: void Link (mglDataC &from)
Method on mglDataC: void Link (dual *A, int NX, int NY=1, int NZ=1)
C function: void mgl_datac_link (HADT dat, dual *A, int NX, int NY, int NZ)

Links external data array, i.e. don’t delete this array at exit.

MGL command: var DAT num v1 [v2=nan]

Creates new variable with name dat for one-dimensional array of size num. Array elements are equidistantly distributed in range [v1, v2]. If v2=nan then v2=v1 is used.

MGL command: fill dat v1 v2 ['dir'='x']
Method on mglData: void Fill (mreal v1, mreal v2, char dir='x')
Method on mglDataC: void Fill (dual v1, dual v2, char dir='x')
C function: void mgl_data_fill (HMDT dat, mreal v1, mreal v2, char dir)
C function: void mgl_datac_fill (HADT dat, dual v1, dual v2, char dir)

Equidistantly fills the data values to range [v1, v2] in direction dir={‘x’,‘y’,‘z’}.

MGL command: fill dat 'eq'
MGL command: fill dat 'eq' vdat
MGL command: fill dat 'eq' vdat wdat
Method on mglData: void Fill (HMGL gr, const char *eq, const char *opt="")
Method on mglData: void Fill (HMGL gr, const char *eq, const mglDataA &vdat, const char *opt="")
Method on mglData: void Fill (HMGL gr, const char *eq, const mglDataA &vdat, const mglDataA &wdat, const char *opt="")
Method on mglDataC: void Fill (HMGL gr, const char *eq, const char *opt="")
Method on mglDataC: void Fill (HMGL gr, const char *eq, const mglDataA &vdat, const char *opt="")
Method on mglDataC: void Fill (HMGL gr, const char *eq, const mglDataA &vdat, const mglDataA &wdat, const char *opt="")
C function: void mgl_data_fill_eq (HMGL gr, HMDT dat, const char *eq, HCDT vdat, HCDT wdat, const char *opt)
C function: void mgl_datac_fill_eq (HMGL gr, HADT dat, const char *eq, HCDT vdat, HCDT wdat, const char *opt)

Fills the value of array according to the formula in string eq. Formula is an arbitrary expression depending on variables ‘x’, ‘y’, ‘z’, ‘u’, ‘v’, ‘w’. Coordinates ‘x’, ‘y’, ‘z’ are supposed to be normalized in axis range of canvas gr (in difference from Modify functions). Variable ‘u’ is the original value of the array. Variables ‘v’ and ‘w’ are values of vdat, wdat which can be NULL (i.e. can be omitted).

MGL command: modify dat 'eq' [dim=0]
MGL command: modify dat 'eq' vdat
MGL command: modify dat 'eq' vdat wdat
Method on mglData: void Modify (const char *eq, int dim=0)
Method on mglData: void Modify (const char *eq, const mglDataA &v)
Method on mglData: void Modify (const char *eq, const mglDataA &v, const mglDataA &w)
Method on mglDataC: void Modify (const char *eq, int dim=0)
Method on mglDataC: void Modify (const char *eq, const mglDataA &v)
Method on mglDataC: void Modify (const char *eq, const mglDataA &v, const mglDataA &w)
C function: void mgl_data_modify (HMDT dat, const char *eq, int dim)
C function: void mgl_data_modify_vw (HMDT dat, const char *eq, HCDT v, HCDT w)
C function: void mgl_datac_modify (HADT dat, const char *eq, int dim)
C function: void mgl_datac_modify_vw (HADT dat, const char *eq, HCDT v, HCDT w)

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.

MGL command: fillsample dat 'how'
Method on mglData: void FillSample (const char *how)
C function: void mgl_data_fill_sample (HMDT a, const char *how)

Fills data by ’x’ or ’k’ samples for Hankel (’h’) or Fourier (’f’) transform.

MGL command: datagrid dat xdat ydat zdat
Method on mglData: mglData Grid (HMGL gr, const mglDataA &x, const mglDataA &y, const mglDataA &z, const char *opt="")
Method on mglData: mglData Grid (const mglDataA &x, const mglDataA &y, const mglDataA &z, mglPoint p1, mglPoint p2)
C function: void mgl_data_grid (HMGL gr, HMDT u, HCDT x, HCDT y, HCDT z, const char *opt)
C function: void mgl_data_grid_xy (HMDT u, HCDT x, HCDT y, HCDT z, mreal x1, mreal x2, mreal y1, mreal y2)

Fills the value of array according to the linear interpolation of triangulated surface assuming x-,y-coordinates equidistantly distributed in axis range (or in range [x1,x2]*[y1,y2]). Triangulated surface is found for arbitrary placed points ‘x’, ‘y’, ‘z’. NAN value is used for grid points placed outside of triangulated surface. See Making regular data, for sample code and picture.

MGL command: put dat val [i=: j=: k=:]
Method on mglData: void Put (mreal val, int i=-1, int j=-1, int k=-1)
Method on mglDataC: void Put (dual val, int i=-1, int j=-1, int k=-1)
C function: void mgl_data_put_val (HMDT a, mreal val, int i, int j, int k)
C function: void mgl_datac_put_val (HADT a, dual val, int i, int j, int k)

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).

MGL command: put dat vdat [i=: j=: k=:]
Method on mglData: void Put (const mglDataA &v, int i=-1, int j=-1, int k=-1)
Method on mglDataC: void Put (const mglDataA &v, int i=-1, int j=-1, int k=-1)
C function: void mgl_data_put_dat (HMDT a, HCDT v, int i, int j, int k)
C function: void mgl_datac_put_dat (HADT a, HCDT v, int i, int j, int k)

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.

MGL command: refill dat xdat vdat [sl=-1]
MGL command: refill dat xdat ydat vdat [sl=-1]
MGL command: refill dat xdat ydat zdat vdat
Method on mglData: void Refill (const mglDataA &x, const mglDataA &v, mreal x1, mreal x2, long sl=-1)
Method on mglData: void Refill (const mglDataA &x, const mglDataA &v, mglPoint p1, mglPoint p2, long sl=-1)
Method on mglData: void Refill (const mglDataA &x, const mglDataA &y, const mglDataA &v, mglPoint p1, mglPoint p2, long sl=-1)
Method on mglData: void Refill (const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &v, mglPoint p1, mglPoint p2)
Method on mglData: void Refill (HMGL gr, const mglDataA &x, const mglDataA &v, long sl=-1, const char *opt="")
Method on mglData: void Refill (HMGL gr, const mglDataA &x, const mglDataA &y, const mglDataA &v, long sl=-1, const char *opt="")
Method on mglData: void Refill (HMGL gr, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &v, const char *opt="")
C function: void mgl_data_refill_x (HMDT a, HCDT x, HCDT v, mreal x1, mreal x2, long sl)
C function: void mgl_data_refill_xy (HMDT a, HCDT x, HCDT y, HCDT v, mreal x1, mreal x2, mreal y1, mreal y2, long sl)
C function: void mgl_data_refill_xyz (HMDT a, HCDT x, HCDT y, HCDT z, HCDT v, mreal x1, mreal x2, mreal y1, mreal y2, mreal z1, mreal z2)
C function: void mgl_data_refill_gr (HMGL gr, HMDT a, HCDT x, HCDT y, HCDT z, HCDT v, long sl, const char *opt)

Fills by interpolated values of array v at the point {x, y, z}={X[i], Y[j], Z[k]} (or {x, y, z}={X[i,j,k], Y[i,j,k], Z[i,j,k]} if x, y, z are not 1d arrays), where X,Y,Z are equidistantly distributed in range [x1,x2]*[y1,y2]*[z1,z2] and have the same sizes as this array. If parameter sl is 0 or positive then changes will be applied only for slice sl.

MGL command: gspline dat xdat vdat [sl=-1]
Method on mglData: void RefillGS (const mglDataA &x, const mglDataA &v, mreal x1, mreal x2, long sl=-1)
C function: void mgl_data_refill_gs (HMDT a, HCDT x, HCDT v, mreal x1, mreal x2, long sl)

Fills by global cubic spline values of array v at the point x=X[i], where X are equidistantly distributed in range [x1,x2] and have the same sizes as this array. If parameter sl is 0 or positive then changes will be applied only for slice sl.

MGL command: idset dat 'ids'
Method on mglData: void SetColumnId (const char *ids)
Method on mglDataC: void SetColumnId (const char *ids)
C function: void mgl_data_set_id (HMDT a, const char *ids)
C function: void mgl_datac_set_id (HADT a, const char *ids)

Sets the symbol ids for data columns. The string should contain one symbol ’a’...’z’ per column. These ids are used in column.





Next: , Previous: , Up: Data processing   [Contents][Index]