mathgl 0.0.5 → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.gitignore +1 -0
- data/README.md +3 -2
- data/ext/mathgl/data.i +507 -0
- data/ext/mathgl/depend +1 -1
- data/ext/mathgl/mathgl.cxx +70062 -60001
- data/ext/mathgl/mathgl.i +12 -13
- data/ext/mathgl/mgl.i +1349 -0
- data/ext/mathgl/type.i +100 -0
- data/lib/mathgl/version.rb +1 -1
- data/mathgl.gemspec +1 -1
- data/misc/Rakefile +2 -2
- data/misc/conv_texi.rb +10 -7
- data/setup.rb +9 -6
- metadata +12 -9
- data/misc/lib/mathgl/libdoc_core_en.rb +0 -4271
- data/misc/lib/mathgl/libdoc_data_en.rb +0 -1364
- data/misc/lib/mathgl/libdoc_other_en.rb +0 -215
- data/misc/lib/mathgl/libdoc_parse_en.rb +0 -175
- data/misc/lib/mathgl/libdoc_window_en.rb +0 -38
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 88f676dd949dc3aad0984447f5a44be418f235a4
|
|
4
|
+
data.tar.gz: 7884864681617c80757b14e494c0cf5ebf0f7841
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: e4fdc6f900da1cdd5e7df788d559bd83a59d2679fdd28350fa41f5c0cc77c39fa6a7097388c6508805266e50db4f76556c69e69b7bb099eea240efe656574bb4
|
|
7
|
+
data.tar.gz: 226c6f868654dca0b0cafdc916667c31352c6f4ba2ab518bd4e9ea4eb8c45ee94b0d00eadcb971be88f80c7e3f506b6328fa0da1b9410a4dfd09ad53abd14967
|
data/.gitignore
CHANGED
data/README.md
CHANGED
|
@@ -7,6 +7,7 @@ MathGL is a library for scientific data visualization developed by Alexey Balaki
|
|
|
7
7
|
(This package is under construction.)
|
|
8
8
|
|
|
9
9
|
- [Plot Samples](https://github.com/masa16/ruby-mathgl-sample)
|
|
10
|
+
([Single page](https://github.com/masa16/ruby-mathgl-sample/blob/master/single_page/README.md))
|
|
10
11
|
- [API Document](http://masa16.github.io/ruby-mathgl/doc/frames.html)
|
|
11
12
|
- [GitHub](https://github.com/masa16/ruby-mathgl)
|
|
12
13
|
- [RubyGems](https://rubygems.org/gems/mathgl)
|
|
@@ -27,7 +28,7 @@ MathGL is a library for scientific data visualization developed by Alexey Balaki
|
|
|
27
28
|
|
|
28
29
|
## Usage
|
|
29
30
|
|
|
30
|
-
Write to PNG
|
|
31
|
+
Write a plot to PNG file:
|
|
31
32
|
|
|
32
33
|
require 'mathgl'
|
|
33
34
|
|
|
@@ -44,7 +45,7 @@ Write to PNG
|
|
|
44
45
|
gr.instance_eval(&prc)
|
|
45
46
|
gr.write_png("test.png","",false)
|
|
46
47
|
|
|
47
|
-
Qt window:
|
|
48
|
+
Display a plot on Qt window:
|
|
48
49
|
|
|
49
50
|
require 'mathgl'
|
|
50
51
|
|
data/ext/mathgl/data.i
ADDED
|
@@ -0,0 +1,507 @@
|
|
|
1
|
+
/***************************************************************************
|
|
2
|
+
* data.i is part of Math Graphic Library
|
|
3
|
+
* Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
|
|
4
|
+
* *
|
|
5
|
+
* This program is free software; you can redistribute it and/or modify *
|
|
6
|
+
* it under the terms of the GNU Library General Public License as *
|
|
7
|
+
* published by the Free Software Foundation; either version 3 of the *
|
|
8
|
+
* License, or (at your option) any later version. *
|
|
9
|
+
* *
|
|
10
|
+
* This program is distributed in the hope that it will be useful, *
|
|
11
|
+
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
12
|
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
13
|
+
* GNU General Public License for more details. *
|
|
14
|
+
* *
|
|
15
|
+
* You should have received a copy of the GNU Library General Public *
|
|
16
|
+
* License along with this program; if not, write to the *
|
|
17
|
+
* Free Software Foundation, Inc., *
|
|
18
|
+
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
19
|
+
***************************************************************************/
|
|
20
|
+
//-----------------------------------------------------------------------------
|
|
21
|
+
#include <string>
|
|
22
|
+
class mglData
|
|
23
|
+
{
|
|
24
|
+
public:
|
|
25
|
+
|
|
26
|
+
long nx; ///< number of points in 1st dimensions ('x' dimension)
|
|
27
|
+
long ny; ///< number of points in 2nd dimensions ('y' dimension)
|
|
28
|
+
long nz; ///< number of points in 3d dimensions ('z' dimension)
|
|
29
|
+
mreal *a; ///< data array
|
|
30
|
+
std::string id; ///< column (or slice) names
|
|
31
|
+
bool link; ///< use external data (i.e. don't free it)
|
|
32
|
+
|
|
33
|
+
/// Initiate by other mglData variable
|
|
34
|
+
mglData(const mglData &d) { a=0; mgl_data_set(this,&d); } // NOTE: must be constructor for mglData& to exclude copy one
|
|
35
|
+
mglData(const mglData *d) { a=0; mgl_data_set(this, d); }
|
|
36
|
+
mglData(bool, mglData *d) // NOTE: Variable d will be deleted!!!
|
|
37
|
+
{ if(d)
|
|
38
|
+
{ nx=d->nx; ny=d->ny; nz=d->nz; a=d->a; d->a=0;
|
|
39
|
+
id=d->id; link=d->link; delete d; }
|
|
40
|
+
else { a=0; Create(1); } }
|
|
41
|
+
/// Initiate by flat array
|
|
42
|
+
mglData(int size, const float *d) { a=0; Set(d,size); }
|
|
43
|
+
mglData(int rows, int cols, const float *d) { a=0; Set(d,cols,rows); }
|
|
44
|
+
mglData(int size, const double *d) { a=0; Set(d,size); }
|
|
45
|
+
mglData(int rows, int cols, const double *d) { a=0; Set(d,cols,rows); }
|
|
46
|
+
mglData(const double *d, int size) { a=0; Set(d,size); }
|
|
47
|
+
mglData(const double *d, int rows, int cols) { a=0; Set(d,cols,rows); }
|
|
48
|
+
mglData(const float *d, int size) { a=0; Set(d,size); }
|
|
49
|
+
mglData(const float *d, int rows, int cols) { a=0; Set(d,cols,rows); }
|
|
50
|
+
/// Read data from file
|
|
51
|
+
mglData(const char *fname) { a=0; Read(fname); }
|
|
52
|
+
/// Allocate the memory for data array and initialize it zero
|
|
53
|
+
mglData(long xx=1,long yy=1,long zz=1) { a=0; Create(xx,yy,zz); }
|
|
54
|
+
/// Delete the array
|
|
55
|
+
virtual ~mglData() { if(!link && a) delete []a; }
|
|
56
|
+
|
|
57
|
+
inline mreal GetVal(long i, long j=0, long k=0) const
|
|
58
|
+
{ return mgl_data_get_value(this,i,j,k);}
|
|
59
|
+
inline void SetVal(mreal f, long i, long j=0, long k=0)
|
|
60
|
+
{ mgl_data_set_value(this,f,i,j,k); }
|
|
61
|
+
/// Get sizes
|
|
62
|
+
long GetNx() const { return nx; }
|
|
63
|
+
long GetNy() const { return ny; }
|
|
64
|
+
long GetNz() const { return nz; }
|
|
65
|
+
|
|
66
|
+
/// Link external data array (don't delete it at exit)
|
|
67
|
+
inline void Link(mreal *A, long NX, long NY=1, long NZ=1)
|
|
68
|
+
{ mgl_data_link(this,A,NX,NY,NZ); }
|
|
69
|
+
inline void Link(mglData &d) { Link(d.a,d.nx,d.ny,d.nz); }
|
|
70
|
+
/// Allocate memory and copy the data from the gsl_vector
|
|
71
|
+
inline void Set(gsl_vector *m) { mgl_data_set_vector(this,m); }
|
|
72
|
+
/// Allocate memory and copy the data from the gsl_matrix
|
|
73
|
+
inline void Set(gsl_matrix *m) { mgl_data_set_matrix(this,m); }
|
|
74
|
+
|
|
75
|
+
/// Allocate memory and copy the data from the (float *) array
|
|
76
|
+
inline void Set(const float *A,long NX,long NY=1,long NZ=1)
|
|
77
|
+
{ mgl_data_set_float(this,A,NX,NY,NZ); }
|
|
78
|
+
/// Allocate memory and copy the data from the (double *) array
|
|
79
|
+
inline void Set(const double *A,long NX,long NY=1,long NZ=1)
|
|
80
|
+
{ mgl_data_set_double(this,A,NX,NY,NZ); }
|
|
81
|
+
/// Allocate memory and copy the data from the (float **) array
|
|
82
|
+
inline void Set(float const * const *A,long N1,long N2)
|
|
83
|
+
{ mgl_data_set_float2(this,A,N1,N2); }
|
|
84
|
+
/// Allocate memory and copy the data from the (double **) array
|
|
85
|
+
inline void Set(double const * const *A,long N1,long N2)
|
|
86
|
+
{ mgl_data_set_double2(this,A,N1,N2); }
|
|
87
|
+
/// Allocate memory and copy the data from the (float ***) array
|
|
88
|
+
inline void Set(float const * const * const *A,long N1,long N2,long N3)
|
|
89
|
+
{ mgl_data_set_float3(this,A,N1,N2,N3); }
|
|
90
|
+
/// Allocate memory and copy the data from the (double ***) array
|
|
91
|
+
inline void Set(double const * const * const *A,long N1,long N2,long N3)
|
|
92
|
+
{ mgl_data_set_double3(this,A,N1,N2,N3); }
|
|
93
|
+
/// Allocate memory and scanf the data from the string
|
|
94
|
+
inline void Set(const char *str,long NX,long NY=1,long NZ=1)
|
|
95
|
+
{ mgl_data_set_values(this,str,NX,NY,NZ); }
|
|
96
|
+
/// Import data from abstract type
|
|
97
|
+
inline void Set(const mglData &dat) { mgl_data_set(this, &dat); }
|
|
98
|
+
|
|
99
|
+
/// Create or recreate the array with specified size and fill it by zero
|
|
100
|
+
inline void Create(long mx,long my=1,long mz=1)
|
|
101
|
+
{ mgl_data_create(this,mx,my,mz); }
|
|
102
|
+
/// Rearange data dimensions
|
|
103
|
+
inline void Rearrange(long mx, long my=0, long mz=0)
|
|
104
|
+
{ mgl_data_rearrange(this,mx,my,mz); }
|
|
105
|
+
/// Transpose dimensions of the data (generalization of Transpose)
|
|
106
|
+
inline void Transpose(const char *dim="yx")
|
|
107
|
+
{ mgl_data_transpose(this,dim); }
|
|
108
|
+
/// Extend data dimensions
|
|
109
|
+
inline void Extend(long n1, long n2=0)
|
|
110
|
+
{ mgl_data_extend(this,n1,n2); }
|
|
111
|
+
/// Reduce size of the data
|
|
112
|
+
inline void Squeeze(long rx,long ry=1,long rz=1,bool smooth=false)
|
|
113
|
+
{ mgl_data_squeeze(this,rx,ry,rz,smooth); }
|
|
114
|
+
/// Crop the data
|
|
115
|
+
inline void Crop(long n1, long n2,char dir='x')
|
|
116
|
+
{ mgl_data_crop(this,n1,n2,dir); }
|
|
117
|
+
/// Insert data rows/columns/slices
|
|
118
|
+
inline void Insert(char dir, long at=0, long num=1)
|
|
119
|
+
{ mgl_data_insert(this,dir,at,num); }
|
|
120
|
+
/// Delete data rows/columns/slices
|
|
121
|
+
inline void Delete(char dir, long at=0, long num=1)
|
|
122
|
+
{ mgl_data_delete(this,dir,at,num); }
|
|
123
|
+
/// Remove rows with duplicate values in column id
|
|
124
|
+
inline void Clean(long id)
|
|
125
|
+
{ mgl_data_clean(this,id); }
|
|
126
|
+
/// Join with another data array
|
|
127
|
+
inline void Join(const mglData &d)
|
|
128
|
+
{ mgl_data_join(this,&d); }
|
|
129
|
+
|
|
130
|
+
/// Modify the data by specified formula
|
|
131
|
+
inline void Modify(const char *eq,long dim=0)
|
|
132
|
+
{ mgl_data_modify(this, eq, dim); }
|
|
133
|
+
/// Modify the data by specified formula
|
|
134
|
+
inline void Modify(const char *eq,const mglData &vdat, const mglData &wdat)
|
|
135
|
+
{ mgl_data_modify_vw(this,eq,&vdat,&wdat); }
|
|
136
|
+
/// Modify the data by specified formula
|
|
137
|
+
inline void Modify(const char *eq,const mglData &vdat)
|
|
138
|
+
{ mgl_data_modify_vw(this,eq,&vdat,0); }
|
|
139
|
+
/// Modify the data by specified formula assuming x,y,z in range [r1,r2]
|
|
140
|
+
inline void Fill(HMGL gr, const char *eq, const char *opt="")
|
|
141
|
+
{ mgl_data_fill_eq(gr,this,eq,0,0,opt); }
|
|
142
|
+
inline void Fill(HMGL gr, const char *eq, const mglData &vdat, const char *opt="")
|
|
143
|
+
{ mgl_data_fill_eq(gr,this,eq,&vdat,0,opt); }
|
|
144
|
+
inline void Fill(HMGL gr, const char *eq, const mglData &vdat, const mglData &wdat,const char *opt="")
|
|
145
|
+
{ mgl_data_fill_eq(gr,this,eq,&vdat,&wdat,opt); }
|
|
146
|
+
/// Equidistantly fill the data to range [x1,x2] in direction dir
|
|
147
|
+
inline void Fill(mreal x1,mreal x2=NaN,char dir='x')
|
|
148
|
+
{ mgl_data_fill(this,x1,x2,dir); }
|
|
149
|
+
/// Fill the data by interpolated values of vdat parametrically depended on xdat,ydat,zdat for x,y,z in range [p1,p2] using global spline
|
|
150
|
+
inline void RefillGS(const mglData &xdat, const mglData &vdat, mreal x1, mreal x2,long sl=-1)
|
|
151
|
+
{ mgl_data_refill_gs(this,&xdat,&vdat,x1,x2,sl); }
|
|
152
|
+
/// Fill the data by interpolated values of vdat parametrically depended on xdat,ydat,zdat for x,y,z in range [p1,p2]
|
|
153
|
+
inline void Refill(const mglData &xdat, const mglData &vdat, mreal x1, mreal x2,long sl=-1)
|
|
154
|
+
{ mgl_data_refill_x(this,&xdat,&vdat,x1,x2,sl); }
|
|
155
|
+
inline void Refill(const mglData &xdat, const mglData &vdat, mglPoint p1, mglPoint p2,long sl=-1)
|
|
156
|
+
{ mgl_data_refill_x(this,&xdat,&vdat,p1.x,p2.x,sl); }
|
|
157
|
+
inline void Refill(const mglData &xdat, const mglData &ydat, const mglData &vdat, mglPoint p1, mglPoint p2,long sl=-1)
|
|
158
|
+
{ mgl_data_refill_xy(this,&xdat,&ydat,&vdat,p1.x,p2.x,p1.y,p2.y,sl); }
|
|
159
|
+
inline void Refill(const mglData &xdat, const mglData &ydat, const mglData &zdat, const mglData &vdat, mglPoint p1, mglPoint p2)
|
|
160
|
+
{ mgl_data_refill_xyz(this,&xdat,&ydat,&zdat,&vdat,p1.x,p2.x,p1.y,p2.y,p1.z,p2.z); }
|
|
161
|
+
/// Fill the data by interpolated values of vdat parametrically depended on xdat,ydat,zdat for x,y,z in axis range of gr
|
|
162
|
+
inline void Refill(HMGL gr, const mglData &xdat, const mglData &vdat, long sl=-1, const char *opt="")
|
|
163
|
+
{ mgl_data_refill_gr(gr,this,&xdat,0,0,&vdat,sl,opt); }
|
|
164
|
+
inline void Refill(HMGL gr, const mglData &xdat, const mglData &ydat, const mglData &vdat, long sl=-1, const char *opt="")
|
|
165
|
+
{ mgl_data_refill_gr(gr,this,&xdat,&ydat,0,&vdat,sl,opt); }
|
|
166
|
+
inline void Refill(HMGL gr, const mglData &xdat, const mglData &ydat, const mglData &zdat, const mglData &vdat, const char *opt="")
|
|
167
|
+
{ mgl_data_refill_gr(gr,this,&xdat,&ydat,&zdat,&vdat,-1,opt); }
|
|
168
|
+
/// Set the data by triangulated surface values assuming x,y,z in axis range of gr
|
|
169
|
+
inline void Grid(HMGL gr, const mglData &x, const mglData &y, const mglData &z, const char *opt="")
|
|
170
|
+
{ mgl_data_grid(gr,this,&x,&y,&z,opt); }
|
|
171
|
+
/// Set the data by triangulated surface values assuming x,y,z in range [p1, p2]
|
|
172
|
+
inline void Grid(const mglData &xdat, const mglData &ydat, const mglData &vdat, mglPoint p1, mglPoint p2)
|
|
173
|
+
{ mgl_data_grid_xy(this,&xdat,&ydat,&vdat,p1.x,p2.x,p1.y,p2.y); }
|
|
174
|
+
/// Put value to data element(s)
|
|
175
|
+
inline void Put(mreal val, long i=-1, long j=-1, long k=-1)
|
|
176
|
+
{ mgl_data_put_val(this,val,i,j,k); }
|
|
177
|
+
/// Put array to data element(s)
|
|
178
|
+
inline void Put(const mglData &dat, long i=-1, long j=-1, long k=-1)
|
|
179
|
+
{ mgl_data_put_dat(this,&dat,i,j,k); }
|
|
180
|
+
/// Set names for columns (slices)
|
|
181
|
+
inline void SetColumnId(const char *ids)
|
|
182
|
+
{ mgl_data_set_id(this,ids); }
|
|
183
|
+
/// Make new id
|
|
184
|
+
inline void NewId() { id.clear(); }
|
|
185
|
+
|
|
186
|
+
/// Read data from tab-separated text file with auto determining size
|
|
187
|
+
inline bool Read(const char *fname)
|
|
188
|
+
{ return mgl_data_read(this,fname); }
|
|
189
|
+
/// Read data from text file with specifeid size
|
|
190
|
+
inline bool Read(const char *fname,long mx,long my=1,long mz=1)
|
|
191
|
+
{ return mgl_data_read_dim(this,fname,mx,my,mz); }
|
|
192
|
+
/// Save whole data array (for ns=-1) or only ns-th slice to text file
|
|
193
|
+
inline void Save(const char *fname,long ns=-1) const
|
|
194
|
+
{ mgl_data_save(this,fname,ns); }
|
|
195
|
+
/// Export data array (for ns=-1) or only ns-th slice to PNG file according color scheme
|
|
196
|
+
inline void Export(const char *fname,const char *scheme,mreal v1=0,mreal v2=0,long ns=-1) const
|
|
197
|
+
{ mgl_data_export(this,fname,scheme,v1,v2,ns); }
|
|
198
|
+
/// Import data array from PNG file according color scheme
|
|
199
|
+
inline void Import(const char *fname,const char *scheme,mreal v1=0,mreal v2=1)
|
|
200
|
+
{ mgl_data_import(this,fname,scheme,v1,v2); }
|
|
201
|
+
/// Read data from tab-separated text files with auto determining size which filenames are result of sprintf(fname,templ,t) where t=from:step:to
|
|
202
|
+
inline bool ReadRange(const char *templ, double from, double to, double step=1, bool as_slice=false)
|
|
203
|
+
{ return mgl_data_read_range(this,templ,from,to,step,as_slice); }
|
|
204
|
+
/// Read data from tab-separated text files with auto determining size which filenames are satisfied to template (like "t_*.dat")
|
|
205
|
+
inline bool ReadAll(const char *templ, bool as_slice=false)
|
|
206
|
+
{ return mgl_data_read_all(this, templ, as_slice); }
|
|
207
|
+
/// Read data from text file with size specified at beginning of the file
|
|
208
|
+
inline bool ReadMat(const char *fname, long dim=2)
|
|
209
|
+
{ return mgl_data_read_mat(this,fname,dim); }
|
|
210
|
+
/// Read data array from HDF file (parse HDF4 and HDF5 files)
|
|
211
|
+
inline int ReadHDF(const char *fname,const char *data)
|
|
212
|
+
{ return mgl_data_read_hdf(this,fname,data); }
|
|
213
|
+
/// Save data to HDF file
|
|
214
|
+
inline void SaveHDF(const char *fname,const char *data,bool rewrite=false) const
|
|
215
|
+
{ mgl_data_save_hdf(this,fname,data,rewrite); }
|
|
216
|
+
/// Put HDF data names into buf as '\t' separated.
|
|
217
|
+
inline static int DatasHDF(const char *fname, char *buf, long size)
|
|
218
|
+
{ return mgl_datas_hdf(fname,buf,size); }
|
|
219
|
+
|
|
220
|
+
/// Get column (or slice) of the data filled by formulas of named columns
|
|
221
|
+
inline mglData Column(const char *eq) const
|
|
222
|
+
{ return mglData(true,mgl_data_column(this,eq)); }
|
|
223
|
+
/// Get momentum (1D-array) of data along direction 'dir'. String looks like "x1" for median in x-direction, "x2" for width in x-dir and so on.
|
|
224
|
+
inline mglData Momentum(char dir, const char *how) const
|
|
225
|
+
{ return mglData(true,mgl_data_momentum(this,dir,how)); }
|
|
226
|
+
/// Get sub-array of the data with given fixed indexes
|
|
227
|
+
inline mglData SubData(long xx,long yy=-1,long zz=-1) const
|
|
228
|
+
{ return mglData(true,mgl_data_subdata(this,xx,yy,zz)); }
|
|
229
|
+
inline mglData SubData(const mglData &xx, const mglData &yy, const mglData &zz) const
|
|
230
|
+
{ return mglData(true,mgl_data_subdata_ext(this,&xx,&yy,&zz)); }
|
|
231
|
+
inline mglData SubData(const mglData &xx, const mglData &yy) const
|
|
232
|
+
{ return mglData(true,mgl_data_subdata_ext(this,&xx,&yy,0)); }
|
|
233
|
+
inline mglData SubData(const mglData &xx) const
|
|
234
|
+
{ return mglData(true,mgl_data_subdata_ext(this,&xx,0,0)); }
|
|
235
|
+
/// Get trace of the data array
|
|
236
|
+
inline mglData Trace() const
|
|
237
|
+
{ return mglData(true,mgl_data_trace(this)); }
|
|
238
|
+
/// Create n-th points distribution of this data values in range [v1, v2]
|
|
239
|
+
inline mglData Hist(long n,mreal v1=0,mreal v2=1, long nsub=0) const
|
|
240
|
+
{ return mglData(true,mgl_data_hist(this,n,v1,v2,nsub)); }
|
|
241
|
+
/// Create n-th points distribution of this data values in range [v1, v2] with weight w
|
|
242
|
+
inline mglData Hist(const mglData &w, long n,mreal v1=0,mreal v2=1, long nsub=0) const
|
|
243
|
+
{ return mglData(true,mgl_data_hist_w(this,&w,n,v1,v2,nsub)); }
|
|
244
|
+
/// Get array which is result of summation in given direction or directions
|
|
245
|
+
inline mglData Sum(const char *dir) const
|
|
246
|
+
{ return mglData(true,mgl_data_sum(this,dir)); }
|
|
247
|
+
/// Get array which is result of maximal values in given direction or directions
|
|
248
|
+
inline mglData Max(const char *dir) const
|
|
249
|
+
{ return mglData(true,mgl_data_max_dir(this,dir)); }
|
|
250
|
+
/// Get array which is result of minimal values in given direction or directions
|
|
251
|
+
inline mglData Min(const char *dir) const
|
|
252
|
+
{ return mglData(true,mgl_data_min_dir(this,dir)); }
|
|
253
|
+
/// Get the data which is direct multiplication (like, d[i,j] = this[i]*a[j] and so on)
|
|
254
|
+
inline mglData Combine(const mglData &dat) const
|
|
255
|
+
{ return mglData(true,mgl_data_combine(this,&dat)); }
|
|
256
|
+
/// Resize the data to new size of box [x1,x2]*[y1,y2]*[z1,z2]
|
|
257
|
+
inline mglData Resize(long mx,long my=0,long mz=0, mreal x1=0,mreal x2=1, mreal y1=0,mreal y2=1, mreal z1=0,mreal z2=1) const
|
|
258
|
+
{ return mglData(true,mgl_data_resize_box(this,mx,my,mz,x1,x2,y1,y2,z1,z2)); }
|
|
259
|
+
/// Get array which values is result of interpolation this for coordinates from other arrays
|
|
260
|
+
inline mglData Evaluate(const mglData &idat, bool norm=true) const
|
|
261
|
+
{ return mglData(true,mgl_data_evaluate(this,&idat,0,0,norm)); }
|
|
262
|
+
inline mglData Evaluate(const mglData &idat, const mglData &jdat, bool norm=true) const
|
|
263
|
+
{ return mglData(true,mgl_data_evaluate(this,&idat,&jdat,0,norm)); }
|
|
264
|
+
inline mglData Evaluate(const mglData &idat, const mglData &jdat, const mglData &kdat, bool norm=true) const
|
|
265
|
+
{ return mglData(true,mgl_data_evaluate(this,&idat,&jdat,&kdat,norm)); }
|
|
266
|
+
/// Find roots for set of nonlinear equations defined by textual formula
|
|
267
|
+
inline mglData Roots(const char *func, char var='x') const
|
|
268
|
+
{ return mglData(true,mgl_data_roots(func, this, var)); }
|
|
269
|
+
/// Find correlation with another data arrays
|
|
270
|
+
inline mglData Correl(const mglData &dat, const char *dir) const
|
|
271
|
+
{ return mglData(true,mgl_data_correl(this,&dat,dir)); }
|
|
272
|
+
/// Find auto correlation function
|
|
273
|
+
inline mglData AutoCorrel(const char *dir) const
|
|
274
|
+
{ return mglData(true,mgl_data_correl(this,this,dir)); }
|
|
275
|
+
|
|
276
|
+
/// Cumulative summation the data in given direction or directions
|
|
277
|
+
inline void CumSum(const char *dir) { mgl_data_cumsum(this,dir); }
|
|
278
|
+
/// Integrate (cumulative summation) the data in given direction or directions
|
|
279
|
+
inline void Integral(const char *dir) { mgl_data_integral(this,dir); }
|
|
280
|
+
/// Differentiate the data in given direction or directions
|
|
281
|
+
inline void Diff(const char *dir) { mgl_data_diff(this,dir); }
|
|
282
|
+
/// Differentiate the parametrically specified data along direction v1 with v2=const
|
|
283
|
+
inline void Diff(const mglData &v1, const mglData &v2)
|
|
284
|
+
{ mgl_data_diff_par(this,&v1,&v2,0); }
|
|
285
|
+
/// Differentiate the parametrically specified data along direction v1 with v2,v3=const
|
|
286
|
+
inline void Diff(const mglData &v1, const mglData &v2, const mglData &v3)
|
|
287
|
+
{ mgl_data_diff_par(this,&v1,&v2,&v3); }
|
|
288
|
+
/// Double-differentiate (like Laplace operator) the data in given direction
|
|
289
|
+
inline void Diff2(const char *dir) { mgl_data_diff2(this,dir); }
|
|
290
|
+
|
|
291
|
+
/// Swap left and right part of the data in given direction (useful for Fourier spectrum)
|
|
292
|
+
inline void Swap(const char *dir) { mgl_data_swap(this,dir); }
|
|
293
|
+
/// Roll data along direction dir by num slices
|
|
294
|
+
inline void Roll(char dir, long num) { mgl_data_roll(this,dir,num); }
|
|
295
|
+
/// Mirror the data in given direction (useful for Fourier spectrum)
|
|
296
|
+
inline void Mirror(const char *dir) { mgl_data_mirror(this,dir); }
|
|
297
|
+
/// Sort rows (or slices) by values of specified column
|
|
298
|
+
inline void Sort(long idx, long idy=-1) { mgl_data_sort(this,idx,idy); }
|
|
299
|
+
|
|
300
|
+
/// Set as the data envelop
|
|
301
|
+
inline void Envelop(char dir='x')
|
|
302
|
+
{ mgl_data_envelop(this,dir); }
|
|
303
|
+
/// Remove phase jump
|
|
304
|
+
inline void Sew(const char *dirs="xyz", mreal da=2*Pi)
|
|
305
|
+
{ mgl_data_sew(this,dirs,da); }
|
|
306
|
+
/// Smooth the data on specified direction or directions
|
|
307
|
+
inline void Smooth(const char *dirs="xyz",mreal delta=0)
|
|
308
|
+
{ mgl_data_smooth(this,dirs,delta); }
|
|
309
|
+
/// Normalize the data to range [v1,v2]
|
|
310
|
+
inline void Norm(mreal v1=0,mreal v2=1,bool sym=false,long dim=0)
|
|
311
|
+
{ mgl_data_norm(this,v1,v2,sym,dim); }
|
|
312
|
+
/// Normalize the data to range [v1,v2] slice by slice
|
|
313
|
+
inline void NormSl(mreal v1=0,mreal v2=1,char dir='z',bool keep_en=true,bool sym=false)
|
|
314
|
+
{ mgl_data_norm_slice(this,v1,v2,dir,keep_en,sym); }
|
|
315
|
+
|
|
316
|
+
/// Apply Hankel transform
|
|
317
|
+
inline void Hankel(const char *dir) { mgl_data_hankel(this,dir); }
|
|
318
|
+
/// Apply Sin-Fourier transform
|
|
319
|
+
inline void SinFFT(const char *dir) { mgl_data_sinfft(this,dir); }
|
|
320
|
+
/// Apply Cos-Fourier transform
|
|
321
|
+
inline void CosFFT(const char *dir) { mgl_data_cosfft(this,dir); }
|
|
322
|
+
/// Fill data by 'x'/'k' samples for Hankel ('h') or Fourier ('f') transform
|
|
323
|
+
inline void FillSample(const char *how)
|
|
324
|
+
{ mgl_data_fill_sample(this,how); }
|
|
325
|
+
|
|
326
|
+
/// Return an approximated x-value (root) when dat(x) = val
|
|
327
|
+
inline mreal Solve(mreal val, bool use_spline=true, long i0=0) const
|
|
328
|
+
{ return mgl_data_solve_1d(this, val, use_spline, i0); }
|
|
329
|
+
/// Return an approximated value (root) when dat(x) = val
|
|
330
|
+
inline mglData Solve(mreal val, char dir, bool norm=true) const
|
|
331
|
+
{ return mglData(true,mgl_data_solve(this, val, dir, 0, norm)); }
|
|
332
|
+
inline mglData Solve(mreal val, char dir, const mglData &i0, bool norm=true) const
|
|
333
|
+
{ return mglData(true,mgl_data_solve(this, val, dir, &i0, norm)); }
|
|
334
|
+
|
|
335
|
+
/// Interpolate by cubic spline the data to given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
|
|
336
|
+
inline mreal Spline(mreal x,mreal y=0,mreal z=0) const
|
|
337
|
+
{ return mgl_data_spline(this, x,y,z); }
|
|
338
|
+
/// Interpolate by cubic spline the data to given point x,\a y,\a z which normalized in range [0, 1]
|
|
339
|
+
inline mreal Spline1(mreal x,mreal y=0,mreal z=0) const
|
|
340
|
+
{ return mgl_data_spline(this, x*(nx-1),y*(ny-1),z*(nz-1)); }
|
|
341
|
+
/// Interpolate by linear function the data to given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
|
|
342
|
+
inline mreal Linear(mreal x,mreal y=0,mreal z=0) const
|
|
343
|
+
{ return mgl_data_linear(this,x,y,z); }
|
|
344
|
+
/// Interpolate by line the data to given point x,\a y,\a z which normalized in range [0, 1]
|
|
345
|
+
inline mreal Linear1(mreal x,mreal y=0,mreal z=0) const
|
|
346
|
+
{ return mgl_data_linear(this,x*(nx-1),y*(ny-1),z*(nz-1)); }
|
|
347
|
+
|
|
348
|
+
/// Interpolate by cubic spline the data and return its derivatives at given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
|
|
349
|
+
inline mreal Spline(mglPoint &dif, mreal x,mreal y=0,mreal z=0) const
|
|
350
|
+
{ return mgl_data_spline_ext(this, x,y,z, &(dif.x),&(dif.y), &(dif.z)); }
|
|
351
|
+
/// Interpolate by cubic spline the data and return its derivatives at given point x,\a y,\a z which normalized in range [0, 1]
|
|
352
|
+
inline mreal Spline1(mglPoint &dif, mreal x,mreal y=0,mreal z=0) const
|
|
353
|
+
{ mreal res=mgl_data_spline_ext(this, x*(nx-1),y*(ny-1),z*(nz-1), &(dif.x),&(dif.y), &(dif.z));
|
|
354
|
+
dif.x*=nx>1?nx-1:1; dif.y*=ny>1?ny-1:1; dif.z*=nz>1?nz-1:1; return res; }
|
|
355
|
+
/// Interpolate by linear function the data and return its derivatives at given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
|
|
356
|
+
inline mreal Linear(mglPoint &dif, mreal x,mreal y=0,mreal z=0) const
|
|
357
|
+
{ return mgl_data_linear_ext(this,x,y,z, &(dif.x),&(dif.y), &(dif.z)); }
|
|
358
|
+
/// Interpolate by line the data and return its derivatives at given point x,\a y,\a z which normalized in range [0, 1]
|
|
359
|
+
inline mreal Linear1(mglPoint &dif, mreal x,mreal y=0,mreal z=0) const
|
|
360
|
+
{ mreal res=mgl_data_linear_ext(this,x*(nx-1),y*(ny-1),z*(nz-1), &(dif.x),&(dif.y), &(dif.z));
|
|
361
|
+
dif.x*=nx>1?nx-1:1; dif.y*=ny>1?ny-1:1; dif.z*=nz>1?nz-1:1; return res; }
|
|
362
|
+
|
|
363
|
+
/// Get information about the data (sizes and momentum) to string
|
|
364
|
+
inline const char *PrintInfo() const { return mgl_data_info(this); }
|
|
365
|
+
/// Print information about the data (sizes and momentum) to FILE (for example, stdout)
|
|
366
|
+
inline void PrintInfo(FILE *fp) const
|
|
367
|
+
{ if(fp) { fprintf(fp,"%s",mgl_data_info(this)); fflush(fp); } }
|
|
368
|
+
/// Get maximal value of the data
|
|
369
|
+
inline mreal Maximal() const { return mgl_data_max(this); }
|
|
370
|
+
/// Get minimal value of the data
|
|
371
|
+
inline mreal Minimal() const { return mgl_data_min(this); }
|
|
372
|
+
/// Get maximal value of the data which is less than 0
|
|
373
|
+
inline mreal MaximalNeg() const { return mgl_data_neg_max(this); }
|
|
374
|
+
/// Get minimal value of the data which is larger than 0
|
|
375
|
+
inline mreal MinimalPos() const { return mgl_data_pos_min(this); }
|
|
376
|
+
/// Get maximal value of the data and its position
|
|
377
|
+
inline mreal Maximal(long &i,long &j,long &k) const
|
|
378
|
+
{ return mgl_data_max_int(this,&i,&j,&k); }
|
|
379
|
+
/// Get minimal value of the data and its position
|
|
380
|
+
inline mreal Minimal(long &i,long &j,long &k) const
|
|
381
|
+
{ return mgl_data_min_int(this,&i,&j,&k); }
|
|
382
|
+
/// Get maximal value of the data and its approximated position
|
|
383
|
+
inline mreal Maximal(mreal &x,mreal &y,mreal &z) const
|
|
384
|
+
{ return mgl_data_max_real(this,&x,&y,&z); }
|
|
385
|
+
/// Get minimal value of the data and its approximated position
|
|
386
|
+
inline mreal Minimal(mreal &x,mreal &y,mreal &z) const
|
|
387
|
+
{ return mgl_data_min_real(this,&x,&y,&z); }
|
|
388
|
+
/// Get "energy" and find first (median) and second (width) momenta of data
|
|
389
|
+
inline mreal Momentum(char dir,mreal &m,mreal &w) const
|
|
390
|
+
{ return mgl_data_momentum_val(this,dir,&m,&w,0,0); }
|
|
391
|
+
/// Get "energy and find 4 momenta of data: median, width, skewness, kurtosis
|
|
392
|
+
inline mreal Momentum(char dir,mreal &m,mreal &w,mreal &s,mreal &k) const
|
|
393
|
+
{ return mgl_data_momentum_val(this,dir,&m,&w,&s,&k); }
|
|
394
|
+
/// Find position (after specified in i,j,k) of first nonzero value of formula
|
|
395
|
+
inline mreal Find(const char *cond, long &i, long &j, long &k) const
|
|
396
|
+
{ return mgl_data_first(this,cond,&i,&j,&k); }
|
|
397
|
+
/// Find position (before specified in i,j,k) of last nonzero value of formula
|
|
398
|
+
inline mreal Last(const char *cond, long &i, long &j, long &k) const
|
|
399
|
+
{ return mgl_data_last(this,cond,&i,&j,&k); }
|
|
400
|
+
/// Find position of first in direction 'dir' nonzero value of formula
|
|
401
|
+
inline long Find(const char *cond, char dir, long i=0, long j=0, long k=0) const
|
|
402
|
+
{ return mgl_data_find(this,cond,dir,i,j,k); }
|
|
403
|
+
/// Find if any nonzero value of formula
|
|
404
|
+
inline bool FindAny(const char *cond) const
|
|
405
|
+
{ return mgl_data_find_any(this,cond); }
|
|
406
|
+
|
|
407
|
+
/// Copy data from other mglData variable
|
|
408
|
+
inline const mglData &operator=(const mglData &d)
|
|
409
|
+
{ if(this!=&d) mgl_data_set(this,&d); return d; }
|
|
410
|
+
inline mreal operator=(mreal val)
|
|
411
|
+
{ mgl_data_fill(this,val,val,'x'); return val; }
|
|
412
|
+
/// Multiply the data by other one for each element
|
|
413
|
+
inline void operator*=(const mglData &d) { mgl_data_mul_dat(this,&d); }
|
|
414
|
+
/// Divide the data by other one for each element
|
|
415
|
+
inline void operator/=(const mglData &d) { mgl_data_div_dat(this,&d); }
|
|
416
|
+
/// Add the other data
|
|
417
|
+
inline void operator+=(const mglData &d) { mgl_data_add_dat(this,&d); }
|
|
418
|
+
/// Subtract the other data
|
|
419
|
+
inline void operator-=(const mglData &d) { mgl_data_sub_dat(this,&d); }
|
|
420
|
+
/// Multiply each element by the number
|
|
421
|
+
inline void operator*=(mreal d) { mgl_data_mul_num(this,d); }
|
|
422
|
+
/// Divide each element by the number
|
|
423
|
+
inline void operator/=(mreal d) { mgl_data_div_num(this,d); }
|
|
424
|
+
/// Add the number
|
|
425
|
+
inline void operator+=(mreal d) { mgl_data_add_num(this,d); }
|
|
426
|
+
/// Subtract the number
|
|
427
|
+
inline void operator-=(mreal d) { mgl_data_sub_num(this,d); }
|
|
428
|
+
};
|
|
429
|
+
//-----------------------------------------------------------------------------
|
|
430
|
+
/// Integral data transformation (like Fourier 'f' or 'i', Hankel 'h' or None 'n') for amplitude and phase
|
|
431
|
+
inline mglData mglTransformA(const mglData &am, const mglData &ph, const char *tr)
|
|
432
|
+
{ return mglData(true,mgl_transform_a(&am,&ph,tr)); }
|
|
433
|
+
/// Integral data transformation (like Fourier 'f' or 'i', Hankel 'h' or None 'n') for real and imaginary parts
|
|
434
|
+
inline mglData mglTransform(const mglData &re, const mglData &im, const char *tr)
|
|
435
|
+
{ return mglData(true,mgl_transform(&re,&im,tr)); }
|
|
436
|
+
/// Apply Fourier transform for the data and save result into it
|
|
437
|
+
inline void mglFourier(mglData &re, mglData &im, const char *dir)
|
|
438
|
+
{ mgl_data_fourier(&re,&im,dir); }
|
|
439
|
+
/// Short time Fourier analysis for real and imaginary parts. Output is amplitude of partial Fourier (result will have size {dn, floor(nx/dn), ny} for dir='x'
|
|
440
|
+
inline mglData mglSTFA(const mglData &re, const mglData &im, long dn, char dir='x')
|
|
441
|
+
{ return mglData(true, mgl_data_stfa(&re,&im,dn,dir)); }
|
|
442
|
+
//-----------------------------------------------------------------------------
|
|
443
|
+
/// Saves result of PDE solving (|u|^2) for "Hamiltonian" ham with initial conditions ini
|
|
444
|
+
inline mglData mglPDE(HMGL gr, const char *ham, const mglData &ini_re, const mglData &ini_im, mreal dz=0.1, mreal k0=100,const char *opt="")
|
|
445
|
+
{ return mglData(true, mgl_pde_solve(gr,ham, &ini_re, &ini_im, dz, k0,opt)); }
|
|
446
|
+
/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)
|
|
447
|
+
inline mglData mglQO2d(const char *ham, const mglData &ini_re, const mglData &ini_im, const mglData &ray, mreal r=1, mreal k0=100)
|
|
448
|
+
{ return mglData(true, mgl_qo2d_solve(ham, &ini_re, &ini_im, &ray, r, k0, 0, 0)); }
|
|
449
|
+
inline mglData mglQO2d(const char *ham, const mglData &ini_re, const mglData &ini_im, const mglData &ray, mglData &xx, mglData &yy, mreal r=1, mreal k0=100)
|
|
450
|
+
{ return mglData(true, mgl_qo2d_solve(ham, &ini_re, &ini_im, &ray, r, k0, &xx, &yy)); }
|
|
451
|
+
/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)
|
|
452
|
+
inline mglData mglQO3d(const char *ham, const mglData &ini_re, const mglData &ini_im, const mglData &ray, mreal r=1, mreal k0=100)
|
|
453
|
+
{ return mglData(true, mgl_qo3d_solve(ham, &ini_re, &ini_im, &ray, r, k0, 0, 0, 0)); }
|
|
454
|
+
inline mglData mglQO3d(const char *ham, const mglData &ini_re, const mglData &ini_im, const mglData &ray, mglData &xx, mglData &yy, mglData &zz, mreal r=1, mreal k0=100)
|
|
455
|
+
{ return mglData(true, mgl_qo3d_solve(ham, &ini_re, &ini_im, &ray, r, k0, &xx, &yy, &zz)); }
|
|
456
|
+
/// Finds ray with starting point r0, p0 (and prepares ray data for mglQO2d)
|
|
457
|
+
inline mglData mglRay(const char *ham, mglPoint r0, mglPoint p0, mreal dt=0.1, mreal tmax=10)
|
|
458
|
+
{ return mglData(true, mgl_ray_trace(ham, r0.x, r0.y, r0.z, p0.x, p0.y, p0.z, dt, tmax)); }
|
|
459
|
+
/// Saves result of ODE solving (|u|^2) for "Hamiltonian" ham with initial conditions ini
|
|
460
|
+
inline mglData mglODE(const char *df, const char *var, const mglData &ini, mreal dt=0.1, mreal tmax=10)
|
|
461
|
+
{ return mglData(true, mgl_ode_solve_str(df,var, &ini, dt, tmax)); }
|
|
462
|
+
/// Calculate Jacobian determinant for D{x(u,v), y(u,v)} = dx/du*dy/dv-dx/dv*dy/du
|
|
463
|
+
inline mglData mglJacobian(const mglData &x, const mglData &y)
|
|
464
|
+
{ return mglData(true, mgl_jacobian_2d(&x, &y)); }
|
|
465
|
+
/// Calculate Jacobian determinant for D{x(u,v,w), y(u,v,w), z(u,v,w)}
|
|
466
|
+
inline mglData mglJacobian(const mglData &x, const mglData &y, const mglData &z)
|
|
467
|
+
{ return mglData(true, mgl_jacobian_3d(&x, &y, &z)); }
|
|
468
|
+
/// Do something like Delone triangulation
|
|
469
|
+
inline mglData mglTriangulation(const mglData &x, const mglData &y, const mglData &z)
|
|
470
|
+
{ return mglData(true,mgl_triangulation_3d(&x,&y,&z)); }
|
|
471
|
+
inline mglData mglTriangulation(const mglData &x, const mglData &y)
|
|
472
|
+
{ return mglData(true,mgl_triangulation_2d(&x,&y)); }
|
|
473
|
+
//-----------------------------------------------------------------------------
|
|
474
|
+
/// Get sub-array of the data with given fixed indexes
|
|
475
|
+
inline mglData mglSubData(const mglData &dat, long xx, long yy=-1, long zz=-1)
|
|
476
|
+
{ return mglData(true,mgl_data_subdata(&dat,xx,yy,zz)); }
|
|
477
|
+
inline mglData mglSubData(const mglData &dat, const mglData &xx, const mglData &yy, const mglData &zz)
|
|
478
|
+
{ return mglData(true,mgl_data_subdata_ext(&dat,&xx,&yy,&zz)); }
|
|
479
|
+
inline mglData mglSubData(const mglData &dat, const mglData &xx, const mglData &yy)
|
|
480
|
+
{ return mglData(true,mgl_data_subdata_ext(&dat,&xx,&yy,0)); }
|
|
481
|
+
inline mglData mglSubData(const mglData &dat, const mglData &xx)
|
|
482
|
+
{ return mglData(true,mgl_data_subdata_ext(&dat,&xx,0,0)); }
|
|
483
|
+
//-----------------------------------------------------------------------------
|
|
484
|
+
/// Prepare coefficients for global spline interpolation
|
|
485
|
+
inline mglData mglGSplineInit(const mglData &xdat, const mglData &ydat)
|
|
486
|
+
{ return mglData(true,mgl_gspline_init(&xdat, &ydat)); }
|
|
487
|
+
/// Evaluate global spline (and its derivatives d1, d2 if not NULL) using prepared coefficients \a coef
|
|
488
|
+
inline mreal mglGSpline(const mglData &coef, mreal dx, mreal *d1=0, mreal *d2=0)
|
|
489
|
+
{ return mgl_gspline(&coef, dx, d1,d2); }
|
|
490
|
+
//-----------------------------------------------------------------------------
|
|
491
|
+
/// Wrapper class for expression evaluating
|
|
492
|
+
class mglExpr
|
|
493
|
+
{
|
|
494
|
+
HMEX ex;
|
|
495
|
+
mglExpr(const mglExpr &){} // copying is not allowed
|
|
496
|
+
const mglExpr &operator=(const mglExpr &t){return t;} // copying is not allowed
|
|
497
|
+
public:
|
|
498
|
+
mglExpr(const char *expr) { ex = mgl_create_expr(expr); }
|
|
499
|
+
~mglExpr() { mgl_delete_expr(ex); }
|
|
500
|
+
/// Return value of expression for given x,y,z variables
|
|
501
|
+
inline double Eval(double x, double y=0, double z=0)
|
|
502
|
+
{ return mgl_expr_eval(ex,x,y,z); }
|
|
503
|
+
/// Return value of expression differentiation over variable dir for given x,y,z variables
|
|
504
|
+
inline double Diff(char dir, double x, double y=0, double z=0)
|
|
505
|
+
{ return mgl_expr_diff(ex,dir, x,y,z); }
|
|
506
|
+
};
|
|
507
|
+
//-----------------------------------------------------------------------------
|