#ifdef PTHREAD_SAMPLE\r
mglWindow gr("test");\r
gr.RunThr();\r
- for(int i=0;i<10;i++) // do calculation\r
+ for(int i=0;i<10;i++) // do calculation\r
{\r
- sleep(1); // which can be very long\r
+#ifdef WIN32\r
+ Sleep(1000);\r
+#else\r
+ sleep(1); // which can be very long\r
+#endif\r
pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);\r
- gr.Clf(); // make new drawing\r
+ gr.Clf(); // make new drawing\r
gr.Line(mglPoint(),pnt,"Ar2");\r
char str[10] = "i=0"; str[3] = '0'+i;\r
gr.Puts(mglPoint(),"");\r
- gr.Update(); // update window\r
+ gr.Update(); // update window\r
}\r
- return 0; // finish calculations and close the window\r
+ return 0; // finish calculations and close the window\r
#else\r
mglWindow *gr;\r
char key = 0;\r
//-----------------------------------------------------------------------------\r
const char *mmgl_flow="subplot 2 2 0 '':title 'Flow plot (default)':box:flow a b\n"\r
"subplot 2 2 1 '':title '\\\'v\\\' style':box:flow a b 'v'\n"\r
-"subplot 2 2 2 '':title 'from edges only':box:flow a b; value -5\n"\r
+"subplot 2 2 2 '':title 'from edges only':box:flow a b '#'\n"\r
"subplot 2 2 3:title '3d variant':rotate 50 60:box:flow ex ey ez\n";\r
void smgl_flow(mglGraph *gr)\r
{\r
gr->Box(); gr->Flow(a,b);\r
if(mini) return;\r
gr->SubPlot(2,2,1,""); gr->Title("'v' style"); gr->Box(); gr->Flow(a,b,"v");\r
- gr->SubPlot(2,2,2,""); gr->Title("from edges only"); gr->Box(); gr->Flow(a,b,"","value -5");\r
+ gr->SubPlot(2,2,2,""); gr->Title("'\\#' style"); gr->Box(); gr->Flow(a,b,"#");\r
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);\r
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60);\r
gr->Box(); gr->Flow(ex,ey,ez);\r
//-----------------------------------------------------------------------------\r
const char *mmgl_pipe="subplot 2 2 0 '':title 'Pipe plot (default)':light on:box:pipe a b\n"\r
"subplot 2 2 1 '':title '\\\'i\\\' style':box:pipe a b 'i'\n"\r
-"subplot 2 2 2 '':title 'from edges only':box:pipe a b; value -5\n"\r
+"subplot 2 2 2 '':title 'from edges only':box:pipe a b '#'\n"\r
"subplot 2 2 3:title '3d variant':rotate 50 60:box:pipe ex ey ez '' 0.1\n";\r
void smgl_pipe(mglGraph *gr)\r
{\r
mglData a,b; mgls_prepare2v(&a,&b);\r
- if(!mini) {gr->SubPlot(2,2,0,""); gr->Title("Flow plot (default)");}\r
+ if(!mini) {gr->SubPlot(2,2,0,""); gr->Title("Pipe plot (default)");}\r
gr->Light(true); gr->Box(); gr->Pipe(a,b);\r
if(mini) return;\r
gr->SubPlot(2,2,1,""); gr->Title("'i' style"); gr->Box(); gr->Pipe(a,b,"i");\r
- gr->SubPlot(2,2,2,""); gr->Title("from edges only"); gr->Box(); gr->Pipe(a,b,"",0.05,"value -5");\r
+ gr->SubPlot(2,2,2,""); gr->Title("'\\#' style"); gr->Box(); gr->Pipe(a,b,"#");\r
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);\r
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60);\r
gr->Box(); gr->Pipe(ex,ey,ez,"",0.1);\r
{\r
mglData a; mgls_prepare2d(&a);\r
gr->Light(true);\r
- gr->SubPlot(2,1,0); gr->Rotate(50,60+3);\r
+ gr->SubPlot(2,1,0); gr->Rotate(50,60+1);\r
gr->Box(); gr->Surf(a);\r
- gr->SubPlot(2,1,1); gr->Rotate(50,60-3);\r
+ gr->SubPlot(2,1,1); gr->Rotate(50,60-1);\r
gr->Box(); gr->Surf(a);\r
}\r
//-----------------------------------------------------------------------------\r
void Foo::Calc()\r
{\r
for(int i=0;i<30;i++) // do calculation\r
- {\r
- sleep(1); // which can be very long\r
- pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);\r
- Gr->Update(); // update window\r
- }\r
+ {\r
+#ifdef WIN32\r
+ Sleep(1000);\r
+#else\r
+ sleep(1); // which can be very long\r
+#endif\r
+ pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);\r
+ Gr->Update(); // update window\r
+ }\r
}\r
//-----------------------------------------------------\r
int Foo::Draw(mglGraph *gr)\r
case '1': gr = new mglWindow(sample_1,"1D plots",1); break;\r
case '2': gr = new mglWindow(sample_2,"2D plots",1); break;\r
case '3': gr = new mglWindow(sample_3,"3D plots",1); break;\r
- case 'd': gr = new mglWindow(sample_d,"Dual plots",1); break;\r
+ case 'd': gr = new mglWindow(sample_d,"Dual plots",1);break;\r
case 't': gr = new mglWindow(test_wnd,"Testing",1); break;\r
- default: gr = new mglWindow(&foo,"Drop and waves",1); break;\r
+ default: gr = new mglWindow(sample,"Drop and waves",1); break;\r
}\r
gr->Run(); return 0;\r
#endif\r
{\r
float xx,yy,zz; // original coordinates\r
float x,y,z; // coordinates\r
- float c,t; // index in color scheme\r
+ float c,t,ta; // index in color scheme\r
float u,v,w; // normales\r
float r,g,b,a; // RGBA color\r
mglPnt() { xx=yy=zz=x=y=z=c=t=u=v=w=r=g=b=a=0; }\r
{ n=0; Set(cols,smooth,alpha); }\r
void Clear() { n=0; }\r
void Set(const char *cols, int smooth=0,float alpha=1);\r
- void GetC(float u,float v,mglPnt &p);\r
- bool IsSame(mglTexture &t);\r
- void GetRGBA(unsigned char *f); // Write as BGRA for fastest export to TGA\r
+ void GetC(float u,float v,mglPnt &p) const;\r
+ bool IsSame(mglTexture &t) const;\r
+ void GetRGBA(unsigned char *f) const; // Write as BGRA for fastest export to TGA\r
};\r
//-----------------------------------------------------------------------------\r
const mglColor NC(-1,-1,-1);\r
long InUse; ///< Smart pointer (number of users)\r
long Flag; ///< Flags for controlling drawing\r
\r
- inline bool get(long fl) { return Flag&fl; }\r
+ inline bool get(long fl) const { return Flag&fl; }\r
inline void set(long fl) { Flag |= fl; }\r
inline void clr(long fl) { Flag &=~fl; }\r
inline void set(bool v,long fl) { Flag = v ? Flag|fl : Flag&(~fl); }\r
/// Set default palette\r
inline void SetPalette(const char *colors)\r
{ Txt[0].Set(mgl_have_color(colors)?colors:MGL_DEF_PAL,-1); }\r
- inline long GetNumPal(long id) { return Txt[abs(id)/256].n; }\r
+ inline long GetNumPal(long id) const { return Txt[abs(id)/256].n; }\r
/// Set default color scheme\r
inline void SetDefScheme(const char *colors)\r
{ Txt[1].Set(mgl_have_color(colors)?colors:"BbcyrR"); }\r
\r
/// Set warning code ant fill Message\r
void SetWarn(int code, const char *who="");\r
- int inline GetWarn() { return WarnCode; }\r
+ int inline GetWarn() const { return WarnCode; }\r
\r
virtual void StartAutoGroup (const char *)=0;\r
void StartGroup(const char *name, int id);\r
inline void CopyFont(mglBase *gr) { fnt->Copy(gr->GetFont()); }\r
/// Set default font size\r
inline void SetFontSize(float val) { FontSize=val>0 ? val:FontSize*val; }\r
- inline float GetFontSize() { return FontSize; };\r
- inline float TextWidth(const wchar_t *text, const char *font, float size)\r
+ inline float GetFontSize() const { return FontSize; };\r
+ inline float TextWidth(const wchar_t *text, const char *font, float size) const\r
{ return (size<0?-size*FontSize:size)*font_factor*fnt->Width(text,(font&&*font)?font:FontDef)/8; }\r
- inline float TextHeight(const char *font, float size)\r
+ inline float TextHeight(const char *font, float size) const\r
{ return (size<0?-size*FontSize:size)*font_factor*fnt->Height(font?font:FontDef)/8; }\r
- inline float FontFactor() { return font_factor; }\r
- virtual float GetRatio();\r
+ inline float FontFactor() const { return font_factor; }\r
+ virtual float GetRatio() const;\r
/// Set to use or not text rotation\r
inline void SetRotatedText(bool val) { set(val,MGL_ENABLE_RTEXT); }\r
/// Set default font style and color\r
\r
/// Set plot quality\r
virtual void SetQuality(int qual=MGL_DRAW_NORM) { Quality=qual; }\r
- inline int GetQuality() { return Quality; }\r
+ inline int GetQuality() const { return Quality; }\r
\r
// ~~~~~~~~~~~~~~~~~~~~~~ Developer functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
/// Add point to the pntN and return its position\r
inline void SetReduceAcc(bool val) { set(val, MGL_REDUCEACC); }\r
\r
// inline long GetPos() { return Pnt.size()-1; }\r
- inline mglPoint GetPntP(long i)\r
+ inline mglPoint GetPntP(long i) const\r
{ const mglPnt &p=Pnt[i]; return mglPoint(p.x,p.y,p.z); }\r
- inline float GetClrC(long i) { return Pnt[i].c; }\r
- inline long GetPntNum() { return Pnt.size(); }\r
- inline mglPnt &GetPnt(long i) { return Pnt[i]; }\r
- inline mglPrim &GetPrm(long i) { return Prm[i]; }\r
- inline long GetPrmNum() { return Prm.size(); }\r
- inline mglText &GetPtx(long i) { return Ptx[i]; }\r
- inline long GetPtxNum() { return Ptx.size(); }\r
- inline mglTexture &GetTxt(long i){ return Txt[i]; }\r
- inline long GetTxtNum() { return Txt.size(); }\r
+ inline float GetClrC(long i) const { return Pnt[i].c; }\r
+ inline const mglPnt &GetPnt(long i) const { return Pnt[i]; }\r
+ inline long GetPntNum() const { return Pnt.size(); }\r
+ inline mglPrim &GetPrm(long i) { return Prm[i]; }\r
+ inline long GetPrmNum() const { return Prm.size(); }\r
+ inline const mglText &GetPtx(long i) const { return Ptx[i]; }\r
+ inline long GetPtxNum() const { return Ptx.size(); }\r
+ inline const mglTexture &GetTxt(long i) const { return Txt[i]; }\r
+ inline long GetTxtNum() const { return Txt.size(); }\r
/// Scale coordinates and cut off some points\r
- virtual bool ScalePoint(mglPoint &p, mglPoint &n, bool use_nan=true);\r
+ virtual bool ScalePoint(mglPoint &p, mglPoint &n, bool use_nan=true) const;\r
\r
- virtual float GetOrgX(char dir)=0; ///< Get Org.x (parse NAN value)\r
- virtual float GetOrgY(char dir)=0; ///< Get Org.y (parse NAN value)\r
- virtual float GetOrgZ(char dir)=0; ///< Get Org.z (parse NAN value)\r
+ virtual float GetOrgX(char dir) const=0; ///< Get Org.x (parse NAN value)\r
+ virtual float GetOrgY(char dir) const=0; ///< Get Org.y (parse NAN value)\r
+ virtual float GetOrgZ(char dir) const=0; ///< Get Org.z (parse NAN value)\r
\r
/// Get color depending on single variable z, which should be scaled if scale=true\r
- inline float GetC(long s,float z,bool scale = true)\r
+ inline float GetC(long s,float z,bool scale = true) const\r
{ return s+(scale?GetA(z):(z>0?z/MGL_FLT_EPS:0)); }\r
/// Get alpha value depending on single variable \a a\r
- float GetA(float a);\r
+ float GetA(float a) const;\r
/// Set pen/palette\r
char SetPenPal(const char *stl, long *id=0);\r
/// Add texture (like color scheme) and return the position of first color\r
float b[9];\r
float x,y,z,pf;\r
mglMatrix() { clear(); }\r
- inline void clear() { x=y=z=pf=0; memset(b,0,9*sizeof(float)); b[0]=b[4]=b[8]=1; }\r
+ inline void clear() { x=y=z=0; memset(b,0,9*sizeof(float)); b[0]=b[4]=b[8]=1; }\r
inline mglMatrix &operator=(mglMatrix &a)\r
{ x=a.x; y=a.y; z=a.z; pf=a.pf; memcpy(b,a.b,9*sizeof(float)); return *this; }\r
};\r
friend struct mglPrim;\r
public:\r
using mglBase::Light;\r
- mglPoint LastMousePos; ///< Last mouse position\r
\r
mglCanvas(int w=800, int h=600);\r
virtual ~mglCanvas();\r
/// Set size of frame in pixels. Normally this function is called internaly.\r
virtual void SetSize(int w,int h);\r
/// Get ratio (float width)/(float height).\r
- float GetRatio();\r
+ float GetRatio() const;\r
/// Get bitmap data prepared for saving to file\r
virtual unsigned char **GetRGBLines(long &w, long &h, unsigned char *&f, bool alpha=false);\r
/// Get RGB bitmap of current state image.\r
/// Get RGBA bitmap of current state image.\r
const unsigned char *GetRGBA() { Finish(); return G4; }\r
/// Get width of the image\r
- int GetWidth() { return Width; }\r
+ int GetWidth() const { return Width; }\r
/// Get height of the image\r
- int GetHeight() { return Height; }\r
+ int GetHeight() const { return Height; }\r
/// Combine plots from 2 canvases. Result will be saved into this.\r
void Combine(const mglCanvas *gr);\r
/// Send graphical information to node id using MPI\r
void MPI_Send(int id);\r
/// Receive graphical information from node id using MPI\r
void MPI_Recv(int id);\r
- inline float GetDelay() { return Delay; }\r
+ inline float GetDelay() const { return Delay; }\r
inline void SetDelay(float d) { Delay=d; }\r
\r
/// Calculate 3D coordinate {x,y,z} for screen point {xs,ys}\r
- mglPoint CalcXYZ(int xs, int ys);\r
+ mglPoint CalcXYZ(int xs, int ys) const;\r
/// Calculate screen point {xs,ys} for 3D coordinate {x,y,z}\r
- void CalcScr(mglPoint p, int *xs, int *ys);\r
- mglPoint CalcScr(mglPoint p);\r
+ void CalcScr(mglPoint p, int *xs, int *ys) const;\r
+ mglPoint CalcScr(mglPoint p) const;\r
/// Set object/subplot id\r
inline void SetObjId(long id) { ObjId = id; }\r
/// Get object id\r
- inline int GetObjId(long x,long y) { return OI[x+Width*y]; }\r
+ inline int GetObjId(long x,long y) const { return OI[x+Width*y]; }\r
/// Get subplot id\r
- int GetSplId(long x,long y);\r
+ int GetSplId(long x,long y) const;\r
\r
/// Create new frame.\r
virtual int NewFrame();\r
/// Finish frame drawing\r
virtual void EndFrame();\r
/// Get the number of created frames\r
- inline int GetNumFrame() { return CurFrameId; }\r
+ inline int GetNumFrame() const { return CurFrameId; }\r
/// Reset frames counter (start it from zero)\r
inline void ResetFrames() { CurFrameId=0; DrwDat.clear(); }\r
\r
/// Clear ZBuffer only\r
void ClfZB();\r
/// Scale coordinates and cut off some points\r
- bool ScalePoint(mglPoint &p, mglPoint &n, bool use_nan=true);\r
+ bool ScalePoint(mglPoint &p, mglPoint &n, bool use_nan=true) const;\r
void LightScale(); ///< Additionally scale positions of light sources\r
\r
/// Push drawing data (for frames only). NOTE: can be VERY large\r
/// Get drawing data for i-th frame.\r
void GetDrwDat(long i);\r
\r
- float GetOrgX(char dir); ///< Get Org.x (parse NAN value)\r
- float GetOrgY(char dir); ///< Get Org.y (parse NAN value)\r
- float GetOrgZ(char dir); ///< Get Org.z (parse NAN value)\r
+ float GetOrgX(char dir) const; ///< Get Org.x (parse NAN value)\r
+ float GetOrgY(char dir) const; ///< Get Org.y (parse NAN value)\r
+ float GetOrgZ(char dir) const; ///< Get Org.z (parse NAN value)\r
\r
void mark_plot(long p, char type, float size=1); // position in pntC\r
void arrow_plot(long p1, long p2, char st); // position in pntC\r
void glyph_draw(const mglPrim *P, mglDrawReg *d);\r
bool IsSame(const mglPrim &pr,float wp,mglColor cp,int st);\r
\r
+ // functions for multi-threading\r
+ void PreparePrim(bool fast);\r
+ void pxl_combine(unsigned long id, unsigned long n, const void *);\r
+ void pxl_memcpy(unsigned long id, unsigned long n, const void *);\r
+ void pxl_backgr(unsigned long id, unsigned long n, const void *);\r
+ void pxl_primdr(unsigned long id, unsigned long n, const void *);\r
+ void pxl_transform(unsigned long id, unsigned long n, const void *);\r
+ void pxl_setz(unsigned long id, unsigned long n, const void *);\r
+ void pxl_setz_adv(unsigned long id, unsigned long n, const void *);\r
+ void pxl_other(unsigned long id, unsigned long n, const void *p);\r
+ /// Put drawing from other mglCanvas (for multithreading, like subplots)\r
+ void PutDrawReg(mglDrawReg *d, const mglCanvas *gr);\r
+ \r
private:\r
// float _tetx,_tety,_tetz; // extra angles\r
std::vector<mglMatrix> stack; ///< stack for transformation matrixes\r
void tick_draw(mglPoint o, mglPoint d1, mglPoint d2, int f, const char *stl);\r
/// Plot point \a p with color \a c\r
void pnt_plot(long x,long y,float z,const unsigned char c[4]);\r
- float FindOptOrg(char dir, int ind);\r
+ float FindOptOrg(char dir, int ind) const;\r
/// Transform float color and alpha to bits format\r
unsigned char* col2int(const mglPnt &p, unsigned char *r);\r
/// Combine colors in 2 plane.\r
void fast_draw(long p1, long p2, mglDrawReg *d);\r
\r
/// Additionally scale points \a p for positioning in image\r
- void PostScale(mglPoint &p);\r
+ void PostScale(mglPoint &p) const;\r
/// Scale points \a p for projection to the face number \a nface in image\r
long ProjScale(int nface, long p);\r
- inline void PostScale(mglPoint *p,long n) { for(long i=0;i<n;i++) PostScale(p[i]); }\r
+ inline void PostScale(mglPoint *p,long n) const { for(long i=0;i<n;i++) PostScale(p[i]); }\r
\r
// functions for glyph drawing\r
void glyph_fill(const mglPnt &p, float f, int nt, const short *trig, mglDrawReg *d);\r
void glyph_wire(const mglPnt &p, float f, int nl, const short *line, mglDrawReg *d);\r
void glyph_line(const mglPnt &p, float f, bool solid, mglDrawReg *d);\r
- // functions for multi-threading\r
- void pxl_combine(unsigned long id, unsigned long n, const void *);\r
- void pxl_memcpy(unsigned long id, unsigned long n, const void *);\r
- void pxl_backgr(unsigned long id, unsigned long n, const void *);\r
- void pxl_primdr(unsigned long id, unsigned long n, const void *);\r
- void pxl_transform(unsigned long id, unsigned long n, const void *);\r
- void pxl_setz(unsigned long id, unsigned long n, const void *);\r
- void pxl_setz_adv(unsigned long id, unsigned long n, const void *);\r
- void pxl_other(unsigned long id, unsigned long n, const void *p);\r
- /// Put drawing from other mglCanvas (for multithreading, like subplots)\r
- void PutDrawReg(mglDrawReg *d, const mglCanvas *gr);\r
};\r
//-----------------------------------------------------------------------------\r
struct mglThreadG\r
void mgl_label(HMGL gr, char dir, const char *text);\r
void mgl_label_ext(HMGL gr, char dir, const char *text, float pos, float shift);\r
void mgl_labelw_ext(HMGL gr, char dir, const wchar_t *text, float pos, float shift);\r
-void mgl_label_pos(HMGL gr, float x, float y, const char *text, const char *fnt);\r
-void mgl_labelw_pos(HMGL gr, float x, float y, const wchar_t *text, const char *fnt);\r
\r
void mgl_colorbar(HMGL gr, const char *sch);\r
void mgl_colorbar_ext(HMGL gr, const char *sch, float x, float y, float w, float h);\r
void mgl_write_stl(HMGL gr, const char *fname,const char *descr);\r
void mgl_write_off(HMGL gr, const char *fname,const char *descr, int colored);\r
void mgl_write_xyz(HMGL gr, const char *fname,const char *descr);\r
-void mgl_write_x3d(HMGL gr, const char *fname,const char *descr);\r
+//void mgl_write_x3d(HMGL gr, const char *fname,const char *descr);\r
void mgl_write_wgl(HMGL gr, const char *fname,const char *descr);\r
void mgl_write_idtf(HMGL gr, const char *fname,const char *descr);\r
void mgl_write_gif(HMGL gr, const char *fname,const char *descr);\r
void mgl_stickplot(HMGL gr, int num, int ind, float tet, float phi);\r
void mgl_title(HMGL gr, const char *title, const char *stl, float size);\r
void mgl_titlew(HMGL gr, const wchar_t *title, const char *stl, float size);\r
+void mgl_set_plotfactor(HMGL gr, float val);\r
\r
void mgl_aspect(HMGL gr, float Ax,float Ay,float Az);\r
void mgl_rotate(HMGL gr, float TetX,float TetZ,float TetY);\r
void mgl_axis_grid_(uintptr_t *gr, const char *dir,const char *pen,int l,int n);\r
void mgl_label_(uintptr_t *gr, const char *dir, const char *text,int,int l);\r
void mgl_label_ext_(uintptr_t *gr, const char *dir, const char *text, float *pos, float *shift,int,int l);\r
-void mgl_label_pos_(uintptr_t *gr, float *x, float *y, const char *txt, const char *fnt,int l,int n);\r
/*****************************************************************************/\r
void mgl_colorbar_(uintptr_t *gr, const char *sch,int l);\r
void mgl_colorbar_ext_(uintptr_t *gr, const char *sch, float *x, float *y, float *w, float *h, int l);\r
void mgl_write_stl_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
void mgl_write_off_(uintptr_t *graph, const char *fname,const char *descr,int *colored,int lf,int ld);\r
void mgl_write_xyz_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
-void mgl_write_wrl_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
-void mgl_write_x3d_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
+//void mgl_write_x3d_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
void mgl_write_tex_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
void mgl_write_wgl_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
void mgl_set_plotid_(uintptr_t *gr, const char *id,int l);\r
void mgl_columnplot_(uintptr_t *graph, int *num, int *i, float *d);\r
void mgl_gridplot_(uintptr_t *graph, int *nx, int *ny, int *i, float *d);\r
void mgl_stickplot_(uintptr_t *graph, int *num, int *i, float *tet, float *phi);\r
+void mgl_set_plotfactor_(uintptr_t *graph, float *val);\r
\r
void mgl_title_(uintptr_t *gr, const char *title, const char *stl, float *size, int,int);\r
void mgl_aspect_(uintptr_t *graph, float *Ax,float *Ay,float *Az);\r
/*****************************************************************************/\r
HMGL mgl_create_graph_qt(int (*draw)(HMGL gr, void *p), const char *title, void *par, void (*load)(void *p));\r
HMGL mgl_create_graph_fltk(int (*draw)(HMGL gr, void *p), const char *title, void *par, void (*load)(void *p));\r
+void mgl_set_click_func(HMGL gr, void (*func)(void *p));\r
int mgl_fltk_run();\r
int mgl_fltk_thr();\r
int mgl_qt_run();\r
class mglCanvasWnd : public mglCanvas\r
{\r
public:\r
+ mglPoint LastMousePos; ///< Last mouse position\r
+ void (*ClickFunc)(void *par); ///< Callback function on click\r
+\r
mglCanvasWnd();\r
virtual ~mglCanvasWnd();\r
\r
void SetSize(int w,int h);\r
void EndFrame();\r
const unsigned char *GetBits();\r
- inline int GetNumFig() { return NumFig; }\r
- inline int GetCurFig() { return CurFig; }\r
+ inline int GetNumFig() const { return NumFig; }\r
+ inline int GetCurFig() const { return CurFig; }\r
void SetCurFig(int c);\r
void ClearFrames();\r
- inline mglPoint GetMousePos() { return LastMousePos;}\r
+ inline mglPoint GetMousePos() const { return LastMousePos;}\r
inline void SetMousePos(mglPoint p) { LastMousePos=p; }\r
inline void Setup(bool clf_upd=true, bool showpos=false)\r
{ set(showpos,MGL_SHOW_POS); set(clf_upd,MGL_CLF_ON_UPD); }\r
const char *title, void *par=NULL,\r
void (*reload)(void *p)=NULL, bool maximize=false)=0;\r
void SetDrawFunc(int (*draw)(mglBase *gr, void *p), void *par=NULL, void (*reload)(void *p)=NULL);\r
-\r
+ \r
private:\r
- mglPoint LastMousePos; ///< Last mouse position\r
int CurFig; ///< Current figure in the list.\r
\r
unsigned char *GG; ///< images for all frames (may be too LARGE !!!)\r
inline mglData(const mglData &d) { a=0; mgl_data_set(this,&d); }\r
inline mglData(const mglDataA *d) { a=0; mgl_data_set(this, d); }\r
inline mglData(bool, mglData *d) // NOTE: Variable d will be deleted!!!\r
- { if(d) {memcpy(this,d,sizeof(mglData)); d->id=0; d->link=true; delete d; }\r
+ { if(d) {memcpy((void*)this,(void*)d,sizeof(mglData)); d->id=0; d->link=true; delete d; }\r
else { a=0; Create(1); } }\r
/// Initiate by flat array\r
inline mglData(int size, const float *d) { a=0; Set(d,size); }\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
#include "mgl/canvas_wnd.h"\r
+#if MGL_HAVE_FLTK\r
//-----------------------------------------------------------------------------\r
#ifdef __MWERKS__\r
# define FL_DLL\r
//-----------------------------------------------------------------------------\r
void mgl_ask_fltk(const wchar_t *quest, wchar_t *res);\r
//-----------------------------------------------------------------------------\r
+#else\r
+#error "Please enable FLTK support"\r
+#endif\r
#endif\r
#endif\r
#define MGL_DEF_FONT_NAME "STIX"\r
#endif\r
//-----------------------------------------------------------------------------\r
-struct mglTeXsymb { unsigned kod; const wchar_t *tex; };
-/// Get font color, style and align for internal parser
+struct mglTeXsymb { unsigned kod; const wchar_t *tex; };\r
+/// Get font color, style and align for internal parser\r
char mglGetStyle(const char *how, int *font, int *align=0);\r
class mglBase;\r
//-----------------------------------------------------------------------------\r
/// Load font data to memory. Normally used by constructor.\r
bool Load(const char *base, const char *path=0);\r
/// Free memory\r
- void Clear();
+ void Clear();\r
/// Copy data from other font\r
void Copy(mglFont *);\r
/// Restore default font\r
void Restore();\r
/// Return true if font is loaded\r
- inline bool Ready() { return numg!=0; };\r
+ inline bool Ready() const { return numg!=0; };\r
\r
/// Get height of text\r
- float Height(int font);\r
+ float Height(int font) const;\r
/// Get height of text\r
- float Height(const char *how);\r
+ float Height(const char *how) const;\r
/// Print text string for font specified by string\r
- float Puts(const char *str,const char *how,float col);\r
+ float Puts(const char *str,const char *how,float col) const;\r
/// Get width of text string for font specified by string\r
- float Width(const char *str,const char *how);\r
+ float Width(const char *str,const char *how) const;\r
/// Print text string for font specified by string\r
- float Puts(const wchar_t *str,const char *how,float col);\r
+ float Puts(const wchar_t *str,const char *how,float col) const;\r
/// Get width of text string for font specified by string\r
- float Width(const wchar_t *str,const char *how);
+ float Width(const wchar_t *str,const char *how) const;\r
\r
/// Return number of glyphs\r
- inline unsigned GetNumGlyph() { return numg; };\r
+ inline unsigned GetNumGlyph() const { return numg; };\r
/// Return some of pointers\r
- inline const short *GetTr(int s, long j) { return Buf+tr[s][j]; };\r
- inline const short *GetLn(int s, long j) { return Buf+ln[s][j]; };\r
- inline int GetNt(int s, long j) { return numt[s][j]; };\r
- inline int GetNl(int s, long j) { return numl[s][j]; };\r
- inline float GetFact(int s) { return fact[s]; };\r
+ inline const short *GetTr(int s, long j) const { return Buf+tr[s][j]; };\r
+ inline const short *GetLn(int s, long j) const { return Buf+ln[s][j]; };\r
+ inline int GetNt(int s, long j) const { return numt[s][j]; };\r
+ inline int GetNl(int s, long j) const { return numl[s][j]; };\r
+ inline float GetFact(int s) const { return fact[s]; };\r
protected:\r
wchar_t *id; ///< Unicode ID for glyph\r
unsigned *tr[4]; ///< Shift of glyph description by triangles (for solid font)\r
unsigned numg; ///< Number of glyphs\r
short *Buf; ///< Buffer for glyph descriptions\r
long numb; ///< Buffer size\r
-
+\r
/// Print text string for font specified by integer constant\r
- float Puts(const wchar_t *str,int font,int align, float col);\r
+ float Puts(const wchar_t *str,int font,int align, float col) const;\r
/// Get width of text string for font specified by integer constant\r
- float Width(const wchar_t *str,int font=0);\r
+ float Width(const wchar_t *str,int font=0) const;\r
/// Replace TeX symbols by its UTF code and add font styles\r
- void Convert(const wchar_t *str, unsigned *res);\r
-
+ void Convert(const wchar_t *str, unsigned *res) const;\r
+\r
/// Draw string recursively\r
/* x,y - position, f - factor, style: 0x1 - italic, 0x2 - bold, 0x4 - overline, 0x8 - underline, 0x10 - empty (not draw) */\r
- float Puts(const unsigned *str, float x,float y,float f,int style,float col);\r
+ float Puts(const unsigned *str, float x,float y,float f,int style,float col) const;\r
/// Parse LaTeX command\r
- unsigned Parse(const wchar_t *s);\r
+ unsigned Parse(const wchar_t *s) const;\r
/// Get internal code for symbol\r
- long Internal(unsigned s);\r
+ long Internal(unsigned s) const;\r
\r
/// Get symbol for character \a ch with given \a font style\r
- unsigned Symbol(char ch);\r
+ unsigned Symbol(char ch) const;\r
private:\r
- float get_ptr(long &i,unsigned *str, unsigned **b1, unsigned **b2,float &w1,float &w2, float f1, float f2, int st);\r
+ float get_ptr(long &i,unsigned *str, unsigned **b1, unsigned **b2,float &w1,float &w2, float f1, float f2, int st) const;\r
bool read_data(const char *fname, float *ff, short *wdt, short *numl, unsigned *posl, short *numt, unsigned *post, unsigned &cur);\r
void main_copy();\r
bool read_main(const char *fname, unsigned &cur);\r
void mem_alloc();\r
bool read_def(unsigned &cur);\r
- void draw_ouline(int st, float x, float y, float f, float g, float ww, float ccol);\r
+ void draw_ouline(int st, float x, float y, float f, float g, float ww, float ccol) const;\r
};\r
//-----------------------------------------------------------------------------\r
#endif\r
inline void StickPlot(int num, int i, float tet, float phi)\r
{ mgl_stickplot(gr,num,i,tet,phi); }\r
\r
+ /// Set PlotFactor\r
+ inline void SetPlotFactor(float val)\r
+ { mgl_set_plotfactor(gr,val); }\r
+ /// Push transformation matrix into stack\r
+ inline void Push() { mgl_mat_push(gr); }\r
+ /// Pop transformation matrix from stack\r
+ inline void Pop() { mgl_mat_pop(gr); }\r
+ \r
/// Add title for current subplot/inplot\r
inline void Title(const char *title,const char *stl="",float size=-2)\r
{ mgl_title(gr,title,stl,size); }\r
{ mgl_putsw_dir(gr, p.x, p.y, p.z, d.x, d.y, d.z, text, font, size); }\r
inline void Puts(mglPoint p, mglPoint d, const char *text, const char *font=":L", float size=-1)\r
{ mgl_puts_dir(gr, p.x, p.y, p.z, d.x, d.y, d.z, text, font, size); }\r
- /// Print the label \a text at arbitrary position {x,y} of plot.\r
- void Label(double x, double y, const char *text, const char *fnt=0)\r
- { mgl_label_pos(gr,x,y,text,fnt); }\r
- void Label(double x, double y, const wchar_t *text, const char *fnt=0)\r
- { mgl_labelw_pos(gr,x,y,text,fnt); }\r
\r
/// Print text along the curve\r
inline void Text(const mglDataA &x, const mglDataA &y, const mglDataA &z, const char *text, const char *font="", const char *opt="")\r
~mglCanvasGL();\r
\r
void SetQuality(int =0) { Quality=2; }\r
- void Finish();\r
+ void Finish(bool fast=true);\r
void SetSize(int ,int ) {}\r
void View(float tetX,float tetY,float tetZ);\r
int NewFrame();\r
#ifdef __cplusplus\r
//-----------------------------------------------------------------------------\r
#include "mgl/canvas_wnd.h"\r
+#if MGL_HAVE_QT\r
#include <QtGui/QWidget>\r
#include <QtGui/QPixmap>\r
//-----------------------------------------------------------------------------\r
void exportOBJ(QString fname=""); ///< export to OBJ file\r
void exportSTL(QString fname=""); ///< export to STL file\r
void exportOFF(QString fname=""); ///< export to OFF file\r
- void exportX3D(QString fname=""); ///< export to XYZ file\r
+// void exportX3D(QString fname=""); ///< export to XYZ file\r
void exportIDTF(QString fname=""); ///< export to IDTF file\r
void setMGLFont(QString path); ///< restore/load font for graphics\r
\r
//-----------------------------------------------------------------------------\r
void mgl_ask_qt(const wchar_t *quest, wchar_t *res);\r
//-----------------------------------------------------------------------------\r
+#else\r
+#error "Please enable Qt support"\r
+#endif\r
#endif\r
#endif\r
{\r
virtual int Draw(mglGraph *)=0; ///< Function for drawing\r
virtual void Reload() {} ///< Function for reloading data\r
+ virtual void Click() {} ///< Callback function on mouse click\r
#if MGL_HAVE_PTHREAD\r
pthread_t thr;\r
bool running;\r
int mgl_draw_graph(mglBase *gr, void *p);\r
// NOTE: mgl_draw_class() and mgl_draw_load() use mglWindow* only. Don't use it with inherited classes\r
int mgl_draw_class(mglBase *gr, void *p);\r
+void mgl_click_class(void *p);\r
void mgl_reload_class(void *p);\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_QT\r
class mglWindow : public mglGraph\r
{\r
friend int mgl_draw_class(mglBase *gr, void *p);\r
+friend void mgl_click_class(void *p);\r
friend void mgl_reload_class(void *p);\r
protected:\r
mglDraw *dr;\r
wnd=kind; dr=draw;\r
if(wnd==1) gr = mgl_create_graph_qt(mgl_draw_class,title,this,mgl_reload_class);\r
else gr = mgl_create_graph_fltk(mgl_draw_class,title,this,mgl_reload_class);\r
+ mgl_set_click_func(gr, mgl_click_class);\r
}\r
inline int Run() ///< Run main loop for event handling\r
{ return (wnd==1)? mgl_qt_run() : mgl_fltk_run(); }\r
{ mgl_wnd_prev_frame(gr); }\r
inline void Animation() ///< Run slideshow (animation) of frames\r
{ mgl_wnd_animation(gr); }\r
+ void SetClickFunc(void (*func)(void *p))\r
+ { if(!dr) mgl_set_click_func(gr,func); }\r
\r
inline void SetDelay(float dt) ///< Delay for animation in seconds\r
{ mgl_wnd_set_delay(gr, dt); }\r
if(MGL_HAVE_PYTHON)
- configure_file(${MathGL_SOURCE_DIR}/lang/mgl.i ${MathGL_BINARY_DIR}/lang/mgl.i COPYONLY)
- configure_file(${MathGL_SOURCE_DIR}/lang/numpy.i ${MathGL_BINARY_DIR}/lang/numpy.i COPYONLY)
+ configure_file(${MathGL_SOURCE_DIR}/lang/mgl.i.in ${MathGL_BINARY_DIR}/lang/mgl.i COPYONLY)
+ configure_file(${MathGL_SOURCE_DIR}/lang/numpy.i.in ${MathGL_BINARY_DIR}/lang/numpy.i COPYONLY)
SET(dep_libs mgl)
# if(MGL_HAVE_FLTK)
get_property(path_to_mglwnd TARGET mgl-wnd PROPERTY LOCATION)
)
add_custom_target(mgl_python_module ALL DEPENDS _mathgl.so mathgl.py)
install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/lang/setup.py install --prefix=${CMAKE_INSTALL_PREFIX} WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/lang )")
- set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "mgl.i;numpy.i;setup.py;mgl_wrap.cpp;build;mathgl.pyc")
+ set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "setup.py;mgl_wrap.cpp;build;mathgl.pyc")
endif(MGL_HAVE_PYTHON)
+++ /dev/null
-/***************************************************************************
- * mgl.i is part of Math Graphic Library
- * Copyright (C) 2007 Alexey Balakin <balakin@appl.sci-nnov.ru>,
- * Xavier Delacour <xavier.delacour@gmail.com>,
- * Alexander Filov <alexander.filov@gmail.com> *
- * *
- * This program is free software; you can redistribute it and/or modify *
- * it under the terms of the GNU General Public License as published by *
- * the Free Software Foundation; either version 2 of the License, or *
- * (at your option) any later version. *
- * *
- * This program is distributed in the hope that it will be useful, *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
- * GNU General Public License for more details. *
- * *
- * You should have received a copy of the GNU General Public License *
- * along with this program; if not, write to the *
- * Free Software Foundation, Inc., *
- * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
- ***************************************************************************/
-
-%module mathgl
-#ifdef SWIGOCTAVE
-%feature("autodoc", 1);
-#endif // SWIGOCTAVE
-
-%ignore operator!;
-%ignore operator=;
-%ignore *::operator=;
-%ignore *::operator+=;
-%ignore *::operator-=;
-%ignore *::operator*=;
-%ignore *::operator/=;
-//%ignore mglDataA
-
-%{
-#define SWIG_FILE_WITH_INIT
-#include "mgl/config.h"
-#include "mgl/type.h"
-#include "mgl/data.h"
-#include "mgl/mgl.h"
-#include "mgl/window.h"
-%}
-
-#if MGL_USE_DOUBLE
-typedef double mreal;
-#else
-typedef float mreal;
-#endif
-
-
-#ifdef SWIGOCTAVE
-%rename(__add) operator+;
-%rename(__sub) operator-;
-%rename(__mul) operator*;
-%rename(__div) operator/;
-%rename(__eq) operator==;
-%rename(__ne) operator!=;
-//%typemap(in,noblock=1) (double* d, int rows, int cols) (Matrix tmp) {
-// if (!$input.is_matrix_type()) {
-// error("A must be a matrix");
-// SWIG_fail;
-// }
-// tmp=$input.matrix_value();
-// $1=tmp.data();
-// $2=tmp.rows();
-// $3=tmp.columns();
-//}
-#endif
-
-#ifdef SWIGPYTHON
-%rename(__add__) *::operator+(const mglData&, const mglData&);
-%rename(__sub__) *::operator-(const mglData&, const mglData &);
-%rename(__mul__) *::operator*(const mglData &, float);
-%rename(__div__) *::operator/(const mglData &, float);
-
-// Get the NumPy typemaps
-%include "numpy.i"
-%init %{
-import_array();
-%}
-%apply (double* IN_ARRAY1, int DIM1) {(const double* d, int size)};
-%apply (int DIM1, double* IN_ARRAY1) {(int size, const double* d)};
-%apply (double* IN_ARRAY2, int DIM1, int DIM2) {(const double* d, int rows, int cols)};
-%apply (int DIM1, int DIM2, double* IN_ARRAY2) {(int rows, int cols, const double* d)};
-%apply (double* IN_ARRAY3, int DIM1, int DIM2, int DIM3) {(const double* d, int rows, int cols, int slc)};
-%apply (int DIM1, int DIM2, int DIM3, double* IN_ARRAY3) {(int rows, int cols, int slc, const double* d)};
-#endif
-
-%include "mgl/config.h"
-%include "mgl/type.h"
-%include "mgl/data.h"
-%include "mgl/mgl.h"
-%include "mgl/window.h"
-%extend mglData
-{
- float __getitem__( int i) { return self->GetVal(i); };
- float __paren( int i) { return self->GetVal(i); };
- void __setitem__( int i, float y) { self->SetVal(y,i); };
- void __paren_asgn( int i, float y) { self->SetVal(y,i); };
-};
--- /dev/null
+/***************************************************************************
+ * mgl.i is part of Math Graphic Library
+ * Copyright (C) 2007 Alexey Balakin <balakin@appl.sci-nnov.ru>,
+ * Xavier Delacour <xavier.delacour@gmail.com>,
+ * Alexander Filov <alexander.filov@gmail.com> *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+
+%module mathgl
+#ifdef SWIGOCTAVE
+%feature("autodoc", 1);
+#endif // SWIGOCTAVE
+
+%ignore operator!;
+%ignore operator=;
+%ignore *::operator=;
+%ignore *::operator+=;
+%ignore *::operator-=;
+%ignore *::operator*=;
+%ignore *::operator/=;
+//%ignore mglDataA
+
+%{
+#define SWIG_FILE_WITH_INIT
+//#include "mgl/config.h"
+#include "mgl/type.h"
+#include "mgl/data.h"
+#include "mgl/mgl.h"
+#include "mgl/window.h"
+%}
+
+#if MGL_USE_DOUBLE
+typedef double mreal;
+#else
+typedef float mreal;
+#endif
+
+
+#ifdef SWIGOCTAVE
+%rename(__add) operator+;
+%rename(__sub) operator-;
+%rename(__mul) operator*;
+%rename(__div) operator/;
+%rename(__eq) operator==;
+%rename(__ne) operator!=;
+//%typemap(in,noblock=1) (double* d, int rows, int cols) (Matrix tmp) {
+// if (!$input.is_matrix_type()) {
+// error("A must be a matrix");
+// SWIG_fail;
+// }
+// tmp=$input.matrix_value();
+// $1=tmp.data();
+// $2=tmp.rows();
+// $3=tmp.columns();
+//}
+#endif
+
+#ifdef SWIGPYTHON
+%rename(__add__) *::operator+(const mglData&, const mglData&);
+%rename(__sub__) *::operator-(const mglData&, const mglData &);
+%rename(__mul__) *::operator*(const mglData &, float);
+%rename(__div__) *::operator/(const mglData &, float);
+
+// Get the NumPy typemaps
+%include "numpy.i"
+%init %{
+import_array();
+%}
+%apply (double* IN_ARRAY1, int DIM1) {(const double* d, int size)};
+%apply (int DIM1, double* IN_ARRAY1) {(int size, const double* d)};
+%apply (double* IN_ARRAY2, int DIM1, int DIM2) {(const double* d, int rows, int cols)};
+%apply (int DIM1, int DIM2, double* IN_ARRAY2) {(int rows, int cols, const double* d)};
+%apply (double* IN_ARRAY3, int DIM1, int DIM2, int DIM3) {(const double* d, int rows, int cols, int slc)};
+%apply (int DIM1, int DIM2, int DIM3, double* IN_ARRAY3) {(int rows, int cols, int slc, const double* d)};
+#endif
+
+//%include "mgl/config.h"
+%include "mgl/type.h"
+%include "mgl/data.h"
+%include "mgl/mgl.h"
+%include "mgl/window.h"
+%extend mglData
+{
+ float __getitem__( int i) { return self->GetVal(i); };
+ float __paren( int i) { return self->GetVal(i); };
+ void __setitem__( int i, float y) { self->SetVal(y,i); };
+ void __paren_asgn( int i, float y) { self->SetVal(y,i); };
+};
+++ /dev/null
-/* -*- C -*- (not really, but good for syntax highlighting) */
-#ifdef SWIGPYTHON
-
-%{
-#ifndef SWIG_FILE_WITH_INIT
-# define NO_IMPORT_ARRAY
-#endif
-#include "stdio.h"
-#include <numpy/arrayobject.h>
-%}
-
-/**********************************************************************/
-
-%fragment("NumPy_Backward_Compatibility", "header")
-{
-/* Support older NumPy data type names
-*/
-%#if NDARRAY_VERSION < 0x01000000
-%#define NPY_BOOL PyArray_BOOL
-%#define NPY_BYTE PyArray_BYTE
-%#define NPY_UBYTE PyArray_UBYTE
-%#define NPY_SHORT PyArray_SHORT
-%#define NPY_USHORT PyArray_USHORT
-%#define NPY_INT PyArray_INT
-%#define NPY_UINT PyArray_UINT
-%#define NPY_LONG PyArray_LONG
-%#define NPY_ULONG PyArray_ULONG
-%#define NPY_LONGLONG PyArray_LONGLONG
-%#define NPY_ULONGLONG PyArray_ULONGLONG
-%#define NPY_FLOAT PyArray_FLOAT
-%#define NPY_DOUBLE PyArray_DOUBLE
-%#define NPY_LONGDOUBLE PyArray_LONGDOUBLE
-%#define NPY_CFLOAT PyArray_CFLOAT
-%#define NPY_CDOUBLE PyArray_CDOUBLE
-%#define NPY_CLONGDOUBLE PyArray_CLONGDOUBLE
-%#define NPY_OBJECT PyArray_OBJECT
-%#define NPY_STRING PyArray_STRING
-%#define NPY_UNICODE PyArray_UNICODE
-%#define NPY_VOID PyArray_VOID
-%#define NPY_NTYPES PyArray_NTYPES
-%#define NPY_NOTYPE PyArray_NOTYPE
-%#define NPY_CHAR PyArray_CHAR
-%#define NPY_USERDEF PyArray_USERDEF
-%#define npy_intp intp
-
-%#define NPY_MAX_BYTE MAX_BYTE
-%#define NPY_MIN_BYTE MIN_BYTE
-%#define NPY_MAX_UBYTE MAX_UBYTE
-%#define NPY_MAX_SHORT MAX_SHORT
-%#define NPY_MIN_SHORT MIN_SHORT
-%#define NPY_MAX_USHORT MAX_USHORT
-%#define NPY_MAX_INT MAX_INT
-%#define NPY_MIN_INT MIN_INT
-%#define NPY_MAX_UINT MAX_UINT
-%#define NPY_MAX_LONG MAX_LONG
-%#define NPY_MIN_LONG MIN_LONG
-%#define NPY_MAX_ULONG MAX_ULONG
-%#define NPY_MAX_LONGLONG MAX_LONGLONG
-%#define NPY_MIN_LONGLONG MIN_LONGLONG
-%#define NPY_MAX_ULONGLONG MAX_ULONGLONG
-%#define NPY_MAX_INTP MAX_INTP
-%#define NPY_MIN_INTP MIN_INTP
-
-%#define NPY_FARRAY FARRAY
-%#define NPY_F_CONTIGUOUS F_CONTIGUOUS
-%#endif
-}
-
-/**********************************************************************/
-
-/* The following code originally appeared in
- * enthought/kiva/agg/src/numeric.i written by Eric Jones. It was
- * translated from C++ to C by John Hunter. Bill Spotz has modified
- * it to fix some minor bugs, upgrade from Numeric to numpy (all
- * versions), add some comments and functionality, and convert from
- * direct code insertion to SWIG fragments.
- */
-
-%fragment("NumPy_Macros", "header")
-{
-/* Macros to extract array attributes.
- */
-%#define is_array(a) ((a) && PyArray_Check((PyArrayObject *)a))
-%#define array_type(a) (int)(PyArray_TYPE(a))
-%#define array_numdims(a) (((PyArrayObject *)a)->nd)
-%#define array_dimensions(a) (((PyArrayObject *)a)->dimensions)
-%#define array_size(a,i) (((PyArrayObject *)a)->dimensions[i])
-%#define array_data(a) (((PyArrayObject *)a)->data)
-%#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a))
-%#define array_is_native(a) (PyArray_ISNOTSWAPPED(a))
-%#define array_is_fortran(a) (PyArray_ISFORTRAN(a))
-}
-
-/**********************************************************************/
-
-%fragment("NumPy_Utilities", "header")
-{
- /* Given a PyObject, return a string describing its type.
- */
- char* pytype_string(PyObject* py_obj) {
- if (py_obj == NULL ) return "C NULL value";
- if (py_obj == Py_None ) return "Python None" ;
- if (PyCallable_Check(py_obj)) return "callable" ;
- if (PyString_Check( py_obj)) return "string" ;
- if (PyInt_Check( py_obj)) return "int" ;
- if (PyFloat_Check( py_obj)) return "float" ;
- if (PyDict_Check( py_obj)) return "dict" ;
- if (PyList_Check( py_obj)) return "list" ;
- if (PyTuple_Check( py_obj)) return "tuple" ;
- if (PyFile_Check( py_obj)) return "file" ;
- if (PyModule_Check( py_obj)) return "module" ;
- if (PyInstance_Check(py_obj)) return "instance" ;
-
- return "unknow type";
- }
-
- /* Given a NumPy typecode, return a string describing the type.
- */
- char* typecode_string(int typecode) {
- static char* type_names[25] = {"bool", "byte", "unsigned byte",
- "short", "unsigned short", "int",
- "unsigned int", "long", "unsigned long",
- "long long", "unsigned long long",
- "float", "double", "long double",
- "complex float", "complex double",
- "complex long double", "object",
- "string", "unicode", "void", "ntypes",
- "notype", "char", "unknown"};
- return typecode < 24 ? type_names[typecode] : type_names[24];
- }
-
- /* Make sure input has correct numpy type. Allow character and byte
- * to match. Also allow int and long to match. This is deprecated.
- * You should use PyArray_EquivTypenums() instead.
- */
- int type_match(int actual_type, int desired_type) {
- return PyArray_EquivTypenums(actual_type, desired_type);
- }
-}
-
-/**********************************************************************/
-
-%fragment("NumPy_Object_to_Array", "header",
- fragment="NumPy_Backward_Compatibility",
- fragment="NumPy_Macros",
- fragment="NumPy_Utilities")
-{
- /* Given a PyObject pointer, cast it to a PyArrayObject pointer if
- * legal. If not, set the python error string appropriately and
- * return NULL.
- */
- PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode)
- {
- PyArrayObject* ary = NULL;
- if (is_array(input) && (typecode == NPY_NOTYPE ||
- PyArray_EquivTypenums(array_type(input), typecode)))
- {
- ary = (PyArrayObject*) input;
- }
- else if is_array(input)
- {
- char* desired_type = typecode_string(typecode);
- char* actual_type = typecode_string(array_type(input));
- PyErr_Format(PyExc_TypeError,
- "Array of type '%s' required. Array of type '%s' given",
- desired_type, actual_type);
- ary = NULL;
- }
- else
- {
- char * desired_type = typecode_string(typecode);
- char * actual_type = pytype_string(input);
- PyErr_Format(PyExc_TypeError,
- "Array of type '%s' required. A '%s' was given",
- desired_type, actual_type);
- ary = NULL;
- }
- return ary;
- }
-
- /* Convert the given PyObject to a NumPy array with the given
- * typecode. On success, return a valid PyArrayObject* with the
- * correct type. On failure, the python error string will be set and
- * the routine returns NULL.
- */
- PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode,
- int* is_new_object)
- {
- PyArrayObject* ary = NULL;
- PyObject* py_obj;
- if (is_array(input) && (typecode == NPY_NOTYPE ||
- PyArray_EquivTypenums(array_type(input),typecode)))
- {
- ary = (PyArrayObject*) input;
- *is_new_object = 0;
- }
- else
- {
- py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_DEFAULT);
- /* If NULL, PyArray_FromObject will have set python error value.*/
- ary = (PyArrayObject*) py_obj;
- *is_new_object = 1;
- }
- return ary;
- }
-
- /* Given a PyArrayObject, check to see if it is contiguous. If so,
- * return the input pointer and flag it as not a new object. If it is
- * not contiguous, create a new PyArrayObject using the original data,
- * flag it as a new object and return the pointer.
- */
- PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object,
- int min_dims, int max_dims)
- {
- PyArrayObject* result;
- if (array_is_contiguous(ary))
- {
- result = ary;
- *is_new_object = 0;
- }
- else
- {
- result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
- array_type(ary),
- min_dims,
- max_dims);
- *is_new_object = 1;
- }
- return result;
- }
-
- /* Given a PyArrayObject, check to see if it is Fortran-contiguous.
- * If so, return the input pointer, but do not flag it as not a new
- * object. If it is not Fortran-contiguous, create a new
- * PyArrayObject using the original data, flag it as a new object
- * and return the pointer.
- */
- PyArrayObject* make_fortran(PyArrayObject* ary, int* is_new_object,
- int min_dims, int max_dims)
- {
- PyArrayObject* result;
- if (array_is_fortran(ary))
- {
- result = ary;
- *is_new_object = 0;
- }
- else
- {
- Py_INCREF(ary->descr);
- result = (PyArrayObject*) PyArray_FromArray(ary, ary->descr, NPY_FORTRAN);
- *is_new_object = 1;
- }
- return result;
- }
-
- /* Convert a given PyObject to a contiguous PyArrayObject of the
- * specified type. If the input object is not a contiguous
- * PyArrayObject, a new one will be created and the new object flag
- * will be set.
- */
- PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
- int typecode,
- int* is_new_object)
- {
- int is_new1 = 0;
- int is_new2 = 0;
- PyArrayObject* ary2;
- PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode,
- &is_new1);
- if (ary1)
- {
- ary2 = make_contiguous(ary1, &is_new2, 0, 0);
- if ( is_new1 && is_new2)
- {
- Py_DECREF(ary1);
- }
- ary1 = ary2;
- }
- *is_new_object = is_new1 || is_new2;
- return ary1;
- }
-
- /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the
- * specified type. If the input object is not a Fortran-ordered
- * PyArrayObject, a new one will be created and the new object flag
- * will be set.
- */
- PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input,
- int typecode,
- int* is_new_object)
- {
- int is_new1 = 0;
- int is_new2 = 0;
- PyArrayObject* ary2;
- PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode,
- &is_new1);
- if (ary1)
- {
- ary2 = make_fortran(ary1, &is_new2, 0, 0);
- if (is_new1 && is_new2)
- {
- Py_DECREF(ary1);
- }
- ary1 = ary2;
- }
- *is_new_object = is_new1 || is_new2;
- return ary1;
- }
-
-} /* end fragment */
-
-
-/**********************************************************************/
-
-%fragment("NumPy_Array_Requirements", "header",
- fragment="NumPy_Backward_Compatibility",
- fragment="NumPy_Macros")
-{
- /* Test whether a python object is contiguous. If array is
- * contiguous, return 1. Otherwise, set the python error string and
- * return 0.
- */
- int require_contiguous(PyArrayObject* ary)
- {
- int contiguous = 1;
- if (!array_is_contiguous(ary))
- {
- PyErr_SetString(PyExc_TypeError,
- "Array must be contiguous. A non-contiguous array was given");
- contiguous = 0;
- }
- return contiguous;
- }
-
- /* Require that a numpy array is not byte-swapped. If the array is
- * not byte-swapped, return 1. Otherwise, set the python error string
- * and return 0.
- */
- int require_native(PyArrayObject* ary)
- {
- int native = 1;
- if (!array_is_native(ary))
- {
- PyErr_SetString(PyExc_TypeError,
- "Array must have native byteorder. "
- "A byte-swapped array was given");
- native = 0;
- }
- return native;
- }
-
- /* Require the given PyArrayObject to have a specified number of
- * dimensions. If the array has the specified number of dimensions,
- * return 1. Otherwise, set the python error string and return 0.
- */
- int require_dimensions(PyArrayObject* ary, int exact_dimensions)
- {
- int success = 1;
- if (array_numdims(ary) != exact_dimensions)
- {
- PyErr_Format(PyExc_TypeError,
- "Array must have %d dimensions. Given array has %d dimensions",
- exact_dimensions, array_numdims(ary));
- success = 0;
- }
- return success;
- }
-
- /* Require the given PyArrayObject to have one of a list of specified
- * number of dimensions. If the array has one of the specified number
- * of dimensions, return 1. Otherwise, set the python error string
- * and return 0.
- */
- int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n)
- {
- int success = 0;
- int i;
- char dims_str[255] = "";
- char s[255];
- for (i = 0; i < n && !success; i++)
- {
- if (array_numdims(ary) == exact_dimensions[i])
- {
- success = 1;
- }
- }
- if (!success)
- {
- for (i = 0; i < n-1; i++)
- {
- sprintf(s, "%d, ", exact_dimensions[i]);
- strcat(dims_str,s);
- }
- sprintf(s, " or %d", exact_dimensions[n-1]);
- strcat(dims_str,s);
- PyErr_Format(PyExc_TypeError,
- "Array must have %s dimensions. Given array has %d dimensions",
- dims_str, array_numdims(ary));
- }
- return success;
- }
-
- /* Require the given PyArrayObject to have a specified shape. If the
- * array has the specified shape, return 1. Otherwise, set the python
- * error string and return 0.
- */
- int require_size(PyArrayObject* ary, npy_intp* size, int n)
- {
- int i;
- int success = 1;
- int len;
- char desired_dims[255] = "[";
- char s[255];
- char actual_dims[255] = "[";
- for(i=0; i < n;i++)
- {
- if (size[i] != -1 && size[i] != array_size(ary,i))
- {
- success = 0;
- }
- }
- if (!success)
- {
- for (i = 0; i < n; i++)
- {
- if (size[i] == -1)
- {
- sprintf(s, "*,");
- }
- else
- {
- sprintf(s, "%ld,", (long int)size[i]);
- }
- strcat(desired_dims,s);
- }
- len = strlen(desired_dims);
- desired_dims[len-1] = ']';
- for (i = 0; i < n; i++)
- {
- sprintf(s, "%ld,", (long int)array_size(ary,i));
- strcat(actual_dims,s);
- }
- len = strlen(actual_dims);
- actual_dims[len-1] = ']';
- PyErr_Format(PyExc_TypeError,
- "Array must have shape of %s. Given array has shape of %s",
- desired_dims, actual_dims);
- }
- return success;
- }
-
- /* Require the given PyArrayObject to to be FORTRAN ordered. If the
- * the PyArrayObject is already FORTRAN ordered, do nothing. Else,
- * set the FORTRAN ordering flag and recompute the strides.
- */
- int require_fortran(PyArrayObject* ary)
- {
- int success = 1;
- int nd = array_numdims(ary);
- int i;
- if (array_is_fortran(ary)) return success;
- /* Set the FORTRAN ordered flag */
- ary->flags = NPY_FARRAY;
- /* Recompute the strides */
- ary->strides[0] = ary->strides[nd-1];
- for (i=1; i < nd; ++i)
- ary->strides[i] = ary->strides[i-1] * array_size(ary,i-1);
- return success;
- }
-}
-
-/* Combine all NumPy fragments into one for convenience */
-%fragment("NumPy_Fragments", "header",
- fragment="NumPy_Backward_Compatibility",
- fragment="NumPy_Macros",
- fragment="NumPy_Utilities",
- fragment="NumPy_Object_to_Array",
- fragment="NumPy_Array_Requirements") { }
-
-/* End John Hunter translation (with modifications by Bill Spotz)
- */
-
-/* %numpy_typemaps() macro
- *
- * This macro defines a family of 41 typemaps that allow C arguments
- * of the form
- *
- * (DATA_TYPE IN_ARRAY1[ANY])
- * (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
- * (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
- *
- * (DATA_TYPE IN_ARRAY2[ANY][ANY])
- * (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
- * (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
- *
- * (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
- * (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
- * (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
- *
- * (DATA_TYPE INPLACE_ARRAY1[ANY])
- * (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
- * (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
- *
- * (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
- * (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
- * (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
- *
- * (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
- * (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
- * (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
- *
- * (DATA_TYPE ARGOUT_ARRAY1[ANY])
- * (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
- * (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
- *
- * (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
- *
- * (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
- *
- * (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
- * (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
- *
- * (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
- * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
- * (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
- * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
- *
- * (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
- * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
- * (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
- * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
- *
- * where "DATA_TYPE" is any type supported by the NumPy module, and
- * "DIM_TYPE" is any int-like type suitable for specifying dimensions.
- * The difference between "ARRAY" typemaps and "FARRAY" typemaps is
- * that the "FARRAY" typemaps expect FORTRAN ordering of
- * multidimensional arrays. In python, the dimensions will not need
- * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1"
- * typemaps). The IN_ARRAYs can be a numpy array or any sequence that
- * can be converted to a numpy array of the specified type. The
- * INPLACE_ARRAYs must be numpy arrays of the appropriate type. The
- * ARGOUT_ARRAYs will be returned as new numpy arrays of the
- * appropriate type.
- *
- * These typemaps can be applied to existing functions using the
- * %apply directive. For example:
- *
- * %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)};
- * double prod(double* series, int length);
- *
- * %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2)
- * {(int rows, int cols, double* matrix )};
- * void floor(int rows, int cols, double* matrix, double f);
- *
- * %apply (double IN_ARRAY3[ANY][ANY][ANY])
- * {(double tensor[2][2][2] )};
- * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])
- * {(double low[2][2][2] )};
- * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])
- * {(double upp[2][2][2] )};
- * void luSplit(double tensor[2][2][2],
- * double low[2][2][2],
- * double upp[2][2][2] );
- *
- * or directly with
- *
- * double prod(double* IN_ARRAY1, int DIM1);
- *
- * void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f);
- *
- * void luSplit(double IN_ARRAY3[ANY][ANY][ANY],
- * double ARGOUT_ARRAY3[ANY][ANY][ANY],
- * double ARGOUT_ARRAY3[ANY][ANY][ANY]);
- */
-
-%define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE)
-
-/************************/
-/* Input Array Typemaps */
-/************************/
-
-/* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY])
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE IN_ARRAY1[ANY])
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE IN_ARRAY1[ANY])
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[1] = { $1_dim0 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 1) ||
- !require_size(array, size, 1)) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-%typemap(freearg)
- (DATA_TYPE IN_ARRAY1[ANY])
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[1] = { -1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 1) ||
- !require_size(array, size, 1)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
-}
-%typemap(freearg)
- (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[1] = {-1};
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 1) ||
- !require_size(array, size, 1)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DATA_TYPE*) array_data(array);
-}
-%typemap(freearg)
- (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY])
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE IN_ARRAY2[ANY][ANY])
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE IN_ARRAY2[ANY][ANY])
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[2] = { $1_dim0, $1_dim1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 2) ||
- !require_size(array, size, 2)) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-%typemap(freearg)
- (DATA_TYPE IN_ARRAY2[ANY][ANY])
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[2] = { -1, -1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 2) ||
- !require_size(array, size, 2)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
-}
-%typemap(freearg)
- (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[2] = { -1, -1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 2) ||
- !require_size(array, size, 2)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DATA_TYPE*) array_data(array);
-}
-%typemap(freearg)
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[2] = { -1, -1 };
- array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 2) ||
- !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
-}
-%typemap(freearg)
- (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[2] = { -1, -1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 2) ||
- !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DATA_TYPE*) array_data(array);
-}
-%typemap(freearg)
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 3) ||
- !require_size(array, size, 3)) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-%typemap(freearg)
- (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
- * DIM_TYPE DIM3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[3] = { -1, -1, -1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 3) ||
- !require_size(array, size, 3)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
- $4 = (DIM_TYPE) array_size(array,2);
-}
-%typemap(freearg)
- (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
- * DATA_TYPE* IN_ARRAY3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[3] = { -1, -1, -1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 3) ||
- !require_size(array, size, 3)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DIM_TYPE) array_size(array,2);
- $4 = (DATA_TYPE*) array_data(array);
-}
-%typemap(freearg)
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
- * DIM_TYPE DIM3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[3] = { -1, -1, -1 };
- array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 3) ||
- !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
- $4 = (DIM_TYPE) array_size(array,2);
-}
-%typemap(freearg)
- (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
- * DATA_TYPE* IN_FARRAY3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
-{
- $1 = is_array($input) || PySequence_Check($input);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
- (PyArrayObject* array=NULL, int is_new_object=0)
-{
- npy_intp size[3] = { -1, -1, -1 };
- array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
- &is_new_object);
- if (!array || !require_dimensions(array, 3) ||
- !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DIM_TYPE) array_size(array,2);
- $4 = (DATA_TYPE*) array_data(array);
-}
-%typemap(freearg)
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
-{
- if (is_new_object$argnum && array$argnum)
- { Py_DECREF(array$argnum); }
-}
-
-/***************************/
-/* In-Place Array Typemaps */
-/***************************/
-
-/* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY])
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE INPLACE_ARRAY1[ANY])
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE INPLACE_ARRAY1[ANY])
- (PyArrayObject* array=NULL)
-{
- npy_intp size[1] = { $1_dim0 };
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) ||
- !require_contiguous(array) || !require_native(array)) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-
-/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
- (PyArrayObject* array=NULL, int i=1)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,1) || !require_contiguous(array)
- || !require_native(array)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = 1;
- for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i);
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
- (PyArrayObject* array=NULL, int i=0)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,1) || !require_contiguous(array)
- || !require_native(array)) SWIG_fail;
- $1 = 1;
- for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i);
- $2 = (DATA_TYPE*) array_data(array);
-}
-
-/* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
- (PyArrayObject* array=NULL)
-{
- npy_intp size[2] = { $1_dim0, $1_dim1 };
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) ||
- !require_contiguous(array) || !require_native(array)) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-
-/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,2) || !require_contiguous(array)
- || !require_native(array)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||
- !require_native(array)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DATA_TYPE*) array_data(array);
-}
-
-/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,2) || !require_contiguous(array)
- || !require_native(array) || !require_fortran(array)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||
- !require_native(array) || !require_fortran(array)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DATA_TYPE*) array_data(array);
-}
-
-/* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
- (PyArrayObject* array=NULL)
-{
- npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) ||
- !require_contiguous(array) || !require_native(array)) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-
-/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
- * DIM_TYPE DIM3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||
- !require_native(array)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
- $4 = (DIM_TYPE) array_size(array,2);
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
- * DATA_TYPE* INPLACE_ARRAY3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,3) || !require_contiguous(array)
- || !require_native(array)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DIM_TYPE) array_size(array,2);
- $4 = (DATA_TYPE*) array_data(array);
-}
-
-/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
- * DIM_TYPE DIM3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||
- !require_native(array) || !require_fortran(array)) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
- $2 = (DIM_TYPE) array_size(array,0);
- $3 = (DIM_TYPE) array_size(array,1);
- $4 = (DIM_TYPE) array_size(array,2);
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
- * DATA_TYPE* INPLACE_FARRAY3)
- */
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
- fragment="NumPy_Macros")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
-{
- $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
- DATA_TYPECODE);
-}
-%typemap(in,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
- (PyArrayObject* array=NULL)
-{
- array = obj_to_array_no_conversion($input, DATA_TYPECODE);
- if (!array || !require_dimensions(array,3) || !require_contiguous(array)
- || !require_native(array) || !require_fortran(array)) SWIG_fail;
- $1 = (DIM_TYPE) array_size(array,0);
- $2 = (DIM_TYPE) array_size(array,1);
- $3 = (DIM_TYPE) array_size(array,2);
- $4 = (DATA_TYPE*) array_data(array);
-}
-
-/*************************/
-/* Argout Array Typemaps */
-/*************************/
-
-/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY])
- */
-%typemap(in,numinputs=0,
- fragment="NumPy_Backward_Compatibility,NumPy_Macros")
- (DATA_TYPE ARGOUT_ARRAY1[ANY])
- (PyObject * array = NULL)
-{
- npy_intp dims[1] = { $1_dim0 };
- array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
- if (!array) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-%typemap(argout)
- (DATA_TYPE ARGOUT_ARRAY1[ANY])
-{
- $result = SWIG_Python_AppendOutput($result,array$argnum);
-}
-
-/* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
- */
-%typemap(in,numinputs=1,
- fragment="NumPy_Fragments")
- (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
- (PyObject * array = NULL)
-{
- npy_intp dims[1];
- if (!PyInt_Check($input))
- {
- char* typestring = pytype_string($input);
- PyErr_Format(PyExc_TypeError,
- "Int dimension expected. '%s' given.",
- typestring);
- SWIG_fail;
- }
- $2 = (DIM_TYPE) PyInt_AsLong($input);
- dims[0] = (npy_intp) $2;
- array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
- if (!array) SWIG_fail;
- $1 = (DATA_TYPE*) array_data(array);
-}
-%typemap(argout)
- (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
-{
- $result = SWIG_Python_AppendOutput($result,array$argnum);
-}
-
-/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
- */
-%typemap(in,numinputs=1,
- fragment="NumPy_Fragments")
- (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
- (PyObject * array = NULL)
-{
- npy_intp dims[1];
- if (!PyInt_Check($input))
- {
- char* typestring = pytype_string($input);
- PyErr_Format(PyExc_TypeError,
- "Int dimension expected. '%s' given.",
- typestring);
- SWIG_fail;
- }
- $1 = (DIM_TYPE) PyInt_AsLong($input);
- dims[0] = (npy_intp) $1;
- array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
- if (!array) SWIG_fail;
- $2 = (DATA_TYPE*) array_data(array);
-}
-%typemap(argout)
- (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
-{
- $result = SWIG_Python_AppendOutput($result,array$argnum);
-}
-
-/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
- */
-%typemap(in,numinputs=0,
- fragment="NumPy_Backward_Compatibility,NumPy_Macros")
- (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
- (PyObject * array = NULL)
-{
- npy_intp dims[2] = { $1_dim0, $1_dim1 };
- array = PyArray_SimpleNew(2, dims, DATA_TYPECODE);
- if (!array) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-%typemap(argout)
- (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
-{
- $result = SWIG_Python_AppendOutput($result,array$argnum);
-}
-
-/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
- */
-%typemap(in,numinputs=0,
- fragment="NumPy_Backward_Compatibility,NumPy_Macros")
- (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
- (PyObject * array = NULL)
-{
- npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 };
- array = PyArray_SimpleNew(3, dims, DATA_TYPECODE);
- if (!array) SWIG_fail;
- $1 = ($1_ltype) array_data(array);
-}
-%typemap(argout)
- (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
-{
- $result = SWIG_Python_AppendOutput($result,array$argnum);
-}
-
-/*****************************/
-/* Argoutview Array Typemaps */
-/*****************************/
-
-/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
- */
-%typemap(in,numinputs=0)
- (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1 )
- (DATA_TYPE* data_temp , DIM_TYPE dim_temp)
-{
- $1 = &data_temp;
- $2 = &dim_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility")
- (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
-{
- npy_intp dims[1] = { *$2 };
- PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1));
- if (!array) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,array);
-}
-
-/* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
- */
-%typemap(in,numinputs=0)
- (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEW_ARRAY1)
- (DIM_TYPE dim_temp, DATA_TYPE* data_temp )
-{
- $1 = &dim_temp;
- $2 = &data_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility")
- (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
-{
- npy_intp dims[1] = { *$1 };
- PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2));
- if (!array) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,array);
-}
-
-/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
- */
-%typemap(in,numinputs=0)
- (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 )
- (DATA_TYPE* data_temp , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp)
-{
- $1 = &data_temp;
- $2 = &dim1_temp;
- $3 = &dim2_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility")
- (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
-{
- npy_intp dims[2] = { *$2, *$3 };
- PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
- if (!array) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,array);
-}
-
-/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
- */
-%typemap(in,numinputs=0)
- (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_ARRAY2)
- (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp )
-{
- $1 = &dim1_temp;
- $2 = &dim2_temp;
- $3 = &data_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility")
- (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
-{
- npy_intp dims[2] = { *$1, *$2 };
- PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
- if (!array) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,array);
-}
-
-/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
- */
-%typemap(in,numinputs=0)
- (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 )
- (DATA_TYPE* data_temp , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp)
-{
- $1 = &data_temp;
- $2 = &dim1_temp;
- $3 = &dim2_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
- (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
-{
- npy_intp dims[2] = { *$2, *$3 };
- PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
- PyArrayObject * array = (PyArrayObject*) obj;
- if (!array || !require_fortran(array)) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,obj);
-}
-
-/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
- */
-%typemap(in,numinputs=0)
- (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_FARRAY2)
- (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp )
-{
- $1 = &dim1_temp;
- $2 = &dim2_temp;
- $3 = &data_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
- (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
-{
- npy_intp dims[2] = { *$1, *$2 };
- PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
- PyArrayObject * array = (PyArrayObject*) obj;
- if (!array || !require_fortran(array)) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,obj);
-}
-
-/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
- DIM_TYPE* DIM3)
- */
-%typemap(in,numinputs=0)
- (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
- (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
-{
- $1 = &data_temp;
- $2 = &dim1_temp;
- $3 = &dim2_temp;
- $4 = &dim3_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility")
- (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
-{
- npy_intp dims[3] = { *$2, *$3, *$4 };
- PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
- if (!array) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,array);
-}
-
-/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
- DATA_TYPE** ARGOUTVIEW_ARRAY3)
- */
-%typemap(in,numinputs=0)
- (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
- (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp)
-{
- $1 = &dim1_temp;
- $2 = &dim2_temp;
- $3 = &dim3_temp;
- $4 = &data_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility")
- (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
-{
- npy_intp dims[3] = { *$1, *$2, *$3 };
- PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3));
- if (!array) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,array);
-}
-
-/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
- DIM_TYPE* DIM3)
- */
-%typemap(in,numinputs=0)
- (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
- (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
-{
- $1 = &data_temp;
- $2 = &dim1_temp;
- $3 = &dim2_temp;
- $4 = &dim3_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
- (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
-{
- npy_intp dims[3] = { *$2, *$3, *$4 };
- PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
- PyArrayObject * array = (PyArrayObject*) obj;
- if (!array || require_fortran(array)) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,obj);
-}
-
-/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
- DATA_TYPE** ARGOUTVIEW_FARRAY3)
- */
-%typemap(in,numinputs=0)
- (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
- (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp)
-{
- $1 = &dim1_temp;
- $2 = &dim2_temp;
- $3 = &dim3_temp;
- $4 = &data_temp;
-}
-%typemap(argout,
- fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
- (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
-{
- npy_intp dims[3] = { *$1, *$2, *$3 };
- PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3));
- PyArrayObject * array = (PyArrayObject*) obj;
- if (!array || require_fortran(array)) SWIG_fail;
- $result = SWIG_Python_AppendOutput($result,obj);
-}
-
-%enddef /* %numpy_typemaps() macro */
-/* *************************************************************** */
-
-/* Concrete instances of the %numpy_typemaps() macro: Each invocation
- * below applies all of the typemaps above to the specified data type.
- */
-%numpy_typemaps(signed char , NPY_BYTE , int)
-%numpy_typemaps(unsigned char , NPY_UBYTE , int)
-%numpy_typemaps(short , NPY_SHORT , int)
-%numpy_typemaps(unsigned short , NPY_USHORT , int)
-%numpy_typemaps(int , NPY_INT , int)
-%numpy_typemaps(unsigned int , NPY_UINT , int)
-%numpy_typemaps(long , NPY_LONG , int)
-%numpy_typemaps(unsigned long , NPY_ULONG , int)
-%numpy_typemaps(long long , NPY_LONGLONG , int)
-%numpy_typemaps(unsigned long long, NPY_ULONGLONG, int)
-%numpy_typemaps(float , NPY_FLOAT , int)
-%numpy_typemaps(double , NPY_DOUBLE , int)
-
-/* ***************************************************************
- * The follow macro expansion does not work, because C++ bool is 4
- * bytes and NPY_BOOL is 1 byte
- *
- * %numpy_typemaps(bool, NPY_BOOL, int)
- */
-
-/* ***************************************************************
- * On my Mac, I get the following warning for this macro expansion:
- * 'swig/python detected a memory leak of type 'long double *', no destructor found.'
- *
- * %numpy_typemaps(long double, NPY_LONGDOUBLE, int)
- */
-
-/* ***************************************************************
- * Swig complains about a syntax error for the following macro
- * expansions:
- *
- * %numpy_typemaps(complex float, NPY_CFLOAT , int)
- *
- * %numpy_typemaps(complex double, NPY_CDOUBLE, int)
- *
- * %numpy_typemaps(complex long double, NPY_CLONGDOUBLE, int)
- */
-
-#endif /* SWIGPYTHON */
--- /dev/null
+/* -*- C -*- (not really, but good for syntax highlighting) */
+#ifdef SWIGPYTHON
+
+%{
+#ifndef SWIG_FILE_WITH_INIT
+# define NO_IMPORT_ARRAY
+#endif
+#include "stdio.h"
+#include <numpy/arrayobject.h>
+%}
+
+/**********************************************************************/
+
+%fragment("NumPy_Backward_Compatibility", "header")
+{
+/* Support older NumPy data type names
+*/
+%#if NDARRAY_VERSION < 0x01000000
+%#define NPY_BOOL PyArray_BOOL
+%#define NPY_BYTE PyArray_BYTE
+%#define NPY_UBYTE PyArray_UBYTE
+%#define NPY_SHORT PyArray_SHORT
+%#define NPY_USHORT PyArray_USHORT
+%#define NPY_INT PyArray_INT
+%#define NPY_UINT PyArray_UINT
+%#define NPY_LONG PyArray_LONG
+%#define NPY_ULONG PyArray_ULONG
+%#define NPY_LONGLONG PyArray_LONGLONG
+%#define NPY_ULONGLONG PyArray_ULONGLONG
+%#define NPY_FLOAT PyArray_FLOAT
+%#define NPY_DOUBLE PyArray_DOUBLE
+%#define NPY_LONGDOUBLE PyArray_LONGDOUBLE
+%#define NPY_CFLOAT PyArray_CFLOAT
+%#define NPY_CDOUBLE PyArray_CDOUBLE
+%#define NPY_CLONGDOUBLE PyArray_CLONGDOUBLE
+%#define NPY_OBJECT PyArray_OBJECT
+%#define NPY_STRING PyArray_STRING
+%#define NPY_UNICODE PyArray_UNICODE
+%#define NPY_VOID PyArray_VOID
+%#define NPY_NTYPES PyArray_NTYPES
+%#define NPY_NOTYPE PyArray_NOTYPE
+%#define NPY_CHAR PyArray_CHAR
+%#define NPY_USERDEF PyArray_USERDEF
+%#define npy_intp intp
+
+%#define NPY_MAX_BYTE MAX_BYTE
+%#define NPY_MIN_BYTE MIN_BYTE
+%#define NPY_MAX_UBYTE MAX_UBYTE
+%#define NPY_MAX_SHORT MAX_SHORT
+%#define NPY_MIN_SHORT MIN_SHORT
+%#define NPY_MAX_USHORT MAX_USHORT
+%#define NPY_MAX_INT MAX_INT
+%#define NPY_MIN_INT MIN_INT
+%#define NPY_MAX_UINT MAX_UINT
+%#define NPY_MAX_LONG MAX_LONG
+%#define NPY_MIN_LONG MIN_LONG
+%#define NPY_MAX_ULONG MAX_ULONG
+%#define NPY_MAX_LONGLONG MAX_LONGLONG
+%#define NPY_MIN_LONGLONG MIN_LONGLONG
+%#define NPY_MAX_ULONGLONG MAX_ULONGLONG
+%#define NPY_MAX_INTP MAX_INTP
+%#define NPY_MIN_INTP MIN_INTP
+
+%#define NPY_FARRAY FARRAY
+%#define NPY_F_CONTIGUOUS F_CONTIGUOUS
+%#endif
+}
+
+/**********************************************************************/
+
+/* The following code originally appeared in
+ * enthought/kiva/agg/src/numeric.i written by Eric Jones. It was
+ * translated from C++ to C by John Hunter. Bill Spotz has modified
+ * it to fix some minor bugs, upgrade from Numeric to numpy (all
+ * versions), add some comments and functionality, and convert from
+ * direct code insertion to SWIG fragments.
+ */
+
+%fragment("NumPy_Macros", "header")
+{
+/* Macros to extract array attributes.
+ */
+%#define is_array(a) ((a) && PyArray_Check((PyArrayObject *)a))
+%#define array_type(a) (int)(PyArray_TYPE(a))
+%#define array_numdims(a) (((PyArrayObject *)a)->nd)
+%#define array_dimensions(a) (((PyArrayObject *)a)->dimensions)
+%#define array_size(a,i) (((PyArrayObject *)a)->dimensions[i])
+%#define array_data(a) (((PyArrayObject *)a)->data)
+%#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a))
+%#define array_is_native(a) (PyArray_ISNOTSWAPPED(a))
+%#define array_is_fortran(a) (PyArray_ISFORTRAN(a))
+}
+
+/**********************************************************************/
+
+%fragment("NumPy_Utilities", "header")
+{
+ /* Given a PyObject, return a string describing its type.
+ */
+ char* pytype_string(PyObject* py_obj) {
+ if (py_obj == NULL ) return "C NULL value";
+ if (py_obj == Py_None ) return "Python None" ;
+ if (PyCallable_Check(py_obj)) return "callable" ;
+ if (PyString_Check( py_obj)) return "string" ;
+ if (PyInt_Check( py_obj)) return "int" ;
+ if (PyFloat_Check( py_obj)) return "float" ;
+ if (PyDict_Check( py_obj)) return "dict" ;
+ if (PyList_Check( py_obj)) return "list" ;
+ if (PyTuple_Check( py_obj)) return "tuple" ;
+ if (PyFile_Check( py_obj)) return "file" ;
+ if (PyModule_Check( py_obj)) return "module" ;
+ if (PyInstance_Check(py_obj)) return "instance" ;
+
+ return "unknow type";
+ }
+
+ /* Given a NumPy typecode, return a string describing the type.
+ */
+ char* typecode_string(int typecode) {
+ static char* type_names[25] = {"bool", "byte", "unsigned byte",
+ "short", "unsigned short", "int",
+ "unsigned int", "long", "unsigned long",
+ "long long", "unsigned long long",
+ "float", "double", "long double",
+ "complex float", "complex double",
+ "complex long double", "object",
+ "string", "unicode", "void", "ntypes",
+ "notype", "char", "unknown"};
+ return typecode < 24 ? type_names[typecode] : type_names[24];
+ }
+
+ /* Make sure input has correct numpy type. Allow character and byte
+ * to match. Also allow int and long to match. This is deprecated.
+ * You should use PyArray_EquivTypenums() instead.
+ */
+ int type_match(int actual_type, int desired_type) {
+ return PyArray_EquivTypenums(actual_type, desired_type);
+ }
+}
+
+/**********************************************************************/
+
+%fragment("NumPy_Object_to_Array", "header",
+ fragment="NumPy_Backward_Compatibility",
+ fragment="NumPy_Macros",
+ fragment="NumPy_Utilities")
+{
+ /* Given a PyObject pointer, cast it to a PyArrayObject pointer if
+ * legal. If not, set the python error string appropriately and
+ * return NULL.
+ */
+ PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode)
+ {
+ PyArrayObject* ary = NULL;
+ if (is_array(input) && (typecode == NPY_NOTYPE ||
+ PyArray_EquivTypenums(array_type(input), typecode)))
+ {
+ ary = (PyArrayObject*) input;
+ }
+ else if is_array(input)
+ {
+ char* desired_type = typecode_string(typecode);
+ char* actual_type = typecode_string(array_type(input));
+ PyErr_Format(PyExc_TypeError,
+ "Array of type '%s' required. Array of type '%s' given",
+ desired_type, actual_type);
+ ary = NULL;
+ }
+ else
+ {
+ char * desired_type = typecode_string(typecode);
+ char * actual_type = pytype_string(input);
+ PyErr_Format(PyExc_TypeError,
+ "Array of type '%s' required. A '%s' was given",
+ desired_type, actual_type);
+ ary = NULL;
+ }
+ return ary;
+ }
+
+ /* Convert the given PyObject to a NumPy array with the given
+ * typecode. On success, return a valid PyArrayObject* with the
+ * correct type. On failure, the python error string will be set and
+ * the routine returns NULL.
+ */
+ PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode,
+ int* is_new_object)
+ {
+ PyArrayObject* ary = NULL;
+ PyObject* py_obj;
+ if (is_array(input) && (typecode == NPY_NOTYPE ||
+ PyArray_EquivTypenums(array_type(input),typecode)))
+ {
+ ary = (PyArrayObject*) input;
+ *is_new_object = 0;
+ }
+ else
+ {
+ py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_DEFAULT);
+ /* If NULL, PyArray_FromObject will have set python error value.*/
+ ary = (PyArrayObject*) py_obj;
+ *is_new_object = 1;
+ }
+ return ary;
+ }
+
+ /* Given a PyArrayObject, check to see if it is contiguous. If so,
+ * return the input pointer and flag it as not a new object. If it is
+ * not contiguous, create a new PyArrayObject using the original data,
+ * flag it as a new object and return the pointer.
+ */
+ PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object,
+ int min_dims, int max_dims)
+ {
+ PyArrayObject* result;
+ if (array_is_contiguous(ary))
+ {
+ result = ary;
+ *is_new_object = 0;
+ }
+ else
+ {
+ result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
+ array_type(ary),
+ min_dims,
+ max_dims);
+ *is_new_object = 1;
+ }
+ return result;
+ }
+
+ /* Given a PyArrayObject, check to see if it is Fortran-contiguous.
+ * If so, return the input pointer, but do not flag it as not a new
+ * object. If it is not Fortran-contiguous, create a new
+ * PyArrayObject using the original data, flag it as a new object
+ * and return the pointer.
+ */
+ PyArrayObject* make_fortran(PyArrayObject* ary, int* is_new_object,
+ int min_dims, int max_dims)
+ {
+ PyArrayObject* result;
+ if (array_is_fortran(ary))
+ {
+ result = ary;
+ *is_new_object = 0;
+ }
+ else
+ {
+ Py_INCREF(ary->descr);
+ result = (PyArrayObject*) PyArray_FromArray(ary, ary->descr, NPY_FORTRAN);
+ *is_new_object = 1;
+ }
+ return result;
+ }
+
+ /* Convert a given PyObject to a contiguous PyArrayObject of the
+ * specified type. If the input object is not a contiguous
+ * PyArrayObject, a new one will be created and the new object flag
+ * will be set.
+ */
+ PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
+ int typecode,
+ int* is_new_object)
+ {
+ int is_new1 = 0;
+ int is_new2 = 0;
+ PyArrayObject* ary2;
+ PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode,
+ &is_new1);
+ if (ary1)
+ {
+ ary2 = make_contiguous(ary1, &is_new2, 0, 0);
+ if ( is_new1 && is_new2)
+ {
+ Py_DECREF(ary1);
+ }
+ ary1 = ary2;
+ }
+ *is_new_object = is_new1 || is_new2;
+ return ary1;
+ }
+
+ /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the
+ * specified type. If the input object is not a Fortran-ordered
+ * PyArrayObject, a new one will be created and the new object flag
+ * will be set.
+ */
+ PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input,
+ int typecode,
+ int* is_new_object)
+ {
+ int is_new1 = 0;
+ int is_new2 = 0;
+ PyArrayObject* ary2;
+ PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode,
+ &is_new1);
+ if (ary1)
+ {
+ ary2 = make_fortran(ary1, &is_new2, 0, 0);
+ if (is_new1 && is_new2)
+ {
+ Py_DECREF(ary1);
+ }
+ ary1 = ary2;
+ }
+ *is_new_object = is_new1 || is_new2;
+ return ary1;
+ }
+
+} /* end fragment */
+
+
+/**********************************************************************/
+
+%fragment("NumPy_Array_Requirements", "header",
+ fragment="NumPy_Backward_Compatibility",
+ fragment="NumPy_Macros")
+{
+ /* Test whether a python object is contiguous. If array is
+ * contiguous, return 1. Otherwise, set the python error string and
+ * return 0.
+ */
+ int require_contiguous(PyArrayObject* ary)
+ {
+ int contiguous = 1;
+ if (!array_is_contiguous(ary))
+ {
+ PyErr_SetString(PyExc_TypeError,
+ "Array must be contiguous. A non-contiguous array was given");
+ contiguous = 0;
+ }
+ return contiguous;
+ }
+
+ /* Require that a numpy array is not byte-swapped. If the array is
+ * not byte-swapped, return 1. Otherwise, set the python error string
+ * and return 0.
+ */
+ int require_native(PyArrayObject* ary)
+ {
+ int native = 1;
+ if (!array_is_native(ary))
+ {
+ PyErr_SetString(PyExc_TypeError,
+ "Array must have native byteorder. "
+ "A byte-swapped array was given");
+ native = 0;
+ }
+ return native;
+ }
+
+ /* Require the given PyArrayObject to have a specified number of
+ * dimensions. If the array has the specified number of dimensions,
+ * return 1. Otherwise, set the python error string and return 0.
+ */
+ int require_dimensions(PyArrayObject* ary, int exact_dimensions)
+ {
+ int success = 1;
+ if (array_numdims(ary) != exact_dimensions)
+ {
+ PyErr_Format(PyExc_TypeError,
+ "Array must have %d dimensions. Given array has %d dimensions",
+ exact_dimensions, array_numdims(ary));
+ success = 0;
+ }
+ return success;
+ }
+
+ /* Require the given PyArrayObject to have one of a list of specified
+ * number of dimensions. If the array has one of the specified number
+ * of dimensions, return 1. Otherwise, set the python error string
+ * and return 0.
+ */
+ int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n)
+ {
+ int success = 0;
+ int i;
+ char dims_str[255] = "";
+ char s[255];
+ for (i = 0; i < n && !success; i++)
+ {
+ if (array_numdims(ary) == exact_dimensions[i])
+ {
+ success = 1;
+ }
+ }
+ if (!success)
+ {
+ for (i = 0; i < n-1; i++)
+ {
+ sprintf(s, "%d, ", exact_dimensions[i]);
+ strcat(dims_str,s);
+ }
+ sprintf(s, " or %d", exact_dimensions[n-1]);
+ strcat(dims_str,s);
+ PyErr_Format(PyExc_TypeError,
+ "Array must have %s dimensions. Given array has %d dimensions",
+ dims_str, array_numdims(ary));
+ }
+ return success;
+ }
+
+ /* Require the given PyArrayObject to have a specified shape. If the
+ * array has the specified shape, return 1. Otherwise, set the python
+ * error string and return 0.
+ */
+ int require_size(PyArrayObject* ary, npy_intp* size, int n)
+ {
+ int i;
+ int success = 1;
+ int len;
+ char desired_dims[255] = "[";
+ char s[255];
+ char actual_dims[255] = "[";
+ for(i=0; i < n;i++)
+ {
+ if (size[i] != -1 && size[i] != array_size(ary,i))
+ {
+ success = 0;
+ }
+ }
+ if (!success)
+ {
+ for (i = 0; i < n; i++)
+ {
+ if (size[i] == -1)
+ {
+ sprintf(s, "*,");
+ }
+ else
+ {
+ sprintf(s, "%ld,", (long int)size[i]);
+ }
+ strcat(desired_dims,s);
+ }
+ len = strlen(desired_dims);
+ desired_dims[len-1] = ']';
+ for (i = 0; i < n; i++)
+ {
+ sprintf(s, "%ld,", (long int)array_size(ary,i));
+ strcat(actual_dims,s);
+ }
+ len = strlen(actual_dims);
+ actual_dims[len-1] = ']';
+ PyErr_Format(PyExc_TypeError,
+ "Array must have shape of %s. Given array has shape of %s",
+ desired_dims, actual_dims);
+ }
+ return success;
+ }
+
+ /* Require the given PyArrayObject to to be FORTRAN ordered. If the
+ * the PyArrayObject is already FORTRAN ordered, do nothing. Else,
+ * set the FORTRAN ordering flag and recompute the strides.
+ */
+ int require_fortran(PyArrayObject* ary)
+ {
+ int success = 1;
+ int nd = array_numdims(ary);
+ int i;
+ if (array_is_fortran(ary)) return success;
+ /* Set the FORTRAN ordered flag */
+ ary->flags = NPY_FARRAY;
+ /* Recompute the strides */
+ ary->strides[0] = ary->strides[nd-1];
+ for (i=1; i < nd; ++i)
+ ary->strides[i] = ary->strides[i-1] * array_size(ary,i-1);
+ return success;
+ }
+}
+
+/* Combine all NumPy fragments into one for convenience */
+%fragment("NumPy_Fragments", "header",
+ fragment="NumPy_Backward_Compatibility",
+ fragment="NumPy_Macros",
+ fragment="NumPy_Utilities",
+ fragment="NumPy_Object_to_Array",
+ fragment="NumPy_Array_Requirements") { }
+
+/* End John Hunter translation (with modifications by Bill Spotz)
+ */
+
+/* %numpy_typemaps() macro
+ *
+ * This macro defines a family of 41 typemaps that allow C arguments
+ * of the form
+ *
+ * (DATA_TYPE IN_ARRAY1[ANY])
+ * (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+ * (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+ *
+ * (DATA_TYPE IN_ARRAY2[ANY][ANY])
+ * (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+ * (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+ *
+ * (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+ * (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+ * (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+ *
+ * (DATA_TYPE INPLACE_ARRAY1[ANY])
+ * (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+ * (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+ *
+ * (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+ * (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+ * (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+ *
+ * (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+ * (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
+ * (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
+ *
+ * (DATA_TYPE ARGOUT_ARRAY1[ANY])
+ * (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+ * (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+ *
+ * (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+ *
+ * (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+ *
+ * (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
+ * (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
+ *
+ * (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
+ * (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
+ *
+ * (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
+ * (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
+ *
+ * where "DATA_TYPE" is any type supported by the NumPy module, and
+ * "DIM_TYPE" is any int-like type suitable for specifying dimensions.
+ * The difference between "ARRAY" typemaps and "FARRAY" typemaps is
+ * that the "FARRAY" typemaps expect FORTRAN ordering of
+ * multidimensional arrays. In python, the dimensions will not need
+ * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1"
+ * typemaps). The IN_ARRAYs can be a numpy array or any sequence that
+ * can be converted to a numpy array of the specified type. The
+ * INPLACE_ARRAYs must be numpy arrays of the appropriate type. The
+ * ARGOUT_ARRAYs will be returned as new numpy arrays of the
+ * appropriate type.
+ *
+ * These typemaps can be applied to existing functions using the
+ * %apply directive. For example:
+ *
+ * %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)};
+ * double prod(double* series, int length);
+ *
+ * %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2)
+ * {(int rows, int cols, double* matrix )};
+ * void floor(int rows, int cols, double* matrix, double f);
+ *
+ * %apply (double IN_ARRAY3[ANY][ANY][ANY])
+ * {(double tensor[2][2][2] )};
+ * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])
+ * {(double low[2][2][2] )};
+ * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])
+ * {(double upp[2][2][2] )};
+ * void luSplit(double tensor[2][2][2],
+ * double low[2][2][2],
+ * double upp[2][2][2] );
+ *
+ * or directly with
+ *
+ * double prod(double* IN_ARRAY1, int DIM1);
+ *
+ * void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f);
+ *
+ * void luSplit(double IN_ARRAY3[ANY][ANY][ANY],
+ * double ARGOUT_ARRAY3[ANY][ANY][ANY],
+ * double ARGOUT_ARRAY3[ANY][ANY][ANY]);
+ */
+
+%define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE)
+
+/************************/
+/* Input Array Typemaps */
+/************************/
+
+/* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE IN_ARRAY1[ANY])
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE IN_ARRAY1[ANY])
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[1] = { $1_dim0 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 1) ||
+ !require_size(array, size, 1)) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+%typemap(freearg)
+ (DATA_TYPE IN_ARRAY1[ANY])
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[1] = { -1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 1) ||
+ !require_size(array, size, 1)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+}
+%typemap(freearg)
+ (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[1] = {-1};
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 1) ||
+ !require_size(array, size, 1)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+ (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE IN_ARRAY2[ANY][ANY])
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE IN_ARRAY2[ANY][ANY])
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[2] = { $1_dim0, $1_dim1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 2) ||
+ !require_size(array, size, 2)) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+%typemap(freearg)
+ (DATA_TYPE IN_ARRAY2[ANY][ANY])
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[2] = { -1, -1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 2) ||
+ !require_size(array, size, 2)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+}
+%typemap(freearg)
+ (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[2] = { -1, -1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 2) ||
+ !require_size(array, size, 2)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[2] = { -1, -1 };
+ array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 2) ||
+ !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+}
+%typemap(freearg)
+ (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[2] = { -1, -1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 2) ||
+ !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 3) ||
+ !require_size(array, size, 3)) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+%typemap(freearg)
+ (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ * DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[3] = { -1, -1, -1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 3) ||
+ !require_size(array, size, 3)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+ $4 = (DIM_TYPE) array_size(array,2);
+}
+%typemap(freearg)
+ (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ * DATA_TYPE* IN_ARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[3] = { -1, -1, -1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 3) ||
+ !require_size(array, size, 3)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DIM_TYPE) array_size(array,2);
+ $4 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ * DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[3] = { -1, -1, -1 };
+ array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 3) ||
+ !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+ $4 = (DIM_TYPE) array_size(array,2);
+}
+%typemap(freearg)
+ (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ * DATA_TYPE* IN_FARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+{
+ $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+ (PyArrayObject* array=NULL, int is_new_object=0)
+{
+ npy_intp size[3] = { -1, -1, -1 };
+ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+ &is_new_object);
+ if (!array || !require_dimensions(array, 3) ||
+ !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DIM_TYPE) array_size(array,2);
+ $4 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+{
+ if (is_new_object$argnum && array$argnum)
+ { Py_DECREF(array$argnum); }
+}
+
+/***************************/
+/* In-Place Array Typemaps */
+/***************************/
+
+/* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE INPLACE_ARRAY1[ANY])
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE INPLACE_ARRAY1[ANY])
+ (PyArrayObject* array=NULL)
+{
+ npy_intp size[1] = { $1_dim0 };
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) ||
+ !require_contiguous(array) || !require_native(array)) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+ (PyArrayObject* array=NULL, int i=1)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,1) || !require_contiguous(array)
+ || !require_native(array)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = 1;
+ for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+ (PyArrayObject* array=NULL, int i=0)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,1) || !require_contiguous(array)
+ || !require_native(array)) SWIG_fail;
+ $1 = 1;
+ for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i);
+ $2 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+ (PyArrayObject* array=NULL)
+{
+ npy_intp size[2] = { $1_dim0, $1_dim1 };
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) ||
+ !require_contiguous(array) || !require_native(array)) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,2) || !require_contiguous(array)
+ || !require_native(array)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||
+ !require_native(array)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,2) || !require_contiguous(array)
+ || !require_native(array) || !require_fortran(array)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||
+ !require_native(array) || !require_fortran(array)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+ (PyArrayObject* array=NULL)
+{
+ npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) ||
+ !require_contiguous(array) || !require_native(array)) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ * DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||
+ !require_native(array)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+ $4 = (DIM_TYPE) array_size(array,2);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ * DATA_TYPE* INPLACE_ARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,3) || !require_contiguous(array)
+ || !require_native(array)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DIM_TYPE) array_size(array,2);
+ $4 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ * DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||
+ !require_native(array) || !require_fortran(array)) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+ $2 = (DIM_TYPE) array_size(array,0);
+ $3 = (DIM_TYPE) array_size(array,1);
+ $4 = (DIM_TYPE) array_size(array,2);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ * DATA_TYPE* INPLACE_FARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+ fragment="NumPy_Macros")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
+{
+ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+ DATA_TYPECODE);
+}
+%typemap(in,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
+ (PyArrayObject* array=NULL)
+{
+ array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+ if (!array || !require_dimensions(array,3) || !require_contiguous(array)
+ || !require_native(array) || !require_fortran(array)) SWIG_fail;
+ $1 = (DIM_TYPE) array_size(array,0);
+ $2 = (DIM_TYPE) array_size(array,1);
+ $3 = (DIM_TYPE) array_size(array,2);
+ $4 = (DATA_TYPE*) array_data(array);
+}
+
+/*************************/
+/* Argout Array Typemaps */
+/*************************/
+
+/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY])
+ */
+%typemap(in,numinputs=0,
+ fragment="NumPy_Backward_Compatibility,NumPy_Macros")
+ (DATA_TYPE ARGOUT_ARRAY1[ANY])
+ (PyObject * array = NULL)
+{
+ npy_intp dims[1] = { $1_dim0 };
+ array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
+ if (!array) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+%typemap(argout)
+ (DATA_TYPE ARGOUT_ARRAY1[ANY])
+{
+ $result = SWIG_Python_AppendOutput($result,array$argnum);
+}
+
+/* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+ */
+%typemap(in,numinputs=1,
+ fragment="NumPy_Fragments")
+ (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+ (PyObject * array = NULL)
+{
+ npy_intp dims[1];
+ if (!PyInt_Check($input))
+ {
+ char* typestring = pytype_string($input);
+ PyErr_Format(PyExc_TypeError,
+ "Int dimension expected. '%s' given.",
+ typestring);
+ SWIG_fail;
+ }
+ $2 = (DIM_TYPE) PyInt_AsLong($input);
+ dims[0] = (npy_intp) $2;
+ array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
+ if (!array) SWIG_fail;
+ $1 = (DATA_TYPE*) array_data(array);
+}
+%typemap(argout)
+ (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+{
+ $result = SWIG_Python_AppendOutput($result,array$argnum);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+ */
+%typemap(in,numinputs=1,
+ fragment="NumPy_Fragments")
+ (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+ (PyObject * array = NULL)
+{
+ npy_intp dims[1];
+ if (!PyInt_Check($input))
+ {
+ char* typestring = pytype_string($input);
+ PyErr_Format(PyExc_TypeError,
+ "Int dimension expected. '%s' given.",
+ typestring);
+ SWIG_fail;
+ }
+ $1 = (DIM_TYPE) PyInt_AsLong($input);
+ dims[0] = (npy_intp) $1;
+ array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
+ if (!array) SWIG_fail;
+ $2 = (DATA_TYPE*) array_data(array);
+}
+%typemap(argout)
+ (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+{
+ $result = SWIG_Python_AppendOutput($result,array$argnum);
+}
+
+/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+ */
+%typemap(in,numinputs=0,
+ fragment="NumPy_Backward_Compatibility,NumPy_Macros")
+ (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+ (PyObject * array = NULL)
+{
+ npy_intp dims[2] = { $1_dim0, $1_dim1 };
+ array = PyArray_SimpleNew(2, dims, DATA_TYPECODE);
+ if (!array) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+%typemap(argout)
+ (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+{
+ $result = SWIG_Python_AppendOutput($result,array$argnum);
+}
+
+/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+ */
+%typemap(in,numinputs=0,
+ fragment="NumPy_Backward_Compatibility,NumPy_Macros")
+ (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+ (PyObject * array = NULL)
+{
+ npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 };
+ array = PyArray_SimpleNew(3, dims, DATA_TYPECODE);
+ if (!array) SWIG_fail;
+ $1 = ($1_ltype) array_data(array);
+}
+%typemap(argout)
+ (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+{
+ $result = SWIG_Python_AppendOutput($result,array$argnum);
+}
+
+/*****************************/
+/* Argoutview Array Typemaps */
+/*****************************/
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
+ */
+%typemap(in,numinputs=0)
+ (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1 )
+ (DATA_TYPE* data_temp , DIM_TYPE dim_temp)
+{
+ $1 = &data_temp;
+ $2 = &dim_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility")
+ (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
+{
+ npy_intp dims[1] = { *$2 };
+ PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1));
+ if (!array) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,array);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
+ */
+%typemap(in,numinputs=0)
+ (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEW_ARRAY1)
+ (DIM_TYPE dim_temp, DATA_TYPE* data_temp )
+{
+ $1 = &dim_temp;
+ $2 = &data_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility")
+ (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
+{
+ npy_intp dims[1] = { *$1 };
+ PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2));
+ if (!array) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,array);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ */
+%typemap(in,numinputs=0)
+ (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 )
+ (DATA_TYPE* data_temp , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp)
+{
+ $1 = &data_temp;
+ $2 = &dim1_temp;
+ $3 = &dim2_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility")
+ (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+{
+ npy_intp dims[2] = { *$2, *$3 };
+ PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
+ if (!array) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,array);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
+ */
+%typemap(in,numinputs=0)
+ (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_ARRAY2)
+ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp )
+{
+ $1 = &dim1_temp;
+ $2 = &dim2_temp;
+ $3 = &data_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility")
+ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
+{
+ npy_intp dims[2] = { *$1, *$2 };
+ PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
+ if (!array) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,array);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ */
+%typemap(in,numinputs=0)
+ (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 )
+ (DATA_TYPE* data_temp , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp)
+{
+ $1 = &data_temp;
+ $2 = &dim1_temp;
+ $3 = &dim2_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+ (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+{
+ npy_intp dims[2] = { *$2, *$3 };
+ PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
+ PyArrayObject * array = (PyArrayObject*) obj;
+ if (!array || !require_fortran(array)) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
+ */
+%typemap(in,numinputs=0)
+ (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_FARRAY2)
+ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp )
+{
+ $1 = &dim1_temp;
+ $2 = &dim2_temp;
+ $3 = &data_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
+{
+ npy_intp dims[2] = { *$1, *$2 };
+ PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
+ PyArrayObject * array = (PyArrayObject*) obj;
+ if (!array || !require_fortran(array)) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+ DIM_TYPE* DIM3)
+ */
+%typemap(in,numinputs=0)
+ (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
+{
+ $1 = &data_temp;
+ $2 = &dim1_temp;
+ $3 = &dim2_temp;
+ $4 = &dim3_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility")
+ (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+{
+ npy_intp dims[3] = { *$2, *$3, *$4 };
+ PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
+ if (!array) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,array);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
+ DATA_TYPE** ARGOUTVIEW_ARRAY3)
+ */
+%typemap(in,numinputs=0)
+ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
+ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp)
+{
+ $1 = &dim1_temp;
+ $2 = &dim2_temp;
+ $3 = &dim3_temp;
+ $4 = &data_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility")
+ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
+{
+ npy_intp dims[3] = { *$1, *$2, *$3 };
+ PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3));
+ if (!array) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,array);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+ DIM_TYPE* DIM3)
+ */
+%typemap(in,numinputs=0)
+ (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
+{
+ $1 = &data_temp;
+ $2 = &dim1_temp;
+ $3 = &dim2_temp;
+ $4 = &dim3_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+ (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+{
+ npy_intp dims[3] = { *$2, *$3, *$4 };
+ PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
+ PyArrayObject * array = (PyArrayObject*) obj;
+ if (!array || require_fortran(array)) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
+ DATA_TYPE** ARGOUTVIEW_FARRAY3)
+ */
+%typemap(in,numinputs=0)
+ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
+ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp)
+{
+ $1 = &dim1_temp;
+ $2 = &dim2_temp;
+ $3 = &dim3_temp;
+ $4 = &data_temp;
+}
+%typemap(argout,
+ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
+{
+ npy_intp dims[3] = { *$1, *$2, *$3 };
+ PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3));
+ PyArrayObject * array = (PyArrayObject*) obj;
+ if (!array || require_fortran(array)) SWIG_fail;
+ $result = SWIG_Python_AppendOutput($result,obj);
+}
+
+%enddef /* %numpy_typemaps() macro */
+/* *************************************************************** */
+
+/* Concrete instances of the %numpy_typemaps() macro: Each invocation
+ * below applies all of the typemaps above to the specified data type.
+ */
+%numpy_typemaps(signed char , NPY_BYTE , int)
+%numpy_typemaps(unsigned char , NPY_UBYTE , int)
+%numpy_typemaps(short , NPY_SHORT , int)
+%numpy_typemaps(unsigned short , NPY_USHORT , int)
+%numpy_typemaps(int , NPY_INT , int)
+%numpy_typemaps(unsigned int , NPY_UINT , int)
+%numpy_typemaps(long , NPY_LONG , int)
+%numpy_typemaps(unsigned long , NPY_ULONG , int)
+%numpy_typemaps(long long , NPY_LONGLONG , int)
+%numpy_typemaps(unsigned long long, NPY_ULONGLONG, int)
+%numpy_typemaps(float , NPY_FLOAT , int)
+%numpy_typemaps(double , NPY_DOUBLE , int)
+
+/* ***************************************************************
+ * The follow macro expansion does not work, because C++ bool is 4
+ * bytes and NPY_BOOL is 1 byte
+ *
+ * %numpy_typemaps(bool, NPY_BOOL, int)
+ */
+
+/* ***************************************************************
+ * On my Mac, I get the following warning for this macro expansion:
+ * 'swig/python detected a memory leak of type 'long double *', no destructor found.'
+ *
+ * %numpy_typemaps(long double, NPY_LONGDOUBLE, int)
+ */
+
+/* ***************************************************************
+ * Swig complains about a syntax error for the following macro
+ * expansions:
+ *
+ * %numpy_typemaps(complex float, NPY_CFLOAT , int)
+ *
+ * %numpy_typemaps(complex double, NPY_CDOUBLE, int)
+ *
+ * %numpy_typemaps(complex long double, NPY_CLONGDOUBLE, int)
+ */
+
+#endif /* SWIGPYTHON */
register long i,j,k1,k2;
SetPenPal(mgl_have_color(stl) ? stl:AxisStl);
-
+ static int cgid=1; StartGroup("Axis",cgid++);
+
p = o + d*aa.v1; k1 = AddPnt(p,CDef,q,-1,3);
for(i=1;i<31;i++) // axis itself
{
for(v=v0;v<aa.v2;v+=aa.ds) tick_draw(o+d*v,da,db,1,stl);
}
if(text) DrawLabels(aa);
+ EndGroup();
}
//-----------------------------------------------------------------------------
void mglCanvas::DrawLabels(mglAxis &aa)
AdjustTicks(dir,false);
SetPenPal(pen);
// TODO: Ternary axis labeling ...
+ static int cgid=1; StartGroup("AxisGrid",cgid++);
if(strchr(dir,'x')) DrawGrid(ax);
if(strchr(dir,'y')) DrawGrid(ay);
if(strchr(dir,'z')) DrawGrid(az);
+ EndGroup();
}
//-----------------------------------------------------------------------------
void mglCanvas::DrawGrid(mglAxis &aa)
}\r
mglBase::~mglBase() { ClearEq(); }\r
//-----------------------------------------------------------------------------\r
-float mglBase::GetRatio() { return 1; }\r
+float mglBase::GetRatio() const { return 1; }\r
//-----------------------------------------------------------------------------\r
void mglBase::StartGroup(const char *name, int id)\r
{\r
q.c=c; q.t=a; q.u=n.x; q.v=n.y; q.w=n.z;\r
}\r
q.x=q.xx=int(p.x*100)*0.01; q.y=q.yy=p.y; q.z=q.zz=p.z;\r
- q.c=c; q.t=a; q.u=n.x; q.v=n.y; q.w=n.z;\r
- Txt[long(c)].GetC(c,a,q); // RGBA color\r
+ q.c=c; q.t=q.ta=a; q.u=n.x; q.v=n.y; q.w=n.z;\r
+ const mglTexture &txt=Txt[long(c)];\r
+ txt.GetC(c,a,q); // RGBA color\r
\r
- if(!get(MGL_ENABLE_ALPHA)) q.a=1;\r
+ if(!get(MGL_ENABLE_ALPHA)) { q.a=1; if(txt.Smooth!=2) q.ta=1; }\r
if(scl&8 && scl>0) q.a=a; // bypass palette for enabling alpha in Error()\r
if(!get(MGL_ENABLE_LIGHT) && !(scl&4)) q.u=q.v=NAN;\r
MGL_PUSH(Pnt,q,mutexPnt); return Pnt.size()-1;\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-bool mglBase::ScalePoint(mglPoint &p, mglPoint &n, bool use_nan)\r
+bool mglBase::ScalePoint(mglPoint &p, mglPoint &n, bool use_nan) const\r
{\r
float &x=p.x, &y=p.y, &z=p.z;\r
if(isnan(x) || isnan(y) || isnan(z)) { x=NAN; return false; }\r
delete []c;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglTexture::GetC(float u,float v,mglPnt &p)\r
+void mglTexture::GetC(float u,float v,mglPnt &p) const\r
{\r
u -= long(u);\r
register long i=long(256*u); u = u*256-i;\r
- mglColor *s=col+2*i;\r
+ const mglColor *s=col+2*i;\r
p.r = (s[0].r*(1-u)+s[2].r*u)*(1-v) + (s[1].r*(1-u)+s[3].r*u)*v;\r
p.g = (s[0].g*(1-u)+s[2].g*u)*(1-v) + (s[1].g*(1-u)+s[3].g*u)*v;\r
p.b = (s[0].b*(1-u)+s[2].b*u)*(1-v) + (s[1].b*(1-u)+s[3].b*u)*v;\r
p.a = (s[0].a*(1-u)+s[2].a*u)*v + (s[1].a*(1-u)+s[3].a*u)*(1-v); // for alpha use inverted\r
}\r
//-----------------------------------------------------------------------------\r
-bool mglTexture::IsSame(mglTexture &t)\r
+bool mglTexture::IsSame(mglTexture &t) const\r
{ return n==t.n && !memcmp(col,t.col,514*sizeof(mglColor)); }\r
//-----------------------------------------------------------------------------\r
long mglBase::AddTexture(const char *cols, int smooth)\r
return mk;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglBase::GetA(float a)\r
+float mglBase::GetA(float a) const\r
{\r
- if(fa) a = fa->Calc(0,0,0,a);\r
+ if(fa) a = fa->Calc(0,0,0,a);\r
a = (a-FMin.c)/(FMax.c-FMin.c);\r
a = (a<1?(a>0?a:0):1)/MGL_FLT_EPS; // for texture a must be <1 always!!!\r
return a;\r
//-----------------------------------------------------------------------------\r
const unsigned char *mglCanvas::GetBits() { Finish(); return G; }\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetRatio() { return inW/inH; }\r
+float mglCanvas::GetRatio() const { return inW/inH; }\r
//-----------------------------------------------------------------------------\r
void mglCanvas::add_prim(mglPrim &a)\r
{\r
std::vector<mglTexture> Txt; ///< Pointer to textures\r
char *Message; ///< Buffer for receiving messages\r
long InUse; ///< Smart pointer (number of users)\r
-mglPoint LastMousePos; ///< Last mouse position\r
mglFont *fnt; ///< Class for printing vector text\r
int Quality; ///< Quality of plot (0x0-pure, 0x1-fast; 0x2-fine; 0x4 - low memory)\r
int Width; ///< Width of the image\r
//-----------------------------------------------------------------------------\r
// Optimal axis position\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::FindOptOrg(char dir, int ind)\r
+float mglCanvas::FindOptOrg(char dir, int ind) const\r
{\r
static mglPoint px, py, pz, m1, m2;\r
static mglMatrix bb; bb.b[0]=1e30;\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetOrgX(char dir)\r
+float mglCanvas::GetOrgX(char dir) const\r
{\r
float res = Org.x;\r
if(isnan(res))\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetOrgY(char dir)\r
+float mglCanvas::GetOrgY(char dir) const\r
{\r
float res = Org.y;\r
if(isnan(res))\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetOrgZ(char dir)\r
+float mglCanvas::GetOrgZ(char dir) const\r
{\r
float res = Org.z;\r
if(isnan(res))\r
Bp.x=(x1+x2)/2/Bp.b[0]; Bp.y=(y1+y2)/2/Bp.b[4];\r
}\r
//-----------------------------------------------------------------------------\r
-int mglCanvas::GetSplId(long x,long y)\r
+int mglCanvas::GetSplId(long x,long y) const\r
{\r
register long i,id=-1;\r
for(i=Sub.size()-1;i>=0;i--)\r
ll = hypot(lx,ly)/(PenWidth*ArrowSize*0.35*font_factor);\r
if(ll==0) return;\r
lx /= ll; ly /= ll; kx = ly; ky = -lx;\r
+ float lz = (p2.z-p1.z)/ll;\r
+\r
Reserve(6);\r
long k1,k2,k3,k4;\r
\r
q2.xx=q2.x=p1.x-kx; q2.yy=q2.y=p1.y-ky; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
line_plot(k1,k2); break;\r
case 'D':\r
- q1.xx=q1.x=p1.x+kx; q1.yy=q1.y=p1.y+ky; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
- q2.xx=q2.x=p1.x+lx; q2.yy=q2.y=p1.y+ly; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
- q3.xx=q3.x=p1.x-kx; q3.yy=q3.y=p1.y-ky; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
- q4.xx=q4.x=p1.x-lx; q4.yy=q4.y=p1.y-ly; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
+ q1.xx=q1.x=p1.x+kx; q1.yy=q1.y=p1.y+ky; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
+ q2.xx=q2.x=p1.x+lx; q2.yy=q2.y=p1.y+ly; q2.zz=q2.z=p1.z+lz; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
+ q3.xx=q3.x=p1.x-kx; q3.yy=q3.y=p1.y-ky; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
+ q4.xx=q4.x=p1.x-lx; q4.yy=q4.y=p1.y-ly; q4.zz=q4.z=p1.z-lz; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
quad_plot(k1,k2,k4,k3); break;\r
case 'S':\r
- q1.xx=q1.x=p1.x+kx-lx; q1.yy=q1.y=p1.y+ky-ly; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
- q2.xx=q2.x=p1.x-kx-lx; q2.yy=q2.y=p1.y-ky-ly; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
- q3.xx=q3.x=p1.x-kx+lx; q3.yy=q3.y=p1.y-ky+ly; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
- q4.xx=q4.x=p1.x+kx+lx; q4.yy=q4.y=p1.y+ky+ly; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
+ q1.xx=q1.x=p1.x+kx-lx; q1.yy=q1.y=p1.y+ky-ly; q1.zz=q1.z=p1.z-lz; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
+ q2.xx=q2.x=p1.x-kx-lx; q2.yy=q2.y=p1.y-ky-ly; q2.zz=q2.z=p1.z-lz; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
+ q3.xx=q3.x=p1.x-kx+lx; q3.yy=q3.y=p1.y-ky+ly; q3.zz=q3.z=p1.z+lz; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
+ q4.xx=q4.x=p1.x+kx+lx; q4.yy=q4.y=p1.y+ky+ly; q4.zz=q4.z=p1.z+lz; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
quad_plot(k1,k2,k4,k3); break;\r
case 'T':\r
- q1.xx=q1.x=p1.x+kx-lx; q1.yy=q1.y=p1.y+ky-ly; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
- q2.xx=q2.x=p1.x-kx-lx; q2.yy=q2.y=p1.y-ky-ly; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
- q3.xx=q3.x=p1.x+lx; q3.yy=q3.y=p1.y+ly; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
+ q1.xx=q1.x=p1.x+kx-lx; q1.yy=q1.y=p1.y+ky-ly; q1.zz=q1.z=p1.z-lz; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
+ q2.xx=q2.x=p1.x-kx-lx; q2.yy=q2.y=p1.y-ky-ly; q2.zz=q2.z=p1.z-lz; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
+ q3.xx=q3.x=p1.x+lx; q3.yy=q3.y=p1.y+ly; q3.zz=q3.z=p1.z+lz; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
trig_plot(k1,k2,k3); break;\r
case 'A':\r
// q1.xx=q1.x=p1.x; q1.yy=q1.y=p1.y; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
- q2.xx=q2.x=p1.x-kx-2*lx; q2.yy=q2.y=p1.y-ky-2*ly; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
- q3.xx=q3.x=p1.x-1.5*lx; q3.yy=q3.y=p1.y-1.5*ly; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
- q4.xx=q4.x=p1.x+kx-2*lx; q4.yy=q4.y=p1.y+ky-2*ly; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
- trig_plot(n1,k2,k3); trig_plot(n1,k4,k3); break;\r
+ q2.xx=q2.x=p1.x-kx-2*lx; q2.yy=q2.y=p1.y-ky-2*ly; q2.zz=q2.z=p1.z-2*lz; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
+ q3.xx=q3.x=p1.x-1.5*lx; q3.yy=q3.y=p1.y-1.5*ly; q3.zz=q3.z=p1.z-1.5*lz; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
+ q4.xx=q4.x=p1.x+kx-2*lx; q4.yy=q4.y=p1.y+ky-2*ly; q4.zz=q4.z=p1.z-2*lz; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
+ trig_plot(n1,k2,k3); trig_plot(n1,k3,k4); break;\r
case 'K':\r
// q1.xx=q1.x=p1.x; q1.yy=q1.y=p1.y; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
- q2.xx=q2.x=p1.x-kx-2*lx; q2.yy=q2.y=p1.y-ky-2*ly; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
- q3.xx=q3.x=p1.x-1.5*lx; q3.yy=q3.y=p1.y-1.5*ly; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
- q4.xx=q4.x=p1.x+kx-2*lx; q4.yy=q4.y=p1.y+ky-2*ly; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
- trig_plot(n1,k2,k3); trig_plot(n1,k4,k3);\r
+ q2.xx=q2.x=p1.x-kx-2*lx; q2.yy=q2.y=p1.y-ky-2*ly; q2.zz=q2.z=p1.z-2*lz; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
+ q3.xx=q3.x=p1.x-1.5*lx; q3.yy=q3.y=p1.y-1.5*ly; q3.zz=q3.z=p1.z-1.5*lz; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
+ q4.xx=q4.x=p1.x+kx-2*lx; q4.yy=q4.y=p1.y+ky-2*ly; q4.zz=q4.z=p1.z-2*lz; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
+ trig_plot(n1,k2,k3); trig_plot(n1,k3,k4);\r
q1.xx=q1.x=p1.x+kx; q1.yy=q1.y=p1.y+ky; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
q2.xx=q2.x=p1.x-kx; q2.yy=q2.y=p1.y-ky; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
line_plot(k1,k2); break;\r
case 'V':\r
// q1.xx=q1.x=p1.x; q1.yy=q1.y=p1.y; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
- q2.xx=q2.x=p1.x-kx+2*lx; q2.yy=q2.y=p1.y-ky+2*ly; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
- q3.xx=q3.x=p1.x+1.5*lx; q3.yy=q3.y=p1.y+1.5*ly; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
- q4.xx=q4.x=p1.x+kx+2*lx; q4.yy=q4.y=p1.y+ky+2*ly; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
- trig_plot(n1,k2,k3); trig_plot(n1,k4,k3); break;\r
+ q2.xx=q2.x=p1.x-kx+2*lx; q2.yy=q2.y=p1.y-ky+2*ly; q2.zz=q2.z=p1.z-2*lz; k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
+ q3.xx=q3.x=p1.x+1.5*lx; q3.yy=q3.y=p1.y+1.5*ly; q3.zz=q3.z=p1.z-1.5*lz; k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
+ q4.xx=q4.x=p1.x+kx+2*lx; q4.yy=q4.y=p1.y+ky+2*ly; q4.zz=q4.z=p1.z-2*lz; k4=Pnt.size(); MGL_PUSH(Pnt,q4,mutexPnt);\r
+ trig_plot(n1,k2,k3); trig_plot(n1,k3,k4); break;\r
case 'O':\r
{\r
q1.xx=q1.x=p1.x; q1.yy=q1.y=p1.y; k1=Pnt.size(); MGL_PUSH(Pnt,q1,mutexPnt);\r
for(int i=0;i<16;i++)\r
{\r
t = M_PI*i/8.; s=sin(t); c=cos(t);\r
- q2.xx=q2.x=p1.x+kx*s+lx*c; q2.yy=q2.y=p1.y+ky*s+ly*c;\r
+ q2.xx=q2.x=p1.x+kx*s+lx*c; q2.yy=q2.y=p1.y+ky*s+ly*c; q2.zz=q2.z=p1.z+c*lz;\r
k2=Pnt.size(); MGL_PUSH(Pnt,q2,mutexPnt);\r
t = M_PI*(i+1)/8.; s=sin(t); c=cos(t);\r
- q3.xx=q3.x=p1.x+kx*s+lx*c; q3.yy=q3.y=p1.y+ky*s+ly*c;\r
+ q3.xx=q3.x=p1.x+kx*s+lx*c; q3.yy=q3.y=p1.y+ky*s+ly*c; q3.zz=q2.z=p1.z+c*lz;\r
k3=Pnt.size(); MGL_PUSH(Pnt,q3,mutexPnt);\r
trig_plot(k1,k2,k3);\r
}\r
if(k4==2) k2=0;\r
if(k4==1) k1=k2=0;\r
float c1=AddTexture(char(k1?k1:'w')), c2=AddTexture(char(k2?k2:'k'));\r
- if((Flag&3)==2) { float cc=c1; c2=c2; c2=cc; };\r
+ if((Flag&3)==2) { float cc=c1; c2=c1; c2=cc; };\r
\r
if(strchr(ff,'#')) // draw bounding box\r
{\r
if(box) // draw boungind box\r
{\r
float c1=AddTexture('w'), c2=AddTexture('k');\r
- if((Flag&3)==2) { float cc=c1; c2=c2; c2=cc; };\r
+ if((Flag&3)==2) { float cc=c1; c2=c1; c2=cc; };\r
long k1,k2,k3,k4;\r
k1=AddPnt(mglPoint(x,y,Depth),c1,q,-1,0);\r
k2=AddPnt(mglPoint(x+inW,y,Depth),c1,q,-1,0);\r
{ _Gr_->Label(dir,text,pos,shift); }\r
void mgl_labelw_ext(HMGL gr, char dir, const wchar_t *text, float pos, float shift)\r
{ _Gr_->Labelw(dir,text,pos,shift); }\r
-void mgl_label_pos(HMGL gr, float x, float y, const char *text, const char *fnt)\r
-{ _Gr_->Label(x,y,text,fnt); }\r
-void mgl_labelw_pos(HMGL gr, float x, float y, const wchar_t *text, const char *fnt)\r
-{ _Gr_->Labelw(x,y,text,fnt); }\r
//-----------------------------------------------------------------------------\r
void mgl_colorbar(HMGL gr, const char *sch)\r
{ _Gr_->Colorbar(sch); }\r
void mgl_label_ext_(uintptr_t *gr, const char *dir, const char *text, float *pos, float *shift,int,int l)\r
{ char *s=new char[l+1]; memcpy(s,text,l); s[l]=0;\r
_GR_->Label(*dir, s, *pos, *shift); delete []s; }\r
-void mgl_label_pos_(uintptr_t *gr, float *x, float *y, const char *txt, const char *fnt,int l,int n)\r
-{ char *s=new char[l+1]; memcpy(s,txt,l); s[l]=0;\r
- char *p=new char[n+1]; memcpy(p,fnt,n); p[n]=0;\r
- _GR_->Label(*x,*y,s,p); delete []s; delete []p; }\r
//-----------------------------------------------------------------------------\r
void mgl_colorbar_(uintptr_t *gr, const char *sch,int l)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
float mgl_diff_expr_(uintptr_t *ex, const char *dir, float *x, float *y,float *z, int)\r
{ return mgl_expr_diff((HMEX) ex, *dir,*x,*y,*z); }\r
//-----------------------------------------------------------------------------\r
+void mgl_set_plotfactor(HMGL gr, float val)\r
+{ _Gr_->SetPlotFactor(val); }\r
+void mgl_set_plotfactor_(uintptr_t *gr, float *val)\r
+{ _GR_->SetPlotFactor(*val); }\r
+//-----------------------------------------------------------------------------\r
//-----------------------------------------------------------------------------
int mgls_label(mglGraph *gr, long , mglArg *a, int k[10], const char *opt)
{
- if(k[0]==3 && k[1]==3 && k[2]==2)
- gr->Label(a[0].v, a[1].v, a[2].w.c_str(), k[3]==2?a[3].s.c_str():"");
- else if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==2)
+ if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==2)
gr->Label(*(a[0].d), *(a[1].d), *(a[2].d), a[3].w.c_str(), k[4]==2?a[4].s.c_str():"", opt);
else if(k[0]==1 && k[1]==1 && k[2]==2)
gr->Label(*(a[0].d), *(a[1].d), a[2].w.c_str(), k[3]==2?a[3].s.c_str():"", opt);
}
void mglc_label(wchar_t out[1024], long , mglArg *a, int k[10], const char *opt)
{
- if(k[0]==3 && k[1]==3 && k[2]==2)
- mglprintf(out,1024,L"gr->Label(%g, %g, \"%ls\", \"%s\");", a[0].v, a[1].v, a[2].w.c_str(), k[3]==2?a[3].s.c_str():"");
- else if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==2)
+ if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==2)
mglprintf(out,1024,L"gr->Label(%s, %s, %s, \"%ls\", \"%s\", \"%s\");", a[0].s.c_str(), a[1].s.c_str(), a[2].s.c_str(), a[3].w.c_str(), k[4]==2?a[4].s.c_str():"", opt);
else if(k[0]==1 && k[1]==1 && k[2]==2)
mglprintf(out,1024,L"gr->Label(%s, %s, \"%ls\", \"%s\", \"%s\");", a[0].s.c_str(), a[1].s.c_str(), a[2].w.c_str(), k[3]==2?a[3].s.c_str():"", opt);
//-----------------------------------------------------------------------------
int mgls_write(mglGraph *gr, long , mglArg *a, int k[10], const char *)
{
- if(k[0]==2) gr->WriteFrame(a[0].s.c_str(), "MathGL");
- else return 1;
+ gr->WriteFrame(k[0]==2?a[0].s.c_str():"", "MathGL");
return 0;
}
void mglc_write(wchar_t out[1024], long , mglArg *a, int k[10], const char *)
{
- if(k[0]==2)
- mglprintf(out,1024,L"gr->WriteFrame(\"%s\", \"MathGL\");", a[0].s.c_str());
+ mglprintf(out,1024,L"gr->WriteFrame(\"%s\", \"MathGL\");", k[0]==2?a[0].s.c_str():"");
}
//-----------------------------------------------------------------------------
int mgls_region(mglGraph *gr, long , mglArg *a, int k[10], const char *opt)
int mgl_pnga_save(const char *fname, int w, int h, unsigned char **p);\r
void mgl_printf(void *fp, bool gz, const char *str, ...);\r
//-----------------------------------------------------------------------------\r
-void mglTexture::GetRGBA(unsigned char *f)\r
+void mglTexture::GetRGBA(unsigned char *f) const\r
{\r
register long i,j,i0;\r
mglColor c1,c2,c;\r
delete []ng;\r
\r
unsigned len=strlen(fname),ntxt=gr->GetTxtNum();\r
- char *tname = new char[len+1]; strcpy(tname,fname);\r
+ char *tname = new char[len+5]; strcpy(tname,fname);\r
FILE *fp=fopen(fname,"wt");\r
// vertices definition\r
fprintf(fp,"# Created by MathGL library\n# Title: %s\n",(descr && *descr) ? descr : fname);\r
{\r
mglPnt pp = gr->GetPnt(i);\r
fprintf(fp,"v %g %g %g\n",pp.x,pp.y,pp.z);\r
- fprintf(fp,"vt %g %g\n",pp.t,pp.c/ntxt);\r
+ fprintf(fp,"vt %g %g\n",1-pp.ta,pp.c/ntxt);\r
// if(isnan(pp.u)) fprintf(fp,"vn 0 0 0\n");\r
// else fprintf(fp,"vn %g %g %g\n",pp.u,pp.v,pp.w);\r
}\r
fprintf(fp,"Kd 1.000 1.000 1.000\n");\r
fprintf(fp,"Ks 0.000 0.000 0.000\n");\r
fprintf(fp,"d 1.0\nillum 2\n");\r
- if(use_png)\r
- { tname[len-4]='.'; tname[len-3]='p'; tname[len-2]='n'; tname[len-1]='g'; }\r
- else\r
- { tname[len-4]='.'; tname[len-3]='t'; tname[len-2]='g'; tname[len-1]='a'; }\r
+ if(use_png) strcat(tname,"_txt.png");\r
+// { tname[len-4]='.'; tname[len-3]='p'; tname[len-2]='n'; tname[len-1]='g'; }\r
+ else strcat(tname,"_txt.tga");\r
+// { tname[len-4]='.'; tname[len-3]='t'; tname[len-2]='g'; tname[len-1]='a'; }\r
fprintf(fp,"map_Ka %s\nmap_Kd %s\nmap_Ks %s\n",tname,tname,tname);\r
fclose(fp);\r
// prepare texture file (TGA or PNG)\r
if(!fp) return true;\r
// NOTE: I'll save Ptx. So prim type=6 is useless,and no LaTeX\r
fprintf(fp,"MGLD %lu %lu %lu\n# %s\n", Pnt.size(), Prm.size(), Txt.size(), (descr && *descr) ? descr : fname);\r
- register size_t i,j;\r
- fprintf(fp,"# Vertexes: x y z c t u v w r g b a\n");\r
+ register size_t i;\r
+ fprintf(fp,"# Vertexes: x y z c t ta u v w r g b a\n");\r
for(i=0;i<Pnt.size();i++)\r
{\r
const mglPnt &q=Pnt[i];\r
- fprintf(fp,"%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\n", q.xx, q.yy, q.zz, q.c, q.t, q.u, q.v, q.w, q.r, q.g, q.b, q.a);\r
+ fprintf(fp,"%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\t%.4g\n", q.xx, q.yy, q.zz, q.c, q.t, q.ta, q.u, q.v, q.w, q.r, q.g, q.b, q.a);\r
}\r
fprintf(fp,"# Primitives: type n1 n2 n3 n4 id s w p\n");\r
for(i=0;i<Prm.size();i++)\r
if(!fgets(buf,512,fp)) *buf=0;\r
if(strncmp(buf,"MGLD",4)) { delete []buf; fclose(fp); return true; }\r
register size_t i;\r
- size_t n,m,l;\r
+ size_t n,m,l, npnt;\r
sscanf(buf+5,"%lu%lu%lu",&n,&m,&l);\r
if(n<=0 || m<=0 || l<=0) { delete []buf; fclose(fp); return true; }\r
if(!add) { Clf(); Txt.clear(); }\r
- else ClfZB();\r
+ else { ClfZB(); npnt=Pnt.size(); }\r
Pnt.reserve(n); Prm.reserve(m); Txt.reserve(l);\r
mglPnt p;\r
for(i=0;i<n;i++)\r
{\r
do { if(!fgets(buf,512,fp)) *buf=0; mgl_strtrim(buf); } while(*buf=='#');\r
- sscanf(buf,"%g%g%g%g%g%g%g%g%g%g%g%g", &p.xx, &p.yy, &p.zz, &p.c, &p.t, &p.u, &p.v, &p.w, &p.r, &p.g, &p.b, &p.a);\r
+ sscanf(buf,"%g%g%g%g%g%g%g%g%g%g%g%g%g", &p.xx, &p.yy, &p.zz, &p.c, &p.t, &p.ta, &p.u, &p.v, &p.w, &p.r, &p.g, &p.b, &p.a);\r
Pnt.push_back(p);\r
}\r
mglPrim q;\r
{\r
do { if(!fgets(buf,512,fp)) *buf=0; mgl_strtrim(buf); } while(*buf=='#');\r
sscanf(buf,"%d%ld%ld%ld%ld%d%g%g%g", &q.type, &q.n1, &q.n2, &q.n3, &q.n4, &q.id, &q.s, &q.w, &q.p);\r
- if(q.type>4) continue;\r
- Prm.push_back(q);\r
+ q.n1 = q.n1>=0?q.n1+npnt:-1;\r
+ q.n2 = q.n2>=0?q.n2+npnt:-1;\r
+ if(q.type==2 || q.type==3)\r
+ {\r
+ q.n3 = q.n3>=0?q.n3+npnt:-1;\r
+ q.n4 = q.n4>=0?q.n4+npnt:-1;\r
+ }\r
+ if(q.type<5) Prm.push_back(q);\r
}\r
mglTexture t;\r
for(i=0;i<l;i++)\r
return col;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Puts(const char *str,const char *how,float col)\r
+float mglFont::Puts(const char *str,const char *how,float col) const\r
{\r
int font=0, align=1;\r
char cc=mglGetStyle(how,&font,&align);\r
return w;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Width(const char *str,const char *how)\r
+float mglFont::Width(const char *str,const char *how) const\r
{\r
int font=0;\r
mglGetStyle(how,&font);\r
return w;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Puts(const wchar_t *str,const char *how,float col)\r
+float mglFont::Puts(const wchar_t *str,const char *how,float col) const\r
{\r
int font=0, align=1;\r
char cc=mglGetStyle(how,&font,&align);\r
return Puts(str, font, align,cc?-cc:col);\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Width(const wchar_t *str,const char *how)\r
+float mglFont::Width(const wchar_t *str,const char *how) const\r
{\r
int font=0;\r
mglGetStyle(how,&font);\r
return Width(str, font);\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Puts(const wchar_t *str,int font,int align, float col)\r
+float mglFont::Puts(const wchar_t *str,int font,int align, float col) const\r
{\r
if(numg==0) return 0;\r
float ww=0,w=0,h = (align&4) ? 500./fact[0] : 0;\r
return ww;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Width(const wchar_t *str,int font)\r
+float mglFont::Width(const wchar_t *str,int font) const\r
{\r
if(numg==0) return 0;\r
float ww=0,w=0;\r
return w;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Height(int font)\r
+float mglFont::Height(int font) const\r
{\r
if(numg==0) return 0;\r
int s = (font/MGL_FONT_BOLD)&3;\r
return (500.f)/fact[s];\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::Height(const char *how)\r
+float mglFont::Height(const char *how) const\r
{\r
if(numg==0) return 0;\r
int s=0;\r
return (500.f)/fact[s];\r
}\r
//-----------------------------------------------------------------------------\r
-long mglFont::Internal(unsigned s)\r
+long mglFont::Internal(unsigned s) const\r
{\r
register long i,i1=0,i2=numg-1;\r
register wchar_t j = wchar_t(s & MGL_FONT_MASK);\r
}\r
//-----------------------------------------------------------------------------\r
// parse LaTeX commands (mostly symbols and acents, and some font-style commands)\r
-unsigned mglFont::Parse(const wchar_t *s)\r
+unsigned mglFont::Parse(const wchar_t *s) const\r
{\r
register long k;\r
unsigned res = unsigned(-2); // Default is no symbol\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglFont::Convert(const wchar_t *str, unsigned *res)\r
+void mglFont::Convert(const wchar_t *str, unsigned *res) const\r
{\r
register unsigned r,i,j,k,i0;\r
wchar_t s[128], ch; // TeX command and current char\r
res[j] = 0;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglFont::get_ptr(long &i,unsigned *str, unsigned **b1, unsigned **b2,float &w1,float &w2, float f1, float f2, int st)\r
+float mglFont::get_ptr(long &i,unsigned *str, unsigned **b1, unsigned **b2,float &w1,float &w2, float f1, float f2, int st) const\r
{\r
static unsigned s1[2]={0,0}, s2[2]={0,0};\r
register long k;\r
return w1>w2 ? w1 : w2;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglFont::draw_ouline(int st, float x, float y, float f, float g, float ww, float ccol)\r
+void mglFont::draw_ouline(int st, float x, float y, float f, float g, float ww, float ccol) const\r
{\r
if(st&MGL_FONT_OLINE)\r
gr->Glyph(x,y+499*f/g, ww*g, (st&MGL_FONT_WIRE)?12:8, 0, ccol);\r
}\r
//-----------------------------------------------------------------------------\r
#define MGL_CLEAR_STYLE {st = style; yy = y; ff = f; ccol=col; a = (st/MGL_FONT_BOLD)&3;}\r
-float mglFont::Puts(const unsigned *text, float x,float y,float f,int style,float col)\r
+float mglFont::Puts(const unsigned *text, float x,float y,float f,int style,float col) const\r
{\r
if(numg==0) return 0;\r
register long j,k;\r
//-----------------------------------------------------------------------------\r
mglCanvasGL::~mglCanvasGL(){}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasGL::Finish()\r
+void mglCanvasGL::Finish(bool fast)\r
{\r
if(Prm.size()>0)\r
{\r
- std::sort(Prm.begin(), Prm.end());\r
+ PreparePrim(fast);\r
glVertexPointer(3, GL_FLOAT, sizeof(mglPnt), &(Pnt[0].x));\r
glNormalPointer(GL_FLOAT, sizeof(mglPnt), &(Pnt[0].u));\r
glColorPointer(4, GL_FLOAT, sizeof(mglPnt), &(Pnt[0].r));\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::PostScale(mglPoint &p)\r
+void mglCanvas::PostScale(mglPoint &p) const\r
{\r
mglPoint q=p/(2*B.pf);\r
p.x = B.x + q.x*B.b[0] + q.y*B.b[1] + q.z*B.b[2];\r
}*/\r
}\r
//-----------------------------------------------------------------------------\r
-bool mglCanvas::ScalePoint(mglPoint &p, mglPoint &n, bool use_nan)\r
+bool mglCanvas::ScalePoint(mglPoint &p, mglPoint &n, bool use_nan) const\r
{\r
bool res = get(MGL_DISABLE_SCALE) || mglBase::ScalePoint(p,n,use_nan);\r
if(TernAxis&4) return res;\r
}\r
//-----------------------------------------------------------------------------\r
// NOTE: Perspective, transformation formulas and lists are not support just now !!! Also it use LAST InPlot parameters!!!\r
-mglPoint mglCanvas::CalcXYZ(int xs, int ys)\r
+mglPoint mglCanvas::CalcXYZ(int xs, int ys) const\r
{\r
float s3 = 2*B.pf, x, y, z; // TODO: Take into account z-value of z-buffer\r
ys = Height - ys;\r
x = s3*(B.b[5]*xx-B.b[2]*yy)/d3;\r
z = s3*(B.b[0]*yy-B.b[3]*xx)/d3;\r
}\r
- LastMousePos = mglPoint(Min.x + (Max.x-Min.x)*(x+1)/2,\r
+ return mglPoint(Min.x + (Max.x-Min.x)*(x+1)/2,\r
Min.y + (Max.y-Min.y)*(y+1)/2,\r
Min.z + (Max.z-Min.z)*(z+1)/2);\r
- return LastMousePos;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::CalcScr(mglPoint p, int *xs, int *ys)\r
+void mglCanvas::CalcScr(mglPoint p, int *xs, int *ys) const\r
{\r
mglPoint n;\r
ScalePoint(p,n);\r
if(ys) *ys=int(p.y);\r
}\r
//-----------------------------------------------------------------------------\r
-mglPoint mglCanvas::CalcScr(mglPoint p)\r
+mglPoint mglCanvas::CalcScr(mglPoint p) const\r
{ int x,y; CalcScr(p,&x,&y); return mglPoint(x,y); }\r
//-----------------------------------------------------------------------------\r
//mglCanvas *mgl_tmp_gr;\r
{ mglPrim &q=Prm[i]; q.z = Pnt[q.n1].z; }\r
}\r
//-----------------------------------------------------------------------------\r
+void mglCanvas::PreparePrim(bool fast)\r
+{\r
+ mglStartThread(&mglCanvas::pxl_transform,this,Pnt.size());\r
+ if(fast) mglStartThread(&mglCanvas::pxl_setz,this,Prm.size());\r
+ else mglStartThread(&mglCanvas::pxl_setz_adv,this,Prm.size());\r
+ std::sort(Prm.begin(), Prm.end());\r
+}\r
+//-----------------------------------------------------------------------------\r
void mglCanvas::Finish(bool fast)\r
{\r
static mglMatrix bp;\r
if(get(MGL_FINISHED)) return; // nothing to do\r
if(!(Quality&4) && Prm.size()>0)\r
{\r
- mglStartThread(&mglCanvas::pxl_transform,this,Pnt.size());\r
- if(fast) mglStartThread(&mglCanvas::pxl_setz,this,Prm.size());\r
- else mglStartThread(&mglCanvas::pxl_setz_adv,this,Prm.size());\r
- std::sort(Prm.begin(), Prm.end()); bp=Bp;\r
+ PreparePrim(fast); bp=Bp;\r
// mglStartThread(&mglCanvas::pxl_primdr,this,Prm.size()); // TODO: check conflicts in pthreads\r
pxl_primdr(-1,Prm.size(),NULL);\r
}\r
@cindex SetWarn
@cindex GetWarn
-Normally user should set it to zero by @code{SetWarn(0);} before plotting and check if @var{GetWarn} return non zero after plotting. Only last warning will be saved. All warnings/errors produced by MathGL is not critical -- the plot just will not be drawn.
+Normally user should set it to zero by @code{SetWarn(0);} before plotting and check if @code{GetWarnCode()} or @code{Message()} return non zero after plotting. Only last warning will be saved. All warnings/errors produced by MathGL is not critical -- the plot just will not be drawn.
@deftypefn {Method on @code{mglGraph}} @code{void} SetWarn (@code{int} code, @code{const char *}info=@code{""})
@deftypefnx {C function} @code{void} mgl_set_warn (@code{HMGL} gr, @code{int} code, @code{const char *}info)
@deftypefn {Method on @code{mglGraph}} @code{const char *}Message ()
@deftypefnx {C function} @code{const char *}mgl_get_mess (@code{HMGL} gr)
-Set buffer for writing messages about matters why some plot are not drawn. Set to NULL to disable messages. The buffer length must be at least 1024. If @var{buf}[0]==0 then there are no messages.
+Return messages about matters why some plot are not drawn. If returned string is empty then there are no messages.
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{int} GetWarnCode ()
@deftypefnx {Method on @code{mglGraph}} @code{void} SetFunc (@code{const char *}EqX, @code{const char *}EqY, @code{const char *}EqZ=@code{""}, @code{const char *}EqA=@code{""})
@deftypefnx {C function} @code{void} mgl_set_func (@code{HMGL} gr, @code{const char *}EqX, @code{const char *}EqY, @code{const char *}EqZ, @code{const char *}EqA)
@end ifclear
-Sets transformation formulas for curvilinear coordinate. Each string should contain mathematical expression for real coordinate depending on internal coordinates @samp{x}, @samp{y}, @samp{z} and @samp{a} or @samp{c} for colorbar. For example, the cylindrical coordinates are introduced as @code{Axis("x*cos(y)", "x*sin(y)", "z");}. For removing of formulas the corresponding parameter should be empty or @code{NULL}. Using transformation formulas will slightly slowing the program. Parameter @var{EqA} set the similar transformation formula for color scheme. @xref{Textual formulas}.
+Sets transformation formulas for curvilinear coordinate. Each string should contain mathematical expression for real coordinate depending on internal coordinates @samp{x}, @samp{y}, @samp{z} and @samp{a} or @samp{c} for colorbar. For example, the cylindrical coordinates are introduced as @code{SetFunc("x*cos(y)", "x*sin(y)", "z");}. For removing of formulas the corresponding parameter should be empty or @code{NULL}. Using transformation formulas will slightly slowing the program. Parameter @var{EqA} set the similar transformation formula for color scheme. @xref{Textual formulas}.
@end deftypefn
@deftypefn {MGL command} {} axis @code{how}
@end deftypefn
@deftypefn {MGL command} {} tuneticks @code{val} [@code{pos=1.15}]
+@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} SetTuneTicks (@code{int} tune, @code{float} pos=@code{1.15})
@deftypefnx {C function} @code{void} mgl_tune_ticks (@code{HMGL} gr, @code{int} tune, @code{float} pos)
+@end ifclear
Switch on/off ticks enhancing by factoring common multiplier (for small, like from 0.001 to 0.002, or large, like from 1000 to 2000, coordinate values -- enabled if @var{tune}&1 is nonzero) or common component (for narrow range, like from 0.999 to 1.000 -- enabled if @var{tune}&2 is nonzero). Also set the position @var{pos} of common multiplier/component on the axis: =0 at minimal axis value, =1 at maximal axis value. Default value is 1.15.
@end deftypefn
Pop (restore last 'pushed') transformation matrix into stack.
@end deftypefn
+@deftypefn {Method on @code{mglGraph}} @code{void} SetPlotFactor (@code{float} val)
+@deftypefnx {C function} @code{void} mgl_set_plotfactor (@code{HMGL} gr, @code{float} val)
+Sets the factor of plot size. It is not recommended to set it lower then 1.5. This is some analogue of function Zoom() but applied not to overall image but for each InPlot. Use negative value or zero to enable automatic selection.
+@end deftypefn
+
There are 2 functions @code{View()} and @code{Zoom()} which transform whole image. I.e. they act as secondary transformation matrix. They were introduced for rotating/zooming the whole plot by mouse.
@deftypefn {Method on @code{mglGraph}} @code{void} View (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
@cindex ShowImage
@end ifclear
-These functions export current view to a graphic file. The filename @var{fname} should have appropriate extension. Parameter @var{descr} gives the short description of the picture. Just now the transparency is supported in PNG and SVG files.
+These functions export current view to a graphic file. The filename @var{fname} should have appropriate extension. Parameter @var{descr} gives the short description of the picture. Just now the transparency is supported in PNG, SVG, OBJ and IDTF files.
@anchor{write}
-@deftypefn {MGL command} {} write 'fname'
+@deftypefn {MGL command} {} write ['fname'='']
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} WriteFrame (@code{const char *}fname=@code{""}, @code{const char *}descr=@code{""})
@deftypefnx {C function} @code{void} mgl_write_frame (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
@deftypefn {Method on @code{mglGraph}} @code{void} WriteSTL (@code{const char *}fname, @code{const char *}descr=@code{""})
@deftypefnx {C function} @code{void} mgl_write_stl (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Exports current frame to STL file using vector representation (see @url{http://en.wikipedia.org/wiki/STL_(file_format), STL format} for details). Note, the output file may be too large for graphic of large data array (especially for surfaces). It is better to use bitmap format (for example PNG or JPEG). However, program has no internal limitations for size of output file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name).
+Exports current frame to STL file using vector representation (see @url{http://en.wikipedia.org/wiki/STL_(file_format), STL format} for details). Note, the output file may be too large for graphic of large data array (especially for surfaces). It is better to use bitmap format (for example PNG or JPEG). However, program has no internal limitations for size of output file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name.
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} WriteOFF (@code{const char *}fname, @code{const char *}descr=@code{""}, @code{bool} colored=@code{false})
@c @deftypefn {Method on @code{mglGraph}} @code{void} WriteX3D (@code{const char *}fname, @code{const char *}descr=@code{""})
@c @deftypefnx {C function} @code{void} mgl_write_x3d (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-@c Exports current frame to OBJ/MTL file using vector representation (see @url{http://en.wikipedia.org/wiki/X3d, X3D format} for details). Note, the output file may be too large for graphic of large data array (especially for surfaces). It is better to use bitmap format (for example PNG or JPEG). However, program has no internal limitations for size of output file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name).
+@c Exports current frame to X3D file using vector representation (see @url{http://en.wikipedia.org/wiki/X3d, X3D format} for details). Note, the output file may be too large for graphic of large data array (especially for surfaces). It is better to use bitmap format (for example PNG or JPEG). However, program has no internal limitations for size of output file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name).
@c @end deftypefn
Exports points and primitives in file using MGLD format. Later this file can be used for faster loading and viewing by @code{mglview} utility. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name).
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} ImportMGLD (@code{const char *}fname, @code{const char *}descr=@code{""})
-@deftypefnx {C function} @code{void} mgl_import_mgld (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Imports points and primitives in file using MGLD format. Later this file can be used for faster loading and viewing by @code{mglview} utility. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name).
+@deftypefn {Method on @code{mglGraph}} @code{void} ImportMGLD (@code{const char *}fname, @code{bool} add=@code{false})
+@deftypefnx {C function} @code{void} mgl_import_mgld (@code{HMGL} gr, @code{const char *}fname, @code{int} add)
+Imports points and primitives in file using MGLD format. Later this file can be used for faster loading and viewing by @code{mglview} utility. Parameter @var{fname} specifies the file name, @var{add} sets to append or replace primitives to existed ones.
@end deftypefn
@end ifclear
@deftypefn {MGL command} {} drop @code{x0 y0 dx dy r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {MGL command} {} drop @code{x0 y0 z0 dx dy dz r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{float} r, @code{const char *}stl=@code{"r"}, @code{float} shift=@code{1}, @code{float} ap=@code{1})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{float} r, @code{const char *}col=@code{"r"}, @code{float} shift=@code{1}, @code{float} ap=@code{1})
@deftypefnx {C function} @code{void} mgl_drop (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} dx, @code{float} dy, @code{float} dz, @code{float} r, @code{const char *}col, @code{float} shift, @code{float} ap)
@end ifclear
Draw the drop with radius @var{r} at point @var{p} elongated in direction @var{d} and with color @var{col}. Parameter @var{shift} set the degree of drop oblongness: @samp{0} is sphere, @samp{1} is maximally oblongness drop. Parameter @var{ap} set relative width of the drop (this is analogue of ``ellipticity'' for the sphere).
@cindex Label
@cindex fgets
-These functions draw the text. There are functions for drawing text in arbitrary place, in arbitrary direction and along arbitrary curve. MathGL can use arbitrary font-faces and parse many TeX commands (for more details see @ref{Font styles}). All these functions have 2 variant: for printing 8-bit text (@code{char *}) and for printing Unicode text (@code{wchar_t *}). In first case the conversion in current locale is used. So sometimes you need to specify it by @code{setlocale()} function. The size argument control the size of text: if positive it give the value, if negative it give the value relative to @var{FontSize}. The font type (STIX, arial, courier, times and so on) can be selected by function LoadFont(). @xref{Font settings}.
+These functions draw the text. There are functions for drawing text in arbitrary place, in arbitrary direction and along arbitrary curve. MathGL can use arbitrary font-faces and parse many TeX commands (for more details see @ref{Font styles}). All these functions have 2 variant: for printing 8-bit text (@code{char *}) and for printing Unicode text (@code{wchar_t *}). In first case the conversion into the current locale is used. So sometimes you need to specify it by @code{setlocale()} function. The size argument control the size of text: if positive it give the value, if negative it give the value relative to @var{SetFontSize()}. The font type (STIX, arial, courier, times and so on) can be selected by function LoadFont(). @xref{Font settings}.
The font parameters are described by string. This string may set the text color @samp{wkrgbcymhRGBCYMHW} (see @ref{Color styles}). Also, after delimiter symbol @samp{:}, it can contain characters of font type (@samp{rbiwou}) and/or align (@samp{LRC}) specification. The font types are: @samp{r} -- roman (or regular) font, @samp{i} -- italic style, @samp{b} -- bold style, @samp{w} -- wired style, @samp{o} -- over-lined text, @samp{u} -- underlined text. By default roman font is used. The align types are: @samp{L} -- align left (default), @samp{C} -- align center, @samp{R} -- align right. For example, string @samp{b:iC} correspond to italic font style for centered text which printed by blue color.
Draws unrotated @var{n}-th line of file @var{fname} at position @{@var{x},@var{y},@var{z}@} with specified @var{size}. By default parameters from @ref{font} command are used.
@end deftypefn
-@deftypefn {MGL command} {} label @code{x y} 'text' ['fnt'='']
-@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{float} x, @code{float} y, @code{const char *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Labelw (@code{float} x, @code{float} y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {C function} @code{void} mgl_label_pos (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const char *}text, @code{const char *}fnt)
-@deftypefnx {C function} @code{void} mgl_labelw_pos (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const wchar_t *}text, @code{const char *}fnt)
-@end ifclear
-The function draws the string @var{text} at position @{@var{x}, @var{y}@} with fonts specifying by @var{fnt}. Coordinates @code{x, y} are supposed to be in range [0,1].
-@end deftypefn
-
@deftypefn {MGL command} {} text ydat 'text' ['fnt'='']
@deftypefnx {MGL command} {} text xdat ydat 'text' ['fnt'='']
@deftypefnx {Method on @code{mglGraph}} @code{void} Legend (@code{int} pos=@code{0x3}, @code{const char *}fnt=@code{"#"}, @code{float} size=@code{-0.8}, @code{float} llen=@code{0.1})
@deftypefnx {C function} @code{void} mgl_legend (@code{HMGL} gr, @code{int} pos, @code{const char *}fnt, @code{float} size, @code{float} llen)
@end ifclear
-Draws legend of accumulated legend entries by font @var{fnt} with @var{size}. Parameter @var{pos} sets the position of the legend: @samp{0} is bottom left corner, @samp{1} is bottom right corner, @samp{2} is top left corner, @samp{3} is top right corner (is default). Paramater font can contain colors for face (1st one), for border (2nd one) and for text (last one). If less than 3 colors are specified then the color for border is black (for 2 and less colors), and the color for face is white (for 1 or none colors). If string @var{fnt} contain @samp{#} then border around the legend is drawn.
+Draws legend of accumulated legend entries by font @var{fnt} with @var{size}. Parameter @var{pos} sets the position of the legend: @samp{0} is bottom left corner, @samp{1} is bottom right corner, @samp{2} is top left corner, @samp{3} is top right corner (is default). Parameter @var{fnt} can contain colors for face (1st one), for border (2nd one) and for text (last one). If less than 3 colors are specified then the color for border is black (for 2 and less colors), and the color for face is white (for 1 or none colors). If string @var{fnt} contain @samp{#} then border around the legend is drawn.
@end deftypefn
@deftypefn {MGL command} {} legend @code{x y} ['fnt'='#' @code{size=-1 llen=0.1}]
@deftypefnx {Method on @code{mglGraph}} @code{void} Radar (@code{const mglData &}a, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {C function} @code{void} mgl_radar (@code{HMGL} gr, @code{HCDT} a, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-This functions draws radar chart which is continuous lines between points located on an radial lines (like plot in Polar coordinates). Parameter @var{value} in options @var{opt} set the additional shift of data (i.e. the data @var{a}+@var{value} is used instead of @var{a}). If @code{value<0} then @code{r=max(0, -min(value)}. If @var{pen} containt @samp{#} symbol then "grid" (radial lines and circle for @var{r}) is drawn See also @ref{plot}. @sref{Radar sample}
+This functions draws radar chart which is continuous lines between points located on an radial lines (like plot in Polar coordinates). Parameter @var{value} in options @var{opt} set the additional shift of data (i.e. the data @var{a}+@var{value} is used instead of @var{a}). If @code{value<0} then @code{r=max(0, -min(value)}. If @var{pen} containt @samp{#} symbol then "grid" (radial lines and circle for @var{r}) is drawn. See also @ref{plot}. @sref{Radar sample}
@end deftypefn
@anchor{step}
@deftypefnx {C function} @code{void} mgl_tens_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} c, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_tens_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-These functions draw continuous lines between points @{@var{x}[i], @var{y}[i], @var{z}[i]@} with color defined by the special array @var{c}[i] (look like tension plot). String @var{pen} specifies the color scheme (see @ref{Color scheme}) and style and/or width of line (see @ref{Line styles}). By default (@code{pen=""}) solid line with current color scheme is used. See also @ref{plot}, @ref{mesh}, @ref{fall}. @sref{Tens sample}
+These functions draw continuous lines between points @{@var{x}[i], @var{y}[i], @var{z}[i]@} with color defined by the special array @var{c}[i] (look like tension plot). String @var{pen} specifies the color scheme (see @ref{Color scheme}) and style and/or width of line (see @ref{Line styles}). See also @ref{plot}, @ref{mesh}, @ref{fall}. @sref{Tens sample}
@end deftypefn
@anchor{tape}
@deftypefnx {C function} @code{void} mgl_bars_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_bars_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-These functions draw vertical bars from points to axis plane. If string contain symbol @samp{a} then lines are drawn one above another (like summation). If string contain symbol @samp{f} then waterfall chart is drawn for determining the cumulative effect of sequentially introduced positive or negative values. You can give different colors for positive and negative values if number of specified colors is equal to 2*number of curves. See also @ref{barh}, @ref{cones}, @ref{area}, @ref{stem}, @ref{chart}, @ref{barwidth}. @sref{Bars sample}
+These functions draw vertical bars from points to axis plane. If string @var{pen} contain symbol @samp{a} then lines are drawn one above another (like summation). If string contain symbol @samp{f} then waterfall chart is drawn for determining the cumulative effect of sequentially introduced positive or negative values. You can give different colors for positive and negative values if number of specified colors is equal to 2*number of curves. See also @ref{barh}, @ref{cones}, @ref{area}, @ref{stem}, @ref{chart}, @ref{barwidth}. @sref{Bars sample}
@end deftypefn
@anchor{barh}
@deftypefnx {C function} @code{void} mgl_cont__val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_cont_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws contour lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z}=@var{v}[k] or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v}. If string @var{sch} have symbol @samp{#} then grid lines are drawn. If string @var{sch} have symbol @samp{t} or @samp{T} then contour labels @var{v}[k] will be drawn below (or above) the contours. See also @ref{dens}, @ref{contf}, @ref{contd}, @ref{axial}, @code{cont[xyz]}. @sref{Cont sample}
+The function draws contour lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z}=@var{v}[k] or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v}. If string @var{sch} have symbol @samp{t} or @samp{T} then contour labels @var{v}[k] will be drawn below (or above) the contours. See also @ref{dens}, @ref{contf}, @ref{contd}, @ref{axial}, @code{cont[xyz]}. @sref{Cont sample}
@end deftypefn
@deftypefn {MGL command} {} cont zdat ['sch'='']
@deftypefnx {C function} @code{void} mgl_contf_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_contf_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws solid (or filled) contour lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z}=@var{v}[k] or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v} (must be @code{v.nx>2}). If string @var{sch} have symbol @samp{#} then grid lines are drawn. See also @ref{dens}, @ref{cont}, @ref{contd}, @code{contf[xyz]}. @sref{ContF sample}
+The function draws solid (or filled) contour lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z}=@var{v}[k] or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v} (must be @code{v.nx>2}). See also @ref{dens}, @ref{cont}, @ref{contd}, @code{contf[xyz]}. @sref{ContF sample}
@end deftypefn
@deftypefn {MGL command} {} contf zdat ['sch'='']
@deftypefnx {C function} @code{void} mgl_contv_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_contv_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws vertical cylinder at contour lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z}=@var{v}[k] or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v}. If string @var{sch} have symbol @samp{#} then grid lines are drawn. If string @var{sch} have symbol @samp{t} or @samp{T} then contour labels @var{v}[k] will be drawn below (or above) the contours. See also @ref{cont}, @ref{contf}. @sref{ContV sample}
+The function draws vertical cylinder at contour lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z}=@var{v}[k] or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v}. See also @ref{cont}, @ref{contf}. @sref{ContV sample}
@end deftypefn
@deftypefn {MGL command} {} contv zdat ['sch'='']
@deftypefnx {C function} @code{void} mgl_grid (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_grid_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws grid lines for density plot of surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z} = @var{zVal}. String @var{sch} sets the color scheme. The minor dimensions of arrays @var{x}, @var{y}, @var{z} should be equal @code{x.nx=z.nx && y.nx=z.ny} or @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Arrays @var{x} and @var{y} can be vectors (not matrices as @var{z}). Grid is plotted for each z slice of the data. See also @ref{dens}, @ref{cont}, @ref{contf}, @ref{meshnum}.
+The function draws grid lines for density plot of surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} at @var{z} = @var{Min}.z. See also @ref{dens}, @ref{cont}, @ref{contf}, @ref{meshnum}.
@end deftypefn
@chapter Ядро MathGL
@cindex mglGraph
+@ifset UDAV
+Эта глава посвящена описанию множества команд построения графиков для 1D, 2D и 3D массивов данных. Сюда включены также команды настройки графика, вывода текста и примитивов, рисования осей координат и др. Дополнительную информацию о цвете, шрифтах, стилях линий и формулах можно найти в @ref{General concepts}.
+@end ifset
+
@ifclear UDAV
-Основным классом MathGL является класс @strong{mglGraph}, определенный в @code{#include <mgl/mgl.h>}. Он включает в себя множество функций для построения графиков от 1D, 2D и 3D массивов. Он также содержит функции вывода текста и построения осей координат. Есть возможность построения в произвольной системе координат, которая задается строковыми формулами. Все графические функции используют класс mglData (@pxref{Data processing}) для хранения массивов данных. Это позволяет легко контролировать размеры, работу с памятью и производить обработку данных. Дополнительная информация о цветах, шрифтах, вычисления формул может быть найдена в @ref{Other classes}.
+Основным классом MathGL является класс @strong{mglGraph}, определённый в @code{#include <mgl/mgl.h>}. Он включает в себя множество функций для построения графиков от 1D, 2D и 3D массивов. Он также содержит функции вывода текста и построения осей координат. Есть возможность построения в произвольной системе координат, которая задается строковыми формулами. Все графические функции используют класс mglData (см. @ref{Data processing}) для хранения массивов данных. Это позволяет легко контролировать размеры, работу с памятью и производить обработку данных. Дополнительная информация о цветах, шрифтах, вычисления формул может быть найдена в @ref{General concepts} и @ref{Other classes}.
@end ifclear
@menu
* Constructor::
* Graphics setup::
* Axis settings::
-* Transformation matrix::
+* Subplots and rotation::
* Export picture::
-* Primitives drawing::
+* Primitives::
* Text printing::
* Axis and Colorbar::
* Legend::
* Vector fields::
* Other plotting::
* Nonlinear fitting::
-* Data distributions::
+* Data manipulation::
* IDTF functions::
@end menu
@deftypefn {Constructor on @code{mglGraph}} {} mglGraph (@code{int} kind=@code{0}, @code{int} width=@code{600}, @code{int} height=@code{400})
@deftypefnx {Constructor on @code{mglGraph}} {} mglGraph (@code{const mglGraph &}gr)
@deftypefnx {Constructor on @code{mglGraph}} {} mglGraph (@code{HMGL} gr)
-@deftypefnx {C function} @code{HMGL} mgl_create_graph (@code{int} width, @code{int} height)
-@deftypefnx {C function} @code{HMGL} mgl_create_graph_gl ()
-Создает (или использует созданный) экземпляр класса, производного от @code{mglBase} (тип @code{HMGL}) с указанными размерами @var{width} и @var{height}. Параметр @var{type} может иметь следующие значения: @samp{0} -- использовать рисование по умолчанию, @samp{1} -- использовать рисование в OpenGL.
+@deftypefnx {Функция С} @code{HMGL} mgl_create_graph (@code{int} width, @code{int} height)
+@deftypefnx {Функция С} @code{HMGL} mgl_create_graph_gl ()
+Создает (или использует созданный) экземпляр класса, производного от @code{mglBase} (тип @code{HMGL}) с указанными размерами @var{width} и @var{height}. Параметр @var{kind} может иметь следующие значения: @samp{0} -- использовать рисование по умолчанию, @samp{1} -- использовать рисование в OpenGL.
@end deftypefn
@deftypefnx {Destructor on @code{mglGraph}} {} ~mglGraph ()
-@deftypefnx {C function} @code{HMGL} mgl_delete_graph (@code{HMGL} gr)
+@deftypefnx {Функция С} @code{HMGL} mgl_delete_graph (@code{HMGL} gr)
Удаляет экземпляр класса mglGraph.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{HMGL} Self ()
+@deftypefn {Метод класса @code{mglGraph}} @code{HMGL} Self ()
Возвращает указатель на используемый объект типа @code{HMGL}.
@end deftypefn
@end ifclear
Устанавливает все настройки по умолчанию.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} SetPlotId (@code{const char *}id)
-Задает имя графика для сохранения в файл (например, в окне GLUT).
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetPlotId (@code{const char *}id)
+@deftypefnx {Функция С} @code{void} mgl_set_plotid (@code{HMGL} gr, @code{const char *}id)
+Задает имя графика для сохранения в файл (например, в окне FLTK).
@end deftypefn
@end ifclear
@cindex AlphaDef
@cindex TranspType
-Эти функции и переменные настраивают тип и степень прозрачности поверхностей. Главной является функция @code{Alpha()}, которая включает/выключает прозрачность для всех графиков, созданных после вызова @code{Alpha()} (за исключением mglGraphGL). Функция @code{SetAlphaDef} устанавливает величину alpha-канала по умолчанию. Прозрачность можно выключить для отдельного графика с помощью @code{SetTransparent}. Наконец, функция @code{SetTranspType} задает тип прозрачности. @sref{Transparent surface sample}
+Эти функции и переменные настраивают тип и степень прозрачности поверхностей. Главной является функция @code{Alpha()}, которая включает/выключает прозрачность для всех графиков, созданных после вызова @code{Alpha()} (за исключением mglGraphGL). Функция @code{SetAlphaDef} устанавливает величину alpha-канала по умолчанию. Прозрачность можно выключить для отдельного графика с помощью @code{SetTransparent}. Наконец, функция @code{SetTranspType} задает тип прозрачности. @sref{Transparency and lighting}
@anchor{alpha}
@deftypefn {MGL command} {} alpha @code{[val=on]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Alpha (@code{bool} enable)
-@deftypefnx {C function} @code{void} mgl_set_alpha (@code{HMGL} gr, @code{int} enable)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Alpha (@code{bool} enable)
+@deftypefnx {Функция С} @code{void} mgl_set_alpha (@code{HMGL} gr, @code{int} enable)
@end ifclear
Включает/выключает прозрачность и возвращает свое предыдущее состояние. По умолчанию прозрачность выключена. Функция включает прозрачность для @emph{всего} рисунка.
@end deftypefn
@anchor{alphadef}
@deftypefn {MGL command} {} alphadef @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetAlphaDef (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_alpha_default (@code{HMGL} gr, @code{float} alpha)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAlphaDef (@code{float} val)
+@deftypefnx {Функция С} @code{void} mgl_set_alpha_default (@code{HMGL} gr, @code{float} alpha)
@end ifclear
Задает значение прозрачности по умолчанию для всех графиков. Значение по умолчанию 0.5.
@end deftypefn
@anchor{transptype}
@deftypefn {MGL command} {} transptype @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTranspType (@code{int} type)
-@deftypefnx {C function} @code{void} mgl_set_transp_type (@code{HMGL} gr, @code{int} enable)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTranspType (@code{int} type)
+@deftypefnx {Функция С} @code{void} mgl_set_transp_type (@code{HMGL} gr, @code{int} type)
@end ifclear
-Задает тип прозрачности. Обычная прозрачность (@samp{0}) -- "закрытые" объекты видны меньше чем закрывающие. Этот режим некорректно отображается в OpenGL (mglGraphGL) для нескольких перекрывающихся поверхностей. "Стеклянная" прозрачность (@samp{1}) -- закрытые и закрывающие объекты единообразно ослабляют интенсивность света (по RGB каналам). "Ламповая" прозрачность (@samp{2}) -- закрытые и закрывающие объекты являются источниками дополнительного освещения (рекомендую установить @code{SetAlphaDef(0.3)} или меньше в этом случае). @xref{Normal transparency}, @ref{Glass-like transparency}, @ref{Lamp-like transparency}.
+Задает тип прозрачности. Обычная прозрачность (@samp{0}) -- "закрытые" объекты видны меньше чем закрывающие. Этот режим некорректно отображается в OpenGL (mglGraphGL) для нескольких перекрывающихся поверхностей. "Стеклянная" прозрачность (@samp{1}) -- закрытые и закрывающие объекты единообразно ослабляют интенсивность света (по RGB каналам). "Ламповая" прозрачность (@samp{2}) -- закрытые и закрывающие объекты являются источниками дополнительного освещения (рекомендую установить @code{SetAlphaDef(0.3)} или меньше в этом случае). @sref{Types of transparency}
@end deftypefn
@c ==================================================================
@anchor{light}
@deftypefn {MGL command} {} light @code{[val=on]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{bool} Light (@code{bool} enable)
-@deftypefnx {C function} @code{void} mgl_set_light (@code{HMGL} gr, @code{int} enable)
+@deftypefnx {Метод класса @code{mglGraph}} @code{bool} Light (@code{bool} enable)
+@deftypefnx {Функция С} @code{void} mgl_set_light (@code{HMGL} gr, @code{int} enable)
@end ifclear
Включает/выключает освещение графика и возвращает предыдущее состояние. По умолчанию освещение выключено.
@end deftypefn
@deftypefn {MGL command} {} light @code{num} @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Light (@code{int} n, @code{bool} enable)
-@deftypefnx {C function} @code{void} mgl_set_light_n (@code{HMGL} gr, @code{int} n, @code{int} enable)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Light (@code{int} n, @code{bool} enable)
+@deftypefnx {Функция С} @code{void} mgl_set_light_n (@code{HMGL} gr, @code{int} n, @code{int} enable)
@end ifclear
Включает/выключает @var{n}-ый источник света.
@end deftypefn
-@deftypefn {MGL command} {} light @code{num xpos ypos zpos} ['col'='w' @code{br=0.5}]
+@deftypefn {MGL command} {} light @code{num xdir ydir zdir} ['col'='w' @code{br=0.5}]
+@deftypefnx {MGL command} {} light @code{num xdir ydir zdir xpos ypos zpos} ['col'='w' @code{br=0.5}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} p, @code{char} c=@code{'w'}, @code{float} bright=@code{0.5}, @code{bool} infty=@code{true}, @code{float} ap=@code{0})
-@deftypefnx {C function} @code{void} mgl_add_light (@code{HMGL} gr, @code{int} n, @code{float} x, @code{float} y, @code{float} z, @code{char} c)
-@deftypefnx {C function} @code{void} mgl_add_light_ext (@code{HMGL} gr, @code{int} n, @code{float} x, @code{float} y, @code{float} z, @code{char} c, @code{float} bright, @code{int} infty, @code{float} ap)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{float} bright=@code{0.5}, @code{float} ap=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} r, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{float} bright=@code{0.5}, @code{float} ap=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_add_light (@code{HMGL} gr, @code{int} n, @code{float} dx, @code{float} dy, @code{float} dz)
+@deftypefnx {Функция С} @code{void} mgl_add_light_ext (@code{HMGL} gr, @code{int} n, @code{float} dx, @code{float} dy, @code{float} dz, @code{char} c, @code{float} bright, @code{float} ap)
+@deftypefnx {Функция С} @code{void} mgl_add_light_loc (@code{HMGL} gr, @code{int} n, @code{float} rx, @code{float} ry, @code{float} rz, @code{float} dx, @code{float} dy, @code{float} dz, @code{char} c, @code{float} bright, @code{float} ap)
@end ifclear
-Добавляет источник света с номером @var{n} в положение @var{p} с цветом @var{c} и яркостью @var{bright}, которая должна быть в диапазоне [0,1]. Флаг @var{infty}=@code{true} делает источник бесконечно удаленным (для более быстрого рисования).
+Добавляет источник света с номером @var{n} в положение @var{p} с цветом @var{c} и яркостью @var{bright}, которая должна быть в диапазоне [0,1]. Если указано положение источника @var{r} и оно не NAN, то источник считается локальным, иначе источник полагается бесконечно удалённым (для более быстрого рисования).
+@end deftypefn
+
+@anchor{diffuse}
+@ifclear UDAV
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetDifLight (@code{bool} enable)
+@deftypefnx {Функция С} @code{void} mgl_set_light_dif (@code{HMGL} gr, @code{int} enable)
+Задает использование диффузного освещения (только для локальных источников света).
@end deftypefn
+@end ifclear
@anchor{ambient}
@deftypefn {MGL command} {} ambient @code{val}
@anchor{fog}
@deftypefn {MGL command} {} fog @code{val [dz=0.25]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Fog (@code{float} d, @code{float} dz=@code{0.25})
-@deftypefnx {C function} @code{void} mgl_set_fog (@code{HMGL} gr, @code{float} d, @code{float} dz)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Fog (@code{float} d, @code{float} dz=@code{0.25})
+@deftypefnx {Функция С} @code{void} mgl_set_fog (@code{HMGL} gr, @code{float} d, @code{float} dz)
@end ifclear
-Имитирует туман на графике. Туман начинается на относительном расстоянии @var{dz} от точки обзора и его плотность растет экспоненциально вглубь по закону ~@math{1-exp(-d*z)}. Здесь @emph{z} -- нормализованная на 1 глубина графика. Если @var{d}=@code{0} то туман отсутствует. @sref{Surface in fog sample}
+Имитирует туман на графике. Туман начинается на относительном расстоянии @var{dz} от точки обзора и его плотность растет экспоненциально вглубь по закону ~@math{1-exp(-d*z)}. Здесь @emph{z} -- нормализованная на 1 глубина графика. Если @var{d}=@code{0} то туман отсутствует. @sref{Adding fog}
@end deftypefn
@c ==================================================================
@anchor{barwidth}
@deftypefn {MGL command} {} barwidth @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetBarWidth ( @code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_bar_width (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetBarWidth ( @code{float} val)
+@deftypefnx {Функция С} @code{void} mgl_set_bar_width (@code{HMGL} gr, @code{float} val)
@end ifclear
-Задает относительный размер прямоугольников в Bars, Barh, BoxPlot (@pxref{Bars}). Значение по умолчанию @code{0.7}.
+Задает относительный размер прямоугольников в Bars, Barh, BoxPlot (см. @ref{Bars}). Значение по умолчанию @code{0.7}.
@end deftypefn
@anchor{marksize}
@deftypefn {MGL command} {} marksize @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetMarkSize (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_mark_size (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetMarkSize (@code{float} val)
+@deftypefnx {Функция С} @code{void} mgl_set_mark_size (@code{HMGL} gr, @code{float} val)
@end ifclear
Задает размер маркеров для @ref{1D plotting}. Значение по умолчанию @code{0.02}.
@end deftypefn
@anchor{arrowsize}
@deftypefn {MGL command} {} arrowsize @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetArrowSize (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_arrow_size (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetArrowSize (@code{float} val)
+@deftypefnx {Функция С} @code{void} mgl_set_arrow_size (@code{HMGL} gr, @code{float} val)
@end ifclear
-Задает размер стрелок для @ref{1D plotting}, линий и кривых (@pxref{Primitives drawing}). Значение по умолчанию @code{0.03}.
+Задает размер стрелок для @ref{1D plotting}, линий и кривых (см. @ref{Primitives drawing}). Значение по умолчанию @code{0.03}.
@end deftypefn
@anchor{meshnum}
@anchor{MeshNum}
@deftypefn {MGL command} {} meshnum @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetMeshNum (@code{int} val)
-@deftypefnx {C function} @code{void} mgl_set_meshnum (@code{HMGL} gr, @code{int} num)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetMeshNum (@code{int} val)
+@deftypefnx {Функция С} @code{void} mgl_set_meshnum (@code{HMGL} gr, @code{int} num)
@end ifclear
Задает ориентировочное число линий в Mesh(), Fall(), Grid() и число стрелок (штрихов) в Vect(), Dew() и число ячеек в Cloud*(). По умолчанию (=0) рисуются все линии, стрелки, ячейки.
@end deftypefn
@end ifclear
@cindex Cut
-Эти функции задают условия когда точка будет исключена (вырезана) из рисования. Замечу, что все точки со значением(-ями) NAN по одной из координат или амплитуде автоматически исключаются из рисования.
+Эти функции задают условия когда точка будет исключена (вырезана) из рисования. Замечу, что все точки со значением(-ями) NAN по одной из координат или амплитуде автоматически исключаются из рисования. @sref{Cutting sample}
@anchor{cut}
@deftypefn {MGL command} {} cut @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetCut (@code{bool} val)
-@deftypefnx {C function} @code{void} mgl_set_cut (@code{HMGL} gr, @code{int} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetCut (@code{bool} val)
+@deftypefnx {Функция С} @code{void} mgl_set_cut (@code{HMGL} gr, @code{int} val)
@end ifclear
Задает обрезание точек за пределами осей координат. Если @code{true} то такие точки исключаются из рисования (это по умолчанию) иначе они проецируются на ограничивающий прямоугольник.
@end deftypefn
-@float
-@image{cut, 7cm}
-@caption{Левый рисунок нарисован при @code{Cut=false}, правый при @code{Cut=true}.}
-@end float
-
@deftypefn {MGL command} {} cut @code{x1 y1 z1 x2 y2 z2}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetCutBox (@code{mglPoint} p1, @code{mglPoint} p1)
-@deftypefnx {C function} @code{void} mgl_set_cut_box (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetCutBox (@code{mglPoint} p1, @code{mglPoint} p1)
+@deftypefnx {Функция С} @code{void} mgl_set_cut_box (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2)
@end ifclear
Задает границы параллелепипеда внутри которого точки не рисуются. Если границы одинаковы (переменные равны), то параллелепипеда считается пустым. @sref{CutMinMax sample}
@end deftypefn
@deftypefn {MGL command} {} cut 'cond'
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} CutOff (@code{const char *}cond)
-@deftypefnx {C function} @code{void} mgl_set_cutoff (@code{HMGL} gr, @code{const char *}cond)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} CutOff (@code{const char *}cond)
+@deftypefnx {Функция С} @code{void} mgl_set_cutoff (@code{HMGL} gr, @code{const char *}cond)
@end ifclear
Задает условие обрезания по формуле @var{cond}. Это условие исключает точки из рисования если результат вычисления формулы не равен нулю. Установите аргумент @code{""} для выключения условия обрезания. @sref{CutOff sample}
@end deftypefn
@anchor{font}
@deftypefn {MGL command} {} font 'fnt' [@code{val=6}]
-Задает стиль и размер шрифта (@pxref{Text printing}). Вначале используется @samp{:rC} -- прямой шрифт с выравниванием по центру. По умолчанию размер подписей оси координат в 1.4 раза больше. См. также @pxref{Font styles}.
+Задает стиль и размер шрифта (см. @ref{Text printing}). Вначале используется @samp{:rC} -- прямой шрифт с выравниванием по центру. По умолчанию размер подписей оси координат в 1.4 раза больше. См. также см. @ref{Font styles}.
@end deftypefn
@anchor{rotatetext}
@deftypefn {MGL command} {} rotatetext @code{val}
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRotatedText (@code{bool} val)
-@deftypefnx {C function} @code{void} mgl_set_rotated_text (@code{HMGL} gr, @code{int} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRotatedText (@code{bool} val)
+@deftypefnx {Функция С} @code{void} mgl_set_rotated_text (@code{HMGL} gr, @code{int} val)
Включает/выключает вращение меток и подписей осей координат вдоль оси.
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} SetFontDef (@code{const char *}fnt)
-@deftypefnx {C function} @code{void} mgl_set_font_def (@code{HMGL} gr, @code{const char *} val)
-Задает стиль шрифта (@pxref{Text printing}). По умолчанию используется @samp{rC} -- прямой шрифт с выравниванием по центру.
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetFontDef (@code{const char *}fnt)
+@deftypefnx {Функция С} @code{void} mgl_set_font_def (@code{HMGL} gr, @code{const char *} val)
+Задает стиль шрифта (см. @ref{Text printing}). По умолчанию используется @samp{rC} -- прямой шрифт с выравниванием по центру.
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{void} SetFontSize (@code{float} val)
@anchor{palette}
@deftypefn {MGL command} {} palette 'colors'
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetPalette (@code{const char *}@var{colors})
-@deftypefnx {C function} @code{void} mgl_set_palette (@code{HMGL} gr, @code{const char *}@var{colors})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetPalette (@code{const char *}@var{colors})
+@deftypefnx {Функция С} @code{void} mgl_set_palette (@code{HMGL} gr, @code{const char *}@var{colors})
@end ifclear
-Задает палитру как последовательность цветов. Значение по умолчанию @code{"Hbgrcmyhlnqeup"}, что соответствует цветам: темно серый @samp{H}, синий @samp{b}, зеленый @samp{g}, красный @samp{r}, голубой @samp{c}, малиновый @samp{m}, желтый @samp{y}, серый @samp{h}, сине-зеленый @samp{l}, небесно-голубой @samp{n}, оранжевый @samp{q}, желто-зеленый @samp{e}, сине-фиолетовый @samp{u}, фиолетовый @samp{p}. Палитра в основном используется в 1D графиках (@pxref{1D plotting}) для кривых с неопределенным стилем линии.
+Задает палитру как последовательность цветов. Значение по умолчанию @code{"Hbgrcmyhlnqeup"}, что соответствует цветам: темно серый @samp{H}, синий @samp{b}, зелёный @samp{g}, красный @samp{r}, голубой @samp{c}, малиновый @samp{m}, жёлтый @samp{y}, серый @samp{h}, сине-зелёный @samp{l}, небесно-голубой @samp{n}, оранжевый @samp{q}, желто-зелёный @samp{e}, сине-фиолетовый @samp{u}, фиолетовый @samp{p}. Палитра в основном используется в 1D графиках (см. @ref{1D plotting}) для кривых с неопределённым стилем линии.
@end deftypefn
@c ==================================================================
@cindex SetWarn
@cindex GetWarn
-Ð\95Ñ\81Ñ\82Ñ\8c 2 пеÑ\80еменнÑ\8bе показÑ\8bваÑ\8eÑ\89ие налиÑ\87ие пÑ\80едÑ\83пÑ\80еждениÑ\8f/оÑ\88ибки пÑ\80и Ñ\81оздании гÑ\80аÑ\84ика. Ð\9eбÑ\8bÑ\87но вÑ\8b должнÑ\8b Ñ\81бÑ\80оÑ\81иÑ\82Ñ\8c иÑ\85 Ñ\81 помоÑ\89Ñ\8cÑ\8e @code{SetWarn(0);} пеÑ\80ед поÑ\81Ñ\82Ñ\80оением и пÑ\80овеÑ\80иÑ\82Ñ\8c пеÑ\80еменнÑ\83Ñ\8e @var{WarnCode} на наличие ошибок после построения. Только последнее предупреждение сохраняется. Замечу, что все предупреждения/ошибки в MathGL не являются критичными -- в худшем из вариантов соответствующий график просто не будет построен.
+Ð\9eбÑ\8bÑ\87но вÑ\8b должнÑ\8b Ñ\81бÑ\80оÑ\81иÑ\82Ñ\8c пÑ\80изнак оÑ\88ибки Ñ\81 помоÑ\89Ñ\8cÑ\8e @code{SetWarn(0);} пеÑ\80ед поÑ\81Ñ\82Ñ\80оением и пÑ\80овеÑ\80иÑ\82Ñ\8c @code{GetWarnCode()} или @code{Message()} на наличие ошибок после построения. Только последнее предупреждение сохраняется. Замечу, что все предупреждения/ошибки в MathGL не являются критичными -- в худшем из вариантов соответствующий график просто не будет построен.
-@deftypefn {Метод класса @code{mglGraph}} @code{void} SetWarn (@code{int} code)
-Задает код предупреждения. Обычно вызывается только для очистки предупреждений (@code{SetWarn(0);}) или внутри библиотеки.
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetWarn (@code{int} code, @code{const char *}info=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_set_warn (@code{HMGL} gr, @code{int} code, @code{const char *}info)
+Задает код предупреждения. Обычно вызывается только для очистки предупреждений (@code{SetWarn(0);}) или внутри библиотеки. Текст @var{info} будет добавлен к предупреждениям как есть при @var{code}<0.
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Message (@code{char *}buf)
-Задает буфер для вывода сообщений библиотеки о причине отсутствия графика. Если равен NULL, то сообщения не выводятся. Размер буфера должен быть не менее 1024 байт. Если @var{buf}[0]==0, то сообщений нет.
+@deftypefn {Метод класса @code{mglGraph}} @code{const char *}Message ()
+@deftypefnx {Функция С} @code{const char *}mgl_get_mess (@code{HMGL} gr)
+Возвращает текст предупреждений о причине отсутствия графика. Если возвращаемая строка пустая, то сообщений нет.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{int} GetWarn ()
-@deftypefnx {C function} @code{int} mgl_get_warn (@code{HMGL} gr)
+@deftypefn {Метод класса @code{mglGraph}} @code{int} GetWarnCode ()
+@deftypefnx {Функция С} @code{int} mgl_get_warn_code (@code{HMGL} gr)
Возвращает код сообщения о причине отсутствия графика. Возможные значения:
@table @code
@item mglWarnNone=0
@c ==================================================================
-@node Axis settings, Transformation matrix, Graphics setup, MathGL core
+@node Axis settings, Subplots and rotation, Graphics setup, MathGL core
@section Настройки осей координат
-Эти функции управляет видом и масштабом осей координат. Перед построением для каждой точки выполняются 3 преобразования: сначала определяется возможность рисования точки (@pxref{Cutting}), далее применяются формулы перехода к криволинейным координатам и наконец точка отображается.
+Эти функции управляет видом и масштабом осей координат. Перед построением для каждой точки выполняются 3 преобразования: сначала определяется возможность рисования точки (см. @ref{Cutting}), далее применяются формулы перехода к криволинейным координатам и наконец точка отображается.
@menu
* Ranges (bounding box)::
-* Transformation::
+* Curved coordinates::
* Ticks::
@end menu
@c ------------------------------------------------------------------
-@node Ranges (bounding box), Transformation, , Axis settings
+@node Ranges (bounding box), Curved coordinates, , Axis settings
@subsection Масштаб осей координат
@cindex CRange
@cindex XRange
@deftypefnx {MGL command} {} zrange @code{v1 v2}
@deftypefnx {MGL command} {} crange @code{v1 v2}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{float} v1, @code{float} v2)
-@deftypefnx {C function} @code{void} mgl_set_range_val (@code{HMGL} gr, @code{char} dir, @code{float} v1, @code{float} v2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{float} v1, @code{float} v2)
+@deftypefnx {Функция С} @code{void} mgl_set_range_val (@code{HMGL} gr, @code{char} dir, @code{float} v1, @code{float} v2)
@end ifclear
Задает диапазон изменения @samp{x}-,@samp{y}-,@samp{z}-,@samp{c}-координат. См. также @ref{ranges}.
@end deftypefn
-
@deftypefn {MGL command} {} xrange dat [@code{add=off}]
@deftypefnx {MGL command} {} yrange dat [@code{add=off}]
@deftypefnx {MGL command} {} zrange dat [@code{add=off}]
@deftypefnx {MGL command} {} crange dat [@code{add=off}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{const mglData &}dat, @code{bool} add=@code{false})
-@deftypefnx {C function} @code{void} mgl_set_range_dat (@code{HMGL} gr, @code{char} dir, @code{const HCDT} a, @code{int} add)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{const mglData &}dat, @code{bool} add=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_set_range_dat (@code{HMGL} gr, @code{char} dir, @code{const HCDT} a, @code{int} add)
@end ifclear
Задает диапазон изменения @samp{x}-,@samp{y}-,@samp{z}-,@samp{c}-координат как минимальное и максимальное значение массива @var{dat}. Параметр @var{add} указывает добавлять новый диапазон к существующему или заменять его.
@end deftypefn
@anchor{ranges}
@deftypefn {MGL command} {} ranges @code{x1 x2 y1 y2 [z1=0 z2=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1=@code{0}, @code{float} z2=@code{0})
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{mglPoint} p1, @code{mglPoint} p2)
-@deftypefnx {C function} @code{void} mgl_set_ranges (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1, @code{float} z2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{mglPoint} p1, @code{mglPoint} p2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1=@code{0}, @code{float} z2=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_set_ranges (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1, @code{float} z2)
@end ifclear
Задает диапазон изменения координат. Если минимальное и максимальное значение координаты равны, то они игнорируются по данному направлению. Также устанавливает размер цветовой шкалы, аналогично команде @code{crange z1 z2}. Начальные диапазоны равны [-1, 1].
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy)
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz)
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz, @code{const mglData &}cc)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz, @code{const mglData &}cc)
Задает диапазон изменения @samp{x}-,@samp{y}-,@samp{z}-,@samp{c}-координат как минимальное и максимальное значение массивов @var{xx}, @var{yy}, @var{zz}, @var{cc} соответственно.
@end deftypefn
@end ifclear
@anchor{origin}
@deftypefn {MGL command} {} origin @code{x0 y0 [z0=nan]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetOrigin (@code{float} x0, @code{float} y0, @code{float} z0=@code{NAN})
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetOrigin (@code{mglPoint} p0)
-@deftypefnx {C function} @code{void} mgl_set_origin (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetOrigin (@code{mglPoint} p0)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetOrigin (@code{float} x0, @code{float} y0, @code{float} z0=@code{NAN})
+@deftypefnx {Функция С} @code{void} mgl_set_origin (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0)
@end ifclear
Задает центр пересечения осей координат. Если одно из значений равно NAN, то MathGL попытается выбрать оптимальное положение осей координат по этому направлению.
@end deftypefn
@c ------------------------------------------------------------------
-@node Transformation, Ticks, Ranges (bounding box), Axis settings
+@node Curved coordinates, Ticks, Ranges (bounding box), Axis settings
@subsection Криволинейные координаты
@cindex Axis
@ifclear UDAV
@deftypefn {MGL command} {} axis 'fx' 'fy' ['fz'='' 'fa'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetFunc (@code{const char *}EqX, @code{const char *}EqY, @code{const char *}EqZ=@code{""}, @code{const char *}EqA=@code{""})
-@deftypefnx {C function} @code{void} mgl_set_func (@code{HMGL} gr, @code{const char *}EqX, @code{const char *}EqY, @code{const char *}EqZ, @code{const char *}EqA)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetFunc (@code{const char *}EqX, @code{const char *}EqY, @code{const char *}EqZ=@code{""}, @code{const char *}EqA=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_set_func (@code{HMGL} gr, @code{const char *}EqX, @code{const char *}EqY, @code{const char *}EqZ, @code{const char *}EqA)
@end ifclear
-Задает формулы перехода к криволинейным координатам. Каждая строка является математическим выражением, зависящим от старых координат @samp{x}, @samp{y}, @samp{z} и @samp{a} или @samp{c} для цветовой шкалы. Например, для цилиндрических координат будет @code{Axis("x*cos(y)", "x*sin(y)", "z");}. Для удаления формул соответствующий параметр должен быть пустым или @code{NULL}. Использование формул преобразования слегка замедляет программу, т.е.. @code{Axis("", "", "")} быстрее чем @code{Axis("1*x", "1*y", "1*z")}. Параметр @var{EqA} задает аналогичную формулу для цветовой шкалы. @xref{Textual formulas}.
+Задает формулы перехода к криволинейным координатам. Каждая строка является математическим выражением, зависящим от старых координат @samp{x}, @samp{y}, @samp{z} и @samp{a} или @samp{c} для цветовой шкалы. Например, для цилиндрических координат будет @code{SetFunc("x*cos(y)", "x*sin(y)", "z");}. Для удаления формул соответствующий параметр должен быть пустым или @code{NULL}. Использование формул преобразования слегка замедляет программу. Параметр @var{EqA} задает аналогичную формулу для цветовой шкалы. @xref{Textual formulas}.
@end deftypefn
@deftypefn {MGL command} {} axis @code{how}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetCoor (@code{int} how)
-@deftypefnx {C function} @code{void} mgl_set_coor (@code{HMGL} gr, @code{int} how)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetCoor (@code{int} how)
+@deftypefnx {Функция С} @code{void} mgl_set_coor (@code{HMGL} gr, @code{int} how)
@end ifclear
-Устанавливает одну из предопределенных систем криволинейных координат в зависимости от параметра @var{how}: @code{mglCartesian=0} -- декартова система (нет преобразования координат, наиболее быстрая); @code{mglPolar=1} -- полярные координаты @math{x_n=x*cos(y),y_n=x*sin(y), z_n=z}; @code{mglSpherical=2} -- сферические координаты @math{x_n=x*sin(y)*cos(z), y_n=x*sin(y)*sin(z), z_n=x*cos(y)}; @code{mglParabolic=3} -- параболические координаты @math{x_n=x*y, y_n=(x*x-y*y)/2, z_n=z}; @code{mglParaboloidal=4} -- Paraboloidal coordinates @math{x_n=(x*x-y*y)*cos(z)/2, y_n=(x*x-y*y)*sin(z)/2, z_n=x*y}; @code{mglOblate=5} -- Oblate coordinates @math{x_n=cosh(x)*cos(y)*cos(z), y_n=cosh(x)*cos(y)*sin(z), z_n=sinh(x)*sin(y)}; @code{mglProlate=6} -- Prolate coordinates @math{x_n=sinh(x)*sin(y)*cos(z), y_n=sinh(x)*sin(y)*sin(z), z_n=cosh(x)*cos(y)}; @code{mglElliptic=7} -- эллиптические координаты @math{x_n=cosh(x)*cos(y), y_n=sinh(x)*sin(y), z_n=z}; @code{mglToroidal=8} -- тороидальные координаты @math{x_n=sinh(x)*cos(z)/(cosh(x)-cos(y)), y_n=sinh(x)*sin(z)/(cosh(x)-cos(y)), z_n=sin(y)/(cosh(x)-cos(y))}; @code{mglBispherical=9} -- бисферические координаты @math{x_n=sin(y)*cos(z)/(cosh(x)-cos(y)), y_n=sin(y)*sin(z)/(cosh(x)-cos(y)), z_n=sinh(x)/(cosh(x)-cos(y))}; @code{mglBipolar=10} -- биполярные координаты @math{x_n=sinh(x)/(cosh(x)-cos(y)), y_n=sin(y)/(cosh(x)-cos(y)), z_n=z}.
+Устанавливает одну из предопределенных систем криволинейных координат в зависимости от параметра @var{how}: @code{mglCartesian=0} -- декартова система (нет преобразования координат, наиболее быстрая); @code{mglPolar=1} -- полярные координаты @math{x_n=x*cos(y),y_n=x*sin(y), z_n=z}; @code{mglSpherical=2} -- сферические координаты @math{x_n=x*sin(y)*cos(z), y_n=x*sin(y)*sin(z), z_n=x*cos(y)}; @code{mglParabolic=3} -- параболические координаты @math{x_n=x*y, y_n=(x*x-y*y)/2, z_n=z}; @code{mglParaboloidal=4} -- Paraboloidal coordinates @math{x_n=(x*x-y*y)*cos(z)/2, y_n=(x*x-y*y)*sin(z)/2, z_n=x*y}; @code{mglOblate=5} -- Oblate coordinates @math{x_n=cosh(x)*cos(y)*cos(z), y_n=cosh(x)*cos(y)*sin(z), z_n=sinh(x)*sin(y)}; @code{mglProlate=6} -- Prolate coordinates @math{x_n=sinh(x)*sin(y)*cos(z), y_n=sinh(x)*sin(y)*sin(z), z_n=cosh(x)*cos(y)}; @code{mglElliptic=7} -- эллиптические координаты @math{x_n=cosh(x)*cos(y), y_n=sinh(x)*sin(y), z_n=z}; @code{mglToroidal=8} -- тороидальные координаты @math{x_n=sinh(x)*cos(z)/(cosh(x)-cos(y)), y_n=sinh(x)*sin(z)/(cosh(x)-cos(y)), z_n=sin(y)/(cosh(x)-cos(y))}; @code{mglBispherical=9} -- бисферические координаты @math{x_n=sin(y)*cos(z)/(cosh(x)-cos(y)), y_n=sin(y)*sin(z)/(cosh(x)-cos(y)), z_n=sinh(x)/(cosh(x)-cos(y))}; @code{mglBipolar=10} -- биполярные координаты @math{x_n=sinh(x)/(cosh(x)-cos(y)), y_n=sin(y)/(cosh(x)-cos(y)), z_n=z}; @code{mglLogLog=11} -- log-log координаты @math{x_n=lg(x), y_n=lg(y), z_n=lg(z)}; @code{mglLogX=12} -- log-x координаты @math{x_n=lg(x), y_n=y, z_n=z}; @code{mglLogY=13} -- log-y координаты @math{x_n=x, y_n=lg(y), z_n=z}.
@end deftypefn
@anchor{ternary}
@deftypefn {MGL command} {} ternary @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Ternary (@code{bool} tern)
-@deftypefnx {C function} @code{void} mgl_set_ternary (@code{HMGL} gr, @code{int} tern)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Ternary (@code{int} tern)
+@deftypefnx {Функция С} @code{void} mgl_set_ternary (@code{HMGL} gr, @code{int} tern)
@end ifclear
-Ð\97адаеÑ\82 Ñ\80иÑ\81ование Ñ\82Ñ\80еÑ\83голÑ\8cнÑ\8bÑ\85 (Ternary) оÑ\81ей кооÑ\80динаÑ\82. ÐÑ\82о Ñ\81пеÑ\86иалÑ\8cнÑ\8bй Ñ\82ип гÑ\80аÑ\84ика длÑ\8f 3 завиÑ\81имÑ\8bÑ\85 кооÑ\80динаÑ\82 (компоненÑ\82) @var{a}, @var{b}, @var{c} Ñ\82акиÑ\85, Ñ\87Ñ\82о @var{a}+@var{b}+@var{c}=1. MathGL иÑ\81полÑ\8cзÑ\83еÑ\82 Ñ\82олÑ\8cко 2 незавиÑ\81имÑ\8bе кооÑ\80динаÑ\82Ñ\8b @var{a}=x и @var{b}=y поÑ\81колÑ\8cкÑ\83 иÑ\85 доÑ\81Ñ\82аÑ\82оÑ\87но длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f вÑ\81еÑ\85 гÑ\80аÑ\84иков. Ð\9fÑ\80и Ñ\8dÑ\82ом Ñ\82Ñ\80еÑ\82Ñ\8cÑ\8f кооÑ\80динаÑ\82а z Ñ\8fвлÑ\8fеÑ\82Ñ\81Ñ\8f незавиÑ\81имÑ\8bм паÑ\80амеÑ\82Ñ\80ом длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f линий Ñ\83Ñ\80овнÑ\8f, повеÑ\80Ñ\85ноÑ\81Ñ\82ей и Ñ\82.д. @sref{Ternary plot sample}
+Ð\97адаеÑ\82 Ñ\80иÑ\81ование Ñ\82Ñ\80еÑ\83голÑ\8cнÑ\8bÑ\85 (Ternary) или пиÑ\80амидалÑ\8cнÑ\8bÑ\85 (Quaternary) оÑ\81ей кооÑ\80динаÑ\82. ÐÑ\82о Ñ\81пеÑ\86иалÑ\8cнÑ\8bй Ñ\82ип гÑ\80аÑ\84ика длÑ\8f 3 завиÑ\81имÑ\8bÑ\85 кооÑ\80динаÑ\82 (компоненÑ\82) @var{a}, @var{b}, @var{c} Ñ\82акиÑ\85, Ñ\87Ñ\82о @var{a}+@var{b}+@var{c}=1. MathGL иÑ\81полÑ\8cзÑ\83еÑ\82 Ñ\82олÑ\8cко 2 незавиÑ\81имÑ\8bе кооÑ\80динаÑ\82Ñ\8b @var{a}=x и @var{b}=y поÑ\81колÑ\8cкÑ\83 иÑ\85 доÑ\81Ñ\82аÑ\82оÑ\87но длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f вÑ\81еÑ\85 гÑ\80аÑ\84иков. Ð\9fÑ\80и Ñ\8dÑ\82ом Ñ\82Ñ\80еÑ\82Ñ\8cÑ\8f кооÑ\80динаÑ\82а z Ñ\8fвлÑ\8fеÑ\82Ñ\81Ñ\8f незавиÑ\81имÑ\8bм паÑ\80амеÑ\82Ñ\80ом длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f линий Ñ\83Ñ\80овнÑ\8f, повеÑ\80Ñ\85ноÑ\81Ñ\82ей и Ñ\82.д. СооÑ\82веÑ\82Ñ\81Ñ\82венно Quaternary кооÑ\80динаÑ\82Ñ\8b -- 4 незавиÑ\81имÑ\8bе кооÑ\80динаÑ\82Ñ\8b @var{a}, @var{b}, @var{c} и @var{d}, Ñ\82акие Ñ\87Ñ\82о @var{a}+@var{b}+@var{c}+@var{d}=1. Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е @code{Ternary(0)}. @sref{Ternary axis}
@end deftypefn
@c ------------------------------------------------------------------
-@node Ticks, , Transformation, Axis settings
+@node Ticks, , Curved coordinates, Axis settings
@subsection Метки осей
@cindex AxisStl
@cindex TickLen
@cindex SetTickSkip
@end ifclear
-@anchor{ticklen}
-@deftypefn {MGL command} {} ticklen @code{val} [@code{stt=1}]
-@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTickLen (@code{float} val, @code{float} stt=@code{1})
-@deftypefnx {C function} @code{void} mgl_set_tick_len (@code{HMGL} gr, @code{float} val, @code{float} stt)
-@end ifclear
-Задает относительную длину меток осей координат. Значение по умолчанию @code{0.1}. Параметр @var{stt}>0 задает относительную длину подметок, которые в @code{sqrt(1+stt)} раз меньше.
-@end deftypefn
-
-@deftypefn {MGL command} {} axisstl 'stl' ['tck'='' 'sub'='']
-@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetAxisStl (@code{const char *}stl=@code{"k"}, @code{const char *}tck=@code{0}, @code{const char *}sub=@code{0})
-@deftypefnx {C function} @code{void} mgl_set_axis_stl (@code{HMGL} gr, @code{const char *}stl, @code{const char *}tck, @code{const char *}sub)
-@end ifclear
-Задает стиль осей (@var{stl}), меток (@var{tck}) и подметок (@var{sub}) осей координат. Если @var{stl} пустая или ноль, то используется стиль по умолчанию (@samp{k} или @samp{w} в зависимости от типа прозрачности). Если @var{tck}, @var{sub} пустая или ноль, то используется стиль осей (т.е. @var{stl}).
-@end deftypefn
-
@anchor{adjust}
@deftypefn {MGL command} {} adjust ['dir'='xyzc']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Adjust (@code{const char *}dir=@code{"xyz"})
-@deftypefnx {C function} @code{void} mgl_adjust_ticks (@code{HMGL} gr, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Adjust (@code{const char *}dir=@code{"xyzc"})
+@deftypefnx {Функция С} @code{void} mgl_adjust_ticks (@code{HMGL} gr, @code{const char *}dir)
@end ifclear
-Автоматически задает шаг меток осей, число подметок и начальное положение меток для осей координат @var{dir} в виде наиболее удобном для человека. Также задает @code{SetTuneTicks(true)}.
+Автоматически задает шаг меток осей, число подметок и начальное положение меток для осей координат @var{dir} в виде наиболее удобном для человека. Также задает @code{SetTuneTicks(true)}. Обычно не требуется вызывать эту функцию кроме случая возвращения настроек по умолчанию.
@end deftypefn
@anchor{xtick}
@deftypefnx {MGL command} {} ztick @code{val [sub=0 org=nan]}
@deftypefnx {MGL command} {} ctick @code{val [sub=0 org=nan]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicks (@code{char} dir, @code{float} d=@code{0}, @code{int} ns=@code{0}, @code{float} org=@code{NAN})
-@deftypefnx {C function} @code{void} mgl_set_ticks_dir (@code{HMGL} gr, @code{char} dir, @code{float} d, @code{int} ns, @code{float} org)
-@deftypefnx {C function} @code{void} mgl_set_ticks(@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} nz)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicks (@code{char} dir, @code{float} d=@code{0}, @code{int} ns=@code{0}, @code{float} org=@code{NAN})
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_dir (@code{HMGL} gr, @code{char} dir, @code{float} d, @code{int} ns, @code{float} org)
+@deftypefnx {Функция С} @code{void} mgl_set_ticks (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} nz)
@end ifclear
-Ð\97адаеÑ\82 Ñ\88аг меÑ\82ок оÑ\81ей @var{d}, Ñ\87иÑ\81ло подмеÑ\82ок @var{ns} и наÑ\87алÑ\8cное положение меÑ\82ок @var{org} длÑ\8f оÑ\81и вдолÑ\8c напÑ\80авлениÑ\8f @var{dir} (иÑ\81полÑ\8cзÑ\83йÑ\82е 'c' длÑ\8f меÑ\82ок colorbar). Ð\9fеÑ\80еменнаÑ\8f @var{d} задаеÑ\82 Ñ\88аг меÑ\82ок (еÑ\81ли положиÑ\82елÑ\8cна) или иÑ\85 Ñ\87иÑ\81ло на оÑ\81и (еÑ\81ли оÑ\82Ñ\80иÑ\86аÑ\82елÑ\8cна). Ð\9dÑ\83левое знаÑ\87ение задаеÑ\82 логаÑ\80иÑ\84миÑ\87еÑ\81кие меÑ\82ки. Если @var{org}=@code{NAN}, то используется значение из переменной @var{Org}.
+Ð\97адаеÑ\82 Ñ\88аг меÑ\82ок оÑ\81ей @var{d}, Ñ\87иÑ\81ло подмеÑ\82ок @var{ns} и наÑ\87алÑ\8cное положение меÑ\82ок @var{org} длÑ\8f оÑ\81и вдолÑ\8c напÑ\80авлениÑ\8f @var{dir} (иÑ\81полÑ\8cзÑ\83йÑ\82е 'c' длÑ\8f меÑ\82ок colorbar). Ð\9fеÑ\80еменнаÑ\8f @var{d} задаеÑ\82 Ñ\88аг меÑ\82ок (еÑ\81ли положиÑ\82елÑ\8cна) или иÑ\85 Ñ\87иÑ\81ло на оÑ\81и (еÑ\81ли оÑ\82Ñ\80иÑ\86аÑ\82елÑ\8cна). Ð\9dÑ\83левое знаÑ\87ение задаеÑ\82 авÑ\82омаÑ\82иÑ\87еÑ\81кÑ\83Ñ\8e Ñ\80аÑ\81Ñ\81Ñ\82ановкÑ\83 меÑ\82ок. Если @var{org}=@code{NAN}, то используется значение из переменной @var{Org}.
@end deftypefn
@deftypefn {MGL command} {} xtick @code{val1} 'lbl1' [@code{val2} 'lbl2' ...]
@deftypefnx {MGL command} {} ytick @code{val1} 'lbl1' [@code{val2} 'lbl2' ...]
@deftypefnx {MGL command} {} ztick @code{val1} 'lbl1' [@code{val2} 'lbl2' ...]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const char *}lbl, @code{bool} add=@code{false})
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const wchar_t *}lbl, @code{bool} add=@code{false})
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const mglData &}val, @code{const char *}lbl, @code{bool} add=@code{false})
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const mglData &}val, @code{const wchar_t *}lbl, @code{bool} add=@code{false})
-@deftypefnx {C function} @code{void} mgl_set_ticks_str (@code{HMGL} gr, @code{char} dir, @code{const char *}lbl, @code{bool} add)
-@deftypefnx {C function} @code{void} mgl_set_ticks_wcs (@code{HMGL} gr, @code{char} dir, @code{const wchar_t *}lbl, @code{bool} add)
-@deftypefnx {C function} @code{void} mgl_set_ticks_val (@code{HMGL} gr, @code{char} dir, @code{HCDT} val, @code{const char *}lbl, @code{bool} add)
-@deftypefnx {C function} @code{void} mgl_set_ticks_valw (@code{HMGL} gr, @code{char} dir, @code{HCDT} val, @code{const wchar_t *}lbl, @code{bool} add)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const char *}lbl, @code{bool} add=@code{false})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const wchar_t *}lbl, @code{bool} add=@code{false})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const mglData &}val, @code{const char *}lbl, @code{bool} add=@code{false})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicksVal (@code{char} dir, @code{const mglData &}val, @code{const wchar_t *}lbl, @code{bool} add=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_str (@code{HMGL} gr, @code{char} dir, @code{const char *}lbl, @code{bool} add)
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_wcs (@code{HMGL} gr, @code{char} dir, @code{const wchar_t *}lbl, @code{bool} add)
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_val (@code{HMGL} gr, @code{char} dir, @code{HCDT} val, @code{const char *}lbl, @code{bool} add)
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_valw (@code{HMGL} gr, @code{char} dir, @code{HCDT} val, @code{const wchar_t *}lbl, @code{bool} add)
@end ifclear
-Задает явное положение @var{val} и подписи @var{lbl} для меток вдоль оси @var{dir}. Если массив @var{val} не указан, то используются значения равнораспределенные в интервале [@var{Min}.x, @var{Max}.x]. Метки разделяются символом @samp{\n}. Используйте @code{SetTicks()} для восстановления автоматических меток. @sref{Manual ticks sample}
+Задает явное положение @var{val} и подписи @var{lbl} для меток вдоль оси @var{dir}. Если массив @var{val} не указан, то используются значения равно распределённые в интервале [@var{Min}.x, @var{Max}.x]. Метки разделяются символом @samp{\n}. Используйте @code{SetTicks()} для восстановления автоматических меток.
@end deftypefn
@deftypefn {MGL command} {} xtick 'templ'
@deftypefnx {MGL command} {} ztick 'templ'
@deftypefnx {MGL command} {} ctick 'templ'
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTickTempl (@code{char} dir, @code{const char *}templ)
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTickTempl (@code{char} dir, @code{const wchar_t *}templ)
-@deftypefnx {C function} @code{void} mgl_set_tick_templ (@code{HMGL} gr, @code{const char *}templ)
-@deftypefnx {C function} @code{void} mgl_set_tick_templw (@code{HMGL} gr, @code{const wchar_t *}templ)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTickTempl (@code{char} dir, @code{const char *}templ)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTickTempl (@code{char} dir, @code{const wchar_t *}templ)
+@deftypefnx {Функция С} @code{void} mgl_set_tick_templ (@code{HMGL} gr, @code{const char *}templ)
+@deftypefnx {Функция С} @code{void} mgl_set_tick_templw (@code{HMGL} gr, @code{const wchar_t *}templ)
@end ifclear
-Задает шаблон @var{templ} для меток вдоль x-,y-,z-оси или colorbar. Шаблон может содержать и символы TeX. Если @var{templ}=@code{""}, то используется шаблон по умолчанию (в простейшем случае @samp{%.2g}). Установка шаблона выключает автоматическое улучшение вида меток (См. @code{SetTuneTicks()}).
+Задает шаблон @var{templ} для меток вдоль x-,y-,z-оси или colorbar. Шаблон может содержать и символы TeX. Если @var{templ}=@code{""}, то используется шаблон по умолчанию (в простейшем случае @samp{%.2g}). Установка шаблона выключает автоматическое улучшение вида меток.
@end deftypefn
-@deftypefn {MGL command} {} xtick val 'templ'
-@deftypefnx {MGL command} {} ytick val 'templ'
-@deftypefnx {MGL command} {} ztick val 'templ'
-@deftypefnx {MGL command} {} ctick val 'templ'
+@deftypefn {MGL command} {} ticktime 'dir' [@code{dv} 'tmpl']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTickTime (@code{char} dir, @code{float} val, @code{const char *}templ)
-@deftypefnx {C function} @code{void} mgl_set_tick_time (@code{HMGL} gr, @code{float} val, @code{const char *}templ)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicksTime (@code{char} dir, @code{float} val, @code{const char *}templ)
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_time (@code{HMGL} gr, @code{float} val, @code{const char *}templ)
@end ifclear
-Задает метки времени с шагом @var{val} и шаблоном @var{templ} для меток вдоль x-,y-,z-оси или colorbar. Шаблон может содержать и символы TeX.
+Задает метки времени с шагом @var{val} и шаблоном @var{templ} для меток вдоль x-,y-,z-оси или colorbar. Шаблон может содержать и символы TeX. Формат шаблона @var{templ} такой же как @url{http://www.manpagez.com/man/3/strftime/}. Наиболее употребительные варианты: @samp{%X} для национального представления времени, @samp{%x} для национального представления даты, @samp{%Y} для года с цифрами столетия. Если @var{val}=0 и/или @var{templ}="", то используется автоматическая расстановка меток и/или выбор шаблона.
@end deftypefn
+@deftypefn {MGL command} {} tuneticks @code{val} [@code{pos=1.15}]
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} SetTuneTicks (@code{bool} tune, @code{float} pos=@code{1.15})
-@deftypefnx {C function} @code{void} mgl_tune_ticks (@code{HMGL} gr, @code{bool} tune, @code{float} pos)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTuneTicks (@code{int} tune, @code{float} pos=@code{1.15})
+@deftypefnx {Функция С} @code{void} mgl_tune_ticks (@code{HMGL} gr, @code{int} tune, @code{float} pos)
+@end ifclear
Включает/выключает улучшение вида меток осей путем вынесения общего множителя (для маленьких, типа 0.001...0.002, или больших, типа 1000...2000, значений координат) или общей компоненты (для узкого диапазона, типа 0.999...1.000). Также задает положение @var{pos} общего множителя на оси: =0 около минимального значения, =1 около максимального значения.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} SetTickRotate (@code{bool} val)
-@deftypefnx {C function} @code{void} mgl_set_tick_rotate (@code{HMGL} gr, @code{bool} val)
+@ifclear UDAV
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetTickRotate (@code{bool} val)
+@deftypefnx {Функция С} @code{void} mgl_set_tick_rotate (@code{HMGL} gr, @code{bool} val)
Включает/выключает поворот меток если их число или длина меток слишком велики.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} SetTickSkip (@code{bool} val)
-@deftypefnx {C function} @code{void} mgl_set_tick_skip (@code{HMGL} gr, @code{bool} val)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetTickSkip (@code{bool} val)
+@deftypefnx {Функция С} @code{void} mgl_set_tick_skip (@code{HMGL} gr, @code{bool} val)
Включает/выключает пропуск меток если их число или длина меток слишком велики.
@end deftypefn
@end ifclear
+@anchor{ticklen}
+@deftypefn {MGL command} {} ticklen @code{val} [@code{stt=1}]
+@ifclear UDAV
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTickLen (@code{float} val, @code{float} stt=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_set_tick_len (@code{HMGL} gr, @code{float} val, @code{float} stt)
+@end ifclear
+Задает относительную длину меток осей координат. Значение по умолчанию @code{0.1}. Параметр @var{stt}>0 задает относительную длину подметок, которые в @code{sqrt(1+stt)} раз меньше.
+@end deftypefn
+
+@deftypefn {MGL command} {} axisstl 'stl' ['tck'='' 'sub'='']
+@ifclear UDAV
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAxisStl (@code{const char *}stl=@code{"k"}, @code{const char *}tck=@code{0}, @code{const char *}sub=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_set_axis_stl (@code{HMGL} gr, @code{const char *}stl, @code{const char *}tck, @code{const char *}sub)
+@end ifclear
+Задает стиль осей (@var{stl}), меток (@var{tck}) и подметок (@var{sub}) осей координат. Если @var{stl} пустая или ноль, то используется стиль по умолчанию (@samp{k} или @samp{w} в зависимости от типа прозрачности). Если @var{tck}, @var{sub} пустая или ноль, то используется стиль осей (т.е. @var{stl}).
+@end deftypefn
+
@c ##################################################################
-@node Transformation matrix, Export picture, Axis settings, MathGL core
+@node Subplots and rotation, Export picture, Axis settings, MathGL core
@section Матрица преобразования
@cindex Aspect
@cindex Rotate
@cindex Push
@cindex Pop
-Эти функции контролируют где и как график будет расположен. Существует определенный порядок вызова этих функций для лучшего вида графика. Вначале должны вызываться функции SubPlot() или InPlot() для указания местоположения вывода. После них -- функции вращения Rotate() и сжатия Aspect(). И наконец любые другие функции для рисования графика. Вместо вращения графика можно вызвать функцию ColumnPlot() для расположения графиков в столбец одного над другим без зазора между осями.
+Эти функции контролируют где и как график будет расположен. Существует определенный порядок вызова этих функций для лучшего вида графика. Вначале должны вызываться функции SubPlot() или InPlot() для указания местоположения вывода. После них -- функции вращения Rotate() и сжатия Aspect(). И наконец любые другие функции для рисования графика. Вместо вращения графика можно вызвать функцию ColumnPlot() для расположения графиков в столбец одного над другим без зазора между осями. @sref{Subplots}
@anchor{subplot}
-@deftypefn {MGL command} {} subplot @code{nx ny m [dx=0 dy=0]}
-@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SubPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{float} dx=@code{0}, @code{float} dy=@code{0})
-@deftypefnx {C function} @code{void} mgl_subplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m)
-@deftypefnx {C function} @code{void} mgl_subplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{float} dx, @code{float} dy)
-@end ifclear
-Помещает последующий вывод в @var{m}-ую ячейку сетки размером @var{nx}*@var{ny} от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". С эстетической точки зрения не рекомендуется вызывать эту функцию с различными (или не кратными) размерами сетки. Ячейка может быть дополнительно сдвинута относительно своего обычного положения на относительный размер @var{dx}, @var{dy}.
-@end deftypefn
-
-@deftypefn {MGL command} {} subplot @code{nx ny m} 'style'
+@deftypefn {MGL command} {} subplot @code{nx ny m ['stl'='<>_^' dx=0 dy=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SubPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{const char *}style)
-@deftypefnx {C function} @code{void} mgl_subplot_s (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}style)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SubPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl=@code{"<>_^"}, @code{float} dx=@code{0}, @code{float} dy=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_subplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl)
+@deftypefnx {Функция С} @code{void} mgl_subplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl, @code{float} dx, @code{float} dy)
@end ifclear
-Ð\90налогиÑ\87но пÑ\80едÑ\8bдÑ\83Ñ\89емÑ\83, но меÑ\81Ñ\82о длÑ\8f оÑ\81ей/colorbar Ñ\80езеÑ\80виÑ\80Ñ\83еÑ\82Ñ\81Ñ\8f Ñ\82олÑ\8cко еÑ\81ли Ñ\81Ñ\82Ñ\80ока @var{style} Ñ\81одеÑ\80жиÑ\82: @samp{L} или @samp{<} -- Ñ\81 левого кÑ\80аÑ\8f, @samp{R} или @samp{>} -- Ñ\81 пÑ\80авого кÑ\80аÑ\8f, @samp{A} или @samp{^} -- Ñ\81 веÑ\80Ñ\85него кÑ\80аÑ\8f, @samp{U} или @samp{_} -- Ñ\81 нижнего кÑ\80аÑ\8f.
+Ð\9fомеÑ\89аеÑ\82 поÑ\81ледÑ\83Ñ\8eÑ\89ий вÑ\8bвод в @var{m}-Ñ\83Ñ\8e Ñ\8fÑ\87ейкÑ\83 Ñ\81еÑ\82ки Ñ\80азмеÑ\80ом @var{nx}*@var{ny} оÑ\82 вÑ\81его Ñ\80иÑ\81Ñ\83нка. ФÑ\83нкÑ\86иÑ\8f Ñ\81бÑ\80аÑ\81Ñ\8bваеÑ\82 маÑ\82Ñ\80иÑ\86Ñ\83 Ñ\82Ñ\80анÑ\81Ñ\84оÑ\80маÑ\86ии (повоÑ\80оÑ\82Ñ\8b и Ñ\81жаÑ\82ие гÑ\80аÑ\84ика) и должна вÑ\8bзÑ\8bваÑ\82Ñ\8cÑ\81Ñ\8f пеÑ\80вой длÑ\8f Ñ\81озданиÑ\8f "подгÑ\80аÑ\84ика". С Ñ\8dÑ\81Ñ\82еÑ\82иÑ\87еÑ\81кой Ñ\82оÑ\87ки зÑ\80ениÑ\8f не Ñ\80екомендÑ\83еÑ\82Ñ\81Ñ\8f вÑ\8bзÑ\8bваÑ\82Ñ\8c Ñ\8dÑ\82Ñ\83 Ñ\84Ñ\83нкÑ\86иÑ\8e Ñ\81 Ñ\80азлиÑ\87нÑ\8bми (или не кÑ\80аÑ\82нÑ\8bми) Ñ\80азмеÑ\80ами Ñ\81еÑ\82ки. Ð\9cеÑ\81Ñ\82о длÑ\8f оÑ\81ей/colorbar Ñ\80езеÑ\80виÑ\80Ñ\83еÑ\82Ñ\81Ñ\8f Ñ\82олÑ\8cко еÑ\81ли Ñ\81Ñ\82Ñ\80ока @var{style} Ñ\81одеÑ\80жиÑ\82: @samp{L} или @samp{<} -- Ñ\81 левого кÑ\80аÑ\8f, @samp{R} или @samp{>} -- Ñ\81 пÑ\80авого кÑ\80аÑ\8f, @samp{A} или @samp{^} -- Ñ\81 веÑ\80Ñ\85него кÑ\80аÑ\8f, @samp{U} или @samp{_} -- Ñ\81 нижнего кÑ\80аÑ\8f. ЯÑ\87ейка можеÑ\82 бÑ\8bÑ\82Ñ\8c дополниÑ\82елÑ\8cно Ñ\81двинÑ\83Ñ\82а оÑ\82ноÑ\81иÑ\82елÑ\8cно Ñ\81воего обÑ\8bÑ\87ного положениÑ\8f на оÑ\82ноÑ\81иÑ\82елÑ\8cнÑ\8bй Ñ\80азмеÑ\80 @var{dx}, @var{dy}.
@end deftypefn
+@anchor{multiplot}
@deftypefn {MGL command} {} multiplot @code{nx ny m dx dy} ['style'='<>_^']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} MultiPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{int} dx, @code{int} dy, @code{const char *}style=@code{"<>_^"})
-@deftypefnx {C function} @code{void} mgl_multiplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{int} dx, @code{int} dy, @code{const char *}style)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} MultiPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{int} dx, @code{int} dy, @code{const char *}stl=@code{"<>_^"})
+@deftypefnx {Функция С} @code{void} mgl_multiplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{int} dx, @code{int} dy, @code{const char *}stl)
@end ifclear
Помещает последующий вывод в прямоугольник из @var{dx}*@var{dy} ячеек, начиная с @var{m}-ой ячейки, сетки размером @var{nx}*@var{ny} от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". Место для осей/colorbar резервируется если строка @var{style} содержит: @samp{L} или @samp{<} -- с левого края, @samp{R} или @samp{>} -- с правого края, @samp{A} или @samp{^} -- с верхнего края, @samp{U} или @samp{_} -- с нижнего края.
@end deftypefn
@anchor{inplot}
@deftypefn {MGL command} {} inplot @code{x1 x2 y1 y2 [rel=off]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} InPlot (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{bool} rel=@code{false})
-@deftypefnx {C function} @code{void} mgl_inplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
-@deftypefnx {C function} @code{void} mgl_relplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} InPlot (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{bool} rel=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_inplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
+@deftypefnx {Функция С} @code{void} mgl_relplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
@end ifclear
-Помещает последующий вывод в прямоугольную область [@var{x1}, @var{x2}]*[@var{y1}, @var{y2}] (исходный размер [0,1]*[0,1]). Эта функция позволяет поместить график в произвольную область рисунка. Если параметр @var{rel}=@code{true}, то используется позиция относительно текщего SubPlot() (или InPlot() с @var{rel}=@code{false}). Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика".
+Ð\9fомеÑ\89аеÑ\82 поÑ\81ледÑ\83Ñ\8eÑ\89ий вÑ\8bвод в пÑ\80Ñ\8fмоÑ\83голÑ\8cнÑ\83Ñ\8e облаÑ\81Ñ\82Ñ\8c [@var{x1}, @var{x2}]*[@var{y1}, @var{y2}] (иÑ\81Ñ\85однÑ\8bй Ñ\80азмеÑ\80 [0,1]*[0,1]). ÐÑ\82а Ñ\84Ñ\83нкÑ\86иÑ\8f позволÑ\8fеÑ\82 помеÑ\81Ñ\82иÑ\82Ñ\8c гÑ\80аÑ\84ик в пÑ\80оизволÑ\8cнÑ\83Ñ\8e облаÑ\81Ñ\82Ñ\8c Ñ\80иÑ\81Ñ\83нка. Ð\95Ñ\81ли паÑ\80амеÑ\82Ñ\80 @var{rel}=@code{true}, Ñ\82о иÑ\81полÑ\8cзÑ\83еÑ\82Ñ\81Ñ\8f позиÑ\86иÑ\8f оÑ\82ноÑ\81иÑ\82елÑ\8cно Ñ\82екÑ\83Ñ\89его SubPlot() (или InPlot() Ñ\81 @var{rel}=@code{false}). ФÑ\83нкÑ\86иÑ\8f Ñ\81бÑ\80аÑ\81Ñ\8bваеÑ\82 маÑ\82Ñ\80иÑ\86Ñ\83 Ñ\82Ñ\80анÑ\81Ñ\84оÑ\80маÑ\86ии (повоÑ\80оÑ\82Ñ\8b и Ñ\81жаÑ\82ие гÑ\80аÑ\84ика) и должна вÑ\8bзÑ\8bваÑ\82Ñ\8cÑ\81Ñ\8f пеÑ\80вой длÑ\8f Ñ\81озданиÑ\8f "подгÑ\80аÑ\84ика".
@end deftypefn
@anchor{columnplot}
@deftypefn {MGL command} {} columnplot @code{num ind [d=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} ColumnPlot (@code{int} num, @code{int} ind, @code{float} d=@code{0})
-@deftypefnx {C function} @code{void} mgl_columnplot (@code{HMGL} gr, @code{int} num, @code{int} ind)
-@deftypefnx {C function} @code{void} mgl_columnplot_d (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} d)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ColumnPlot (@code{int} num, @code{int} ind, @code{float} d=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_columnplot (@code{HMGL} gr, @code{int} num, @code{int} ind)
+@deftypefnx {Функция С} @code{void} mgl_columnplot_d (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} d)
+@end ifclear
+Помещает последующий вывод в @var{ind}-ую строку столбца из @var{num} строк. Положение столбца выбирается относительно последнего вызова SubPlot() (или InPlot() с @var{rel}=@code{false}). Параметр @var{d} задает дополнительный зазор между строк.
+@end deftypefn
+
+@anchor{gridplot}
+@deftypefn {MGL command} {} gridplot @code{nx ny ind [d=0]}
+@ifclear UDAV
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} GridPlot (@code{int} nx, @code{int} ny, @code{int} ind, @code{float} d=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_gridplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind)
+@deftypefnx {Функция С} @code{void} mgl_gridplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind, @code{float} d)
@end ifclear
-Ð\9fомеÑ\89аеÑ\82 поÑ\81ледÑ\83Ñ\8eÑ\89ий вÑ\8bвод в @var{ind}-Ñ\83Ñ\8e Ñ\81Ñ\82Ñ\80окÑ\83 Ñ\81Ñ\82олбÑ\86а из @var{num} Ñ\81Ñ\82Ñ\80ок. Ð\9fоложение Ñ\81Ñ\82олбÑ\86а вÑ\8bбиÑ\80аеÑ\82Ñ\81Ñ\8f оÑ\82ноÑ\81иÑ\82елÑ\8cно поÑ\81леднего вÑ\8bзова SubPlot() (или InPlot() Ñ\81 @var{rel}=@code{false}). Ð\9fаÑ\80амеÑ\82Ñ\80 @var{d} задаеÑ\82 дополниÑ\82елÑ\8cнÑ\8bй зазоÑ\80 междÑ\83 Ñ\81Ñ\82Ñ\80ок. @sref{ColumnPlot sample}
+Ð\9fомеÑ\89аеÑ\82 поÑ\81ледÑ\83Ñ\8eÑ\89ий вÑ\8bвод в @var{ind}-Ñ\83Ñ\8e Ñ\8fÑ\87ейкÑ\83 Ñ\82аблиÑ\86Ñ\8b @var{nx}*@var{ny}. Ð\9fоложение Ñ\8fÑ\87ейки вÑ\8bбиÑ\80аеÑ\82Ñ\81Ñ\8f оÑ\82ноÑ\81иÑ\82елÑ\8cно поÑ\81леднего вÑ\8bзова SubPlot() (или InPlot() Ñ\81 @var{rel}=@code{false}). Ð\9fаÑ\80амеÑ\82Ñ\80 @var{d} задаеÑ\82 дополниÑ\82елÑ\8cнÑ\8bй зазоÑ\80 междÑ\83 Ñ\81Ñ\82Ñ\80ок.
@end deftypefn
@anchor{stickplot}
@deftypefn {MGL command} {} stickplot @code{num ind tet phi}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} StickPlot (@code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
-@deftypefnx {C function} @code{void} mgl_stickplot (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} StickPlot (@code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
+@deftypefnx {Функция С} @code{void} mgl_stickplot (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
@end ifclear
-Помещает последующий вывод в @var{ind}-ую ячейку "бруска" из @var{num} ячеек. При этом сам брусок повернут на углы @var{tet}, @var{phi}. Положение выбирается относительно последнего вызова SubPlot() (или InPlot() с @var{rel}=@code{false}). @sref{StickPlot sample}
+Помещает последующий вывод в @var{ind}-ую ячейку "бруска" из @var{num} ячеек. При этом сам брусок повернут на углы @var{tet}, @var{phi}. Положение выбирается относительно последнего вызова SubPlot() (или InPlot() с @var{rel}=@code{false}).
@end deftypefn
@anchor{title}
-@deftypefn {MGL command} {} title 'txt' ['stl'='#' @code{size=-2}]
+@deftypefn {MGL command} {} title 'title' ['stl'='' @code{size=-2}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Title (@code{const char *}txt, @code{const char *}stl=@code{"#"}, @code{float} size=@code{-2})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Title (@code{const wchar_t *}txt, @code{const char *}stl=@code{"#"}, @code{float} size=@code{-2})
-@deftypefnx {C function} @code{void} mgl_title(@code{HMGL} gr, @code{const char *}txt, @code{const char *}stl, @code{float} size)
-@deftypefnx {C function} @code{void} mgl_titlew (@code{HMGL} gr, @code{const wchar_t *}txt, @code{const char *}stl, @code{float} size)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Title (@code{const char *}txt, @code{const char *}stl=@code{""}, @code{float} size=@code{-2})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Title (@code{const wchar_t *}txt, @code{const char *}stl=@code{""}, @code{float} size=@code{-2})
+@deftypefnx {Функция С} @code{void} mgl_title (@code{HMGL} gr, @code{const char *}txt, @code{const char *}stl, @code{float} size)
+@deftypefnx {Функция С} @code{void} mgl_titlew (@code{HMGL} gr, @code{const wchar_t *}txt, @code{const char *}stl, @code{float} size)
@end ifclear
Выводит заголовок @var{title} для текущего "подграфика" шрифтом @var{stl} с размером @var{size}. Если строка @var{stl} содержит @samp{#}, то рисуется обрамляющий прямоугольник. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться сразу после создания "подграфика".
@end deftypefn
@anchor{rotate}
@deftypefn {MGL command} {} rotate @code{tetz tetx [tety=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Rotate (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
-@deftypefnx {C function} @code{void} mgl_rotate (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Rotate (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_rotate (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
@end ifclear
Вращает систему координат относительно осей @{x, z, y@} последовательно на углы @var{TetX}, @var{TetZ}, @var{TetY}.
@end deftypefn
@deftypefn {MGL command} {} rotate @code{tet x y z}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} RotateN (@code{float} Tet, @code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {C function} @code{void} mgl_rotate_vector (@code{HMGL} gr, @code{float Tet}, @code{float x}, @code{float y}, @code{float z})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} RotateN (@code{float} Tet, @code{float} x, @code{float} y, @code{float} z)
+@deftypefnx {Функция С} @code{void} mgl_rotate_vector (@code{HMGL} gr, @code{float Tet}, @code{float x}, @code{float y}, @code{float z})
@end ifclear
Вращает систему координат относительно вектора @{@var{x}, @var{y}, @var{z}@} на угол @var{Tet}.
@end deftypefn
@anchor{aspect}
@deftypefn {MGL command} {} aspect @code{ax ay [az=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Aspect (@code{float} Ax, @code{float} Ay, @code{float} Az)
-@deftypefnx {C function} @code{void} mgl_aspect (@code{HMGL} gr, @code{float} Ax, @code{float} Ay, @code{float} Az)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Aspect (@code{float} Ax, @code{float} Ay, @code{float} Az=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_aspect (@code{HMGL} gr, @code{float} Ax, @code{float} Ay, @code{float} Az)
@end ifclear
Устанавливает соотношение размеров осей в отношении @var{Ax:Ay:Az}. Для лучшего вида следует вызывать после функции Rotate().
@end deftypefn
@anchor{perspective}
@deftypefn {MGL command} {} perspective @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Perspective (@code{float} a)
-@deftypefnx {C function} @code{void} mgl_perspective (@code{HMGL} gr, @code{float} a)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Perspective (@code{float} a)
+@deftypefnx {Функция С} @code{void} mgl_perspective (@code{HMGL} gr, @code{float} a)
@end ifclear
Добавляет (включает) перспективу для графика. Параметр @math{a ~ 1/z_@{eff@} \in [0,1)}. По умолчанию (@code{a=0}) перспектива отключена.
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} View (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
-@deftypefnx {C function} @code{void} mgl_view (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
-Вращает систему координат относительно осей @{x, z, y@} последовательно на углы @var{TetX}, @var{TetZ}, @var{TetY}. Вращение происходит независимо от @code{Rotate()}.
-@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} Push ()
-@deftypefnx {C function} @code{void} mgl_mat_push (@code{HMGL} gr)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Push ()
+@deftypefnx {Функция С} @code{void} mgl_mat_push (@code{HMGL} gr)
Помещает матрицу преобразования в стек. Позднее вы можете восстановить текущее состояние с помощью функции Pop(). Стек может содержать до 10 матриц.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} Pop ()
-@deftypefnx {C function} @code{void} mgl_mat_pop (@code{HMGL} gr)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Pop ()
+@deftypefnx {Функция С} @code{void} mgl_mat_pop (@code{HMGL} gr)
Заменяет (восстанавливает) матрицу преобразования на последнюю помещенную в стек матрицу.
@end deftypefn
+
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetPlotFactor (@code{float} val)
+@deftypefnx {Функция С} @code{void} mgl_set_plotfactor (@code{HMGL} gr, @code{float} val)
+Задает масштаб картинки. Не рекомендуется устанавливать значения меньше 1.5. Это аналог функции Zoom(), но применяется только к конкретному подграфику. Используйте ноль для включения автоматического масштабирования.
+@end deftypefn
+
+Также есть 2 функции, которые управляют масштабированием @code{Zoom()} и вращением @code{View()} всего рисунка. Т.е. они действуют как ещё одна матрица трансформации. Они были введены для вращения/приближения графика с помощью мыши.
+
+@deftypefn {Метод класса @code{mglGraph}} @code{void} View (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_view (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
+Вращает систему координат относительно осей @{x, z, y@} последовательно на углы @var{TetX}, @var{TetZ}, @var{TetY}. Вращение происходит независимо от @code{Rotate()}.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Zoom (@code{float} x1, @code{float} y1, @code{float} x2, @code{float} y2)
+@deftypefnx {Функция С} @code{void} mgl_set_zoom (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} x2, @code{float} y2)
+Масштабирует весь рисунок. После вызова функции текущий график будет очищен и в дальнейшем рисунок будет содержать только область [x1,x2]*[y1,y2] от исходного рисунка. Координаты @var{x1}, @var{x2}, @var{y1}, @var{y2} меняются в диапазоне от 0 до 1. Внимание! эти настройки не могут быть переписаны никакими другими функциями. Используйте @code{Zoom(0,0,1,1)} для перехода в масштаб по умолчанию.
+@end deftypefn
+
@end ifclear
@c ##################################################################
-@node Export picture, Primitives drawing, Transformation matrix, MathGL core
+@node Export picture, Primitives, Subplots and rotation, MathGL core
@section Экспорт рисунка
@cindex SetSize
@anchor{setsize}
@deftypefn {MGL command} {} setsize @code{w h}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetSize (@code{int} width, @code{int} height)
-@deftypefnx {C function} @code{void} mgl_set_size (@code{HMGL} gr, @code{int} width, @code{int} height)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetSize (@code{int} width, @code{int} height)
+@deftypefnx {Функция С} @code{void} mgl_set_size (@code{HMGL} gr, @code{int} width, @code{int} height)
@end ifclear
Изменяет размер картинки в пикселях. Функция должна вызываться @strong{перед} любыми функциями построения потому что полностью очищает содержимое рисунка.
@end deftypefn
@anchor{quality}
@deftypefn {MGL command} {} quality @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetQuality (@code{int} val=@code{MGL_DRAW_NORM})
-@deftypefnx {C function} @code{void} mgl_set_quality (@code{HMGL} gr, @code{int} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetQuality (@code{int} val=@code{MGL_DRAW_NORM})
+@deftypefnx {Функция С} @code{void} mgl_set_quality (@code{HMGL} gr, @code{int} val)
@end ifclear
Задает качество графика в зависимости от значения @var{val}: @code{MGL_DRAW_WIRE=0} -- нет рисования граней (наиболее быстрый), @code{MGL_DRAW_FAST=1} -- нет интерполяции цвета (быстрый), @code{MGL_DRAW_NORM=2} -- высокое качество (нормальный). Если установлен бит @code{MGL_DRAW_LMEM=0x4}, то происходит прямое рисование в растровое изображение (меньше затраты памяти).
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} StartGroup (const char *name)
-@deftypefnx {C function} @code{void} mgl_start_group (@code{HMGL} gr, @code{const char *}name)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} StartGroup (const char *name)
+@deftypefnx {Функция С} @code{void} mgl_start_group (@code{HMGL} gr, @code{const char *}name)
Начинает определение группы. Группа может содержать объекты и другие группы. Они используются для выбора части модели при приближении, изменении прозрачности и т.д.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} EndGroup ()
-@deftypefnx {C function} @code{void} mgl_end_group (@code{HMGL} gr)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} EndGroup ()
+@deftypefnx {Функция С} @code{void} mgl_end_group (@code{HMGL} gr)
Завершает определение группы.
@end deftypefn
@end ifclear
@cindex ShowImage
@end ifclear
-Эти функции экспортируют текущую картинку (кадр) в файл. Имя файла @var{fname} должно иметь соответствующее расширение. Параметр @var{descr} дает краткое описание картинки. Пока прозрачность поддерживается только для форматов PNG, SVG и IDTF.
+Эти функции экспортируют текущую картинку (кадр) в файл. Имя файла @var{fname} должно иметь соответствующее расширение. Параметр @var{descr} дает краткое описание картинки. Пока прозрачность поддерживается только для форматов PNG, SVG, OBJ и IDTF.
@anchor{write}
-@deftypefn {MGL command} {} write 'fname'
+@deftypefn {MGL command} {} write ['fname'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} WriteFrame (@code{const char *}fname=@code{""}, @code{const char *}descr=@code{""})
-@deftypefnx {C function} @code{void} mgl_write_frame (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} WriteFrame (@code{const char *}fname=@code{""}, @code{const char *}descr=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_write_frame (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
@end ifclear
Экспортирует текущий кадр в файл @var{fname} с типом, определяемым по расширению. Параметр @var{descr} добавляет описание (может быть пустым). Если @var{fname} пустой, то используется имя @samp{frame####.jpg}, где @samp{####} -- текущий номер кадра и имя @samp{frame} определяется переменной @var{PlotId}.
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteTEX (@code{const char *}fname, @code{const char *}descr=@code{""})
@deftypefnx {Функция С} @code{void} mgl_write_tex (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Экспортирует текущий кадр в LaTeX файл (пакет Tikz/PGF), используя векторное представление графика (класс mglGraphPS). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+Экспортирует текущий кадр в LaTeX файл (пакет Tikz/PGF), используя векторное представление графика. Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteOBJ (@code{const char *}fname, @code{const char *}descr=@code{""})
@deftypefnx {Функция С} @code{void} mgl_write_obj (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Экспортирует текущий кадр в OBJ/MTL файл, используя векторное представление графика (класс mglGraphPS). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+Экспортирует текущий кадр в OBJ/MTL файл, используя векторное представление графика (см. @url{http://en.wikipedia.org/wiki/Wavefront_.obj_file, OBJ формат}). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+@end deftypefn
+
+
+@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteXYZ (@code{const char *}fname, @code{const char *}descr=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_write_xyz (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
+Экспортирует текущий кадр в XYZ/XYZL/XYZF файлы, используя векторное представление графика (см. @url{http://people.sc.fsu.edu/~jburkardt/data/xyz/xyz.html, XYZ формат}). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteSTL (@code{const char *}fname, @code{const char *}descr=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_write_stl (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
+Экспортирует текущий кадр в STL файл, используя векторное представление графика (см. @url{http://en.wikipedia.org/wiki/STL_(file_format), STL формат}). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteOFF (@code{const char *}fname, @code{const char *}descr=@code{""}, @code{bool} colored=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_write_off (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr, @code{bool} colored)
+Экспортирует текущий кадр в OFF файл, используя векторное представление графика (см. @url{http://people.sc.fsu.edu/~jburkardt/data/off/off.html, OFF формат}). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
@end deftypefn
+@c @deftypefn {Метод класса @code{mglGraph}} @code{void} WriteX3D (@code{const char *}fname, @code{const char *}descr=@code{""})
+@c @deftypefnx {Функция С} @code{void} mgl_write_x3d (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
+@c Экспортирует текущий кадр в X3D файл, используя векторное представление графика (см. @url{http://en.wikipedia.org/wiki/X3d, X3D формат}). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+@c @end deftypefn
+
+
@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteIDTF (@code{const char *}fname, @code{const char *}descr=@code{""})
@deftypefnx {Функция С} @code{void} mgl_write_idtf (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
Экспортирует текущий кадр в IDTF файл, используя векторное представление графика (класс mglGraphIDTF). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
Отображает текущий кадр используя внешнюю программу просмотра @var{viewer}. Функция сохраняет картинку во временный файл и вызывает @var{viewer} для его отображения. Если @var{nowait}=@code{true}, то функция возвращает управление немедленно -- не ждет пока окно просмотра будет закрыто.
@end deftypefn
+
+@deftypefn {Method on @code{mglGraph}} @code{void} ExportMGLD (@code{const char *}fname, @code{const char *}descr=@code{""})
+@deftypefnx {C function} @code{void} mgl_export_mgld (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
+Экспортирует точки и примитивы в файл MGLD формата. В дальнейшем этот файл можно загрузить и просмотреть с помощью @code{mglview}. Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+@end deftypefn
+
+@deftypefn {Method on @code{mglGraph}} @code{void} ImportMGLD (@code{const char *}fname, @code{bool} add=@code{false})
+@deftypefnx {C function} @code{void} mgl_import_mgld (@code{HMGL} gr, @code{const char *}fname, @code{int} add)
+Импортирует точки и примитивы из файла в формате MGLD. Параметры функции следующие: @var{fname} -- имя файла, @var{add} -- флаг добавления или замены существующих точек и примитивов.
+@end deftypefn
+
@end ifclear
@subsection Кадры/Анимация
@ifset UDAV
-Ð\92 MGL неÑ\82 Ñ\81пеÑ\86иалÑ\8cнÑ\8bÑ\85 комманд длÑ\8f Ñ\81озданиÑ\8f анимаÑ\86ии. Ð\9eднако можно воÑ\81полÑ\8cзоваÑ\82Ñ\8cÑ\81Ñ\8f возможноÑ\81Ñ\82Ñ\8fми Ñ\83Ñ\82илиÑ\82 (@pxref{Utilities}). Например, используя комментарии спеиального вида @samp{##a } или @samp{##c }.
+Ð\92 MGL неÑ\82 Ñ\81пеÑ\86иалÑ\8cнÑ\8bÑ\85 команд длÑ\8f Ñ\81озданиÑ\8f анимаÑ\86ии. Ð\9eднако можно воÑ\81полÑ\8cзоваÑ\82Ñ\8cÑ\81Ñ\8f возможноÑ\81Ñ\82Ñ\8fми Ñ\83Ñ\82илиÑ\82 (Ñ\81м. @ref{Utilities}). Например, используя комментарии спеиального вида @samp{##a } или @samp{##c }.
@end ifset
@ifclear UDAV
@cindex StartGIF
@cindex CloseGIF
-Эти функции позволяют создавать несколько картинок одновременно. В большинстве случаев это бесполезно, но для органов управления (@pxref{Widget classes}) это позволяет показывать анимацию. Также можно записать несколько кадров в анимированный GIF файл.
+Эти функции позволяют создавать несколько картинок одновременно. В большинстве случаев это бесполезно, но для органов управления (см. @ref{Widget classes}) это позволяет показывать анимацию. Также можно записать несколько кадров в анимированный GIF файл.
@deftypefn {Метод класса @code{mglGraph}} @code{int} NewFrame ()
@deftypefnx {Функция С} @code{int} mgl_new_frame (@code{HMGL} gr)
@ifclear UDAV
Эти функции возвращают созданный растровый рисунок, его ширину и высоту. В дальнейшем его можно использовать в любой графической библиотеке (см. также, @ref{Widget classes}) или сохранить в файл (см. также, @ref{Export to file}).
-@deftypefn {Метод класса @code{mglGraph}} @code{void} GetRGB (@code{char *}buf, @code{int} size)
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} GetBGRN (@code{char *}buf, @code{int} size)
+@deftypefn {Method on @code{mglGraph}} @code{const unsigned char *} GetRGB ()
+@deftypefnx {Method on @code{mglGraph}} @code{void} GetRGB (@code{char *}buf, @code{int} size)
+@deftypefnx {Method on @code{mglGraph}} @code{void} GetBGRN (@code{char *}buf, @code{int} size)
@deftypefnx {C function} @code{const unsigned char *} mgl_get_rgb (@code{HMGL} gr)
Возвращает растровое изображение в формате RGB для текущего кадра. Формат каждого элемента (пикселя): @{red, green, blue@}. Число элементов Width*Height. Положение элемента @{i,j@} есть [3*i + 3*Width*j] (или [4*i + 4*Width*j] для @code{GetBGRN()}). В Python вы должны предоставить буфер @var{buf} достаточного размера @var{size}, т.е. код должен выглядеть следующим образом
@verbatim
@end verbatim
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} GetRGBA (@code{char *}buf, @code{int} size)
+@deftypefn {Method on @code{mglGraph}} @code{const unsigned char *} GetRGBA ()
+@deftypefnx {Method on @code{mglGraph}} @code{void} GetRGBA (@code{char *}buf, @code{int} size)
@deftypefnx {C function} @code{const unsigned char *} mgl_get_rgba (@code{HMGL} gr)
Возвращает растровое изображение в формате RGBA для текущего кадра. Формат каждого элемента (пикселя): @{red, green, blue, alpha@}. Число элементов Width*Height. Положение элемента @{i,j@} есть [4*i + 4*Width*j].
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{int} GetWidth ()
@deftypefnx {Метод класса @code{mglGraph}} @code{int} GetHeight ()
-@deftypefnx {C function} @code{int} mgl_get_width (@code{HMGL} gr)
-@deftypefnx {C function} @code{int} mgl_get_height (@code{HMGL} gr)
+@deftypefnx {Функция С} @code{int} mgl_get_width (@code{HMGL} gr)
+@deftypefnx {Функция С} @code{int} mgl_get_height (@code{HMGL} gr)
Возвращает ширину и высоту изображения.
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{mglPoint} CalcXYZ (@code{int} xs, @code{int} ys)
-@deftypefnx {C function} @code{void} mgl_calc_xyz (@code{HMGL} gr, @code{int} xs, @code{int} ys, @code{float *}x, @code{float *}y, @code{float *}z)
-Вычисляет 3D координаты @{x,y,z@} для экранной точки @{xs,ys@}. В данный момент игнорируется перспектива графика и формулы перехода в криволинейные координаты. Вычисления производятся для последнего использованного InPlot (@pxref{Transformation matrix}).
+@deftypefnx {Функция С} @code{void} mgl_calc_xyz (@code{HMGL} gr, @code{int} xs, @code{int} ys, @code{float *}x, @code{float *}y, @code{float *}z)
+Вычисляет 3D координаты @{x,y,z@} для экранной точки @{xs,ys@}. В данный момент игнорируется перспектива графика и формулы перехода в криволинейные координаты. Вычисления производятся для последнего использованного InPlot (см. @ref{Transformation matrix}).
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{mglPoint} CalcScr (@code{mglPoint} p)
-@deftypefnx {C function} @code{void} mgl_calc_scr (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{int *}xs, @code{int *}ys)
-Вычисляет экранные координаты @{xs,ys@} для 3D координат @{x,y,z@}. Вычисления производятся для последнего использованного InPlot (@pxref{Transformation matrix}).
+@deftypefnx {Функция С} @code{void} mgl_calc_scr (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{int *}xs, @code{int *}ys)
+Вычисляет экранные координаты @{xs,ys@} для 3D координат @{x,y,z@}. Вычисления производятся для последнего использованного InPlot (см. @ref{Transformation matrix}).
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} SetObjId (@code{int} id)
-@deftypefnx {C function} @code{void} mgl_set_obj_id (@code{HMGL} gr, @code{int} id)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetObjId (@code{int} id)
+@deftypefnx {Функция С} @code{void} mgl_set_obj_id (@code{HMGL} gr, @code{int} id)
Задает числовой идентификатор для объектов или "подграфиков".
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{int} GetObjId (@code{long} xs, @code{long} ys)
-@deftypefnx {C function} @code{int} mgl_get_obj_id (@code{HMGL} gr, @code{long} xs, @code{long} ys)
+@deftypefn {Метод класса @code{mglGraph}} @code{int} GetObjId (@code{long} xs, @code{long} ys)
+@deftypefnx {Функция С} @code{int} mgl_get_obj_id (@code{HMGL} gr, @code{long} xs, @code{long} ys)
Возвращает числовой идентификатор верхнего объекта в точке @{xs, ys@} рисунка.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{int} GetSplId (@code{long} xs, @code{long} ys)
-@deftypefnx {C function} @code{int} mgl_get_spl_id (@code{HMGL} gr, @code{long} xs, @code{long} ys)
+@deftypefn {Метод класса @code{mglGraph}} @code{int} GetSplId (@code{long} xs, @code{long} ys)
+@deftypefnx {Функция С} @code{int} mgl_get_spl_id (@code{HMGL} gr, @code{long} xs, @code{long} ys)
Возвращает числовой идентификатор верхнего "подграфика" в точке @{xs, ys@} рисунка.
@end deftypefn
+@deftypefn {Method on @code{mglGraph}} @code{void} Highlight (@code{int} id)
+@deftypefnx {C function} @code{void} mgl_highlight (@code{HMGL} gr, @code{int} id)
+Выделяет объект с заданным @var{id}.
+@end deftypefn
+
@end ifclear
@c ------------------------------------------------------------------
@cindex MPI_Send
@cindex MPI_Recv
-There are few functions which allow parallelization at user-level. First 2 limit the drawing region (for example, by subplot per thread) and copy data from that region in another @code{mglGraph} instance.
+Многие функции MathGL используют несколько потоков для ускорения работы (если MathGL была собрана с поддержкой pthread). При этом можно настраивать число используемых потоков.
-@deftypefn {Method on @code{mglGraph}} @code{int} SetDrawReg (@code{int} nx, @code{int} ny, @code{int} m)
-@deftypefnx {C function} @code{int} mgl_set_draw_reg (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m)
-Set drawable region as a @var{m}-th cell of @var{nx}*@var{ny} grid of the whole frame area.
+@deftypefn {C function} @code{int} mgl_set_num_thr (@code{int} n)
+Задает число потоков, которое будет использовано в MathGL. При @var{n}<1 число потоков задается как максимальное число процессоров (ядер) в системе. При @var{n}=1 не используется распараллеливание.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{int} PutDrawReg (@code{int} nx, @code{int} ny, @code{int} m, @code{const mglGraph *}g)
-@deftypefnx {C function} @code{int} mgl_put_draw_reg (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{HMGL} g)
-Put drawing from another instance @var{g} for a @var{m}-th cell of @var{nx}*@var{ny} grid of the whole frame area. The width and height of both instances must be the same.
-@end deftypefn
-
-Another option is combining bitmap image (taking into account Z-ordering) from different instances. This method is most appropriate for computer clusters when the data size is so large that it exceed the memory of single computer node.
+Другая возможность -- комбинирование изображений из разных объектов @code{mglGraph}. Эти методы наиболее подходят для компьютерных кластеров, когда данные настолько велики, что не могут поместиться в памяти отдельного компьютера.
-@deftypefn {Method on @code{mglGraph}} @code{int} Combine (@code{const mglGraph *}g)
-@deftypefnx {C function} @code{int} mgl_combine_gr (@code{HMGL} gr, @code{HMGL} g)
-Combine drawing from instance @var{g} with @var{gr} (or with this) taking into account Z-ordering of pixels. The width and height of both instances must be the same.
+@deftypefn {Метод класса @code{mglGraph}} @code{int} Combine (@code{const mglGraph *}g)
+@deftypefnx {Функция С} @code{int} mgl_combine_gr (@code{HMGL} gr, @code{HMGL} g)
+Комбинирует (добавляет) рисунок из @var{g} с @var{gr}, принимая во внимание ``высоту'' пикселей. Ширина и высота обоих рисунков должна быть одинаковы.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{int} MPI_Send (@code{int} id)
-@deftypefnx {C function} @code{int} mgl_mpi_send (@code{HMGL} gr, @code{int} id)
-Send graphical information from node @var{id} using MPI. The width and height in both nodes must be the same.
+@deftypefn {Метод класса @code{mglGraph}} @code{int} MPI_Send (@code{int} id)
+@deftypefnx {Функция С} @code{int} mgl_mpi_send (@code{HMGL} gr, @code{int} id)
+Посылает рисунок из компьютера (ноды) @var{id}, используя MPI. Ширина и высота обоих рисунков должна быть одинаковы.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{int} MPI_Recv (@code{int} id)
-@deftypefnx {C function} @code{int} mgl_mpi_send (@code{HMGL} gr, @code{int} id)
-Receive graphical information from node @var{id} using MPI. The width and height in both nodes must be the same.
+@deftypefn {Метод класса @code{mglGraph}} @code{int} MPI_Recv (@code{int} id)
+@deftypefnx {Функция С} @code{int} mgl_mpi_send (@code{HMGL} gr, @code{int} id)
+Принимает рисунок из компьютера (ноды) @var{id}, используя MPI. Ширина и высота обоих рисунков должна быть одинаковы.
@end deftypefn
@end ifclear
@c ##################################################################
-@node Primitives drawing, Text printing, Export picture, MathGL core
+@node Primitives, Text printing, Export picture, MathGL core
@section Рисование примитивов
@cindex Ball
@cindex Clf
@cindex Line
@cindex Curve
@cindex Glyph
-@cindex Mark
-@cindex Error
@cindex Face
@cindex FaceX
@cindex FaceY
@cindex Drop
@cindex Sphere
+@ifclear UDAV
+@cindex Mark
+@cindex Error
+@end ifclear
+
Эти функции рисуют рисуют простые объекты типа линий, точек, сфер, капель, конусов, и т.д.
@anchor{clf}
@deftypefn {MGL command} {} clf
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Clf ()
-@deftypefnx {Method on @code{mglGraph}} @code{void} Clf (@code{float} r, @code{float} g, @code{float} b)
-@deftypefnx {C function} @code{void} mgl_clf (@code{HMGL} gr)
-@deftypefnx {C function} @code{void} mgl_clf_rgb (@code{HMGL} gr, @code{float} r, @code{float} g, @code{float} b)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Clf ()
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Clf (@code{float} r, @code{float} g, @code{float} b)
+@deftypefnx {Функция С} @code{void} mgl_clf (@code{HMGL} gr)
+@deftypefnx {Функция С} @code{void} mgl_clf_rgb (@code{HMGL} gr, @code{float} r, @code{float} g, @code{float} b)
@end ifclear
-Очищает рисунок и заполняет его цветом @var{Back}.
+Очищает рисунок и заполняет его заданным цветом.
@end deftypefn
@anchor{ball}
@deftypefn {MGL command} {} ball @code{x y} ['col'='r.']
@deftypefnx {MGL command} {} ball @code{x y z} ['col'='r.']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Ball (@code{mglPoint} p, @code{char} col=@code{'r'})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Mark (@code{mglPoint} p, @code{const char *}mark)
-@deftypefnx {C function} @code{void} mgl_ball (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {C function} @code{void} mgl_mark (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}mark)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Ball (@code{mglPoint} p, @code{char} col=@code{'r'})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Mark (@code{mglPoint} p, @code{const char *}mark)
+@deftypefnx {Функция С} @code{void} mgl_ball (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z)
+@deftypefnx {Функция С} @code{void} mgl_mark (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}mark)
@end ifclear
Рисует маркер (точку по умолчанию) с координатами @var{p}=@{@var{x}, @var{y}, @var{z}@} и цветом @var{col}.
@end deftypefn
@ifclear UDAV
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Error (@code{mglPoint} p, @code{mglPoint} e, @code{char} *pen=@code{""})
-Рисует 3d error box в точке @var{p} размером @var{e} и стилем @var{pen}.
+@deftypefn {Method on @code{mglGraph}} @code{void} Error (@code{mglPoint} p, @code{mglPoint} e, @code{char} *stl=@code{""})
+@deftypefnx {C function} @code{void} mgl_error_box (@code{HMGL} gr, @code{float} px, @code{float} py, @code{float} pz, @code{float} ex, @code{float} ey, @code{float} ez, @code{char *}stl)
+Рисует 3d error box в точке @var{p} размером @var{e} и стилем @var{stl}.
@end deftypefn
@end ifclear
@deftypefn {MGL command} {} line @code{x1 y1 x2 y2} ['stl'='']
@deftypefnx {MGL command} {} line @code{x1 y1 z1 x2 y2 z2} ['stl'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Line (@code{mglPoint} p1, @code{mglPoint} p2, @code{char *}stl=@code{"B"}, @code{int}num=@code{2})
-@deftypefnx {C function} @code{void} mgl_line (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{char *}stl, @code{int}num)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Line (@code{mglPoint} p1, @code{mglPoint} p2, @code{char *}stl=@code{"B"}, @code{int}num=@code{2})
+@deftypefnx {Функция С} @code{void} mgl_line (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{char *}stl, @code{int}num)
@end ifclear
Рисует геодезическую линию (декартовых координатах -- прямую) из точки @var{p1} в @var{p2} использую стиль линии @var{stl}. Параметр @var{num} определяет гладкость линии (число точек на линии). Если @var{num}=@code{2}, то рисуется прямая даже в криволинейных координатах. Наоборот, для больших значений (например, =@code{100}) рисуется геодезическая линия (окружность в полярных координатах, парабола в параболических и т.д.). Линия рисуется даже если часть ее лежит вне диапазона осей координат.
@end deftypefn
@deftypefn {MGL command} {} curve @code{x1 y1 dx1 dy1 x2 y2 dx2 dy2} ['stl'='']
@deftypefnx {MGL command} {} curve @code{x1 y1 z1 dx1 dy1 dz1 x2 y2 z2 dx2 dy2 dz2} ['stl'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Curve (@code{mglPoint} p1, @code{mglPoint} d1, @code{mglPoint} p2, @code{mglPoint} d2, @code{const char *}stl=@code{"B"}, @code{int} num=@code{100})
-@deftypefnx {C function} @code{void} mgl_curve (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} dx1, @code{float} dy1, @code{float} dz1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} dx2, @code{float} dy2, @code{float} dz2, @code{const char *}stl, @code{int} num)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Curve (@code{mglPoint} p1, @code{mglPoint} d1, @code{mglPoint} p2, @code{mglPoint} d2, @code{const char *}stl=@code{"B"}, @code{int} num=@code{100})
+@deftypefnx {Функция С} @code{void} mgl_curve (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} dx1, @code{float} dy1, @code{float} dz1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} dx2, @code{float} dy2, @code{float} dz2, @code{const char *}stl, @code{int} num)
@end ifclear
Рисует кривую Безье из точки @var{p1} в @var{p2} используя стиль линии @var{stl}. Касательные в точках пропорциональны @var{d1}, @var{d2}. Параметр @var{num} определяет гладкость линии (число точек на линии). Кривая рисуется даже если часть ее лежит вне диапазона осей координат.
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} Face (@code{mglPoint} p1, @code{mglPoint} p2, @code{mglPoint} p3, @code{mglPoint} p4, @code{const char *}stl=@code{"w"})
-@deftypefnx {C function} @code{void} mgl_curve (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} x3, @code{float} y3, @code{float} z3, @code{float} x4, @code{float} y4, @code{float} z4, @code{const char *}stl)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Face (@code{mglPoint} p1, @code{mglPoint} p2, @code{mglPoint} p3, @code{mglPoint} p4, @code{const char *}stl=@code{"w"})
+@deftypefnx {Функция С} @code{void} mgl_curve (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} x3, @code{float} y3, @code{float} z3, @code{float} x4, @code{float} y4, @code{float} z4, @code{const char *}stl)
Рисует заполненный четырехугольник (грань) с углами в точках @var{p1}, @var{p2}, @var{p3}, @var{p4} и цветом(-ами) @var{stl}. При этом цвет может быть один для всей грани, или различным если указаны все 4 цвета. Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
@end deftypefn
@end ifclear
@deftypefn {MGL command} {} facex @code{x0 y0 z0 wy wz} ['stl'='' @code{d1=0 d2=0}]
@deftypefnx {MGL command} {} facey @code{x0 y0 z0 wx wz} ['stl'='' @code{d1=0 d2=0}]
@deftypefnx {MGL command} {} facez @code{x0 y0 z0 wx wy} ['stl'='' @code{d1=0 d2=0}]
-@deftypefnx {Method on @code{mglGraph}} @code{void} FaceX (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {Method on @code{mglGraph}} @code{void} FaceY (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {Method on @code{mglGraph}} @code{void} FaceZ (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {C function} @code{void} mgl_facex (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
-@deftypefnx {C function} @code{void} mgl_facey (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
-@deftypefnx {C function} @code{void} mgl_facez (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl, @code{float} d1, @code{float} d2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceX (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceY (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceZ (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_facex (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
+@deftypefnx {Функция С} @code{void} mgl_facey (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
+@deftypefnx {Функция С} @code{void} mgl_facez (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl, @code{float} d1, @code{float} d2)
Рисует закрашенный прямоугольник (грань) перпендикулярно оси [x,y,z] в точке @{@var{x0}, @var{y0}, @var{z0}@} цветом @var{stl} и шириной @var{wx}, @var{wy}, @var{wz} вдоль соответствующего направления. При этом цвет может быть один для всей грани, или различным для разных вершин если указаны все 4 цвета. Параметры @var{d1}!=0, @var{d2}!=0 задают дополнительный сдвиг последней точки (т.е. рисуют четырехугольник).Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
@end deftypefn
@deftypefn {MGL command} {} sphere @code{x0 y0 r} ['col'='r']
@deftypefnx {MGL command} {} sphere @code{x0 y0 z0 r} ['col'='r']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Sphere (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
-@deftypefnx {C function} @code{void} mgl_sphere (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} r, @code{const char *}stl)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Sphere (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
+@deftypefnx {Функция С} @code{void} mgl_sphere (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} r, @code{const char *}stl)
@end ifclear
Рисует сферу радиуса @var{r} с центром в точке @var{p}=@{@var{x0}, @var{y0}, @var{z0}@} цветом @var{stl}.
@end deftypefn
@anchor{drop}
-@deftypefn {MGL command} {} drop @code{x0 y0 dx dy r} ['col'='b' @code{sh=1 asp=1}]
-@deftypefnx {MGL command} {} drop @code{x0 y0 z0 dx dy dz r} ['col'='b' @code{sh=1 asp=1}]
+@deftypefn {MGL command} {} drop @code{x0 y0 dx dy r} ['col'='r' @code{sh=1 asp=1}]
+@deftypefnx {MGL command} {} drop @code{x0 y0 z0 dx dy dz r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{float} r, @code{mglColor} col, @code{float} shift=@code{1}, @code{float} ap=@code{1})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{float} r, @code{const char *}col=@code{"r"}, @code{float} shift=@code{1}, @code{float} ap=@code{1})
@deftypefnx {C function} @code{void} mgl_drop (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} dx, @code{float} dy, @code{float} dz, @code{float} r, @code{const char *}col, @code{float} shift, @code{float} ap)
@end ifclear
Рисует каплю радиуса @var{r} в точке @var{p} вытянутую вдоль направления @var{d} цветом @var{col}. Параметр @var{shift} определяет степень вытянутости: @samp{0} -- сфера, @samp{1} -- классическая капля. Параметр @var{ap} определяет относительную ширину капли (аналог "эллиптичности" для сферы). @sref{Drops sample}
@anchor{cone}
@deftypefn {MGL command} {} cone @code{x1 y1 z1 x2 y2 z2 r1} [@code{r2=-1} 'stl'='' @code{edge=off}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Cone (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r1, @code{float} r2=@code{-1}, @code{const char *}stl=@code{"B"}, @code{bool} edge=@code{false})
-@deftypefnx {C function} @code{void} mgl_cone (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r1, @code{float} r2, @code{const char *}stl, @code{int} draw_edge)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cone (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r1, @code{float} r2=@code{-1}, @code{const char *}stl=@code{"B"}, @code{bool} edge=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_cone (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r1, @code{float} r2, @code{const char *}stl, @code{int} draw_edge)
@end ifclear
Рисует трубу (или усеченный конус если @var{edge}=@code{false}) между точками @var{p1}, @var{p2} с радиусами на концах @var{r1}, @var{r2}. Если @var{r2}<0, то полагается @var{r2}=@var{r1}. Цвет конуса задается строкой @var{stl}.
@end deftypefn
@deftypefn {MGL command} {} circle @code{x0 y0 r} ['col'='r']
@deftypefnx {MGL command} {} circle @code{x0 y0 z0 r} ['col'='r']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Circle (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Circle (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
@end ifclear
Рисует круг радиуса @var{r} с центром в точке @var{p}=@{@var{x0}, @var{y0}, @var{z0}@} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными).
@end deftypefn
@deftypefn {MGL command} {} ellipse @code{x1 y1 x2 y2 r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {MGL command} {} ellipse @code{x1 y1 z1 x2 y2 z2 r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Ellipse (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
-@deftypefnx {C function} @code{void} mgl_ellipse(@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Ellipse (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
+@deftypefnx {Функция С} @code{void} mgl_ellipse(@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
@end ifclear
Рисует круг радиуса @var{r} с фокусами в точках @var{p1}, @var{p2} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными). @sref{Ellipse sample}
@end deftypefn
@deftypefn {MGL command} {} rhomb @code{x1 y1 x2 y2 r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {MGL command} {} rhomb @code{x1 y1 z1 x2 y2 z2 r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Rhomb (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
-@deftypefnx {C function} @code{void} mgl_rhomb(@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Rhomb (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
+@deftypefnx {Функция С} @code{void} mgl_rhomb(@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
@end ifclear
Рисует ромб ширины @var{r} с вершинами в точках @var{p1}, @var{p2} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными). Если @var{col} содержит 3 цвета, то используется градиентная заливка. @sref{Ellipse sample}
@end deftypefn
@c ##################################################################
-@node Text printing, Axis and Colorbar, Primitives drawing, MathGL core
+@node Text printing, Axis and Colorbar, Primitives, MathGL core
@section Вывод текста
@ifclear UDAV
@cindex Puts
@cindex Label
@cindex fgets
-Функции для вывода текста позволяют вывести строку текста в произвольном месте рисунка, в произвольном направлении и вдоль произвольной кривой. MathGL позволяет использовать произвольное начертание шрифта и многие ТеХ-ие команды (детальнее @pxref{Font styles}). Все функции вывода текста имеют варианты для 8-bit строк (@code{char *}) и для Unicode строк (@code{wchar_t *}). В первом случае используется конверсия из текущей локали, т.е. иногда вам требуется явно указать локаль с помощью функции @code{setlocale()}. Аргумент @var{size} определяет размер текста: размер шрифта если положителен или относительный размер (=-@var{size}*@var{FontSize}) если отрицателен. Начертание шрифта (STIX, arial, courier, times и др) можно изменить с помощью функции LoadFont(). @xref{Font settings}.
+Функции для вывода текста позволяют вывести строку текста в произвольном месте рисунка, в произвольном направлении и вдоль произвольной кривой. MathGL позволяет использовать произвольное начертание шрифта и многие ТеХ-ие команды (детальнее см. @ref{Font styles}). Все функции вывода текста имеют варианты для 8-bit строк (@code{char *}) и для Unicode строк (@code{wchar_t *}). В первом случае используется конверсия из текущей локали, т.е. иногда вам требуется явно указать локаль с помощью функции @code{setlocale()}. Аргумент @var{size} определяет размер текста: размер шрифта если положителен или относительный размер (=-@var{size}*@var{FontSize}) если отрицателен. Начертание шрифта (STIX, arial, courier, times и др) можно изменить с помощью функции LoadFont(). @xref{Font settings}.
-Параметры шрифта задаются строкой, которая может содержать символы цвета @samp{wkrgbcymhRGBCYMHW} (@pxref{Line styles}) и, после символа @samp{:}, символы стиля (@samp{rbiwou}) и/или выравнивания (@samp{LRC}). Стили шрифта: @samp{r} -- прямой, @samp{i} -- курсив, @samp{b} -- жирный, @samp{w} -- контурный, @samp{o} -- надчеркнутый, @samp{u} -- подчеркнутый. По умолчанию используется прямой шрифт. Типы выравнивания: @samp{L} -- по левому краю (по умолчанию), @samp{C} -- по центру, @samp{R} -- по правому краю. Например, строка @samp{b:iC} соответствует курсиву синего цвета с выравниванием по центру.
+Параметры шрифта задаются строкой, которая может содержать символы цвета @samp{wkrgbcymhRGBCYMHW} (см. @ref{Line styles}) и, после символа @samp{:}, символы стиля (@samp{rbiwou}) и/или выравнивания (@samp{LRC}). Стили шрифта: @samp{r} -- прямой, @samp{i} -- курсив, @samp{b} -- жирный, @samp{w} -- контурный, @samp{o} -- надчеркнутый, @samp{u} -- подчеркнутый. По умолчанию используется прямой шрифт. Типы выравнивания: @samp{L} -- по левому краю (по умолчанию), @samp{C} -- по центру, @samp{R} -- по правому краю. Например, строка @samp{b:iC} соответствует курсиву синего цвета с выравниванием по центру.
Если строка содержит символы @samp{aA}, то текст выводится в абсолютных координатах (полагаются в диапазоне [0,1]). При этом используются координаты относительно рисунка (если указано @samp{A}) или относительно последнего SubPlot()/InPlot() (если указано @samp{a}). Если строка содержит символ @samp{@@}, то вокруг текста рисуется прямоугольник.
+@sref{Text features}
+
@anchor{text}
@deftypefn {MGL command} {} text @code{x y} 'text' ['fnt'='' @code{size=-1}]
@deftypefnx {MGL command} {} text @code{x y z} 'text' ['fnt'='' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{float} size=@code{-1})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{float} size=@code{-1})
-@deftypefnx {C function} @code{void} mgl_puts (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}text, @code{const char *}fnt, @code{float} size)
-@deftypefnx {C function} @code{void} mgl_putsw (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{float} size=@code{-1})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{float} size=@code{-1})
+@deftypefnx {Функция С} @code{void} mgl_puts (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Функция С} @code{void} mgl_putsw (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
@end ifclear
Выводит строку @var{text} от точки @var{p} шрифтом определяемым строкой @var{fnt}.
@end deftypefn
@deftypefn {MGL command} {} text @code{x y dx dy} 'text' ['fnt'=':L' @code{size=-1}]
@deftypefnx {MGL command} {} text @code{x y z dx dy dz} 'text' ['fnt'=':L' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{mglPoint} d, @code{const char *}text, @code{const char *}fnt=@code{':L'}, @code{float} size=@code{-1})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{mglPoint} d, @code{const wchar_t *}text, @code{const char *}fnt=@code{':L'}, @code{float} size=@code{-1})
-@deftypefnx {C function} @code{void} mgl_puts_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const char *}text, @code{const char *}fnt, @code{float} size)
-@deftypefnx {C function} @code{void} mgl_putsw_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{mglPoint} d, @code{const char *}text, @code{const char *}fnt=@code{':L'}, @code{float} size=@code{-1})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{mglPoint} d, @code{const wchar_t *}text, @code{const char *}fnt=@code{':L'}, @code{float} size=@code{-1})
+@deftypefnx {Функция С} @code{void} mgl_puts_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const char *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Функция С} @code{void} mgl_putsw_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
@end ifclear
Выводит строку @var{text} от точки @var{p} вдоль направления @var{d}. Параметр @var{fnt} задает стиль текста и указывает выводить текст над линией (@samp{T}) или под ней (@samp{t}).
@end deftypefn
Выводит @var{n}-ую строку файла @var{fname} от точки @{@var{x},@var{y},@var{z}@} шрифтом @var{fnt} и размером @var{size}.
@end deftypefn
-@anchor{label}
-@deftypefn {MGL command} {} label @code{x y} 'text' ['fnt'='']
-@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{float} x, @code{float} y, @code{const char *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Labelw (@code{float} x, @code{float} y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {C function} @code{void} mgl_label_xy (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const char *}text, @code{const char *}fnt)
-@deftypefnx {C function} @code{void} mgl_labelw_xy (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const wchar_t *}text, @code{const char *}fnt)
-@end ifclear
-Выводит строку @var{text} в произвольном месте экрана от точки @{@var{x}, @var{y}@} шрифтом указанным @var{fnt}. Координаты @code{x, y} считаются лежащими в диапазоне [0,1].
-@end deftypefn
-
+@deftypefn {MGL command} {} text ydat 'text' ['fnt'='']
@deftypefnx {MGL command} {} text xdat ydat 'text' ['fnt'='' @code{size=-1 zval=nan}]
@deftypefnx {MGL command} {} text xdat ydat zdat 'text' ['fnt'='' @code{size=-1}]
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} Text (@code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Text (@code{const mglData &}y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_text_y (@code{HMGL} gr, @code{HCDT} y, @code{const char *}text, @code{const char *}fnt, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_textw_y (@code{HMGL} gr, @code{HCDT} y, @code{const wchar_t *}text, @code{const char *}fnt, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_text_xy (@code{HCDT} x, @code{HCDT} y, @code{const char *}text, @code{const char *}fnt, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_textw_xy (@code{HCDT} x, @code{HCDT} y, @code{const wchar_t *}text, @code{const char *}fnt, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_text_xyz (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}text, @code{const char *}fnt, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_textw_xyz (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{const char *}opt)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_text_y (@code{HMGL} gr, @code{HCDT} y, @code{const char *}text, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_textw_y (@code{HMGL} gr, @code{HCDT} y, @code{const wchar_t *}text, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_text_xy (@code{HCDT} x, @code{HCDT} y, @code{const char *}text, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_textw_xy (@code{HCDT} x, @code{HCDT} y, @code{const wchar_t *}text, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_text_xyz (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}text, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_textw_xyz (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{const char *}opt)
@end ifclear
-Выводит строку @var{text} вдоль кривой @{@var{x}[i], @var{y}[i], @var{z}[i]@} шрифтом @var{fnt}. Строка @var{fnt} может содержать символы: @samp{t} для вывода текста под кривой (по умолчанию), или @samp{T} для вывода текста над кривой. Размеры по 1-ой размерности должны быть одинаковы для всех массивов @code{x.nx=y.nx=z.nx}. Если массив @var{x} не указан, то используется "автоматический" массив со значениями в диапазоне [@var{Min}.x, @var{Max}.x] (@pxref{Ranges (bounding box)}). Если массив @var{z} не указан, то используется @var{z}[i] = @var{Min}.z. Строка @var{opt} содержит опции команды (@pxref{Command options}). @sref{Text sample}
+Выводит строку @var{text} вдоль кривой @{@var{x}[i], @var{y}[i], @var{z}[i]@} шрифтом @var{fnt}. Строка @var{fnt} может содержать символы: @samp{t} для вывода текста под кривой (по умолчанию), или @samp{T} для вывода текста над кривой. Размеры по 1-ой размерности должны быть одинаковы для всех массивов @code{x.nx=y.nx=z.nx}. Если массив @var{x} не указан, то используется "автоматический" массив со значениями в диапазоне [@var{Min}.x, @var{Max}.x] (см. @ref{Ranges (bounding box)}). Если массив @var{z} не указан, то используется @var{z}[i] = @var{Min}.z. Строка @var{opt} содержит опции команды (см. @ref{Command options}). @sref{Text sample}
@end deftypefn
@c ##################################################################
@cindex Colorbar
@cindex Label
-Эти функции рисуют объекты для "измерения" типа осей координат, цветовой таблицы (colorbar), сетку по осям, обрамляющий параллелепипед и подписи по осям координат. См. также @pxref{Axis settings}.
+Эти функции рисуют объекты для "измерения" типа осей координат, цветовой таблицы (colorbar), сетку по осям, обрамляющий параллелепипед и подписи по осям координат. См. также см. @ref{Axis settings}.
@anchor{axis}
-@deftypefn {MGL command} {} axis ['dir'='xyz' @code{adjust=off}]
+@deftypefn {MGL command} {} axis ['dir'='xyz' 'stl'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Axis (@code{const char *}dir=@code{"xyz"}, @code{bool} adjust=@code{false})
-@deftypefnx {C function} @code{void} mgl_axis (@code{HMGL} gr, @code{const char *}dir, @code{int} adjust)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Axis (@code{const char *}dir=@code{"xyz"}, @code{const char *}stl=@code{""})
+@deftypefnx {C function} @code{void} mgl_axis (@code{HMGL} gr, @code{const char *}dir, @code{const char *}stl)
@end ifclear
-Рисует оси координат и метки на них (@pxref{Axis settings}) в направлениях, указанных строкой @var{dir}. Если строка содержит символ @samp{_}, то подписи меток отображаться не будут. Шрифт подписей определяется функцией @code{SetFontDef()} (@pxref{Font settings}). Метки будут "подогнаны" если @var{adjust}=@code{true} (с помощью вызова функции @code{AdjustTicks()}).
+Рисует оси координат и метки на них (см. @ref{Axis settings}) в направлениях @samp{xyz}, указанных строкой @var{dir}. Если строка содержит символ @samp{_}, то подписи меток отображаться не будут. Если строка содержит символ @samp{AKDTVISO}, то будет нарисована соответствующая стрелка на конце оси. Стиль меток и оси(ей) задается строкой @var{stl}. @sref{Axis and ticks}
@end deftypefn
@anchor{colorbar}
-@deftypefn {MGL command} {} colorbar ['sch'='' @code{pos=0}]
+@deftypefn {MGL command} {} colorbar ['sch'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch=@code{""}, @code{int} pos=@code{0})
-@deftypefnx {C function} @code{void} mgl_colorbar (@code{HMGL} gr, @code{const char *}sch, @code{int} pos)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_colorbar (@code{HMGL} gr, @code{const char *}sch)
@end ifclear
-РиÑ\81Ñ\83еÑ\82 полоÑ\81Ñ\83 Ñ\81ооÑ\82веÑ\82Ñ\81Ñ\82виÑ\8f Ñ\86веÑ\82а и Ñ\87иÑ\81ловÑ\8bÑ\85 знаÑ\87ений (colorbar) длÑ\8f Ñ\86веÑ\82овой Ñ\81Ñ\85емÑ\8b @var{sch} (иÑ\81полÑ\8cзÑ\83еÑ\82Ñ\81Ñ\8f Ñ\82екÑ\83Ñ\89аÑ\8f длÑ\8f @code{sch=""}) Ñ\81 кÑ\80аÑ\8e оÑ\82 гÑ\80аÑ\84ика. Ð\9fаÑ\80амеÑ\82Ñ\80 @var{pos} задаеÑ\82 меÑ\81Ñ\82оположение: @samp{0} - Ñ\81пÑ\80ава (по Ñ\83молÑ\87аниÑ\8e), @samp{1} - Ñ\81лева, @samp{2} - Ñ\81веÑ\80Ñ\85Ñ\83, @samp{3} - Ñ\81низÑ\83. Ð\95Ñ\81ли Ñ\81Ñ\82Ñ\80ока @var{sch} Ñ\81одеÑ\80жиÑ\82 @samp{<>^_}, Ñ\82о паÑ\80амеÑ\82Ñ\80 @var{pos} опÑ\80еделÑ\8fеÑ\82Ñ\81Ñ\8f как: @code{pos=0} длÑ\8f @samp{>} (Ñ\81пÑ\80ава), @code{pos=1} длÑ\8f @samp{<} (Ñ\81лева), @code{pos=2} длÑ\8f @samp{^} (Ñ\81веÑ\80Ñ\85Ñ\83), @code{pos=3} длÑ\8f @samp{_} (Ñ\81низÑ\83). Ð\95Ñ\81ли Ñ\81Ñ\82Ñ\80ока Ñ\81одеÑ\80жиÑ\82 @samp{A}, Ñ\82о иÑ\81полÑ\8cзÑ\83Ñ\8eÑ\82Ñ\81Ñ\8f абÑ\81олÑ\8eÑ\82нÑ\8bе кооÑ\80динаÑ\82Ñ\8b (оÑ\82ноÑ\81иÑ\82елÑ\8cно Ñ\80иÑ\81Ñ\83нка). @sref{Dens sample}
+РиÑ\81Ñ\83еÑ\82 полоÑ\81Ñ\83 Ñ\81ооÑ\82веÑ\82Ñ\81Ñ\82виÑ\8f Ñ\86веÑ\82а и Ñ\87иÑ\81ловÑ\8bÑ\85 знаÑ\87ений (colorbar) длÑ\8f Ñ\86веÑ\82овой Ñ\81Ñ\85емÑ\8b @var{sch} (иÑ\81полÑ\8cзÑ\83еÑ\82Ñ\81Ñ\8f Ñ\82екÑ\83Ñ\89аÑ\8f длÑ\8f @code{sch=""}) Ñ\81 кÑ\80аÑ\8e оÑ\82 гÑ\80аÑ\84ика. Ð\95Ñ\81ли Ñ\81Ñ\82Ñ\80ока @var{sch} Ñ\81одеÑ\80жиÑ\82 @samp{<>^_}, Ñ\82о положение вÑ\8bбиÑ\80аеÑ\82Ñ\81Ñ\8f: @samp{>} -- Ñ\81пÑ\80ава, @samp{<} -- Ñ\81лева, @samp{^} -- Ñ\81веÑ\80Ñ\85Ñ\83, @samp{_} -- Ñ\81низÑ\83. Ð\95Ñ\81ли Ñ\81Ñ\82Ñ\80ока Ñ\81одеÑ\80жиÑ\82 @samp{A}, Ñ\82о иÑ\81полÑ\8cзÑ\83Ñ\8eÑ\82Ñ\81Ñ\8f абÑ\81олÑ\8eÑ\82нÑ\8bе кооÑ\80динаÑ\82Ñ\8b (оÑ\82ноÑ\81иÑ\82елÑ\8cно Ñ\80иÑ\81Ñ\83нка). @sref{Colorbars}
@end deftypefn
-@deftypefn {MGL command} {} colorbar vdat ['sch'='' @code{pos=0}]
+@deftypefn {MGL command} {} colorbar vdat ['sch'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch=@code{""}, @code{int} pos=@code{0})
-@deftypefnx {C function} @code{void} mgl_colorbar_val (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch, @code{int} pos)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_colorbar_val (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch)
@end ifclear
Аналогично предыдущему, но для цветовой схемы без сглаживания с заданными значениями @var{v}. @sref{ContD sample}
@end deftypefn
-@deftypefn {MGL command} {} colorbar 'sch' @code{pos x y w h}
+@deftypefn {MGL command} {} colorbar 'sch' @code{x y [w=1 h=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch, @code{int} pos, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
-@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{int} pos, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
-@deftypefnx {C function} @code{void} mgl_colorbar_ext (@code{HMGL} gr, @code{const char *}sch, @code{int} pos, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch, @code{float} x, @code{float} y, @code{float} w=@code{1}, @code{float} h=@code{1})
+@deftypefnx {C function} @code{void} mgl_colorbar_ext (@code{HMGL} gr, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
@end ifclear
Аналогично первому, но в произвольном месте графика @{@var{x}, @var{y}@} (полагаются в диапазоне [0,1]). Параметры @var{w}, @var{h} задают относительную ширину и высоту colorbar.
@end deftypefn
+@deftypefn {MGL command} {} colorbar vdat 'sch' @code{x y [w=1 h=1]}
@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch, @code{int} pos, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
-@deftypefnx {C function} @code{void} mgl_colorbar_val_ext (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch, @code{int} pos, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w=@code{1}, @code{float} h=@code{1})
+@deftypefnx {C function} @code{void} mgl_colorbar_val_ext (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
+@end ifclear
Аналогично предыдущему, но для цветовой схемы без сглаживания с заданными значениями @var{v}.
@end deftypefn
-@end ifclear
@anchor{grid}
@deftypefn {MGL command} {} grid ['dir'='xyz' 'pen'='B']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Grid (@code{const char *}dir=@code{"xyz"}, @code{const char *}pen=@code{"B"})
-@deftypefnx {C function} @code{void} mgl_axis_grid (@code{HMGL} gr, @code{const char *}dir, @code{const char *}pen)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Grid (@code{const char *}dir=@code{"xyz"}, @code{const char *}pen=@code{"B"})
+@deftypefnx {Функция С} @code{void} mgl_axis_grid (@code{HMGL} gr, @code{const char *}dir, @code{const char *}pen)
@end ifclear
Рисует линии сетки в направлениях перпендикулярным @var{dir}. Шаг сетки такой же как у меток осей координат. Стиль линий задается параметром @var{pen} (по умолчанию -- сплошная темно синяя линия @samp{B-}).
@end deftypefn
@anchor{box}
@deftypefn {MGL command} {} box ['stl'='k' @code{ticks=on}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Box (@code{const char *}col=@code{""}, @code{bool} ticks=@code{true})
-@deftypefnx {C function} @code{void} mgl_box (@code{HMGL} gr, @code{int} ticks)
-@deftypefnx {C function} @code{void} mgl_box_str (@code{HMGL} gr, @code{const char *}col, @code{int} ticks)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Box (@code{const char *}col=@code{""}, @code{bool} ticks=@code{true})
+@deftypefnx {Функция С} @code{void} mgl_box (@code{HMGL} gr, @code{int} ticks)
+@deftypefnx {Функция С} @code{void} mgl_box_str (@code{HMGL} gr, @code{const char *}col, @code{int} ticks)
@end ifclear
-Рисует ограничивающий параллелепипед цветом @var{col}.
+Рисует ограничивающий параллелепипед цветом @var{col}. Если @var{col} содержит @samp{@@}, то рисуются закрашенные задние грани. При этом первый цвет используется для граней (по умолчанию светло жёлтый), а последний для рёбер и меток.
@end deftypefn
@anchor{xlabel}
@cindex SetLegendBox
@cindex SetLegendMarks
-Эти функции обеспечивают рисование легенды графика (полезно для @ref{1D plotting}). Запись в легенде состоит из двух строк: одна для стиля линии и маркеров, другая с текстом описания (с включенным разбором TeX-их команд). Можно использовать непосредственно массивы строк, или накопление во внутренние массивы с помощью функции AddLegend() с последующим отображением. Положение легенды можно задать автоматически или вручную. Параметры @var{fnt} и @var{size} задают стиль и размер шрифта (@pxref{Font settings}). Параметр @var{llen} задает относительную ширину примера линии. Ели стиль линии пустой, то соответствующий текст печатается без отступа. Если строка @var{fnt} содержит символ @samp{A}, то координаты легенды считаются относительно картинки (а не текущего subplot). Если строка @var{fnt} содержит символ @samp{#}, то рисуется прямоугольник вокруг легенды. @sref{Legend sample}
+Эти функции обеспечивают рисование легенды графика (полезно для @ref{1D plotting}). Запись в легенде состоит из двух строк: одна для стиля линии и маркеров, другая с текстом описания (с включенным разбором TeX-их команд). Можно использовать непосредственно массивы строк, или накопление во внутренние массивы с помощью функции AddLegend() с последующим отображением. Положение легенды можно задать автоматически или вручную. Параметры @var{fnt} и @var{size} задают стиль и размер шрифта (см. @ref{Font settings}). Параметр @var{llen} задает относительную ширину примера линии. Ели стиль линии пустой, то соответствующий текст печатается без отступа. Если строка @var{fnt} содержит символ @samp{A}, то координаты легенды считаются относительно картинки (а не текущего subplot). Если строка @var{fnt} содержит символ @samp{#}, то рисуется прямоугольник вокруг легенды. @sref{Legend sample}
@anchor{legend}
@deftypefn {MGL command} {} legend [@code{pos=3} 'fnt'='#' @code{size=-0.8 llen=0.1}]
@deftypefnx {Method on @code{mglGraph}} @code{void} Legend (@code{int} pos=@code{0x3}, @code{const char *}fnt=@code{"#"}, @code{float} size=@code{-0.8}, @code{float} llen=@code{0.1})
@deftypefnx {C function} @code{void} mgl_legend (@code{HMGL} gr, @code{int} pos, @code{const char *}fnt, @code{float} size, @code{float} llen)
@end ifclear
-Рисует легенду из накопленных записей шрифтом @var{fnt} размером @var{size}. Параметр @var{pos} задает положение легенды: @samp{0} -- в нижнем левом углу, @samp{1} -- нижнем правом углу, @samp{2} -- верхнем левом углу, @samp{3} -- верхнем правом углу (по умолчанию).
+Рисует легенду из накопленных записей шрифтом @var{fnt} размером @var{size}. Параметр @var{pos} задает положение легенды: @samp{0} -- в нижнем левом углу, @samp{1} -- нижнем правом углу, @samp{2} -- верхнем левом углу, @samp{3} -- верхнем правом углу (по умолчанию). Строка @var{fnt} может содержать вет для прямоугольника (1-ый цвет), для его границы (2-ой цвет) и для текста (последний). Если указано менее 3 цветов, то цвет рёбер будет чёрным (2 и менее цвета), а цвет прямоугольника белым (1 и менее цвета). Прямоугольник рисуется если строка @var{fnt} содержит @samp{#}.
@end deftypefn
@deftypefn {MGL command} {} legend @code{x y} ['fnt'='#' @code{size=-1 llen=0.1}]
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} Legend (@code{float} x, @code{float} y, @code{const char *}fnt=@code{"#"}, @code{float} size=@code{-0.8}, @code{float} llen=@code{0.1})
-@deftypefnx {C function} @code{void} mgl_legend_xy (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const char *}fnt, @code{float} size, @code{float} llen)
+@deftypefnx {C function} @code{void} mgl_legend_pos (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const char *}fnt, @code{float} size, @code{float} llen)
@end ifclear
Рисует легенду из накопленных записей шрифтом @var{fnt} размером @var{size}. Положение легенды задается параметрами @var{x}, @var{y}, которые полагаются нормированными в диапазоне [0,1].
@end deftypefn
@deftypefnx {C function} @code{void} mgl_add_legend (@code{HMGL} gr, @code{const char *}text, @code{const char *}style)
@deftypefnx {C function} @code{void} mgl_add_legendw (@code{HMGL} gr, @code{const wchar_t *}text, @code{const char *}style)
@end ifclear
-Добавляет описание @var{text} кривой со стилем @var{style} (@pxref{Line styles}) во внутренний массив записей легенды.
+Добавляет описание @var{text} кривой со стилем @var{style} (см. @ref{Line styles}) во внутренний массив записей легенды.
@end deftypefn
@anchor{clearlegend}
@anchor{legendmarks}
@deftypefn {MGL command} {} legendmarks @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetLegendMarks (@code{int} num)
-@deftypefnx {C function} @code{void} mgl_set_legend_marks (@code{HMGL} gr, @code{int} num)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetLegendMarks (@code{int} num)
+@deftypefnx {Функция С} @code{void} mgl_set_legend_marks (@code{HMGL} gr, @code{int} num)
@end ifclear
Задает число маркеров в легенде. По умолчанию используется 1 маркер.
@end deftypefn
@node 1D plotting, 2D plotting, Legend, MathGL core
@section 1D графики
-Эти функции строят графики для одномерных (1D) массивов. Одномерными считаются массивы, зависящие только от одного параметра (индекса) подобно кривой в параметрической форме @{x(i),y(i),z(i)@}, i=1...n. Есть 5 основных типов 1D графиков: линия (Plot), линия с заполнением (Area), ступеньки (Step), прямоугольники (Bars, Barh) и вертикальные линии (Stem). Все эти типы графиков имеют похожий интерфейс. Есть версии для рисования в пространстве и на плоскости. В последнем случае имеется возможность использования только одного массива. Стиль линии и маркеров указывается строковой переменной. Если она равна "", то используется сплошная линия с цветом из палитры (@pxref{Palette and colors}). Кроме того, есть еще несколько типов графиков для одномерных массивов, имеющих другой интерфейс и вид: поверхность вращения кривой (Torus), диаграмма (Chart), размер ошибки (Error), маркеры переменного размера (Mark), трубками (Tube) и т.д. @xref{Line styles}. @sref{1D plot sample}
-
-@menu
-* Plot::
-* Radar::
-* Tens::
-* Area::
-* Region::
-* Stem::
-* Bars::
-* Barh::
-* Chart::
-* Step::
-* Torus::
-* Tube::
-* Mark::
-* TextMark::
-* Error::
-* BoxPlot::
-@end menu
-
-@c ==================================================================
-@node Plot, Radar, , 1D plotting
-@subsection Plot
@cindex Plot
-
-Функции рисуют ломанную линию по точкам. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) рисуется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). См. также @ref{Area}, @ref{Step}, @ref{Stem}, @ref{Tube}, @ref{Mark}, @ref{Error}, @ref{Belt}, @ref{Tens}. @sref{Plot sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Plot (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_plot_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}pen)
-Рисует в пространстве линию между точками @{@var{x}[i], @var{y}[i], @var{z}[i]@}.
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Plot (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_plot_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const char *}pen)
-Рисует линию между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Plot (@code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_plot (@code{HMGL} gr, @code{const HMDT} y, @code{const char *}pen)
-Рисует линию между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
-@end deftypefn
-
-@c ==================================================================
-@node Radar, Tens, Plot, 1D plotting
-@subsection Radar
@cindex Radar
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Radar (@code{const mglData &}a, @code{const char *}pen=@code{""}, @code{float} r=@code{-1})
-@deftypefnx {Функция С} @code{void} mgl_radar (@code{HMGL} gr, @code{const HMDT} a, @code{const char *}pen, @code{float} r)
-Функции рисуют radar chart, представляющий собой ломанную с вершинами на радиальных линиях (типа ломанной в полярных координатах). График рисуется для каждой строки если один из массивов матрица. Параметр @var{r} задает дополнительный сдвиг данных (т.е. используется @var{a}+@var{r} вместо @var{a}). Если @code{r<0}, то @code{r=max(0, -min(a)}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). Если @var{pen} содержит символ @samp{#}, то также рисуется "сетка" (радиальные линии и круг для @var{r}). См. также @ref{Plot}. @sref{Radar sample}
-@end deftypefn
-
-@c ==================================================================
-@node Tens, Area, Radar, 1D plotting
-@subsection Tens
@cindex Tens
-
-Функции рисуют ломанную линию по точкам с цветом, определяемым массивом @var{c} (типа графика натяжений). График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx=c.nx}. Строка @var{pen} задает цветовую схему (@pxref{Color scheme}) и стиль и/или толщину линии (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущей цветовой схемой. См. также @ref{Plot}, @ref{Mesh}, @ref{Fall}. @sref{Tens sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tens_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} c, @code{const char *}pen)
-Рисует в пространстве линию между точками @{@var{x}[i], @var{y}[i], @var{z}[i]@} с цветом @var{c}[i].
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}c, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tens_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} c, @code{const char *}pen)
-Рисует линию между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}) с цветом @var{c}[i].
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tens (@code{const mglData &}y, @code{const mglData &}c, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tens (@code{HMGL} gr, @code{const HMDT} y, @code{const HMDT} c, @code{const char *}pen)
-Рисует линию между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}) с цветом @var{c}[i], где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
-@end deftypefn
-
-@c ==================================================================
-@node Area, Region, Tens, 1D plotting
-@subsection Area
@cindex Area
-
-Функции рисуют ломанную линию между точками и закрашивает ее вниз до плоскости осей координат. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). Также можно использовать градиентное закрашивание если число указанных цветов равно удвоенному числу кривых для построения. Если строка содержит символ @samp{a}, то линии рисуются одна поверх другой (с суммированием) -- того же эффекта можно достичь вызовом @code{y.CumSum("y");} перед построением графика. См. также @ref{Plot}, @ref{Bars}, @ref{Stem}. @sref{Area sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Area (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_area_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}pen)
-Рисует в пространстве линию между точками @{@var{x}[i], @var{y}[i], @var{z}[i]@} и закрашивает ее вниз до плоскости @var{z} = Org.z.
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Area (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_area_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const char *}pen)
-Рисует линию между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}) и закрашивает ее до прямой @var{y} = Org.y.
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Area (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{bool} sum=@code{false})
-@deftypefnx {Функция С} @code{void} mgl_area (@code{HMGL} gr, @code{const HMDT} y, @code{const char *}pen)
-@deftypefnx {Функция С} @code{void} mgl_area_s (@code{HMGL} gr, @code{const HMDT} y, @code{const char *}pen)
-Рисует линию между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}) и закрашивает ее до прямой @var{y} = Org.y, где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x]. Параметр @var{sum} задает режим рисования линий одна поверх другой (с сумированием). Замечу, что того же эффекта можно достичь вызовом @code{y.CumSum("y");} перед построением графика.
-@end deftypefn
-
-@c ==================================================================
-@node Region, Stem, Area, 1D plotting
-@subsection Region
@cindex Region
-
-Функции закрашивают область между 2 кривыми. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y1.nx=y2.nx} и размеры массивов @var{y1}, @var{y2} должны быть также одинаковы. Строка @var{pen} задает цвет (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется текущий цвет из палитры (@pxref{Palette and colors}). Также можно использовать градиентное закрашивание если число указанных цветов равно удвоенному числу кривых для построения. См. также @ref{Area}, @ref{Bars}, @ref{Stem}. @sref{Region sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Region (@code{const mglData &}x, @code{const mglData &}y1, @code{const mglData &}y2, @code{const char *}pen=@code{""}, @code{float} zVal=@code{NAN}, @code{bool} inside=@code{true})
-@deftypefnx {Функция С} @code{void} mgl_region_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y1, @code{const HMDT} y2, @code{const char *}pen, @code{int} inside)
-Закрашивает область между кривыми @{@var{x}[i], @var{y1}[i]@} и @{@var{x}[i], @var{y2}[i]@} при z=@var{zVal}. При @code{inside=off} закрашивается только область y1<y<y2, в противном случае также будет закращена область y2<y<y1.
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Region (@code{const mglData &}y1, @code{const mglData &}y2, @code{const char *}pen=@code{""}, @code{float} zVal=@code{NAN}, @code{bool} inside=@code{true})
-@deftypefnx {Функция С} @code{void} mgl_region (@code{HMGL} gr, @code{const HMDT} y1, @code{const HMDT} y2, @code{const char *}pen, @code{int} inside)
-Закрашивает область между кривыми @{@var{x}[i], @var{y1}[i]@} и @{@var{x}[i], @var{y2}[i]@} при z=@var{zVal}, где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
-@end deftypefn
-
-@c ==================================================================
-@node Stem, Bars, Region, 1D plotting
-@subsection Stem
@cindex Stem
-
-Функции рисуют вертикальные линии из точек до плоскости осей координат. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). См. также @ref{Area}, @ref{Bars}, @ref{Plot}, @ref{Mark}. @sref{Stem sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Stem (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_stem_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}pen)
-Рисует вертикальные линии из точек @{@var{x}[i], @var{y}[i], @var{z}[i]@} вниз до плоскости @var{z} = Org.z.
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Stem (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_stem_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const char *}pen)
-Рисует вертикальные линии из точек @{@var{x}[i], @var{y}[i]@} до @var{y} = Org.y в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Stem (@code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_stem (@code{HMGL} gr, @code{const HMDT} y, @code{const char *}pen)
-Рисует вертикальные линии из точек @{@var{x}[i], @var{y}[i]@} до @var{y} = Org.y в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
-@end deftypefn
-
-@c ==================================================================
-@node Bars, Barh, Stem, 1D plotting
-@subsection Bars
@cindex Bars
-
-Функции рисуют вертикальные полосы (прямоугольники) из точек до плоскости осей координат. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). Если строка содержит символ @samp{a}, то линии рисуются одна поверх другой. Если строка содержит символ @samp{f}, то рисуется график типа waterfall для определения кумулятивного эффекта последовательности положительных и отрицательных значений. Можно использовать разные цвета для положительных и отрицательных значений если число указанных цветов равно удвоенному числу кривых для построения. См. также @ref{Barh}, @ref{Area}, @ref{Stem}, @ref{Chart}, @ref{Default sizes}. @sref{Bars sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Bars (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_bars_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}pen)
-Рисует вертикальные полосы из точек @{@var{x}[i], @var{y}[i], @var{z}[i]@} вниз до плоскости @var{z} = Org.z.
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Bars (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_bars_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const char *}pen)
-Рисует вертикальные полосы из точек @{@var{x}[i], @var{y}[i]@} до @var{y} = Org.y в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Bars (@code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_bars (@code{HMGL} gr, @code{const HMDT} y, @code{const char *}pen)
-Рисует вертикальные полосы из точек @{@var{x}[i], @var{y}[i]@} до @var{y} = Org.y в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
-@end deftypefn
-
-@c ==================================================================
-@node Barh, Chart, Bars, 1D plotting
-@subsection Barh
@cindex Barh
+@cindex Chart
+@cindex Step
+@cindex Torus
+@cindex Tube
+@cindex Mark
+@cindex TextMark
+@cindex Error
+@cindex BoxPlot
+@cindex Candle
+@cindex Tape
+@cindex Label
+@cindex Cones
-ФÑ\83нкÑ\86ии Ñ\80иÑ\81Ñ\83Ñ\8eÑ\82 гоÑ\80изонÑ\82алÑ\8cнÑ\8bе полоÑ\81Ñ\8b (пÑ\80Ñ\8fмоÑ\83голÑ\8cники) из Ñ\82оÑ\87ек до плоÑ\81коÑ\81Ñ\82и оÑ\81ей кооÑ\80динаÑ\82. Ð\93Ñ\80аÑ\84ик Ñ\80иÑ\81Ñ\83еÑ\82Ñ\81Ñ\8f длÑ\8f каждой Ñ\81Ñ\82Ñ\80оки еÑ\81ли один из маÑ\81Ñ\81ивов маÑ\82Ñ\80иÑ\86а. РазмеÑ\80 по 1-ой кооÑ\80динаÑ\82е @strong{должен бÑ\8bÑ\82Ñ\8c одинаков} длÑ\8f вÑ\81еÑ\85 маÑ\81Ñ\81ивов @code{x.nx=y.nx=z.nx}. СÑ\82Ñ\80ока @var{pen} задаеÑ\82 Ñ\86веÑ\82 и Ñ\81Ñ\82илÑ\8c линии и маÑ\80кеÑ\80ов (@pxref{Line styles}). Ð\9fо Ñ\83молÑ\87аниÑ\8e (@code{pen=""}) иÑ\81полÑ\8cзÑ\83еÑ\82Ñ\81Ñ\8f Ñ\81плоÑ\88наÑ\8f линиÑ\8f Ñ\81 Ñ\82екÑ\83Ñ\89им Ñ\86веÑ\82ом из палиÑ\82Ñ\80Ñ\8b (@pxref{Palette and colors}). Ð\95Ñ\81ли Ñ\81Ñ\82Ñ\80ока Ñ\81одеÑ\80жиÑ\82 Ñ\81имвол @samp{a}, Ñ\82о линии Ñ\80иÑ\81Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f одна повеÑ\80Ñ\85 дÑ\80Ñ\83гой. Ð\95Ñ\81ли Ñ\81Ñ\82Ñ\80ока Ñ\81одеÑ\80жиÑ\82 Ñ\81имвол @samp{f}, Ñ\82о Ñ\80иÑ\81Ñ\83еÑ\82Ñ\81Ñ\8f гÑ\80аÑ\84ик Ñ\82ипа waterfall длÑ\8f опÑ\80еделениÑ\8f кÑ\83мÑ\83лÑ\8fÑ\82ивного Ñ\8dÑ\84Ñ\84екÑ\82а поÑ\81ледоваÑ\82елÑ\8cноÑ\81Ñ\82и положиÑ\82елÑ\8cнÑ\8bÑ\85 и оÑ\82Ñ\80иÑ\86аÑ\82елÑ\8cнÑ\8bÑ\85 знаÑ\87ений. Ð\9cожно иÑ\81полÑ\8cзоваÑ\82Ñ\8c Ñ\80азнÑ\8bе Ñ\86веÑ\82а длÑ\8f положиÑ\82елÑ\8cнÑ\8bÑ\85 и оÑ\82Ñ\80иÑ\86аÑ\82елÑ\8cнÑ\8bÑ\85 знаÑ\87ений еÑ\81ли Ñ\87иÑ\81ло Ñ\83казаннÑ\8bÑ\85 Ñ\86веÑ\82ов Ñ\80авно Ñ\83двоенномÑ\83 Ñ\87иÑ\81лÑ\83 кÑ\80ивÑ\8bÑ\85 длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f. См. Ñ\82акже @ref{Barh}, @ref{Default sizes}. @sref{Barh sample}
+ÐÑ\82и Ñ\84Ñ\83нкÑ\86ии Ñ\81Ñ\82Ñ\80оÑ\8fÑ\82 гÑ\80аÑ\84ики длÑ\8f одномеÑ\80нÑ\8bÑ\85 (1D) маÑ\81Ñ\81ивов. Ð\9eдномеÑ\80нÑ\8bми Ñ\81Ñ\87иÑ\82аÑ\8eÑ\82Ñ\81Ñ\8f маÑ\81Ñ\81ивÑ\8b, завиÑ\81Ñ\8fÑ\89ие Ñ\82олÑ\8cко оÑ\82 одного паÑ\80амеÑ\82Ñ\80а (индекÑ\81а) подобно кÑ\80ивой в паÑ\80амеÑ\82Ñ\80иÑ\87еÑ\81кой Ñ\84оÑ\80ме @{x(i),y(i),z(i)@}, i=1...n. Ð\9fо Ñ\83молÑ\87аниÑ\8e (еÑ\81ли оÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82вÑ\83Ñ\8eÑ\82) знаÑ\87ениÑ\8f @var{x}[i] Ñ\80авно Ñ\80аÑ\81пÑ\80еделенÑ\8b в диапазоне оÑ\81и Ñ\85, и @var{z}[i]=@var{Min}.z. Ð\93Ñ\80аÑ\84ики Ñ\80иÑ\81Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f длÑ\8f каждой Ñ\81Ñ\82Ñ\80оки маÑ\81Ñ\81ива даннÑ\8bÑ\85 еÑ\81ли он двÑ\83меÑ\80нÑ\8bй. РазмеÑ\80 по 1-ой кооÑ\80динаÑ\82е @strong{должен бÑ\8bÑ\82Ñ\8c одинаков} длÑ\8f вÑ\81еÑ\85 маÑ\81Ñ\81ивов @code{x.nx=y.nx=z.nx}.
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Barh (@code{const mglData &}y, @code{const mglData &}v, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_barh_xy (@code{HMGL} gr, @code{const HMDT} y, @code{const HMDT} v, @code{const char *}pen)
-Рисует горизонтальные полосы из точек @{@var{v}[i], @var{y}[i]@} до @var{x} = Org.x в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
-@end deftypefn
+Строка @var{pen} задает цвет и стиль линии и маркеров (см. @ref{Line styles}). По умолчанию (@code{pen=""}) рисуется сплошная линия с текущим цветом из палитры (см. @ref{Palette and colors}). Символ @samp{!} в строке задает использование нового цвета из палитры для каждой точки данных (не для всей кривой, как по умолчанию). Строка @var{opt} задает опции графика (см. @ref{Command options}). @sref{1D samples}
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Barh (@code{const mglData &}v, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_barh (@code{HMGL} gr, @code{const HMDT} v, @code{const char *}pen)
-Рисует горизонтальные полосы из точек @{@var{v}[i], @var{y}[i]@} до @var{x} = Org.x в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{y}[i] равно распределены в интервале [@var{Min}.y, @var{Max}.y].
+@anchor{plot}
+@deftypefn {MGL command} {} plot ydat ['stl'='']
+@deftypefnx {MGL command} {} plot xdat ydat ['stl'='']
+@deftypefnx {MGL command} {} plot xdat ydat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Plot (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Plot (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Plot (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_plot (@code{HMGL} gr, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_plot_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_plot_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют ломанную линию по точкам. См. также @ref{area}, @ref{step}, @ref{stem}, @ref{tube}, @ref{mark}, @ref{error}, @ref{belt}, @ref{tens}, @ref{tape}. @sref{Plot sample}
@end deftypefn
-@c ==================================================================
-@node Chart, Step, Barh, 1D plotting
-@subsection Chart
-@cindex Chart
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Chart (@code{const mglData &}a, @code{const char *}col=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_chart (@code{HMGL} gr, @code{const HMDT} a, @code{const char *}col)
-Рисует цветные полосы (пояса) для массива данных @var{a}. Число полос равно числу строк @var{a} (равно @var{a.ny}). Цвет полос поочередно меняется из цветов указанных в @var{col} или в палитре (@pxref{Palette and colors}). Пробел в цветах соответствует прозрачному "цвету", т.е. если @var{col} содержит пробел(ы), то соответствующая полоса не рисуется. Ширина полосы пропорциональна значению элемента в @var{a}. График строится только для массивов не содержащих отрицательных значений. Если строка @var{col} содержит @samp{#}, то рисуется также черная граница полос. График выглядит лучше в (после вращения системы координат) и/или в полярной системе координат (становится Pie chart). @sref{Chart sample}
+@anchor{radar}
+@deftypefn {MGL command} {} radar adat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Radar (@code{const mglData &}a, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_radar (@code{HMGL} gr, @code{HCDT} a, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют radar chart, представляющий собой ломанную с вершинами на радиальных линиях (типа ломанной в полярных координатах). Параметр @var{value} в опциях @var{opt} задает дополнительный сдвиг данных (т.е. использование @var{a}+@var{value} вместо @var{a}). Если @var{pen} содержит @samp{#}, то рисуется "сетка" (радиальные линии). См. также @ref{plot}. @sref{Radar sample}
@end deftypefn
-
-@c ==================================================================
-@node Step, Torus, Chart, 1D plotting
-@subsection Step
-@cindex Step
-
-Функции рисуют ступеньки для точек массива. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). См. также @ref{Plot}, @ref{Stem}, @ref{Tile}, @ref{Boxs}. @sref{Step sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Step (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_step_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}pen)
-Рисует ступеньки для точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}.
+@anchor{step}
+@deftypefn {MGL command} {} step ydat ['stl'='']
+@deftypefnx {MGL command} {} step xdat ydat ['stl'='']
+@deftypefnx {MGL command} {} step xdat ydat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Step (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Step (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Step (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_step (@code{HMGL} gr, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_step_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_step_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют ступеньки для точек массива. См. также @ref{plot}, @ref{stem}, @ref{tile}, @ref{boxs}. @sref{Step sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Step (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_step_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const char *}pen)
-Рисует ступеньки для точек @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
+@anchor{tens}
+@deftypefn {MGL command} {} tens ydat cdat ['stl'='']
+@deftypefnx {MGL command} {} tens xdat ydat cdat ['stl'='']
+@deftypefnx {MGL command} {} tens xdat ydat zdat cdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tens (@code{const mglData &}y, @code{const mglData &}c, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}c, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_tens (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} c, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tens_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} c, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tens_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют ломанную линию по точкам с цветом, определяемым массивом @var{c} (типа графика натяжений). Строка @var{pen} задает цветовую схему (см. @ref{Color scheme}) и стиль линий и/или маркеров (см. @ref{Line styles}). См. также @ref{plot}, @ref{mesh}, @ref{fall}. @sref{Tens sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Step (@code{const mglData &}y, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_step (@code{HMGL} gr, @code{const HMDT} y, @code{const char *}pen)
-Рисует ступеньки для точек @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
+@anchor{tape}
+@deftypefn {MGL command} {} tape ydat ['stl'='']
+@deftypefnx {MGL command} {} tape xdat ydat ['stl'='']
+@deftypefnx {MGL command} {} tape xdat ydat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tape (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tape (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tape (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_tape (@code{HMGL} gr, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tape_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tape_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют ленты, которые вращаются вокруг кривой @{@var{x}[i], @var{y}[i], @var{z}[i]@} как её нормали. Начальная лента(ы) выбираются в плоскости x-y (для @samp{x} в @var{pen}) и/или y-z (для @samp{x} в @var{pen}). Ширина лент пропорциональна @code{SetBarWidth()}. См. также @ref{plot}, @ref{flow}, @ref{barwidth}. @sref{Tape sample}
@end deftypefn
-@c ==================================================================
-@node Torus, Tube, Step, 1D plotting
-@subsection Torus
-@cindex Torus
-
-Функции рисуют поверхность вращения кривой @{@var{r}, @var{z}@} относительно оси. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @var{r.nx=z.nx}. Строка @var{pen} задает цвет (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется цвет из палитры (@pxref{Palette and colors}). См. также @ref{Plot}, @ref{Axial}. @sref{Torus sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Torus (@code{const mglData &}r, @code{const mglData &}z, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_torus (@code{HMGL} gr, @code{const HMDT} r, @code{const HMDT} z, @code{const char *}pen)
-Рисует поверхность вращения кривой @{@var{r}[i], @var{z}[i]@}.
+@anchor{area}
+@deftypefn {MGL command} {} area ydat ['stl'='']
+@deftypefnx {MGL command} {} area xdat ydat ['stl'='']
+@deftypefnx {MGL command} {} area xdat ydat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Area (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Area (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Area (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_area (@code{HMGL} gr, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_area_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_area_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют ломанную линию между точками и закрашивает её вниз до плоскости осей координат. Градиентная заливка используется если число цветов равно удвоенному число кривых. См. также @ref{plot}, @ref{bars}, @ref{stem}, @ref{region}. @sref{Area sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Torus (@code{const mglData &}z, @code{const char *}pen=@code{""})
-Рисует поверхность вращения кривой @{@var{r}[i], @var{z}[i]@}, где значения @var{r}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
+@anchor{region}
+@deftypefn {MGL command} {} region ydat1 ydat2 ['stl'='']
+@deftypefnx {MGL command} {} region xdat ydat1 ydat2 ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Region (@code{const mglData &}y1, @code{const mglData &}y2, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Region (@code{const mglData &}x, @code{const mglData &}y1, @code{const mglData &}y2, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_region (@code{HMGL} gr, @code{HCDT} y1, @code{HCDT} y2, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_region_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y1, @code{HCDT} y2, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции закрашивают область между 2 кривыми. Градиентная заливка используется если число цветов равно удвоенному число кривых. Если @var{pen} содержит @samp{i}, то закрашивается только область y1<y<y2, в противном случае будет закрашена и область y2<y<y1. См. также @ref{area}, @ref{bars}, @ref{stem}. @sref{Region sample}
@end deftypefn
-@c ==================================================================
-@node Tube, Mark, Torus, 1D plotting
-@subsection Tube
-@cindex Tube
-
-Функции рисуют трубу радиуса @var{r}[i] вдоль кривой между точками @{@var{x}[i], @var{y}[i], @var{z}[i]@}. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx=r.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). См. также @ref{Plot}. @sref{Tube sample}
+@anchor{stem}
+@deftypefn {MGL command} {} stem ydat ['stl'='']
+@deftypefnx {MGL command} {} stem xdat ydat ['stl'='']
+@deftypefnx {MGL command} {} stem xdat ydat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Stem (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Stem (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Stem (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_stem (@code{HMGL} gr, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_stem_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_stem_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют вертикальные линии из точек до плоскости осей координат. См. также @ref{area}, @ref{bars}, @ref{plot}, @ref{mark}. @sref{Stem sample}
+@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}pen=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{float} r, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tube_xyzr (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} r, @code{const char *}pen)
-@deftypefnx {Функция С} @code{void} mgl_tube_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{float} r, @code{const char *}pen)
-Рисует трубу радиуса @var{r} в пространстве между точками @{@var{x}[i], @var{y}[i], @var{z}[i]@}.
+@anchor{bars}
+@deftypefn {MGL command} {} bars ydat ['stl'='']
+@deftypefnx {MGL command} {} bars xdat ydat ['stl'='']
+@deftypefnx {MGL command} {} bars xdat ydat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Bars (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Bars (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Bars (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_bars (@code{HMGL} gr, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_bars_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_bars_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют вертикальные полосы (прямоугольники) из точек до плоскости осей координат. Если строка @var{pen} содержит символ @samp{a}, то линии рисуются одна поверх другой. Если строка содержит символ @samp{f}, то рисуется график типа waterfall для определения кумулятивного эффекта последовательности положительных и отрицательных значений. Можно использовать разные цвета для положительных и отрицательных значений если число указанных цветов равно удвоенному числу кривых для построения. См. также @ref{barh}, @ref{cones}, @ref{area}, @ref{stem}, @ref{chart}, @ref{barwidth}. @sref{Bars sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tube_xyr (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} r, @code{const char *}pen)
-@deftypefnx {Функция С} @code{void} mgl_tube_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{float} r, @code{const char *}pen)
-Рисует трубу радиуса @var{r} между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
+@anchor{barh}
+@deftypefn {MGL command} {} barh vdat ['stl'='']
+@deftypefnx {MGL command} {} barh ydat vdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Barh (@code{const mglData &}v, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Barh (@code{const mglData &}y, @code{const mglData &}v, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_barh (@code{HMGL} gr, @code{HCDT} v, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_barh_xy (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} v, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют горизонтальные полосы (прямоугольники) из точек до плоскости осей координат. Если строка @var{pen} содержит символ @samp{a}, то линии рисуются одна поверх другой. Если строка содержит символ @samp{f}, то рисуется график типа waterfall для определения кумулятивного эффекта последовательности положительных и отрицательных значений. Можно использовать разные цвета для положительных и отрицательных значений если число указанных цветов равно удвоенному числу кривых для построения. См. также @ref{bars}, @ref{barwidth}. @sref{Barh sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tube_r (@code{HMGL} gr, @code{const HMDT} y, @code{const HMDT} r, @code{const char *}pen)
-@deftypefnx {Функция С} @code{void} mgl_tube (@code{HMGL} gr, @code{const HMDT} y, @code{float} r, @code{const char *}pen)
-Рисует трубу радиуса @var{r} между точками @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
+@anchor{cones}
+@deftypefn {MGL command} {} cones ydat ['stl'='']
+@deftypefnx {MGL command} {} cones xdat ydat ['stl'='']
+@deftypefnx {MGL command} {} cones xdat ydat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cones (@code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cones (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cones (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_cones (@code{HMGL} gr, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cones_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cones_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют конусы из точек до плоскости осей координат. Если строка @var{pen} содержит символ @samp{a}, то линии рисуются одна поверх другой. Можно использовать разные цвета для положительных и отрицательных значений если число указанных цветов равно удвоенному числу кривых для построения. См. также @ref{bars}, @ref{barwidth}. @sref{Cones sample}
@end deftypefn
-@c ==================================================================
-@node Mark, TextMark, Tube, 1D plotting
-@subsection Mark
-@cindex Mark
-Функции рисуют маркеры размером @var{r}*@var{MarkSize} (@pxref{Default sizes}) в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx=r.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). Для рисования маркеров одинакового размера можно использовать функцию @ref{Plot} с невидимой линией (со стилем содержащим @samp{ }). См. также @ref{Plot}, @ref{TextMark}, @ref{Stem}, @ref{Error}. @sref{Mark sample}
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Mark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_mark_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} r, @code{const char *}pen)
-Рисует маркеры для точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}.
+@anchor{chart}
+@deftypefn {MGL command} {} chart adat ['col'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Chart (@code{const mglData &}a, @code{const char *}col=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_chart (@code{HMGL} gr, @code{HCDT} a, @code{const char *}col, @code{const char *}opt)
+@end ifclear
+Рисует цветные полосы (пояса) для массива данных @var{a}. Число полос равно числу строк @var{a} (равно @var{a.ny}). Цвет полос поочерёдно меняется из цветов указанных в @var{col} или в палитре (см. @ref{Palette and colors}). Пробел в цветах соответствует прозрачному "цвету", т.е. если @var{col} содержит пробел(ы), то соответствующая полоса не рисуется. Ширина полосы пропорциональна значению элемента в @var{a}. График строится только для массивов не содержащих отрицательных значений. Если строка @var{col} содержит @samp{#}, то рисуется также чёрная граница полос. График выглядит лучше в (после вращения системы координат) и/или в полярной системе координат (становится Pie chart). @sref{Chart sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Mark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_mark_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} r, @code{const char *}pen)
-Рисует маркеры для точек @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
+@anchor{boxplot}
+@deftypefn {MGL command} {} boxplot adat ['stl'='']
+@deftypefnx {MGL command} {} boxplot xdat adat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} BoxPlot (@code{const mglData &}a, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} BoxPlot (@code{const mglData &}x, @code{const mglData &}a, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_boxplot (@code{HMGL} gr, @code{HCDT} a, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_boxplot_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} a, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют boxplot (называемый также как box-and-whisker diagram или как "ящик с усами") в точках @var{x}[i] на плоскости @var{z} = @var{zVal} (по умолчанию @var{z}=@var{Min.z}). Это график, компактно изображающий распределение вероятностей @var{a}[i,j] (минимум, нижний квартиль (Q1), медиана (Q2), верхний квартиль (Q3) и максимум) вдоль второго (j-го) направления. См. также @ref{plot}, @ref{error}, @ref{bars}, @ref{barwidth}. @sref{BoxPlot sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Mark (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_mark_y (@code{HMGL} gr, @code{const HMDT} y, @code{const HMDT} r, @code{const char *}pen)
-Рисует маркеры для точек @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
+@anchor{candle}
+@deftypefn {MGL command} {} candle vdat1 ['stl'='']
+@deftypefnx {MGL command} {} candle vdat1 vdat2 ['stl'='']
+@deftypefnx {MGL command} {} candle vdat1 ydat1 ydat2 ['stl'='']
+@deftypefnx {MGL command} {} candle vdat1 vdat2 ydat1 ydat2 ['stl'='']
+@deftypefnx {MGL command} {} candle xdat vdat1 vdat2 ydat1 ydat2 ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Candle (@code{const mglData &}v1, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Candle (@code{const mglData &}v1, @code{const mglData &}v2, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Candle (@code{const mglData &}v1, @code{const mglData &}y1, @code{const mglData &}y2, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Candle (@code{const mglData &}v1, @code{const mglData &}v2, @code{const mglData &}y1, @code{const mglData &}y2, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Candle (@code{const mglData &}x, @code{const mglData &}v1, @code{const mglData &}v2, @code{const mglData &}y1, @code{const mglData &}y2, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_candle (@code{HMGL} gr, @code{HCDT} v1, @code{HCDT} y1, @code{HCDT} y2, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_candle_yv (@code{HMGL} gr, @code{HCDT} v1, @code{HCDT} v2, @code{HCDT} y1, @code{HCDT} y2, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_candle_xyv (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} v1, @code{HCDT} v2, @code{HCDT} y1, @code{HCDT} y2, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют candlestick chart в точках @var{x}[i]. Этот график показывает прямоугольником ("свечой") диапазон изменения величины. Прозрачная (белая) свеча соответствует росту величины @var{v1}[i]<@var{v2}[i], чёрная -- уменьшению. "Тени" показывают минимальное @var{y1} и максимальное @var{y2} значения. Если @var{v2} отсутствует, то он определяется как @var{v2}[i]=@var{v1}[i+1]. См. также @ref{plot}, @ref{bars}, @ref{barwidth}. @sref{Candle sample}
@end deftypefn
-@c ==================================================================
-@node TextMark, Error, Mark, 1D plotting
-@subsection TextMark
-@cindex TextMark
-
-Функции рисуют текст @var{text} как маркер с размером пропорциональным @var{r}*@var{MarkSize} (@pxref{Default sizes}) в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx=r.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). См. также @ref{Plot}, @ref{Mark}, @ref{Stem}. @sref{TextMark sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const wchar_t *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_textmarkw_xyzr (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} r, @code{const wchar_t *}text, @code{const char *}fnt)
-@deftypefnx {Функция С} @code{void} mgl_textmark_xyzr (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} r, @code{const char *}text, @code{const char *}fnt)
-Рисует текстовые маркеры в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}.
-@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const wchar_t *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_textmarkw_xyr (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} r, @code{const wchar_t *}text, @code{const char *}fnt)
-@deftypefnx {Функция С} @code{void} mgl_textmark_xyr (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} r, @code{const char *}text, @code{const char *}fnt)
-Рисует текстовые маркеры в точках @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}).
+@anchor{error}
+@deftypefn {MGL command} {} error ydat yerr ['stl'='']
+@deftypefnx {MGL command} {} error xdat ydat yerr ['stl'='']
+@deftypefnx {MGL command} {} error xdat ydat xerr yerr ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Error (@code{const mglData &}y, @code{const mglData &}ey, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Error (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ey, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Error (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ex, @code{const mglData &}ey, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_error (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} ey, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_error_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ey, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_error_exy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ex, @code{HCDT} ey, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют размер ошибки в точках @{@var{x}[i], @var{y}[i]@} на плоскости @var{z} = @var{zVal} (по умолчанию @var{z}=@var{Min.z}). Такой график полезен для отображения ошибки эксперимента, вычислений и пр. Если @var{pen} содержит @samp{@@}, то будут использованы большие полупрозрачные маркеры. См. также @ref{plot}, @ref{mark}. @sref{Error sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const mglData &}r, @code{const wchar_t *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_textmarkw_yr (@code{HMGL} gr, @code{const HMDT} y, @code{const HMDT} r, @code{const wchar_t *}text, @code{const char *}fnt)
-@deftypefnx {Функция С} @code{void} mgl_textmark_yr (@code{HMGL} gr, @code{const HMDT} y, @code{const HMDT} r, @code{const char *}text, @code{const char *}fnt)
-Рисует текстовые маркеры в точках @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
+@anchor{mark}
+@deftypefn {MGL command} {} mark ydat rdat ['stl'='']
+@deftypefnx {MGL command} {} mark xdat ydat rdat ['stl'='']
+@deftypefnx {MGL command} {} mark xdat ydat zdat rdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Mark (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Mark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Mark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_mark_y (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_mark_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_mark_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют маркеры размером @var{r}*@var{MarkSize} (см. @ref{Default sizes}) в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Для рисования маркеров одинакового размера можно использовать функцию @ref{plot} с невидимой линией (со стилем содержащим @samp{ }). Для маркеров с размером как у координат можно использовать @ref{error} со стилем @samp{@@}. См. также @ref{plot}, @ref{textmark}, @ref{error}, @ref{stem}. @sref{Mark sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_textmarkw (@code{HMGL} gr, @code{const HMDT} y, @code{const wchar_t *}text, @code{const char *}fnt)
-@deftypefnx {Функция С} @code{void} mgl_textmark (@code{HMGL} gr, @code{const HMDT} y, @code{const char *}text, @code{const char *}fnt)
-Рисует текстовые маркеры в точках @{@var{x}[i], @var{y}[i]@} в плоскости @var{z}=@var{zVal} (по умолчанию в плоскости @var{z}=@var{Min.z}), где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x]. The mark sizes @var{r}[i]=1 for all points.
+@anchor{textmark}
+@deftypefn {MGL command} {} textmark ydat 'txt' ['stl'='']
+@deftypefnx {MGL command} {} textmark ydat rdat 'txt' ['stl'='']
+@deftypefnx {MGL command} {} textmark xdat ydat rdat 'txt' ['stl'='']
+@deftypefnx {MGL command} {} textmark xdat ydat zdat rdat 'txt' ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const char *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const wchar_t *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}y, @code{const mglData &}r, @code{const wchar_t *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const wchar_t *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} TextMark (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const wchar_t *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_textmark (@code{HMGL} gr, @code{HCDT} y, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_textmarkw (@code{HMGL} gr, @code{HCDT} y, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_textmark_yr (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} r, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_textmarkw_yr (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} r, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_textmark_xyr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} r, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_textmarkw_xyr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} r, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_textmark_xyzr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_textmarkw_xyzr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
+@end ifclear
+Функции рисуют текст @var{text} как маркер с размером пропорциональным @var{r}*@var{MarkSize} (см. @ref{Default sizes}) в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. См. также @ref{plot}, @ref{mark}, @ref{stem}. @sref{TextMark sample}
@end deftypefn
-@c ==================================================================
-@node Error, BoxPlot, TextMark, 1D plotting
-@subsection Error
-@cindex Error
-
-Функции рисуют размер ошибки в точках @{@var{x}[i], @var{y}[i]@} на плоскости @var{z} = @var{zVal} (по умолчанию @var{z}=@var{Min.z}). Такой график полезен для отображения ошибки эксперимента, вычислений и пр. График рисуется для каждой строки если один из массивов матрица. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=y.nx=z.nx=r.nx}. Строка @var{pen} задает цвет и стиль линии и маркеров (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). См. также @ref{Plot}. @sref{Error sample}
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Error (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ex, @code{const mglData &}ey, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_error_exy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} ex, @code{const HMDT} ey, @code{const char *}pen)
-Рисует размер ошибки @{@var{ex}, @var{ey}@} в точках @{@var{x}, @var{y}@}.
+@anchor{label}
+@deftypefn {MGL command} {} label ydat 'txt' ['stl'='']
+@deftypefnx {MGL command} {} label xdat ydat 'txt' ['stl'='']
+@deftypefnx {MGL command} {} label xdat ydat zdat 'txt' ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{const mglData &}y, @code{const char *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{const mglData &}y, @code{const wchar_t *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{const mglData &}x, @code{const mglData &}y, @code{const wchar_t *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const wchar_t *}txt, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_label (@code{HMGL} gr, @code{HCDT} y, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_labelw (@code{HMGL} gr, @code{HCDT} y, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_label_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_labelw_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_label_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_labelw_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
+@end ifclear
+Функции выводят текстовую строку @var{txt} в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Если строка @var{txt} содержит @samp{%x}, @samp{%y}, @samp{%z} или @samp{%n}, то они будут заменены на значения соответствующих координат или на номер точки. См. также @ref{plot}, @ref{mark}, @ref{textmark}. @sref{Label sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Error (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ey, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_error_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} ey, @code{const char *}pen)
-Рисует размер ошибки @var{ey} (только вдоль одного направления) в точках @{@var{x}, @var{y}@}.
+@anchor{tube}
+@deftypefn {MGL command} {} tube ydat rdat ['stl'='']
+@deftypefnx {MGL command} {} tube ydat @code{rval} ['stl'='']
+@deftypefnx {MGL command} {} tube xdat ydat rdat ['stl'='']
+@deftypefnx {MGL command} {} tube xdat ydat @code{rval} ['stl'='']
+@deftypefnx {MGL command} {} tube xdat ydat zdat rdat ['stl'='']
+@deftypefnx {MGL command} {} tube xdat ydat zdat @code{rval} ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_tube_r (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube (@code{HMGL} gr, @code{HCDT} y, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube_xyr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube_xyzr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют трубу радиуса @var{r}[i] вдоль кривой между точками @{@var{x}[i], @var{y}[i], @var{z}[i]@}. См. также @ref{plot}. @sref{Tube sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Error (@code{const mglData &}y, @code{const mglData &}ey, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_error (@code{HMGL} gr, @code{const HMDT} y, @code{const HMDT} ey, @code{const char *}pen)
-Рисует размер ошибки @var{ey} (только вдоль одного направления) в точках @{@var{x}, @var{y}@}, где значения @var{x}[i] равно распределены в интервале [@var{Min}.x, @var{Max}.x].
+@anchor{torus}
+@deftypefn {MGL command} {} torus rdat zdat ['stl'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Torus (@code{const mglData &}r, @code{const mglData &}z, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_torus (@code{HMGL} gr, @code{HCDT} r, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
+@end ifclear
+Функции рисуют поверхность вращения кривой @{@var{r}, @var{z}@} относительно оси. Если строка @var{pen} содержит @samp{x} или @samp{z}, то ось вращения будет выбрана в указанном направлении (по умолчанию вдоль оси y). См. также @ref{plot}, @ref{axial}. @sref{Torus sample}
@end deftypefn
-@c ==================================================================
-@node BoxPlot, , Error, 1D plotting
-@subsection BoxPlot
-@cindex BoxPlot
-Функции рисуют boxplot (называемый также как box-and-whisker diagram или как "ящик с усами") в точках @var{x}[i] на плоскости @var{z} = @var{zVal} (по умолчанию @var{z}=@var{Min.z}). Это график, компактно изображающий распределение вероятностей @var{a}[i,j] (минимум, нижний квартиль (Q1), медиана (Q2), верхний квартиль (Q3) и максимум) вдоль второго (j-го) направления. Размер по 1-ой координате @strong{должен быть одинаков} для всех массивов @code{x.nx=a.nx}. Строка @var{pen} задает цвет и стиль линий (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется сплошная линия с текущим цветом из палитры (@pxref{Palette and colors}). См. также @ref{Plot}, @ref{Error}, @ref{Bars}, @ref{Default sizes}. @sref{BoxPlot sample}
-@deftypefn {Метод класса @code{mglGraph}} @code{void} BoxPlot (@code{const mglData &}x, @code{const mglData &}a, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_boxplot_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} a, @code{const char *}pen)
-Рисует boxplot с заданными значениями координат @var{x}[i].
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} BoxPlot (@code{const mglData &}a, @code{const char *}pen=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_boxplot (@code{HMGL} gr, @code{const HMDT} a, @code{const char *}pen)
-Рисует boxplot со значениями @var{x}[i] равно распределенными в интервале [@var{Min}.x, @var{Max}.x].
-@end deftypefn
@c ##################################################################
@node 2D plotting, 3D plotting, 1D plotting, MathGL core
@section 2D графики
-
-Эти функции строят графики для двумерных (2D) массивов. Двумерными считаются массивы, зависящие только от двух параметров (индексов) подобно матрице @math{f(x_i,y_j), i=1...n, j=1...m}. Есть несколько основных типов 2D графиков: сплошная поверхность (Surf), сетчатая поверхность (Mesh), поверхность из ящиков (Boxs), поверхность из плиток (Tile), водопад (Fall), ленточки (Belt), график плотности (Dens), линии уровня (Cont), линии уровня с заполнением (ContF) и результат их вращения (Axial). В функциях Cont(), ContF() и Axial() значения уровней можно задавать автоматически и вручную. Можно также нарисовать сетку (Grid) по массиву данных для улучшения вида графика плотности или линий уровня. Каждый тип графика имеет похожий интерфейс. Есть версия для рисования одного массива с автоматическими координатами и версия для параметрически заданной поверхности. Параметры цветовой схемы задаются строкой @xref{Color scheme}. @sref{2D plot sample}
-
-@menu
-* Mesh::
-* Fall::
-* Belt::
-* Surf::
-* Boxs::
-* Tile::
-* Dens::
-* Cont::
-* ContF::
-* ContD::
-* Axial::
-* Grad::
-* Grid::
-@end menu
-
-@c ==================================================================
-@node Mesh, Fall, , 2D plotting
-@subsection Mesh
@cindex Mesh
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Mesh (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_mesh_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-Рисует сетчатую поверхность, заданную параметрически @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Surf}, @ref{Fall}, @ref{MeshNum}, @ref{Cont}, @ref{Tens}. @sref{Mesh sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Mesh (@code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_mesh (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
-
-@c ==================================================================
-@node Fall, Belt, Mesh, 2D plotting
-@subsection Fall
@cindex Fall
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Fall (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_fall_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-Рисует водопад для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. График удобен для построения нескольких кривых, сдвинутых вглубь друг относительно друга. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если @var{sch} содержит @samp{x}, то линии рисуются вдоль x-оси (по умолчанию линии рисуются вдоль y-оси). Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Belt}, @ref{Mesh}, @ref{Tens}, @ref{MeshNum}. @sref{Fall sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Fall (@code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_fall (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
-
-@c ==================================================================
-@node Belt, Surf, Fall, 2D plotting
-@subsection Belt
@cindex Belt
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Belt (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_belt_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-Рисует ленточки для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. График может использоваться как 3d обобщение графика Plot() (@pxref{Plot}). Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если @var{sch} содержит @samp{x}, то линии рисуются вдоль x-оси (по умолчанию линии рисуются вдоль y-оси). Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Fall}, @ref{Surf}, @ref{Plot}, @ref{MeshNum}. @sref{Belt sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Belt (@code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_belt (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
-
-@c ==================================================================
-@node Surf, Boxs, Belt, 2D plotting
-@subsection Surf
@cindex Surf
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Surf (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_surf_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-Рисует параметрически заданную поверхность @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если @var{sch} содержит @samp{#}, то на поверхности рисуется сетка. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Mesh}, @ref{Dens}, @ref{Belt}, @ref{Tile}, @ref{Boxs}, @ref{SurfC}, @ref{SurfA}. @sref{Surf sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Surf (@code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_surf (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
-
-@c ==================================================================
-@node Boxs, Tile, Surf, 2D plotting
-@subsection Boxs
@cindex Boxs
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Boxs (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_boxs_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-Рисует вертикальные ящики для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Surf}, @ref{Dens}, @ref{Tile}, @ref{Step}. @sref{Boxs sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Boxs (@code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_boxs (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
-
-@c ==================================================================
-@node Tile, Dens, Boxs, 2D plotting
-@subsection Tile
@cindex Tile
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tile (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tile_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-Рисует плитки для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. График может использоваться как 3d обобщение Step() (@pxref{Step}). Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Surf}, @ref{Boxs}, @ref{Step}, @ref{TileS}. @sref{Tile sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Tile (@code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_tile (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
-
-@c ==================================================================
-@node Dens, Cont, Tile, 2D plotting
-@subsection Dens
@cindex Dens
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Dens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_dens_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Рисует график плотности для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z} = @var{zVal}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если @var{sch} содержит @samp{#}, то рисуется сетка. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Surf}, @ref{Cont}, @ref{ContF}, @ref{Boxs}, @ref{Tile}, @ref{DensXYZ}. @sref{Dens sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Dens (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_dens (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
-
-@c ==================================================================
-@node Cont, ContF, Dens, 2D plotting
-@subsection Cont
@cindex Cont
+@cindex ContF
+@cindex ContD
+@cindex Axial
+@cindex Grad
+@cindex Grid
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Cont (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_cont_xy_val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Рисует линии уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z} = @var{zVal} (или при @var{z=v}[k] если @code{zVal==NAN}). Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если @var{sch} содержит @samp{#}, то рисуется сетка. Если @var{sch} содержит @samp{t} или @samp{T}, то значения @var{v}[k] будут выведены вдоль контуров над (или под) кривой. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Dens}, @ref{ContF}, @ref{ContD}, @ref{Axial}, @ref{ContXYZ}. @sref{Cont sample}
-@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Cont (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_cont__val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
-@end deftypefn
+Эти функции строят графики для двумерных (2D) массивов. Двумерными считаются массивы, зависящие только от двух параметров (индексов) подобно матрице @math{f(x_i,y_j), i=1...n, j=1...m}. По умолчанию (если отсутствуют) значения @var{x}, @var{y} равно распределены в диапазоне осей координат. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. Строка @var{sch} задает цветовую схему (см. @ref{Color scheme}). Строка @var{opt} задает опции графика (см. @ref{Command options}). @sref{2D samples}
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Cont (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_cont_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в интервале [@var{Cmin}, @var{Cmax}].
-@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Cont (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_cont (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@anchor{surf}
+@deftypefn {MGL command} {} surf zdat ['sch'='']
+@deftypefnx {MGL command} {} surf xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_surf (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_surf_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует параметрически заданную поверхность @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Если @var{sch} содержит @samp{#}, то рисуется сетка на поверхности. См. также @ref{mesh}, @ref{dens}, @ref{belt}, @ref{tile}, @ref{boxs}, @ref{surfc}, @ref{surfa}. @sref{Surf sample}
@end deftypefn
-@c ==================================================================
-@node ContF, ContD, Cont, 2D plotting
-@subsection ContF
-@cindex ContF
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContF (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contf_xy_val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Рисует закрашенные линии (контуры) уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z} = @var{zVal} (или при @var{z=v}[k] если @code{zVal==NAN}). Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если @var{sch} содержит @samp{#}, то рисуется сетка. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Dens}, @ref{Cont}, @ref{Axial}, @ref{ContFXYZ}. @sref{ContF sample}
+@anchor{mesh}
+@deftypefn {MGL command} {} mesh zdat ['sch'='']
+@deftypefnx {MGL command} {} mesh xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Mesh (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Mesh (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_mesh (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_mesh_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует сетчатую поверхность, заданную параметрически @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. См. также @ref{surf}, @ref{fall}, @ref{meshnum}, @ref{cont}, @ref{tens}. @sref{Mesh sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContF (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contf_val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@anchor{fall}
+@deftypefn {MGL command} {} fall zdat ['sch'='']
+@deftypefnx {MGL command} {} fall xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Fall (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Fall (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_fall (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_fall_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует водопад для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. График удобен для построения нескольких кривых, сдвинутых вглубь друг относительно друга. Если @var{sch} содержит @samp{x}, то линии рисуются вдоль оси x, иначе (по умолчанию) вдоль оси y. См. также @ref{belt}, @ref{mesh}, @ref{tens}, @ref{meshnum}. @sref{Fall sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContF (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contf_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в интервале [@var{Cmin}, @var{Cmax}].
+@anchor{belt}
+@deftypefn {MGL command} {} belt zdat ['sch'='']
+@deftypefnx {MGL command} {} belt xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Belt (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Belt (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_belt (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_belt_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует ленточки для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. График может использоваться как 3d обобщение графика @ref{plot}. Если @var{sch} содержит @samp{x}, то ленточки рисуются вдоль оси x, иначе (по умолчанию) вдоль оси y. См. также @ref{fall}, @ref{surf}, @ref{plot}, @ref{meshnum}. @sref{Belt sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContF (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contf (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@anchor{boxs}
+@deftypefn {MGL command} {} boxs zdat ['sch'='']
+@deftypefnx {MGL command} {} boxs xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Boxs (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Boxs (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_boxs (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_boxs_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует вертикальные ящики для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. См. также @ref{surf}, @ref{dens}, @ref{tile}, @ref{step}. @sref{Boxs sample}
@end deftypefn
-@c ==================================================================
-@node ContD, Axial, ContF, 2D plotting
-@subsection ContD
-@cindex ContD
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContD (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contd_xy_val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Рисует закрашенные линии (контуры) уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z} = @var{zVal} (или при @var{z=v}[k] если @code{zVal==NAN}) цветами заданными явно. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k] (должно быть @code{v.nx>2}). Строка @var{sch} задает цвет контуров: цвет k-го контура определяется символом @code{sch[k%strlen(sch)]}. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Dens}, @ref{Cont}, @ref{ContF}. @sref{ContD sample}
+@anchor{tile}
+@deftypefn {MGL command} {} tile zdat ['sch'='']
+@deftypefnx {MGL command} {} tile xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tile (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tile (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_tile (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tile_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует плитки для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. График может использоваться как 3d обобщение @ref{step}. См. также @ref{surf}, @ref{boxs}, @ref{step}, @ref{tiles}. @sref{Tile sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContD (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contd_val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@anchor{dens}
+@deftypefn {MGL command} {} dens zdat ['sch'='']
+@deftypefnx {MGL command} {} dens xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Dens (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{float} zVal=@code{NAN})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Dens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{float} zVal=@code{NAN})
+@deftypefnx {C function} @code{void} mgl_dens (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_dens_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует график плотности для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z} = @var{Min}.z. Если @var{sch} содержит @samp{#}, то рисуется сетка. См. также @ref{surf}, @ref{cont}, @ref{contf}, @ref{boxs}, @ref{tile}, @code{dens[xyz]}. @sref{Dens sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContD (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contd_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в интервале [@var{Cmin}, @var{Cmax}].
+@anchor{cont}
+@deftypefn {MGL command} {} cont vdat zdat ['sch'='']
+@deftypefnx {MGL command} {} cont vdat xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_cont__val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует линии уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z=v}[k] или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Если @var{sch} содержит @samp{t} или @samp{T}, то значения @var{v}[k] будут выведены вдоль контуров над (или под) кривой. См. также @ref{dens}, @ref{contf}, @ref{contd}, @ref{axial}, @code{cont[xyz]}. @sref{Cont sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContD (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_contd (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@deftypefn {MGL command} {} cont zdat ['sch'='']
+@deftypefnx {MGL command} {} cont xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_cont (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в диапазоне изменения цвета. Здесь @var{num} равен значению параметра @var{value} в опциях @var{opt} (по умолчанию 7).
@end deftypefn
-@c ==================================================================
-@node Axial, Grad, ContD, 2D plotting
-@subsection Axial
-@cindex Axial
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Axial (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_axial_xy_val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-Рисует поверхность вращения линии уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если @var{sch} содержит @samp{#}, то рисуется сетчатая поверхность. Если строка содержит символы @samp{x}, @samp{y} или @samp{z}, то ось вращения устанавливается в указанное направление. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Cont}, @ref{ContF}, @ref{Torus}, @ref{Surf3}. @sref{Axial sample}
+@anchor{contf}
+@deftypefn {MGL command} {} contf vdat zdat ['sch'='']
+@deftypefnx {MGL command} {} contf vdat xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContF (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContF (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contf_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует закрашенные линии (контуры) уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z=v}[k] или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. См. также @ref{dens}, @ref{cont}, @ref{contd}, @code{contf[xyz]}. @sref{ContF sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Axial (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_axial_val (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} z, @code{const char *}sch)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@deftypefn {MGL command} {} contf zdat ['sch'='']
+@deftypefnx {MGL command} {} contf xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContF (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContF (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contf (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в диапазоне изменения цвета. Здесь @var{num} равен значению параметра @var{value} в опциях @var{opt} (по умолчанию 7).
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Axial (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{3})
-@deftypefnx {Функция С} @code{void} mgl_axial_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{int} num)
-Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в интервале [@var{Cmin}, @var{Cmax}].
+@anchor{contd}
+@deftypefn {MGL command} {} contd vdat zdat ['sch'='']
+@deftypefnx {MGL command} {} contd vdat xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContD (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContD (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contd_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contd_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует закрашенные линии (контуры) уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z=v}[k] или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Строка @var{sch} задает цвета контуров: цвет k-го контура определяется как k-ый цвет строки. См. также @ref{dens}, @ref{cont}, @ref{contf}. @sref{ContD sample}
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Axial (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{3})
-@deftypefnx {Функция С} @code{void} mgl_axial (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch, @code{int} num)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@deftypefn {MGL command} {} contd zdat ['sch'='']
+@deftypefnx {MGL command} {} contd xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContD (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContD (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contd (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contd_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в диапазоне изменения цвета. Здесь @var{num} равен значению параметра @var{value} в опциях @var{opt} (по умолчанию 7).
@end deftypefn
-@c ==================================================================
-@node Grad, Grid, Axial, 2D plotting
-@subsection Grad
-@cindex Grad
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Grad (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}phi, @code{const char *}sch=@code{""}, @code{int} num=@code{5})
-@deftypefnx {Функция С} @code{void} mgl_grad_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Рисует линии градиента скалярного поля @var{phi}[i,j,k] заданного параметрически @{@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]@}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Число линий пропорционально @var{num}. Линии рисуются только с границ интервала при @var{num}<0. Младшие размерности массивов @var{x}, @var{y}, @var{z}, @var{phi} должны быть одинаковы @code{x.nx=phi.nx && y.nx=phi.ny && z.nx=phi.nz} или @code{x.nx=y.nx=z.nx=phi.nx && x.ny=y.ny=z.ny=phi.ny && x.nz=y.nz=z.nz=phi.nz}. Массивы @var{x}, @var{y} и @var{z} могут быть векторами (не матрицами как @var{phi}). См. также @ref{Dens3}, @ref{Cont3}, @ref{Flow}.
+@anchor{contv}
+@deftypefn {MGL command} {} contv vdat zdat ['sch'='']
+@deftypefnx {MGL command} {} contv vdat xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContV (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContV (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contv_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contv_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует вертикальные цилиндры от линий уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z=v}[k] или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. См. также @ref{cont}, @ref{contf}. @sref{ContV sample}
@end deftypefn
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Grad (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{5}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_grad_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Рисует линии градиента скалярного поля @var{phi}[i,j] заданного параметрически @{@var{x}[i,j], @var{y}[i,j]@} при @var{z} = @var{zVal}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Число линий пропорционально @var{num}. Линии рисуются только с границ интервала при @var{num}<0. Младшие размерности массивов @var{x}, @var{y}, @var{phi} должны быть одинаковы @code{x.nx=phi.nx && y.nx=phi.ny} или @code{x.nx=y.nx=phi.nx && x.ny=y.ny=phi.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{phi}). График строится для каждого z среза данных. См. также @ref{Dens}, @ref{Cont}, @ref{ContF}, @ref{Flow}. @sref{Grad sample}
+@deftypefn {MGL command} {} contv zdat ['sch'='']
+@deftypefnx {MGL command} {} contv xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContV (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContV (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contv (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contv_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в диапазоне изменения цвета. Здесь @var{num} равен значению параметра @var{value} в опциях @var{opt} (по умолчанию 7).
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Grad (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{int} num=@code{5}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_grad (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@anchor{axial}
+@deftypefn {MGL command} {} axial vdat zdat ['sch'='']
+@deftypefnx {MGL command} {} axial vdat xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Axial (@code{const mglData &}v, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Axial (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_axial_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_axial_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует поверхность вращения линии уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Если @var{sch} содержит @samp{#}, то рисуется сетчатая поверхность. Если строка содержит символы @samp{x}, @samp{y} или @samp{z}, то ось вращения устанавливается в указанное направление. См. также @ref{cont}, @ref{contf}, @ref{torus}, @ref{surf3}. @sref{Axial sample}
@end deftypefn
-@c ==================================================================
-@node Grid, , Grad, 2D plotting
-@subsection Grid
-@cindex Grid
-
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Grid (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_grid_xy (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Рисует плоскую сету для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z} = @var{zVal}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. См. также @ref{Dens}, @ref{Cont}, @ref{ContF}.
+@deftypefn {MGL command} {} axial zdat ['sch'='']
+@deftypefnx {MGL command} {} axial xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Axial (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{int} num=@code{3})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Axial (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{int} num=@code{3})
+@deftypefnx {C function} @code{void} mgl_axial (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_axial_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Как предыдущий с вектором @var{v} из @var{num} элементов равно распределенных в диапазоне изменения цвета. Здесь @var{num} равен значению параметра @var{value} в опциях @var{opt} (по умолчанию 3).
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Grid (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_grid (@code{HMGL} gr, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
-Как предыдущий с @var{x}, @var{y} равно распределенными в интервале [@var{Min}, @var{Max}].
+@anchor{grid2}
+@deftypefn {MGL command} {} grid2 zdat ['sch'='']
+@deftypefnx {MGL command} {} grid2 xdat ydat zdat ['sch'='']
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Grid (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Grid (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_grid (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_grid_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
+@end ifclear
+Рисует плоскую сету для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z} = @var{Min}.z. См. также @ref{dens}, @ref{cont}, @ref{contf}, @ref{meshnum}.
@end deftypefn
* Pipe::
@end menu
+@c ==================================================================
+@subsection Grad
+@cindex Grad
+
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Grad (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}phi, @code{const char *}sch=@code{""}, @code{int} num=@code{5})
+@deftypefnx {Функция С} @code{void} mgl_grad_xyz (@code{HMGL} gr, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{int} num, @code{float} zVal)
+Рисует линии градиента скалярного поля @var{phi}[i,j,k] заданного параметрически @{@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]@}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Число линий пропорционально @var{num}. Линии рисуются только с границ интервала при @var{num}<0. Младшие размерности массивов @var{x}, @var{y}, @var{z}, @var{phi} должны быть одинаковы @code{x.nx=phi.nx && y.nx=phi.ny && z.nx=phi.nz} или @code{x.nx=y.nx=z.nx=phi.nx && x.ny=y.ny=z.ny=phi.ny && x.nz=y.nz=z.nz=phi.nz}. Массивы @var{x}, @var{y} и @var{z} могут быть векторами (не матрицами как @var{phi}). См. также @ref{Dens3}, @ref{Cont3}, @ref{Flow}.
+@end deftypefn
+
+
@c ==================================================================
@node Traj, Vect, , Vector fields
@subsection Traj
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Traj (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN}, @code{float} len=@code{0})
@deftypefnx {Функция С} @code{void} mgl_traj_xyz (@code{HMGL} gr, @code{const HMDT}x, @code{const HMDT}y, @code{const HMDT}z, @code{const HMDT}ax, @code{const HMDT}ay, @code{const HMDT}az, @code{const char *}sch, @code{float} len)
@deftypefnx {Функция С} @code{void} mgl_traj_xy (@code{HMGL} gr, @code{const HMDT}x, @code{const HMDT}y, @code{const HMDT}ax, @code{const HMDT}ay, @code{const char *}sch, @code{float} zVal, @code{float} len)
-Рисует вектора @{@var{ax}, @var{ay}, @var{az}@} вдоль кривой @{@var{x}, @var{y}, @var{z}@}. Длина векторов пропорциональна @math{\sqrt@{ax^2+ay^2+az^2@}}. Строка @var{pen} задает цвет (@pxref{Line styles}). По умолчанию (@code{pen=""}) используется текущий цвет из палитры (@pxref{Palette and colors}). Параметр @var{len} задает фактор длины векторов (если не нуль) или выбирать длину пропорционально расстоянию между точками кривой (если @var{len}=0). Размер по 1-му индексу должен быть 2 или больше. График рисуется для каждой строки если один из массивов матрица. См. также @ref{Vect}. @sref{Traj sample}
+Рисует вектора @{@var{ax}, @var{ay}, @var{az}@} вдоль кривой @{@var{x}, @var{y}, @var{z}@}. Длина векторов пропорциональна @math{\sqrt@{ax^2+ay^2+az^2@}}. Строка @var{pen} задает цвет (см. @ref{Line styles}). По умолчанию (@code{pen=""}) используется текущий цвет из палитры (см. @ref{Palette and colors}). Параметр @var{len} задает фактор длины векторов (если не нуль) или выбирать длину пропорционально расстоянию между точками кривой (если @var{len}=0). Размер по 1-му индексу должен быть 2 или больше. График рисуется для каждой строки если один из массивов матрица. См. также @ref{Vect}. @sref{Traj sample}
@end deftypefn
@c ==================================================================
@subsection TriCont
@cindex TriCont
-@deftypefn {Method on @code{mglGraph}} @code{void} TriContV (@code{const mglData &}v, @code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Method on @code{mglGraph}} @code{void} TriContV (@code{const mglData &}v, @code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {C function} @code{void} mgl_tricont_xyzcv (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} c, @code{const char *}sch, @code{float} zVal)
-@deftypefnx {C function} @code{void} mgl_tricont_xyzv (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} TriContV (@code{const mglData &}v, @code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} TriContV (@code{const mglData &}v, @code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
+@deftypefnx {Функция С} @code{void} mgl_tricont_xyzcv (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} c, @code{const char *}sch, @code{float} zVal)
+@deftypefnx {Функция С} @code{void} mgl_tricont_xyzv (@code{HMGL} gr, @code{const HMDT} v, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{float} zVal)
Рисует линии уровня поверхности из треугольников при @var{z} = @var{zVal} (или для @var{z=v}[k] если @code{zVal==NAN}). Вершины треугольников задаются индексами @var{id} в массиве точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Размер по 1-му индексу массива @var{id} должен быть 3 или больше. Массивы @var{x}, @var{y}, @var{z} должны иметь одинаковые размеры. Массив @var{c} задает цвет треугольников (если @var{id}.ny=@var{c}.nx) или цвет вершин (если @var{x}.nx=@var{c}.nx). См. также @ref{TriPlot}, @ref{Cont}.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} TriCont (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{num}=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {Method on @code{mglGraph}} @code{void} TriCont (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{num}=@code{7}, @code{float} zVal=@code{NAN})
-@deftypefnx {C function} @code{void} mgl_tricont_xyzc (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} c, @code{const char *}sch, @code{num}, @code{float} zVal)
-@deftypefnx {C function} @code{void} mgl_tricont_xyz (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{num}, @code{float} zVal)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} TriCont (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{num}=@code{7}, @code{float} zVal=@code{NAN})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} TriCont (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{num}=@code{7}, @code{float} zVal=@code{NAN})
+@deftypefnx {Функция С} @code{void} mgl_tricont_xyzc (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} c, @code{const char *}sch, @code{num}, @code{float} zVal)
+@deftypefnx {Функция С} @code{void} mgl_tricont_xyz (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch, @code{num}, @code{float} zVal)
Аналогично предыдущему с вектором @var{v} из @var{num} элементов равно распределенных в интервале [@var{Cmin}, @var{Cmax}].
@end deftypefn
@subsection QuadPlot
@cindex QuadPlot
-@deftypefn {Method on @code{mglGraph}} @code{void} QuadPlot (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}sch=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} QuadPlot (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
-@deftypefnx {C function} @code{void} mgl_quadplot_xyz (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
-@deftypefnx {C function} @code{void} mgl_quadplot_xyzc (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} c, @code{const char *}sch)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} QuadPlot (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}c, @code{const char *}sch=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} QuadPlot (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_quadplot_xyz (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const char *}sch)
+@deftypefnx {Функция С} @code{void} mgl_quadplot_xyzc (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} c, @code{const char *}sch)
Рисует поверхность из четырехугольников. Вершины четырехугольников задаются индексами @var{id} в массиве точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Строка @var{sch} задает цветовую схему. Предыдущая цветовая схема используется по умолчанию. Если строка содержит @samp{#}, то рисуется сетчатая поверхность. Размер по 1-му индексу массива @var{id} должен быть 4 или больше. Массивы @var{x}, @var{y}, @var{z} должны иметь одинаковые размеры. Массив @var{c} задает цвет четырехугольников (если @var{id}.ny=@var{c}.nx) или цвет вершин (если @var{x}.nx=@var{c}.nx). См. также @ref{TriPlot}.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} QuadPlot (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {C function} @code{void} mgl_quadplot_xy (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const char *}sch, @code{float} zVal)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} QuadPlot (@code{const mglData &}id, @code{const mglData &}x, @code{const mglData &}y, @code{const char *}sch=@code{""}, @code{float} zVal=@code{NAN})
+@deftypefnx {Функция С} @code{void} mgl_quadplot_xy (@code{HMGL} gr, @code{const HMDT} id, @code{const HMDT} x, @code{const HMDT} y, @code{const char *}sch, @code{float} zVal)
Как предыдущий с @var{z}[i]=@var{zVal}.
@end deftypefn
@cindex Plot
@cindex Surf
-Эти функции строят графики 1D или 2D функций, заданный текстовыми формулами. Вам не нужно создавать массивы для их построения. Параметр @var{stl} задаект стиль линии (@pxref{Line styles}) для @code{Plot()} или цветовую схему (@pxref{Color scheme}) для @code{Surf()}. Параметр @var{n} задает минимальное число точек по координате(ам) для графика. В настоящее время (v. 1.10) число точек автоматически увеличивается для области резкого изменения функции, но только для 1D графиков (т.е. для Plot()).
+Эти функции строят графики 1D или 2D функций, заданный текстовыми формулами. Вам не нужно создавать массивы для их построения. Параметр @var{stl} задаект стиль линии (см. @ref{Line styles}) для @code{Plot()} или цветовую схему (см. @ref{Color scheme}) для @code{Surf()}. Параметр @var{n} задает минимальное число точек по координате(ам) для графика. В настоящее время (v. 1.10) число точек автоматически увеличивается для области резкого изменения функции, но только для 1D графиков (т.е. для Plot()).
@deftypefn {Метод класса @code{mglGraph}} @code{void} Plot (@code{const char *}eqY, @code{const char *}stl=@code{""}, @code{float} zVal=@code{NAN}, @code{int} n=@code{100})
@deftypefnx {Функция С} @code{void} mgl_fplot (@code{HMGL} gr, @code{const char *}eqY, @code{const char *}stl, @code{float} zVal, @code{int} n)
@cindex Fit2
@cindex Fit3
-Эти функции подбирают параметры функции для наилучшей аппроксимации данных, т.е. минимизируют сумму @math{\sum_i (f(x_i, y_i, z_i) - a_i)^2/s_i^2}. При этом аппроксимирующая функция @samp{f} может зависеть от одного аргумента @samp{x} (1D случай), от двух аргументов @samp{x,y} (2D случай) или от трех аргументов @samp{x,y,z} (3D случай). Функция @samp{f} также может зависеть от параметров. Список параметров задается строкой @var{var} (например, @samp{abcd}). Обычно пользователь должен предоставить начальные значения параметров в переменной @var{ini}. Однако, при его отсутствии используются нулевые значения. Параметр @var{print}=@code{true} включает вывод найденной формулы в @var{Message} (@pxref{Error handling}).
+Эти функции подбирают параметры функции для наилучшей аппроксимации данных, т.е. минимизируют сумму @math{\sum_i (f(x_i, y_i, z_i) - a_i)^2/s_i^2}. При этом аппроксимирующая функция @samp{f} может зависеть от одного аргумента @samp{x} (1D случай), от двух аргументов @samp{x,y} (2D случай) или от трех аргументов @samp{x,y,z} (3D случай). Функция @samp{f} также может зависеть от параметров. Список параметров задается строкой @var{var} (например, @samp{abcd}). Обычно пользователь должен предоставить начальные значения параметров в переменной @var{ini}. Однако, при его отсутствии используются нулевые значения. Параметр @var{print}=@code{true} включает вывод найденной формулы в @var{Message} (см. @ref{Error handling}).
Функции Fit() и FitS() не рисуют полученные массивы. Они заполняют массив @var{fit} по формуле @samp{f} с найденными коэффициентами и возвращают @math{\chi^2} ошибку аппроксимации. При этом, координаты @samp{x,y,z} равнораспределены в интервале @var{Min}--@var{Max}. Число точек в @var{fit} выбирается максимальным из размера массива @var{fit} и значения переменной @var{FitPnts}. Функции используют библиотеку GSL. @sref{Fitting sample}
Эти функции создают распределения данных. Они не выполняют построение сами по себе. Функции могут быть полезны в случае когда данные пользователя определены на случайно расположенных точка (например, после PIC расчетов) и он хочет построить график, требующий регулярных данных (данных на сетках). Диапазон сеток равен диапазону осей координат Min...Max. Массивы @var{x}, @var{y}, @var{z} определяют положение (координаты) точек. Массив @var{a} задает значения данных. Число точек в результате @var{res} -- максимум из размера @var{res} и значения @var{FitPnts}.
-@deftypefn {Method on @code{mglGraph}} @code{void} Hist (@code{mglData &}res, @code{const mglData &}x, @code{const mglData &}a)
-@deftypefnx {C function} @code{int} mgl_hist_x (@code{HMGL} gr, @code{HMDT} res, @code{const HMDT} x, @code{const HMDT} a)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Hist (@code{mglData &}res, @code{const mglData &}x, @code{const mglData &}a)
+@deftypefnx {Функция С} @code{int} mgl_hist_x (@code{HMGL} gr, @code{HMDT} res, @code{const HMDT} x, @code{const HMDT} a)
Создет 1D распределение значений массива @var{a} в диапазоне [Min, Max].
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} Hist (@code{mglData &}res, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}a)
-@deftypefnx {C function} @code{int} mgl_hist_xy (@code{HMGL} gr, @code{HMDT} res, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} a)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Hist (@code{mglData &}res, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}a)
+@deftypefnx {Функция С} @code{int} mgl_hist_xy (@code{HMGL} gr, @code{HMDT} res, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} a)
Создет 2D распределение значений массива @var{a} в диапазоне [Min, Max].
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} Hist (@code{mglData &}res, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a)
-@deftypefnx {C function} @code{int} mgl_hist_xyz (@code{HMGL} gr, @code{HMDT} res, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} a)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Hist (@code{mglData &}res, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a)
+@deftypefnx {Функция С} @code{int} mgl_hist_xyz (@code{HMGL} gr, @code{HMDT} res, @code{const HMDT} x, @code{const HMDT} y, @code{const HMDT} z, @code{const HMDT} a)
Создет 3D распределение значений массива @var{a} в диапазоне [Min, Max].
@end deftypefn
gr->SubPlot(2,2,1,""); gr->Title("'v' style");
gr->Box(); gr->Flow(a,b,"v");
- gr->SubPlot(2,2,2,""); gr->Title("from edges only");
- gr->Box(); gr->Flow(a,b,"","value -5");
+ gr->SubPlot(2,2,2,""); gr->Title("'\\#' style");
+ gr->Box(); gr->Flow(a,b,"#");
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60);
int sample(mglGraph *gr)
{
mglData a,b; mgls_prepare2v(&a,&b);
- gr->SubPlot(2,2,0,""); gr->Title("Flow plot (default)");
+ gr->SubPlot(2,2,0,""); gr->Title("Pipe plot (default)");
gr->Light(true); gr->Box(); gr->Pipe(a,b);
gr->SubPlot(2,2,1,""); gr->Title("'i' style");
gr->Box(); gr->Pipe(a,b,"i");
- gr->SubPlot(2,2,2,""); gr->Title("from edges only");
- gr->Box(); gr->Pipe(a,b,"",0.05,"value -5");
+ gr->SubPlot(2,2,2,""); gr->Title("'\\#' style");
+ gr->Box(); gr->Pipe(a,b,"#");
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60);
mglData a; mgls_prepare2d(&a);
gr->Light(true);
- gr->SubPlot(2,1,0); gr->Rotate(50,60+3);
+ gr->SubPlot(2,1,0); gr->Rotate(50,60+1);
gr->Box(); gr->Surf(a);
- gr->SubPlot(2,1,1); gr->Rotate(50,60-3);
+ gr->SubPlot(2,1,1); gr->Rotate(50,60-1);
gr->Box(); gr->Surf(a);
return 0;
}
There are some keys handles for manipulating by the plot: 'a', 'd', 'w', 's' for the rotating; ',', '.' for viewing of the previous or next frames in the list; 'r' for the switching of transparency; 'f' for the switching of lightning; 'x' for hiding (closing) the window.
@end deftypefn
-@deftypefn {Method on @code{mglWindow}} @code{void} RunThr ()
-@c @deftypefnx {C function} @code{HMGL} mgl_qt_run ()
-@deftypefnx {C function} @code{HMGL} mgl_fltk_thr ()
+@deftypefn {Method on @code{mglWindow}} @code{int} RunThr ()
+@deftypefnx {C function} @code{int} mgl_fltk_thr ()
Run main loop for event handling in separate thread. Note, right now it work for FLTK windows only.
@end deftypefn
-@deftypefn {Method on @code{mglWindow}} @code{void} Run ()
-@deftypefnx {C function} @code{HMGL} mgl_qt_run ()
-@deftypefnx {C function} @code{HMGL} mgl_fltk_run ()
+@deftypefn {Method on @code{mglWindow}} @code{int} Run ()
+@deftypefnx {C function} @code{int} mgl_qt_run ()
+@deftypefnx {C function} @code{int} mgl_fltk_run ()
Run main loop for event handling. Usually it should be called in a separate thread or as last function call in @code{main()}.
@end deftypefn
+@deftypefn {Method on @code{mglWindow}} @code{void} SetClickFunc (@code{void} (*func)(@code{HMGL} gr, @code{void *}p))
+@deftypefnx {C function} @code{void} mgl_set_click_func (@code{void} (*func)(@code{HMGL} gr, @code{void *}p))
+Set callback function @code{func} which will be called on mouse click.
+@end deftypefn
+
@deftypefn {Method on @code{mglWindow}} @code{void} ToggleAlpha ()
@deftypefnx {C function} @code{int} mgl_wnd_toggle_alpha (@code{HMGL} gr)
Switch on/off transparency but do not overwrite switches in user drawing function.
21. MGL testing system ???
22. Export to X3D
23. Try libtcc (TinyCC) as alternative to MGL -- in mgllab???
-24. Use OI & Z for determening {x,y,z} from {xs,ys}. Try to find closest.
+24. Use OI & Z for determining {x,y,z} from {xs,ys}. Try to find closest.
+25. More accurate intersections in Region
+26. Add flag for drawing 3d arrows instead of 2d (S,D -- cube, T -- sq.pyramid, I -- square, O -- sphere???, A,K,V -- ???)
============= UDAV =============
a->setShortcut(Qt::Key_F1); o->addAction(a);
// a = new QAction(QPixmap(":/xpm/help-faq.png"), tr("&Examples"), this);
// connect(a, SIGNAL(triggered()), this, SLOT(showExamples()));
- a->setToolTip(tr("Show examples of MGL usage (Shift+F1)."));
- a->setShortcut(Qt::SHIFT+Qt::Key_F1); o->addAction(a);
+// a->setToolTip(tr("Show examples of MGL usage (Shift+F1)."));
+// a->setShortcut(Qt::SHIFT+Qt::Key_F1); o->addAction(a);
a = new QAction(QPixmap(":/xpm/help-faq.png"), tr("H&ints"), this);
connect(a, SIGNAL(triggered()), this, SLOT(showHint()));
a->setToolTip(tr("Show hints of MGL usage.")); o->addAction(a);
const Fl_Menu_Item *m = popup->popup(Fl::event_x(), Fl::event_y(), 0, 0, 0);
if(m) m->do_callback(wpar, vpar);
}
- else if(gr->get(MGL_SHOW_POS) && !zoom && !rotate && code==FL_PUSH && Fl::event_button()==FL_LEFT_MOUSE)
+ else if(!zoom && !rotate && code==FL_PUSH && Fl::event_button()==FL_LEFT_MOUSE)
{
- mglPoint p = gr->CalcXYZ(Fl::event_x()-x(), Fl::event_y()-y());
- char s[128];
- sprintf(s,"x=%g, y=%g, z=%g",p.x,p.y,p.z);
- draw(); fl_color(FL_BLACK); fl_draw(s,40,70);
+ mglCanvasWnd *g=dynamic_cast<mglCanvasWnd *>(gr);
+ if(g && g->ClickFunc) g->ClickFunc(draw_par);
+ if(gr->get(MGL_SHOW_POS))
+ {
+ mglPoint p = gr->CalcXYZ(Fl::event_x()-x(), Fl::event_y()-y());
+ if(g) g->LastMousePos = p;
+ char s[128];
+ sprintf(s,"x=%g, y=%g, z=%g",p.x,p.y,p.z);
+ draw(); fl_color(FL_BLACK); fl_draw(s,40,70);
+ }
}
else if((!rotate && !zoom) || Fl::event_button()!=FL_LEFT_MOUSE)
{
if(!zoom && !rotate && ev->button()&Qt::LeftButton)
{
mglPoint p = gr->CalcXYZ(ev->x(), ev->y());
+ mglCanvasWnd *g=dynamic_cast<mglCanvasWnd *>(gr);
+ if(g) g->LastMousePos = p;
mousePos.sprintf("x=%g, y=%g, z=%g",p.x,p.y,p.z);
repaint();
+
+ if(g && g->ClickFunc) g->ClickFunc(draw_par);
emit mouseClick(p.x,p.y,p.z);
emit posChanged(mousePos);
emit objChanged(gr->GetObjId(ev->x(),ev->y())-1);
}
}
//-----------------------------------------------------------------------------
-void QMathGL::exportX3D(QString fname)
+/*void QMathGL::exportX3D(QString fname)
{
if(fname.isEmpty()) fname = gr->PlotId.c_str();
if(fname.isEmpty()) QMessageBox::critical(this, appName, tr("No filename."),QMessageBox::Ok,0,0);
mgl_write_x3d(gr,setExtension(fname,"svg").toAscii(), appName.toAscii());
setlocale(LC_NUMERIC, "");
}
-}
+}*/
//-----------------------------------------------------------------------------
void QMathGL::exportTGA(QString fname)
{
{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->Animation(); }\r
void mgl_setup_window(HMGL gr, int clf_upd, int showpos)\r
{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->Setup(clf_upd, showpos); }\r
+void mgl_set_click_func(HMGL gr, void (*func)(void *p))\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ClickFunc = func; }\r
//-----------------------------------------------------------------------------\r
void mgl_wnd_toggle_alpha_(uintptr_t *gr)\r
{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
// mglDraw class handling\r
//\r
//-----------------------------------------------------------------------------\r
-int mgl_draw_class(mglBase *gr, void *p)\r
+int mgl_draw_class(mglBase *gr, void *p) // so stupid way to save mglDraw class inheritance :(\r
{\r
- mglGraph g(gr);\r
- mglWindow *w = (mglWindow *)p; // so stupid way to save mglDraw class inheritance :(\r
+ mglGraph g(gr); mglWindow *w = (mglWindow *)p;\r
return (w && w->dr) ? w->dr->Draw(&g) : 0;\r
}\r
-void mgl_reload_class(void *p)\r
-{\r
- mglWindow *w = (mglWindow *)p; // so stupid way to save mglDraw class inheritance :(\r
- if(w && w->dr) w->dr->Reload();\r
-}\r
+void mgl_reload_class(void *p) // so stupid way to save mglDraw class inheritance :(\r
+{ mglWindow *w = (mglWindow *)p; if(w && w->dr) w->dr->Reload();}\r
+void mgl_click_class(void *p) // so stupid way to save mglDraw class inheritance :(\r
+{ mglWindow *w = (mglWindow *)p; if(w && w->dr) w->dr->Click(); }\r
//-----------------------------------------------------------------------------\r
int mgl_draw_graph(mglBase *gr, void *p)\r
{\r
projects / mathgl.git / commitdiff