-cmake_minimum_required(VERSION 2.8.6)
+cmake_minimum_required(VERSION 2.8.9)
project( MathGL )
set(CMAKE_VERBOSE_MAKEFILE ON)
set(MathGL_VERSION_MAJOR 2)
-set(MathGL_VERSION_MINOR 2.0)
-set(MathGL_SOVERSION 7.1.0)
+set(MathGL_VERSION_MINOR 2.1)
+set(MathGL_SOVERSION 7.2.0)
MACRO(MGL_DEPENDENT_OPTION option doc default depends1 force1 depends2 force2)
option(enable-all-widgets "Enable all Widgets")
option(enable-all-swig "Enable all SWIG based interfaces")
option(enable-pthread "Enable POSIX threads support" OFF)
-option(enable-openmp "Enable POSIX threads support" ON)
+option(enable-openmp "Enable OpenMP support" ON)
option(enable-lgpl "Enable only LGPL part of MathGL")
option(enable-mgl2 "Use names 'libmgl2-*' instead of 'libmgl-*'")
#option(enable-ltdl "Enable loading modules support")
MGL_DEPENDENT_OPTION(enable-glut "Enable glut support" OFF "NOT enable-lgpl" ON "NOT enable-all-widgets" ON)
MGL_DEPENDENT_OPTION(enable-fltk "Enable fltk widget" OFF "NOT enable-lgpl" ON "NOT enable-all-widgets" ON)
CMAKE_DEPENDENT_OPTION(enable-wx "Enable wxWidget widget" OFF "NOT enable-lgpl" OFF)
-MGL_DEPENDENT_OPTION(enable-qt "Enable Qt4 widget" OFF "NOT enable-lgpl" ON "NOT enable-all-widgets" ON)
+MGL_DEPENDENT_OPTION(enable-qt4 "Enable Qt4 widget" OFF "NOT enable-lgpl" ON "NOT enable-all-widgets" ON)
+MGL_DEPENDENT_OPTION(enable-qt5 "Enable Qt5 widget" OFF "NOT enable-lgpl" ON "NOT enable-all-widgets" ON)
+CMAKE_DEPENDENT_OPTION(enable-qt5asqt "Set Qt5 as default libmgl-qt" ON "enable-qt5" OFF)
MGL_DEPENDENT_OPTION(enable-python "Enable python interface" OFF "NOT enable-lgpl" ON "NOT enable-all-swig" ON)
MGL_DEPENDENT_OPTION(enable-lua "Enable Lua (v.5.1) interface" OFF "NOT enable-lgpl" ON "NOT enable-all-swig" ON)
MGL_DEPENDENT_OPTION(enable-octave "Enable octave interface" OFF "NOT enable-lgpl" ON "NOT enable-all-swig" ON)
set(MGL_INCLUDE_PATH "${CMAKE_INSTALL_PREFIX}/include/mgl2")
set(MGL_CGI_PATH "${CMAKE_INSTALL_PREFIX}/share/mathgl" CACHE STRING "Set CGI install directory")
+if(enable-qt4 OR enable-qt5)
+set(enable-qt ON)
+endif(enable-qt4 OR enable-qt5)
+
if(NOT WIN32)
# set(MGL_CGI_PATH "${CMAKE_INSTALL_PREFIX}/share/mathgl")
set(MGL_DATA_PATH "${CMAKE_INSTALL_PREFIX}/share/mathgl")
set(MGL_HAVE_WX 0)
endif(enable-wx)
-if(enable-qt)
- set(MGL_HAVE_QT 1)
- FIND_PACKAGE(Qt4 4.8 REQUIRED QtCore QtGui QtNetwork QtWebKit)
- if(NOT QT4_FOUND)
- message(SEND_ERROR "Couldn't find Qt4 library.")
- endif(NOT QT4_FOUND)
-else(enable-qt)
- set(MGL_HAVE_QT 0)
-endif(enable-qt)
-
if(enable-python)
set(MGL_HAVE_SWIG 1)
set(MGL_HAVE_PYTHON 1)
+ set(Python_ADDITIONAL_VERSIONS 2.7)
FIND_PACKAGE(PythonInterp)
if(NOT PYTHONINTERP_FOUND)
message(SEND_ERROR "Couldn't find python interpreter.")
-2.2 Release 11 November 2013
+2.2.1 Released 22 January 2014
+
+* Add Qt5 support.
+* Add Pascal interface.
+* Improve JavaScript interface.
+* Add function AddRange(char dir, mreal v1, mreal v2) and extend corresponding MGL commands '[xyzc]range'.
+* Add 'hypot' function for known functions in formula parsing.
+* Add style '~' to disable colorbar or axis labels. NOTE, axis style '_' is obsolete and should be replaced by '~'.
+* Change Aspect() if Ax=NAN. Now, Ay and Az set the ratio to optimal aspect (not exact value as previously).
+* Disable changes by View(),Zoom(),Perspective() for position of Title(), Legend(), Colorbar().
+* Partial support of perspective in CalcXYZ().
+* Speed up PDE solving.
+* Add complex versions of PDE, QO2d, QO3d.
+* Correct filled background for Box() in curved coordinates.
+* Allow nx=1 for Stem and Error.
+* Bugfix for drawing single axis.
+* Bugfix for missing options parsing for some of MGL commands.
+* Bugfix for .pmin suffix in MGL. Add mglData::MaximalNeg() and mglData::MinimalPos() functions. Add .nmin and .nmax suffixes.
+* Bugfix for colorbar labels.
+* Force using python 2.7 by default due to bug in Ubuntu. Debian sid works well with python 3.* too.
+* Minor bugfixes and memory leaks.
+
+
+2.2 Released 11 November 2013
* Add OpenMP calls mostly everywhere (can work as replacement of pthreads - a bit faster since more loops is parallelized).
* Greatly speed up consequent FFT and Hankel transforms. Add mgl_clear_fft() function for manual clearing of saved FFT/Hankel data.
--- /dev/null
+set(MGL_HAVE_QT4 1)
+FIND_PACKAGE(Qt4 4.8 REQUIRED QtCore QtGui QtNetwork QtWebKit)
+if(NOT QT4_FOUND)
+ message(SEND_ERROR "Couldn't find Qt4 library.")
+endif(NOT QT4_FOUND)
+include(${QT_USE_FILE})
--- /dev/null
+set(MGL_HAVE_QT5 1)
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Widgets REQUIRED)
+find_package(Qt5Gui REQUIRED)
+find_package(Qt5Network REQUIRED)
+find_package(Qt5WebKit REQUIRED)
+find_package(Qt5PrintSupport REQUIRED)
+if(NOT Qt5Core_FOUND)
+ message(SEND_ERROR "Couldn't find Qt5 Core library.")
+endif(NOT Qt5Core_FOUND)
+if(NOT Qt5Gui_FOUND)
+ message(SEND_ERROR "Couldn't find Qt5 Gui library.")
+endif(NOT Qt5Gui_FOUND)
+if(NOT Qt5Network_FOUND)
+ message(SEND_ERROR "Couldn't find Qt5 Network library.")
+endif(NOT Qt5Network_FOUND)
+if(NOT Qt5WebKit_FOUND)
+ message(SEND_ERROR "Couldn't find Qt5 WebKit library.")
+endif(NOT Qt5WebKit_FOUND)
+if(NOT Qt5PrintSupport_FOUND)
+ message(SEND_ERROR "Couldn't find Qt5 PrintSupport library.")
+endif(NOT Qt5PrintSupport_FOUND)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
target_link_libraries(mgl_wx_example mgl-wx)
endif(MGL_HAVE_WX)
-if(MGL_HAVE_QT)
- include(${QT_USE_FILE})
-# qt_wrap_cpp(mgl_qt_example MGL_MOC_EX_FILES ../include/mgl2/qt.h)
+if(enable-qt)
add_executable(mgl_qt_example wnd_samples.cpp qt_example.cpp ${MGL_MOC_EX_FILES})
- target_link_libraries(mgl_qt_example mgl-qt)
-endif(MGL_HAVE_QT)
+ if(enable-qt5)
+ include(../cmake-qt5.txt)
+ target_link_libraries(mgl_qt_example mgl-qt5)
+ else(enable-qt5)
+ include(../cmake-qt4.txt)
+ target_link_libraries(mgl_qt_example mgl-qt4)
+ endif(enable-qt5)
+endif(enable-qt)
/***************************************************************************\r
* fltk_example.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/***************************************************************************\r
* full_test.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
void smgl_stfa(mglGraph *gr); // STFA sample\r
void smgl_text(mglGraph *gr); // text drawing\r
void smgl_surf(mglGraph *gr);\r
+#include <mgl2/base.h>\r
+#include <mgl2/font.h>\r
void test(mglGraph *gr)\r
{\r
mglParse par;\r
setlocale(LC_CTYPE, "");\r
-// par.Execute(gr,"axis");\r
- par.Execute(gr,"axis 'lg(x)' '' '':axis:box:fplot 'x^2'");\r
+ par.Execute(gr,"box\r\n\r\naxis");\r
}\r
//-----------------------------------------------------------------------------\r
#if !defined(_MSC_VER) && !defined(__BORLANDC__)\r
/***************************************************************************\r
* glut_example.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/***************************************************************************\r
* qt_example.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/***************************************************************************
* samples.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* 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 *
}
//-----------------------------------------------------------------------------
const char *mmgl_refill="new x 10 '0.5+rnd':cumsum x 'x':norm x -1 1\n"
-"copy y sin(pi*x)/2\nbox:axis:plot x y 'o '\n"
+"copy y sin(pi*x)/2\ntitle 'Refill sample'\nbox:axis:plot x y 'o '\n"
"new r 100:refill r x y\nplot r 'r'\nfplot 'sin(pi*x)/2' 'B:'";
void smgl_refill(mglGraph *gr)
{
mglData x(10), y(10), r(100);
x.Modify("0.5+rnd"); x.CumSum("x"); x.Norm(-1,1);
y.Modify("sin(pi*v)/2",x);
+ if(big!=3) gr->Title("Refill sample");
gr->Axis(); gr->Box(); gr->Plot(x,y,"o ");
gr->Refill(r,x,y); // or you can use r.Refill(x,y,-1,1);
gr->Plot(r,"r"); gr->FPlot("sin(pi*x)/2","B:");
/***************************************************************************\r
* wnd_sample.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/***************************************************************************\r
* wx_example.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/***************************************************************************
* thread.h is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
//-----------------------------------------------------------------------------
class mglBase;
class mglData;
+class mglDataC;
class mglParser;
class mglFormula;
class mglFormulaC;
class mglFont;
typedef mglBase* HMGL;
typedef mglData* HMDT;
+typedef mglDataC* HADT;
typedef mglParser* HMPR;
typedef mglFormula* HMEX;
typedef mglFormulaC* HAEX;
#else
typedef void *HMGL;
typedef void *HMDT;
+typedef void *HADT;
typedef void *HMEX;
typedef void *HAEX;
typedef void *HMPR;
/***************************************************************************
* addon.h is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
#include "mgl2/define.h"
#ifdef __cplusplus
//-----------------------------------------------------------------------------
-/// Get integer power of x
-dual MGL_EXPORT mgl_ipowc(dual x,int n);
-/// Get exp(i*a)
-dual MGL_EXPORT mgl_expi(dual a);
-/// Get exp(i*a)
-dual MGL_EXPORT mgl_expi(double a);
-
/// Explicit scheme for 1 step of axial diffraction
-bool MGL_EXPORT mgl_difr_axial(dual *a, int n, dual q, int Border,dual *b, dual *d, int kk, double di);
+int MGL_EXPORT mgl_difr_axial(dual *a, int n, dual q, int Border,dual *b, dual *d, int kk, double di);
/// Explicit scheme for 1 step of plane diffraction
-bool MGL_EXPORT mgl_difr_grid(dual *a,int n,dual q,int Border,dual *b,dual *d,int kk);
+int MGL_EXPORT mgl_difr_grid(dual *a,int n,dual q,int Border,dual *b,dual *d,int kk);
//-----------------------------------------------------------------------------
extern "C" {
#endif
-/// Set seed for random numbers
-void MGL_EXPORT mgl_srnd(long seed);
-/// Get random number
-double MGL_EXPORT mgl_rnd();
-/// Get integer power of x
-double MGL_EXPORT mgl_ipow(double x,int n);
-
/// Get random number with Gaussian distribution
double MGL_EXPORT mgl_gauss_rnd();
/// Fill frequencies for FFT
/***************************************************************************\r
* base.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
{\r
mreal b[9];\r
mreal x,y,z,pf;\r
+ bool norot; // flag to disable pnts rotation\r
mglMatrix() { clear(); }\r
void Rotate(mreal tetz,mreal tetx,mreal tety);\r
void RotateN(mreal Tet,mreal x,mreal y,mreal z);\r
- inline void clear() { x=y=z=0; memset(b,0,9*sizeof(mreal)); b[0]=b[4]=b[8]=1; }\r
+ inline void clear() { x=y=z=pf=0; memset(b,0,9*sizeof(mreal)); b[0]=b[4]=b[8]=1; norot=false; }\r
inline mglMatrix &operator=(const mglMatrix &a)\r
- { x=a.x; y=a.y; z=a.z; pf=a.pf; memcpy(b,a.b,9*sizeof(mreal)); return *this; }\r
+ { x=a.x; y=a.y; z=a.z; pf=a.pf; memcpy(b,a.b,9*sizeof(mreal)); norot=false; return *this; }\r
};\r
inline bool operator==(const mglMatrix &a, const mglMatrix &b)\r
{ return b.x==a.x&&b.y==a.y&&b.z==a.z&&b.pf==a.pf&&!memcmp(b.b,a.b,9*sizeof(mreal));}\r
struct MGL_EXPORT mglGroup\r
{\r
std::vector<long> p; ///< list of primitives (not filled!!!)\r
- int Id; ///< Current list of primitives\r
+ int Id; ///< Current list of primitives\r
std::string Lbl; ///< Group label\r
mglGroup(const char *lbl="", int id=0) { Lbl=lbl; Id=id; }\r
};\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=ta=u=v=w=r=g=b=a=0; }\r
+ short sub; // subplot id and rotation information (later will be in subplot)\r
+ mglPnt() { xx=yy=zz=x=y=z=c=t=ta=u=v=w=r=g=b=a=sub=0; }\r
};\r
inline mglPnt operator+(const mglPnt &a, const mglPnt &b)\r
{ mglPnt c=a;\r
/// Structure active points\r
struct MGL_EXPORT mglActivePos\r
{\r
- int x,y; ///< coordinates of active point\r
+ int x,y; ///< coordinates of active point\r
int id; ///< object id for active point\r
int n; ///< position of active point in command (object id)\r
};\r
void SetRanges(mglPoint v1, mglPoint v2);\r
/// Set values of mglGraph::Cmin and mglGraph::Cmax as minimal and maximal values of data a\r
void CRange(HCDT a, bool add = false, mreal fact=0);\r
- inline void CRange(mreal v1,mreal v2) { if(v1!=v2) {OMin.c=Min.c=v1; OMax.c=Max.c=v2; RecalcCRange();} }\r
+ void CRange(mreal v1,mreal v2,bool add=false);\r
/// Set values of mglGraph::Min.x and mglGraph::Max.x as minimal and maximal values of data a\r
void XRange(HCDT a, bool add = false, mreal fact=0);\r
- inline void XRange(mreal v1,mreal v2) { if(v1!=v2) {OMin.x=Min.x=v1; OMax.x=Max.x=v2; RecalcBorder();} }\r
+ void XRange(mreal v1,mreal v2,bool add=false);\r
/// Set values of mglGraph::Min.x and mglGraph::Max.x as minimal and maximal values of data a\r
void YRange(HCDT a, bool add = false, mreal fact=0);\r
- inline void YRange(mreal v1,mreal v2) { if(v1!=v2) {OMin.y=Min.y=v1; OMax.y=Max.y=v2; RecalcBorder();} }\r
+ void YRange(mreal v1,mreal v2,bool add=false);\r
/// Set values of mglGraph::Min.x and mglGraph::Max.x as minimal and maximal values of data a\r
void ZRange(HCDT a, bool add = false, mreal fact=0);\r
- inline void ZRange(mreal v1,mreal v2) { if(v1!=v2) {OMin.z=Min.z=v1; OMax.z=Max.z=v2; RecalcBorder();} }\r
+ void ZRange(mreal v1,mreal v2,bool add=false);\r
/// Set ranges for automatic variables\r
void SetAutoRanges(mreal x1, mreal x2, mreal y1=0, mreal y2=0, mreal z1=0, mreal z2=0, mreal c1=0, mreal c2=0);\r
/// Set axis origin\r
/***************************************************************************\r
* base_cf.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
void MGL_EXPORT mgl_set_rdc_acc_(uintptr_t *gr, int *reduce);\r
\r
/// Start group of objects\r
-void MGL_EXPORT mgl_start_group(HMGL gr, const char *);\r
-void MGL_EXPORT mgl_start_group_(uintptr_t *gr, const char *,int);\r
+void MGL_EXPORT mgl_start_group(HMGL gr, const char *name);\r
+void MGL_EXPORT mgl_start_group_(uintptr_t *gr, const char *name,int);\r
/// End group of objects\r
void MGL_EXPORT mgl_end_group(HMGL gr);\r
void MGL_EXPORT mgl_end_group_(uintptr_t *gr);\r
/// Set range in direction dir as [v1, v2]\r
void MGL_EXPORT mgl_set_range_val(HMGL gr, char dir, double v1,double v2);\r
void MGL_EXPORT mgl_set_range_val_(uintptr_t *gr, const char *dir, mreal *v1, mreal *v2,int);\r
+/// Add [v1, v2] to the current range in direction dir\r
+void MGL_EXPORT mgl_add_range_val(HMGL gr, char dir, double v1,double v2);\r
+void MGL_EXPORT mgl_add_range_val_(uintptr_t *gr, const char *dir, mreal *v1, mreal *v2,int);\r
/// Set range in direction dir as minimal and maximal values of data a\r
void MGL_EXPORT mgl_set_range_dat(HMGL gr, char dir, HCDT a, int add);\r
void MGL_EXPORT mgl_set_range_dat_(uintptr_t *gr, const char *dir, uintptr_t *a, int *add,int);\r
/***************************************************************************\r
* canvas.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
mglMatrix Bt; ///< temporary matrix for text\r
\r
/// Draw generic colorbar\r
- void colorbar(HCDT v, const mreal *s, int where, mreal x, mreal y, mreal w, mreal h);\r
+ void colorbar(HCDT v, const mreal *s, int where, mreal x, mreal y, mreal w, mreal h, bool text);\r
/// Draw labels for ticks\r
- void DrawLabels(mglAxis &aa, bool inv=false);\r
+ void DrawLabels(mglAxis &aa, bool inv=false, const mglMatrix *M=0);\r
/// Get label style\r
char GetLabelPos(mreal c, long kk, mglAxis &aa);\r
/// Draw tick\r
/***************************************************************************\r
* canvas_cf.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
void MGL_EXPORT mgl_set_def_param(HMGL gr);\r
void MGL_EXPORT mgl_set_def_param_(uintptr_t *gr);\r
/// Combine plots from 2 canvases. Result will be saved into gr\r
-void MGL_EXPORT mgl_combine_gr(HMGL gr, HMGL in);\r
-void MGL_EXPORT mgl_combine_gr_(uintptr_t *gr, uintptr_t *in);\r
+void MGL_EXPORT mgl_combine_gr(HMGL gr, HMGL gr2);\r
+void MGL_EXPORT mgl_combine_gr_(uintptr_t *gr, uintptr_t *gr2);\r
/// Force preparing the image. It can be useful for OpenGL mode mostly.\r
void MGL_EXPORT mgl_finish(HMGL gr);\r
void MGL_EXPORT mgl_finish_(uintptr_t *gr);\r
void MGL_EXPORT mgl_del_frame_(uintptr_t *gr, int *i);\r
\r
/// Set the transparency type (0 - usual, 1 - glass, 2 - lamp)\r
-void MGL_EXPORT mgl_set_transp_type(HMGL gr, int type);\r
-void MGL_EXPORT mgl_set_transp_type_(uintptr_t *gr, int *type);\r
+void MGL_EXPORT mgl_set_transp_type(HMGL gr, int kind);\r
+void MGL_EXPORT mgl_set_transp_type_(uintptr_t *gr, int *kind);\r
/// Set the transparency on/off.\r
void MGL_EXPORT mgl_set_alpha(HMGL gr, int enable);\r
void MGL_EXPORT mgl_set_alpha_(uintptr_t *gr, int *enable);\r
uintptr_t MGL_EXPORT mgl_parser_calc_(uintptr_t *pr, const char *formula,int);\r
HMDT MGL_EXPORT mgl_parser_calcw(HMPR pr, const wchar_t *formula);\r
\r
-//-----------------------------------------------------------------------------\r
-/// Create HMEX object for expression evaluating\r
-HMEX MGL_EXPORT mgl_create_expr(const char *expr);\r
-uintptr_t MGL_EXPORT mgl_create_expr_(const char *expr, int);\r
-HAEX MGL_EXPORT mgl_create_cexpr(const char *expr);\r
-/// Delete HMEX object\r
-void MGL_EXPORT mgl_delete_expr(HMEX ex);\r
-void MGL_EXPORT mgl_delete_expr_(uintptr_t *ex);\r
-void MGL_EXPORT mgl_delete_cexpr(HAEX ex);\r
-/// Return value of expression for given x,y,z variables\r
-double MGL_EXPORT mgl_expr_eval(HMEX ex, double x, double y,double z);\r
-double MGL_EXPORT mgl_eval_expr_(uintptr_t *ex, mreal *x, mreal *y, mreal *z);\r
-dual MGL_EXPORT mgl_cexpr_eval(HAEX ex, dual x, dual y,dual z);\r
-/// Return value of expression for given variables\r
-double MGL_EXPORT mgl_expr_eval_v(HMEX ex, mreal *var);\r
-dual MGL_EXPORT mgl_cexpr_eval_v(HAEX ex, dual *var);\r
-/// Return value of expression differentiation over variable dir for given x,y,z variables\r
-double MGL_EXPORT mgl_expr_diff(HMEX ex, char dir, double x, double y,double z);\r
-double MGL_EXPORT mgl_diff_expr_(uintptr_t *ex, const char *dir, mreal *x, mreal *y, mreal *z, int);\r
-/// Return value of expression differentiation over variable dir for given variables\r
-double MGL_EXPORT mgl_expr_diff_v(HMEX ex, char dir, mreal *var);\r
-\r
#ifdef __cplusplus\r
}\r
#endif\r
/***************************************************************************\r
* window.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* cont.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* data.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
inline mreal Maximal() const { return mgl_data_max(this); }\r
/// Get minimal value of the data\r
inline mreal Minimal() const { return mgl_data_min(this); }\r
+ /// Get maximal value of the data which is less than 0\r
+ inline mreal MaximalNeg() const { return mgl_data_neg_max(this); }\r
+ /// Get minimal value of the data which is larger than 0\r
+ inline mreal MinimalPos() const { return mgl_data_pos_min(this); }\r
/// Get maximal value of the data and its position\r
inline mreal Maximal(long &i,long &j,long &k) const\r
{ return mgl_data_max_int(this,&i,&j,&k); }\r
inline mglData mglTriangulation(const mglDataA &x, const mglDataA &y)\r
{ return mglData(true,mgl_triangulation_2d(&x,&y)); }\r
//-----------------------------------------------------------------------------\r
+/// Wrapper class expression evaluating\r
+class MGL_EXPORT mglExpr\r
+{\r
+ HMEX ex;\r
+public:\r
+ mglExpr(const char *expr) { ex = mgl_create_expr(expr); }\r
+ ~mglExpr() { mgl_delete_expr(ex); }\r
+ /// Return value of expression for given x,y,z variables\r
+ inline double Eval(double x, double y=0, double z=0)\r
+ { return mgl_expr_eval(ex,x,y,z); }\r
+ /// Return value of expression differentiation over variable dir for given x,y,z variables\r
+ inline double Diff(char dir, double x, double y=0, double z=0)\r
+ { return mgl_expr_diff(ex,dir, x,y,z); }\r
+#ifndef SWIG\r
+ /// Return value of expression for given variables\r
+ inline double Eval(mreal var[26])\r
+ { return mgl_expr_eval_v(ex,var); }\r
+ /// Return value of expression differentiation over variable dir for given variables\r
+ inline double Diff(char dir, mreal var[26])\r
+ { return mgl_expr_diff_v(ex,dir, var); }\r
+#endif\r
+};\r
+//-----------------------------------------------------------------------------\r
+#ifndef SWIG\r
+/// Structure for handling named mglData (used by mglParse class).\r
+class MGL_EXPORT mglVar : public mglData\r
+{\r
+public:\r
+ std::wstring s; ///< Data name\r
+ void *o; ///< Pointer to external object\r
+ mglVar *next; ///< Pointer to next instance in list\r
+ mglVar *prev; ///< Pointer to previous instance in list\r
+ bool temp; ///< This is temporary variable\r
+ void (*func)(void *); ///< Callback function for destroying\r
+\r
+ mglVar(std::wstring name=L""):mglData()\r
+ { o=0; next=prev=0; func=0; temp=false; s=name; }\r
+ mglVar(mglVar **head, std::wstring name=L""):mglData()\r
+ { o=0; next=*head; prev=0; *head=this; func=0; temp=false; s=name; }\r
+ mglVar(mglVar **head, const mglData &dat, std::wstring name):mglData(dat)\r
+ { o=0; next=*head; prev=0; *head=this; func=0; temp=false; s=name; }\r
+ mglVar(mglVar **head, HCDT dat, std::wstring name):mglData(dat)\r
+ { o=0; next=*head; prev=0; *head=this; func=0; temp=false; s=name; }\r
+ mglVar(mglVar *v, std::wstring name, bool link=true):mglData() // NOTE: use carefully due to Link()!\r
+ { if(!v) throw mglWarnZero;\r
+ if(link) Link(*v); else Set(*v);\r
+ o=0; temp=false; s=name; func = v->func;\r
+ prev = v; next = v->next; v->next = this;\r
+ if(next) next->prev = this; }\r
+ virtual ~mglVar()\r
+ {\r
+ if(func) func(o);\r
+ if(prev) prev->next = next;\r
+ if(next) next->prev = prev;\r
+ }\r
+ /// Make copy which link on the same data but have different name. NOTE: use carefully due to Link()!\r
+ inline void Duplicate(std::wstring name)\r
+ { mglVar *v=new mglVar(name); v->Link(*this); v->MoveAfter(this); }\r
+ /// Move variable after var and copy func from var (if func is 0)\r
+ inline void MoveAfter(mglVar *var)\r
+ {\r
+ if(prev) prev->next = next;\r
+ if(next) next->prev = prev;\r
+ prev = next = 0;\r
+ if(var)\r
+ {\r
+ prev = var; next = var->next;\r
+ var->next = this;\r
+ if(func==0) func = var->func;\r
+ }\r
+ if(next) next->prev = this;\r
+ }\r
+};\r
+#endif\r
+//-----------------------------------------------------------------------------\r
#endif\r
#endif\r
/***************************************************************************\r
* data_cf.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
int MGL_EXPORT mgl_data_read_dim(HMDT dat, const char *fname,long mx,long my,long mz);\r
int MGL_EXPORT mgl_data_read_dim_(uintptr_t *dat, const char *fname,int *mx,int *my,int *mz,int);\r
/// Read data from tab-separated text files with auto determining size which filenames are result of sprintf(fname,templ,t) where t=from:step:to\r
-int MGL_EXPORT mgl_data_read_range(HMDT d, const char *templ, double from, double to, double step, int as_slice);\r
-int MGL_EXPORT mgl_data_read_range_(uintptr_t *d, const char *fname, mreal *from, mreal *to, mreal *step, int *as_slice,int l);\r
+int MGL_EXPORT mgl_data_read_range(HMDT d, const char *templ, double n1, double n2, double step, int as_slice);\r
+int MGL_EXPORT mgl_data_read_range_(uintptr_t *d, const char *fname, mreal *n1, mreal *n2, mreal *step, int *as_slice,int l);\r
/// Read data from tab-separated text files with auto determining size which filenames are satisfied to template (like "t_*.dat")\r
int MGL_EXPORT mgl_data_read_all(HMDT dat, const char *templ, int as_slice);\r
int MGL_EXPORT mgl_data_read_all_(uintptr_t *d, const char *fname, int *as_slice,int l);\r
/// Get maximal value of the data\r
mreal MGL_EXPORT mgl_data_max(HCDT dat);\r
mreal MGL_EXPORT mgl_data_max_(uintptr_t *dat);\r
+/// Get maximal value of the data which is less than 0\r
+mreal MGL_EXPORT mgl_data_neg_max(HCDT dat);\r
+mreal MGL_EXPORT mgl_data_neg_max_(uintptr_t *dat);\r
/// Get minimal value of the data\r
mreal MGL_EXPORT mgl_data_min(HCDT dat);\r
mreal MGL_EXPORT mgl_data_min_(uintptr_t *dat);\r
+/// Get minimal value of the data which is larger than 0\r
+mreal MGL_EXPORT mgl_data_pos_min(HCDT dat);\r
+mreal MGL_EXPORT mgl_data_pos_min_(uintptr_t *dat);\r
/// Returns pointer to data element [i,j,k]\r
MGL_EXPORT mreal *mgl_data_value(HMDT dat, long i,long j,long k);\r
/// Returns pointer to internal data array\r
/// Find root for nonlinear equation\r
mreal MGL_EXPORT mgl_find_root(mreal (*func)(mreal val, void *par), mreal ini, void *par);\r
/// Find root for nonlinear equation defined by textual formula\r
-mreal MGL_EXPORT mgl_find_root_txt(const char *func, mreal ini, char var);\r
-mreal MGL_EXPORT mgl_find_root_txt_(const char *func, mreal *ini, const char *var,int,int);\r
+mreal MGL_EXPORT mgl_find_root_txt(const char *func, mreal ini, char var_id);\r
+mreal MGL_EXPORT mgl_find_root_txt_(const char *func, mreal *ini, const char *var_id,int,int);\r
/// Find roots for nonlinear equation defined by textual formula\r
-HMDT MGL_EXPORT mgl_data_roots(const char *func, HCDT ini, char var);\r
-uintptr_t MGL_EXPORT mgl_data_roots_(const char *func, uintptr_t *ini, const char *var,int,int);\r
+HMDT MGL_EXPORT mgl_data_roots(const char *func, HCDT ini, char var_id);\r
+uintptr_t MGL_EXPORT mgl_data_roots_(const char *func, uintptr_t *ini, const char *var_id,int,int);\r
+\r
+//-----------------------------------------------------------------------------\r
+/// Create HMEX object for expression evaluating\r
+HMEX MGL_EXPORT mgl_create_expr(const char *expr);\r
+uintptr_t MGL_EXPORT mgl_create_expr_(const char *expr, int);\r
+/// Delete HMEX object\r
+void MGL_EXPORT mgl_delete_expr(HMEX ex);\r
+void MGL_EXPORT mgl_delete_expr_(uintptr_t *ex);\r
+/// Return value of expression for given x,y,z variables\r
+double MGL_EXPORT mgl_expr_eval(HMEX ex, double x, double y,double z);\r
+double MGL_EXPORT mgl_eval_expr_(uintptr_t *ex, mreal *x, mreal *y, mreal *z);\r
+/// Return value of expression for given variables\r
+double MGL_EXPORT mgl_expr_eval_v(HMEX ex, mreal *vars);\r
+/// Return value of expression differentiation over variable dir for given x,y,z variables\r
+double MGL_EXPORT mgl_expr_diff(HMEX ex, char dir, double x, double y,double z);\r
+double MGL_EXPORT mgl_diff_expr_(uintptr_t *ex, const char *dir, mreal *x, mreal *y, mreal *z, int);\r
+/// Return value of expression differentiation over variable dir for given variables\r
+double MGL_EXPORT mgl_expr_diff_v(HMEX ex, char dir, mreal *vars);\r
\r
#ifdef __cplusplus\r
}\r
/***************************************************************************\r
* data.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
dual mglSpline3C(const dual *a, long nx, long ny, long nz, mreal x, mreal y, mreal z,dual *dx=0, dual *dy=0, dual *dz=0);\r
#endif\r
//-----------------------------------------------------------------------------\r
+/// Saves result of PDE solving (|u|^2) for "Hamiltonian" ham with initial conditions ini\r
+inline mglDataC mglPDEc(mglBase *gr, const char *ham, const mglDataA &ini_re, const mglDataA &ini_im, mreal dz=0.1, mreal k0=100,const char *opt="")\r
+{ return mglDataC(true, mgl_pde_solve_c(gr,ham, &ini_re, &ini_im, dz, k0,opt)); }\r
+/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)\r
+inline mglDataC mglQO2dc(const char *ham, const mglDataA &ini_re, const mglDataA &ini_im, const mglDataA &ray, mreal r=1, mreal k0=100)\r
+{ return mglDataC(true, mgl_qo2d_solve_c(ham, &ini_re, &ini_im, &ray, r, k0, 0, 0)); }\r
+inline mglDataC mglQO2dc(const char *ham, const mglDataA &ini_re, const mglDataA &ini_im, const mglDataA &ray, mglData &xx, mglData &yy, mreal r=1, mreal k0=100)\r
+{ return mglDataC(true, mgl_qo2d_solve_c(ham, &ini_re, &ini_im, &ray, r, k0, &xx, &yy)); }\r
+/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)\r
+inline mglDataC mglQO3dc(const char *ham, const mglDataA &ini_re, const mglDataA &ini_im, const mglDataA &ray, mreal r=1, mreal k0=100)\r
+{ return mglDataC(true, mgl_qo3d_solve_c(ham, &ini_re, &ini_im, &ray, r, k0, 0, 0, 0)); }\r
+inline mglDataC mglQO3dc(const char *ham, const mglDataA &ini_re, const mglDataA &ini_im, const mglDataA &ray, mglData &xx, mglData &yy, mglData &zz, mreal r=1, mreal k0=100)\r
+{ return mglDataC(true, mgl_qo3d_solve_c(ham, &ini_re, &ini_im, &ray, r, k0, &xx, &yy, &zz)); }\r
+//-----------------------------------------------------------------------------\r
#define _DN_(a) ((mglDataC *)*(a))\r
#define _DC_ ((mglDataC *)*d)\r
//-----------------------------------------------------------------------------\r
+#ifndef SWIG\r
+/// Wrapper class expression evaluating\r
+class MGL_EXPORT mglExprC\r
+{\r
+ HAEX ex;\r
+public:\r
+ mglExprC(const char *expr) { ex = mgl_create_cexpr(expr); }\r
+ ~mglExprC() { mgl_delete_cexpr(ex); }\r
+ /// Return value of expression for given x,y,z variables\r
+ inline dual Eval(dual x, dual y=0, dual z=0)\r
+ { return mgl_cexpr_eval(ex,x,y,z); }\r
+ /// Return value of expression for given x,y,z,u,v,w variables\r
+ inline dual Eval(dual x, dual y, dual z, dual u, dual v, dual w)\r
+ {\r
+ dual var[26];\r
+ var['x'-'a']=x; var['y'-'a']=y; var['z'-'a']=z;\r
+ var['u'-'a']=u; var['v'-'a']=v; var['w'-'a']=w;\r
+ return mgl_cexpr_eval_v(ex,var); }\r
+ /// Return value of expression for given variables\r
+ inline dual Eval(dual var[26])\r
+ { return mgl_cexpr_eval_v(ex,var); }\r
+};\r
+#endif\r
+//-----------------------------------------------------------------------------\r
#endif\r
#endif\r
/***************************************************************************\r
* data_cf.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
typedef void *HADT;\r
#endif\r
\r
+/// Set seed for random numbers\r
+void MGL_EXPORT mgl_srnd(long seed);\r
+/// Get random number\r
+double MGL_EXPORT mgl_rnd();\r
+/// Get integer power of x\r
+dual MGL_EXPORT mgl_ipowc(dual x,int n);\r
+/// Get exp(i*a)\r
+dual MGL_EXPORT mgl_expi(dual a);\r
+\r
/// Create HMDT object\r
HADT MGL_EXPORT mgl_create_datac();\r
uintptr_t MGL_EXPORT mgl_create_datac_();\r
int MGL_EXPORT mgl_datac_read_dim_(uintptr_t *dat, const char *fname,int *mx,int *my,int *mz,int);\r
/// Read data from tab-separated text files with auto determining size which filenames are result of sprintf(fname,templ,t) where t=from:step:to\r
int MGL_EXPORT mgl_datac_read_range(HADT d, const char *templ, double from, double to, double step, int as_slice);\r
-int MGL_EXPORT mgl_data_read_range_(uintptr_t *d, const char *fname, mreal *from, mreal *to, mreal *step, int *as_slice,int l);\r
+int MGL_EXPORT mgl_datac_read_range_(uintptr_t *d, const char *fname, mreal *from, mreal *to, mreal *step, int *as_slice,int l);\r
/// Read data from tab-separated text files with auto determining size which filenames are satisfied to template (like "t_*.dat")\r
int MGL_EXPORT mgl_datac_read_all(HADT dat, const char *templ, int as_slice);\r
int MGL_EXPORT mgl_data_read_all_(uintptr_t *d, const char *fname, int *as_slice,int l);\r
dual MGL_EXPORT mgl_datac_spline_ext(HCDT dat, mreal x,mreal y,mreal z, dual *dx,dual *dy,dual *dz);\r
dual MGL_EXPORT mgl_datac_spline_ext_(uintptr_t *dat, mreal *x,mreal *y,mreal *z, dual *dx,dual *dy,dual *dz);\r
\r
+//-----------------------------------------------------------------------------\r
+/// Create HAEX object for expression evaluating\r
+HAEX MGL_EXPORT mgl_create_cexpr(const char *expr);\r
+/// Delete HAEX object\r
+void MGL_EXPORT mgl_delete_cexpr(HAEX ex);\r
+/// Return value of expression for given x,y,z variables\r
+dual MGL_EXPORT mgl_cexpr_eval(HAEX ex, dual x, dual y,dual z);\r
+/// Return value of expression for given variables\r
+dual MGL_EXPORT mgl_cexpr_eval_v(HAEX ex, dual *vars);\r
+\r
#ifdef __cplusplus\r
}\r
#endif\r
/***************************************************************************\r
* define.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
#endif\r
#endif\r
\r
-#define MGL_VER2 2.0 // minor version of MathGL 2.* (like 1.3 for v.2.1.3)\r
+#define MGL_VER2 2.1 // minor version of MathGL 2.* (like 1.3 for v.2.1.3)\r
//-----------------------------------------------------------------------------\r
#ifdef WIN32 //_MSC_VER needs this before math.h\r
#define _USE_MATH_DEFINES\r
/***************************************************************************\r
* eval.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* evalc.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* fit.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
//-----------------------------------------------------------------------------\r
extern int mglFitPnts; ///< Number of output points in fitting\r
extern char mglFitRes[1024]; ///< Last fitted formula\r
-HMDT MGL_EXPORT mgl_fit_1(HMGL gr, HCDT y, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_2(HMGL gr, HCDT z, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_3(HMGL gr, HCDT a, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_xy(HMGL gr, HCDT x, HCDT y, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_xyza(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_ys(HMGL gr, HCDT y, HCDT s, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_xys(HMGL gr, HCDT x, HCDT y, HCDT s, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_xyzs(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT s, const char *eq, const char *var, HMDT ini, const char *opt);\r
-HMDT MGL_EXPORT mgl_fit_xyzas(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, HCDT s, const char *eq, const char *var, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_1(HMGL gr, HCDT y, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_2(HMGL gr, HCDT z, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_3(HMGL gr, HCDT a, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_xy(HMGL gr, HCDT x, HCDT y, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_xyza(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_ys(HMGL gr, HCDT y, HCDT s, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_xys(HMGL gr, HCDT x, HCDT y, HCDT s, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_xyzs(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT s, const char *eq, const char *vars, HMDT ini, const char *opt);\r
+HMDT MGL_EXPORT mgl_fit_xyzas(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, HCDT s, const char *eq, const char *vars, HMDT ini, const char *opt);\r
\r
MGL_EXPORT const char *mgl_get_fit(HMGL gr);\r
\r
\r
void MGL_EXPORT mgl_puts_fit(HMGL gr, double x, double y, double z, const char *prefix, const char *font, double size);\r
//-----------------------------------------------------------------------------\r
-uintptr_t MGL_EXPORT mgl_fit_1_(uintptr_t* gr, uintptr_t* y, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_2_(uintptr_t* gr, uintptr_t* z, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_3_(uintptr_t* gr, uintptr_t* a, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_xy_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_xyz_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_xyza_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_ys_(uintptr_t* gr, uintptr_t* y, uintptr_t* ss, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_xys_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* ss, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_xyzs_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* ss, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-uintptr_t MGL_EXPORT mgl_fit_xyzas_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, uintptr_t* ss, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_1_(uintptr_t* gr, uintptr_t* y, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_2_(uintptr_t* gr, uintptr_t* z, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_3_(uintptr_t* gr, uintptr_t* a, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_xy_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_xyz_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_xyza_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_ys_(uintptr_t* gr, uintptr_t* y, uintptr_t* ss, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_xys_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* ss, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_xyzs_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* ss, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
+uintptr_t MGL_EXPORT mgl_fit_xyzas_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, uintptr_t* ss, const char *eq, const char *vars, uintptr_t *ini, const char *opt,int, int l, int n);\r
\r
uintptr_t MGL_EXPORT mgl_hist_x_(uintptr_t* gr, uintptr_t* x, uintptr_t* a, const char *opt,int);\r
uintptr_t MGL_EXPORT mgl_hist_xy_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* a, const char *opt,int);\r
/***************************************************************************\r
* window.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* font.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* glut.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
--- /dev/null
+\ GNU Scientific Library interface Mon Sep 12 14:40:15 MDT 2005
+\ Copyright (C) 2007, Sergey Plis
+\
+\ 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.
+
+\needs float import float
+warning off
+\needs locals| include locals.fs
+warning on
+\needs atlas include atlas.fs
+\needs callback include callback.fs
+\needs vectors include vectors.fs
+\needs complex include complex.fb
+
+Module GSL
+
+\ stole the hash function from hash.fs of bigforth
+| &14 Value Hashbits
+| 1 Hashbits << Value Hashlen
+
+Label (hash ( SI:string -- AX:key ) :R DX push
+ .b lods $1F # AX and AX CX mov DX DX xor CX 1 # shr
+ b IF SI ) AH mov SI inc THEN CX dec
+ 0>= IF BEGIN .w SI ) DX mov 2 # SI add CX dec
+ DX AX *2 I) AX lea 0< UNTIL THEN
+ & Hashbits A#) CX mov AX DX mov AX shr DX AX add
+ & Hashlen A#) CX mov CX dec CX AX and DX pop ret
+| Code Hash ( string -- key )
+ R: SI push AX SI mov (hash rel) call SI pop
+ Next end-code
+
+also dos also complex also float also atlas also vectors
+
+s" libptcblas.so" getlib 0<>
+[IF]
+ library libblas libptcblas.so depends libatlas
+[ELSE]
+ library libblas libcblas.so depends libatlas
+[THEN]
+
+library libgsl libgsl.so.0 depends libblas
+
+legacy off
+
+\ some functions
+libgsl gsl_log1p df (fp) gsl_log1p ( df -- df )
+libgsl gsl_acosh df (fp) gsl_acosh ( df -- df )
+
+\ error handling Wed Sep 21 23:04:06 MDT 2005
+libgsl gsl_set_error_handler ptr (int) gsl_set_error_handler
+( function -- function )
+libgsl gsl_strerror int (ptr) gsl_strerror
+
+callback 4:0 (void) int int int int callback;
+: cstr-fstr ( addr -- addr len )
+ 0
+ begin 2dup + c@ 0 = not while
+ 1+
+ repeat ;
+
+| : .bold-red ." \e[1;31;40m" ;
+| : .red ." \e[2;31;40m" ;
+| : .reset ." \e[0;37;40m" ;
+| : cb-test
+ cr
+ \ .bold-red
+ ." GSL ERROR: " cr
+ \ .reset cr
+ 10 spaces gsl_strerror cstr-fstr type cr
+ drop \ ." at line: " . cr
+ drop \ ." of file: " cstr-fstr type cr
+ 10 spaces cstr-fstr type cr
+ \ .red
+ -1 abort" failed at" ;
+' cb-test 4:0 c_plus
+
+\ 1 2 c_plus 2:1call .
+| variable old_handler
+c_plus gsl_set_error_handler old_handler !
+
+0 Constant GSL_SUCCESS
+
+\ random number generation Mon Sep 12 22:06:01 MDT 2005
+
+libgsl gsl_rng_types_setup (ptr) gsl_rng_types_setup ( -- *gsl_rng_type)
+libgsl gsl_rng_env_setup (ptr) gsl_rng_env_setup ( -- *gsl_rng)
+libgsl gsl_rng_alloc int (int) gsl_rng_alloc ( *gsl_rng_type -- *gsl_rng )
+libgsl gsl_rng_name int (int) gsl_rng_name ( *gsl_rng -- string )
+libgsl gsl_rng_set int int (void) gsl_rng_set ( *gsl_rng int -- )
+libgsl gsl_rng_uniform int (fp) gsl_rng_uniform ( *gsl_rng -- df )
+libgsl gsl_rng_uniform_pos int (fp) gsl_rng_uniform_pos ( *gsl_rng -- df )
+libgsl gsl_rng_uniform_int int int (int) gsl_rng_uniform_int ( *gsl_rng n --n )
+libgsl gsl_rng_get int (int) gsl_rng_get ( *gsl_rng -- int )
+libgsl gsl_rng_max int (int) gsl_rng_max ( *gsl_rng -- int )
+libgsl gsl_rng_min int (int) gsl_rng_min ( *gsl_rng -- int )
+libgsl gsl_rng_clone int (int) gsl_rng_clone ( *gsl_rng -- *gsl_rng )
+libgsl gsl_rng_free int (int) gsl_rng_free ( *gsl_rng -- )
+
+
+
+\ random number distributions Tue Sep 13 00:44:35 MDT 2005
+\ Gaussian
+libgsl gsl_ran_gaussian df int (fp) gsl_ran_gaussian ( *gsl_rng df -- df )
+libgsl gsl_ran_gaussian_ratio_method df int (fp) gsl_ran_gaussian_ratio_method ( *gsl_rng df -- df )
+libgsl gsl_ran_gaussian_pdf df df (fp) gsl_ran_gaussian_pdf ( df df -- df )
+\ sigma = 1
+libgsl gsl_ran_ugaussian int (fp) gsl_ran_ugaussian ( *gsl_rng -- df )
+libgsl gsl_ran_ugaussian_ratio_method int (fp) gsl_ran_ugaussian_ratio_method ( *gsl_rng -- df )
+libgsl gsl_ran_ugaussian_pdf df (fp) gsl_ran_ugaussian_pdf ( df df -- df )
+libgsl gsl_ran_discrete_preproc int int (int) gsl_ran_discrete_preproc ( int int -- int )
+libgsl gsl_ran_discrete int int (int) gsl_ran_discrete
+libgsl gsl_ran_discrete_free int (void) gsl_ran_discrete_free
+libgsl gsl_ran_shuffle int int ptr ptr (void) gsl_ran_shuffle
+\ cdf P(x) = \int_{-\infty}^{x} p(x)dx Q(x) = \int_{x}^{\infty} p(x)dx
+libgsl gsl_cdf_gaussian_P df df (fp) gsl_cdf_gaussian_P ( df df -- df )
+libgsl gsl_cdf_gaussian_Q df df (fp) gsl_cdf_gaussian_Q ( df df -- df )
+libgsl gsl_cdf_gaussian_Pinv df df (fp) gsl_cdf_gaussian_Pinv ( df df -- df )
+libgsl gsl_cdf_gaussian_Qinv df df (fp) gsl_cdf_gaussian_Qinv ( df df -- df )
+\ sigma = 1 cdf
+libgsl gsl_cdf_ugaussian_P df (fp) gsl_cdf_ugaussian_P ( df -- df )
+libgsl gsl_cdf_ugaussian_Q df (fp) gsl_cdf_ugaussian_Q ( df -- df )
+libgsl gsl_cdf_ugaussian_Pinv df (fp) gsl_cdf_ugaussian_Pinv ( df -- df )
+libgsl gsl_cdf_ugaussian_Qinv df (fp) gsl_cdf_ugaussian_Qinv ( df -- df )
+
+
+\ statistics Tue Sep 13 01:17:35 MDT 2005
+libgsl gsl_stats_mean int int int (fp) gsl_stats_mean ( array{ step size -- df )
+libgsl gsl_stats_variance int int int (fp) gsl_stats_variance ( array{ step size -- df )
+libgsl gsl_stats_variance_m df int int int (fp) gsl_stats_variance_m ( df array{ step size -- df )
+libgsl gsl_stats_sd int int int (fp) gsl_stats_sd ( array{ step size -- df )
+libgsl gsl_stats_sd_m df int int int (fp) gsl_stats_sd_m ( df array{ step size -- df )
+libgsl gsl_stats_skew int int int (fp) gsl_stats_skew ( array{ step size -- df )
+libgsl gsl_stats_kurtosis int int int (fp) gsl_stats_kurtosis ( array{ step size -- df )
+libgsl gsl_stats_lag1_autocorrelation int int int (fp) gsl_stats_lag1_autocorrelation
+( array{ step size -- df )
+libgsl gsl_stats_max int int int (fp) gsl_stats_max ( array{ step size -- df )
+libgsl gsl_stats_min int int int (fp) gsl_stats_min ( array{ step size -- df )
+libgsl gsl_stats_max_index int int int (int) gsl_stats_max_index ( array{ step size -- n )
+libgsl gsl_stats_min_index int int int (int) gsl_stats_min_index ( array{ step size -- n )
+
+\ vectors and matrices Wed Sep 14 00:15:36 MDT 2005
+
+\ Vectors
+libgsl gsl_block_alloc int (int) gsl_block_alloc ( n -- addr )
+libgsl gsl_block_calloc int (int) gsl_block_calloc ( n -- addr )
+libgsl gsl_block_free int (int) gsl_block_free ( n -- addr )
+
+libgsl gsl_vector_alloc int (int) gsl_vector_alloc ( n -- addr )
+libgsl gsl_vector_calloc int (int) gsl_vector_calloc ( n -- addr )
+libgsl gsl_vector_alloc_from_vector int int int ptr (int) gsl_vector_alloc_from_vector
+libgsl gsl_vector_free int (void) gsl_vector_free ( addr -- )
+libgsl gsl_vector_get int int (fp) gsl_vector_get ( addr i -- df )
+libgsl gsl_vector_set df int int (void/fp) gsl_vector_set ( df addr i -- )
+libgsl gsl_vector_set_all df int (void) gsl_vector_set_all ( df addr -- )
+libgsl gsl_vector_set_zero int (void) gsl_vector_set_zero ( addr -- )
+libgsl gsl_vector_memcpy int int (int) gsl_vector_memcpy ( dest_addr src_addr -- n )
+
+libgsl gsl_vector_add int int (int) gsl_vector_add ( addr addr -- n )
+libgsl gsl_vector_sub int int (int) gsl_vector_sub ( addr addr -- n )
+libgsl gsl_vector_mul int int (int) gsl_vector_mul ( addr addr -- n )
+libgsl gsl_vector_div int int (int) gsl_vector_div ( addr addr -- n )
+libgsl gsl_vector_scale df int (int) gsl_vector_scale ( df addr -- n )
+libgsl gsl_vector_add_constant df int (int) gsl_vector_add_constant ( df addr -- n )
+libgsl gsl_vector_max int (fp) gsl_vector_max ( addr -- df )
+libgsl gsl_vector_min int (fp) gsl_vector_min ( addr -- df )
+libgsl gsl_vector_max_index int (fp) gsl_vector_max_index ( addr -- df )
+libgsl gsl_vector_min_index int (fp) gsl_vector_min_index ( addr -- df )
+libgsl gsl_vector_subvector int int int (int) gsl_vector_subvector
+\ Vector properties
+libgsl gsl_vector_isnull ptr (int) gsl_vector_isnull
+libgsl gsl_vector_ispos ptr (int) gsl_vector_ispos
+libgsl gsl_vector_isneg ptr (int) gsl_vector_isneg
+
+\ permutations
+libgsl gsl_permutation_alloc int (int) gsl_permutation_alloc ( n -- *gsl_prm)
+libgsl gsl_permutation_calloc int (int) gsl_permutation_calloc ( n -- *gsl_prm)
+libgsl gsl_permutation_init int (void) gsl_permutation_init ( *gsl_prm -- )
+libgsl gsl_permutation_free int (void) gsl_permutation_free ( *gsl_prm -- )
+libgsl gsl_permutation_get int int (int) gsl_permutation_get ( *gsl_prm i -- n)
+
+\ Matrices
+\ Allocation
+libgsl gsl_matrix_alloc int int (int) gsl_matrix_alloc
+libgsl gsl_matrix_calloc int int (int) gsl_matrix_calloc
+libgsl gsl_matrix_alloc_from_block [ 5 ] ints (int) gsl_matrix_alloc_from_block
+libgsl gsl_matrix_alloc_from_matrix [ 5 ] ints (int) gsl_matrix_alloc_from_matrix
+libgsl gsl_matrix_free ( *gsl_matrix -- ) int (void) gsl_matrix_free
+\ Accessing matrix elements
+libgsl gsl_matrix_get int int int (fp) gsl_matrix_get ( *m i j -- df )
+libgsl gsl_matrix_set df int int int (void) gsl_matrix_set ( df *m i j -- )
+libgsl gsl_matrix_ptr int int int (int) gsl_matrix_ptr ( *m i j -- *[i,j] )
+\ Initializing matrix elements
+libgsl gsl_matrix_set_all df int (void) gsl_matrix_set_all ( *m df -- n )
+libgsl gsl_matrix_set_zero df int (void) gsl_matrix_set_zero ( *m df -- n )
+libgsl gsl_matrix_set_identity df int (void) gsl_matrix_set_identity ( *m df -- n )
+\ Reading and writing matrices
+libgsl gsl_matrix_fwrite ptr ptr (int) gsl_matrix_fwrite
+libgsl gsl_matrix_fread ptr ptr (int) gsl_matrix_fread
+libgsl gsl_matrix_fprintf ptr ptr ptr (int) gsl_matrix_fprintf
+libgsl gsl_matrix_fscanf ptr ptr (int) gsl_matrix_fscanf
+\ Copying matrices
+libgsl gsl_matrix_memcpy int int (int) gsl_matrix_memcpy ( *m *m -- n )
+libgsl gsl_matrix_swap int int (int) gsl_matrix_swap ( *m *m -- n )
+\ Copying Rows and columns
+libgsl gsl_matrix_get_row int int int (int) gsl_matrix_get_row
+libgsl gsl_matrix_set_row int int int (int) gsl_matrix_set_row
+libgsl gsl_matrix_get_col int int int (int) gsl_matrix_get_col
+libgsl gsl_matrix_set_col int int int (int) gsl_matrix_set_col
+\ Exchanging rows and columns
+libgsl gsl_matrix_swap_rows int int ptr (int) gsl_matrix_swap_rows
+libgsl gsl_matrix_swap_columns int int ptr (int) gsl_matrix_swap_columns
+libgsl gsl_matrix_swap_rowcol int int ptr (int) gsl_matrix_swap_rowcol
+libgsl gsl_matrix_transpose_memcpy int int (int) gsl_matrix_transpose_memcpy
+libgsl gsl_matrix_transpose int (int) gsl_matrix_transpose
+\ Matrix operations
+libgsl gsl_matrix_add int int (int) gsl_matrix_add
+libgsl gsl_matrix_sub int int (int) gsl_matrix_sub
+libgsl gsl_matrix_mul_elements int int (int) gsl_matrix_mul_elements
+libgsl gsl_matrix_div_elements int int (int) gsl_matrix_div_elements
+libgsl gsl_matrix_scale df int (int) gsl_matrix_scale
+libgsl gsl_matrix_add_constant df int (int) gsl_matrix_add_constant
+\ Finding maximum and minimum elements of matrices
+libgsl gsl_matrix_max ptr (fp) gsl_matrix_max
+libgsl gsl_matrix_min ptr (fp) gsl_matrix_min
+libgsl gsl_matrix_minmax ptr ptr ptr (void) gsl_matrix_minmax
+libgsl gsl_matrix_min_index ptr ptr ptr (void) gsl_matrix_min_index
+libgsl gsl_matrix_max_index ptr ptr ptr (void) gsl_matrix_max_index
+libgsl gsl_matrix_minmax_index ptr ptr ptr ptr ptr (void) gsl_matrix_minmax_index
+\ Matrix properties
+libgsl gsl_matrix_isnull ptr (int) gsl_matrix_isnull
+libgsl gsl_matrix_ispos ptr (int) gsl_matrix_ispos
+libgsl gsl_matrix_isneg ptr (int) gsl_matrix_isneg
+\ libgsl gsl_matrix_isnonneg ptr (int) gsl_matrix_isnonneg
+
+
+libgsl gsl_matrix_submatrix int int int int int (int) gsl_matrix_submatrix ( *gsl_matrix k1 k2 n1 n2 -- n )
+libgsl gsl_matrix_row int int (int) gsl_matrix_row ( *gsl_matrix idx -- *gsl_vector )
+libgsl gsl_matrix_column int int (int) gsl_matrix_column ( *gsl_matrix idx -- *gsl_vector )
+libgsl gsl_matrix_diagonal int (int) gsl_matrix_diagonal ( *gsl_matrix -- *gsl_vector )
+
+
+\ BLAS Wed Sep 14 16:10:34 MDT 2005
+\ libblas cblas_dgemm int int df int int int
+\ int df int int int int int int (void/fp) cblas_dgemm
+libblas cblas_dgemv int int int int df int
+int df int int int int (void/fp) cblas_dgemv
+libgsl gsl_blas_ddot int int int (int) gsl_blas_ddot
+( *gsl_vector *gsl_vector df -- n )
+libgsl gsl_blas_dgemm int df int int df int int (int/fp) gsl_blas_dgemm
+libgsl gsl_blas_dger int int int df (int/fp) gsl_blas_dger
+( alpha *gsl_vector *gsl_vector *gsl_matrix -- n ) ( A=\alpha x y^T+A )
+libgsl gsl_blas_dgemv int df int int df int (int/fp) gsl_blas_dgemv
+( n alpha *gsl_matrix *gsl_vector beta *gsl_vector -- n )
+
+\ Linear ALgebra Wed Sep 14 13:39:22 MDT 2005
+
+libgsl gsl_linalg_LU_decomp int int int (int) gsl_linalg_LU_decomp
+( *gsl_matrix *gsl_permutation *variable -- n )
+libgsl gsl_linalg_LU_invert int int int (int) gsl_linalg_LU_invert
+( *gsl_matrix *gsl_permutation *gsl_matrix -- n )
+libgsl gsl_linalg_SV_decomp int int int int (int) gsl_linalg_SV_decomp
+( *gsl_matrix *gsl_matrix *gsl_vector *gsl_vector -- n )
+libgsl gsl_linalg_SV_decomp_mod int int int int int (int) gsl_linalg_SV_decomp_mod
+( *gsl_matrix *gsl_matrix *gsl_matrix *gsl_vector *gsl_vector -- n )
+
+\ -----------------------------------------------------------------------------
+\ *** Ordinary Differential Equations ***
+\ --- ODE system
+struct{
+ cell func \ (* function)
+ \ (double t, const double y[], double dydt[], void * params);
+ cell jac \ (* jacobian)
+ \ (double t, const double y[], double * dfdy, double dfdt[],
+ \ void * params);
+ cell dim \ dimension;
+ cell params \ * params;
+} gsl_odeiv_system
+\ constants related to ODE
+ 1 constant GSL_ODEIV_HADJ_INC
+ 0 constant GSL_ODEIV_HADJ_NIL
+-1 constant GSL_ODEIV_HADJ_DEC
+
+callback gsl_odeiv_func4:1 (int) df int int int callback;
+callback gsl_odeiv_jac5:1 (int) df int int int int callback;
+
+\ --- Stepping Functions
+libgsl gsl_odeiv_step_alloc ptr int (ptr) gsl_odeiv_step_alloc
+( *step_type int -- *step )
+libgsl gsl_odeiv_step_reset ptr (int) gsl_odeiv_step_reset ( *step -- r )
+libgsl gsl_odeiv_step_free ptr (void) gsl_odeiv_step_free ( *step -- )
+libgsl gsl_odeiv_step_name ptr (ptr) gsl_odeiv_step_name ( *step -- *str0 )
+libgsl gsl_odeiv_step_order ptr (int) gsl_odeiv_step_order ( *step -- order)
+libgsl gsl_odeiv_step_apply int int int int int df df int (int) gsl_odeiv_step_apply
+( -- )
+\ --- Available algorithms
+libgsl _gsl_odeiv_step_rk2 (int) gsl_odeiv_step_rk2
+libgsl _gsl_odeiv_step_rk4 (int) gsl_odeiv_step_rk4
+libgsl _gsl_odeiv_step_rkf45 (int) gsl_odeiv_step_rkf45
+libgsl _gsl_odeiv_step_rkck (int) gsl_odeiv_step_rkck
+libgsl _gsl_odeiv_step_rk8pd (int) gsl_odeiv_step_rk8pd
+libgsl _gsl_odeiv_step_rk2imp (int) gsl_odeiv_step_rk2imp
+libgsl _gsl_odeiv_step_rk4imp (int) gsl_odeiv_step_rk4imp
+libgsl _gsl_odeiv_step_bsimp (int) gsl_odeiv_step_bsimp
+libgsl _gsl_odeiv_step_gear1 (int) gsl_odeiv_step_gear1
+libgsl _gsl_odeiv_step_gear2 (int) gsl_odeiv_step_gear2
+
+: gsl_odeiv_step_rk2 [func'] _gsl_odeiv_step_rk2 @ ;
+: gsl_odeiv_step_rk4 [func'] _gsl_odeiv_step_rk4 @ ;
+: gsl_odeiv_step_rkf45 [func'] _gsl_odeiv_step_rkf45 @ ;
+: gsl_odeiv_step_rkck [func'] _gsl_odeiv_step_rkck @ ;
+: gsl_odeiv_step_rk8pd [func'] _gsl_odeiv_step_rk8pd @ ;
+: gsl_odeiv_step_rk2imp [func'] _gsl_odeiv_step_rk2imp @ ;
+: gsl_odeiv_step_rk4imp [func'] _gsl_odeiv_step_rk4imp @ ;
+: gsl_odeiv_step_bsimp [func'] _gsl_odeiv_step_bsimp @ ;
+: gsl_odeiv_step_gear1 [func'] _gsl_odeiv_step_gear1 @ ;
+: gsl_odeiv_step_gear2 [func'] _gsl_odeiv_step_gear2 @ ;
+
+\ --- Adaptive Step-size Control
+libgsl gsl_odeiv_control_standard_new df df df df (ptr) gsl_odeiv_control_standard_new ( a_dydt a_y eps_rel eps_abs -- *control )
+libgsl gsl_odeiv_control_y_new df df (int) gsl_odeiv_control_y_new
+( eps_abs eps_rel -- *control )
+libgsl gsl_odeiv_control_yp_new df df (ptr) gsl_odeiv_control_yp_new
+( eps_abs eps_rel -- *control )
+libgsl gsl_odeiv_control_free ptr (void) gsl_odeiv_control_free ( *control -- )
+libgsl gsl_odeiv_control_name ptr (ptr) gsl_odeiv_control_name ( *c -- *str0 )
+
+\ --- Evolution
+libgsl gsl_odeiv_evolve_alloc int (int) gsl_odeiv_evolve_alloc
+( #dimensions -- evolution_func )
+libgsl gsl_odeiv_evolve_apply int int df int int int int int (int) gsl_odeiv_evolve_apply
+( -- )
+libgsl gsl_odeiv_evolve_reset ptr (int) gsl_odeiv_evolve_reset ( *e -- r )
+libgsl gsl_odeiv_evolve_free ptr (void) gsl_odeiv_evolve_free ( *e -- )
+\ -----------------------------------------------------------------------------
+\ *** Fast Fourier Transform ***
+\ -- real
+libgsl gsl_fft_real_wavetable_alloc int (ptr) gsl_fft_real_wavetable_alloc
+libgsl gsl_fft_real_wavetable_free ptr (void) gsl_fft_real_wavetable_free
+libgsl gsl_fft_real_workspace_alloc int (ptr) gsl_fft_real_workspace_alloc
+libgsl gsl_fft_real_workspace_free ptr (void) gsl_fft_real_workspace_free
+\ in-place
+libgsl gsl_fft_real_transform ptr int int ptr ptr (int) gsl_fft_real_transform
+libgsl gsl_fft_real_unpack ptr ptr int int (int) gsl_fft_real_unpack
+
+\ -- halfcomplex
+\ - mixed radix
+libgsl gsl_fft_hc_wtbl_alloc int (ptr) gsl_fft_halfcomplex_wavetable_alloc
+libgsl gsl_fft_hc_wtbl_free ptr (void) gsl_fft_halfcomplex_wavetable_free
+libgsl gsl_fft_hc_backward ptr int int ptr ptr (int) gsl_fft_halfcomplex_backward
+libgsl gsl_fft_hc_inverse ptr int int ptr ptr (int) gsl_fft_halfcomplex_inverse
+libgsl gsl_fft_hc_transform ptr int int ptr ptr (int) gsl_fft_halfcomplex_transform
+libgsl gsl_fft_hc_unpack ptr ptr int int (int) gsl_fft_halfcomplex_unpack
+\ - radix2
+libgsl gsl_fft_hc_r2_unpack ptr ptr int int (int) gsl_fft_halfcomplex_radix2_unpack
+libgsl gsl_fft_hc_r2_backward ptr int int (int) gsl_fft_halfcomplex_radix2_backward
+libgsl gsl_fft_hc_r2_inverse ptr int int (int) gsl_fft_halfcomplex_radix2_inverse
+libgsl gsl_fft_hc_r2_transform ptr int int (int) gsl_fft_halfcomplex_radix2_transform
+
+
+| hashlen 32 vector fftpre(
+struct{
+ cell next
+ cell size
+ cell workspace
+ cell r_wavetable
+ cell hc_wavetable
+} gsl_fft_precomputes
+| create $buf 255 allot
+| : 2str dup >r abs s>d <# #s r> sign #> $buf 0place ;
+| : s>hash ( n -- key ) 2str $buf hash ;
+| : (cache-fft) ( n -- addr )
+ sizeof gsl_fft_precomputes allocate throw >r
+ 0 r@ gsl_fft_precomputes next !
+ dup r@ gsl_fft_precomputes size !
+ dup gsl_fft_real_workspace_alloc r@ gsl_fft_precomputes workspace !
+ dup gsl_fft_real_wavetable_alloc r@ gsl_fft_precomputes r_wavetable !
+ gsl_fft_hc_wtbl_alloc r@ gsl_fft_precomputes hc_wavetable !
+ r> ;
+| : cache-fft ( size -- addr )
+ dup s>hash
+ fftpre( over )@ 0= if
+ swap (cache-fft)
+ fftpre( rot dup >r )!
+ fftpre( r> )@
+ else
+ swap (cache-fft)
+ swap fftpre( over )@
+ over gsl_fft_precomputes next !
+ fftpre( rot dup >r )!
+ fftpre( r> )@
+ then ;
+\ in case not found addr is just the size
+| : find-fft-cache ( n -- addr 0/1 )
+ dup s>hash fftpre( swap )@ dup
+ begin while
+ 2dup gsl_fft_precomputes size @ =
+ if nip true exit then
+ gsl_fft_precomputes next @ dup
+ repeat ;
+
+legacy on
+
+\ Structures
+
+struct{
+ cell name
+ cell max
+ cell min
+ cell size
+ cell set
+ cell get
+ cell get_double
+} gsl_rng_type
+
+struct{
+ cell type
+ cell state
+} gsl_rng
+
+struct{
+ cell size
+ cell data
+} gsl_block
+
+struct{
+ cell size
+ cell stride
+ cell data
+ cell block
+ cell owner
+} gsl_vector
+
+' gsl_block alias gsl_permutation
+
+struct{
+ cell size1
+ cell size2
+ cell tda
+ cell data
+ cell block
+ cell owner
+} gsl_matrix
+
+\ random number generation functions
+: 0-len dup 1- 0 begin 1+ 2dup + c@ 0= until nip ;
+: )gsl-rng ( addr i -- *gsl_rng_type )
+ cells + @ ;
+
+\ setting up all available random number generators
+gsl_rng_types_setup value gsl_rng_array(
+0 value gsl_rng_default
+: gsl-free ( -- )
+ gsl_rng_default gsl_rng_free ;
+
+: borosh13 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 0 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: cmrg ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 1 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: coveyou ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 2 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: fishman18 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 3 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: fishman20 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 4 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: fishman2x ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 5 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: gfsr4 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 6 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: knuthran ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 7 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: knuthran2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 8 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: lecuyer21 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 9 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: minstd ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 10 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: mrg ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 11 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: mt19937 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 12 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: mt19937_1999 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 13 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: mt19937_1998 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 14 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: r250 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 15 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ran0 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 16 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ran1 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 17 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ran2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 18 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ran3 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 19 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: rand ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 20 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: rand48 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 21 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random128-bsd ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 22 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random128-glibc2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 23 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random128-libc5 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 24 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random256-bsd ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 25 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random256-glibc2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 26 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random256-libc5 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 27 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random32-bsd ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 28 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random32-glibc2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 29 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random32-libc5 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 30 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random64-bsd ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 31 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random64-glibc2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 32 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random64-libc5 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 33 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random8-bsd ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 34 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random8-glibc2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 35 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random8-libc5 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 36 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random-bsd ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 37 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random-glibc2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 38 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: random-libc5 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 39 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: randu ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 40 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranf ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 41 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranlux ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 42 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranlux389 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 43 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranlxd1 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 44 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranlxd2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 45 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranlxs0 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 46 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranlxs1 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 47 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranlxs2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 48 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: ranmar ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 49 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: slatec ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 50 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: taus ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 51 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: taus2 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 52 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: taus113 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 53 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: transputer ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 54 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: tt800 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 55 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: uni ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 56 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: uni32 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 57 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: vax ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 58 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: waterman14 ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 59 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+: zuf ( -- *gsl_rng ) gsl_rng_default 0<> if gsl-free then
+ gsl_rng_array( 60 )gsl-rng gsl_rng_alloc to gsl_rng_default ;
+
+\ words for actual generation of random numbers
+: gsl-randomg ( -- n )
+ gsl_rng_default gsl_rng_get ;
+: gsl-randomu /* -- f \in [0,1) */
+ gsl_rng_default gsl_rng_uniform ;
+: gsl-randomu+ /* -- f \in (0,1) */
+ gsl_rng_default gsl_rng_uniform_pos ;
+: gsl-random-up ( n -- f \in [0,n] )
+ gsl_rng_default swap gsl_rng_uniform_int ;
+: gsl-set-seed ( n -- )
+ gsl_rng_default swap gsl_rng_set ;
+: gsl-clone ( -- *gsl_rng )
+ gsl_rng_default gsl_rng_clone ;
+: gsl-gaussian ( -- df )
+ gsl_rng_default !1 gsl_ran_gaussian ;
+: gsl-discrete ( *gsl_ran_discrete -- n )
+ gsl_rng_default swap gsl_ran_discrete ;
+
+\ vectors and matrices
+0 constant GSL_VECTOR_TYPE
+1 constant GSL_MATRIX_TYPE
+: gsltypeof ' >body cell + @ ;
+
+: fvector ( n -- | -- id addr )
+ create
+ gsl_vector_calloc ,
+ GSL_VECTOR_TYPE ,
+ does> @ ;
+
+\ allocate a nameless vector
+: :] ( # -- addr ) gsl_vector_calloc ;
+\ allocate a nameless matrix
+: :]] ( # # -- addr ) gsl_matrix_calloc ;
+
+: ]@ ( addr i -- df ) gsl_vector_get ;
+: ]! ( df addr i -- ) gsl_vector_set ;
+: ]data ( addr -- *data ) gsl_vector data @ ;
+: ]stride ( addr -- *data ) gsl_vector stride @ ;
+: ]fill ( df addr -- ) gsl_vector_set_all ;
+: ]erase ( addr -- ) gsl_vector_set_zero ;
+: ]+ ( *gsl_vector *gsl_vector -- ) gsl_vector_add drop ;
+: ]- ( *gsl_vector *gsl_vector -- ) gsl_vector_sub drop ;
+: ]e*! ( *gsl_vector *gsl_vector -- ) gsl_vector_mul drop ;
+: ]size ( *gsl_vector -- n ) gsl_vector size @ ;
+: ]outer* ( *gsl_vector *gsl_vector -- *gsl_matrix )
+ over ]size over ]size gsl_matrix_calloc dup >r !1
+ gsl_blas_dger drop r> ;
+\ no control for divizion by zero (I get segfaults)
+: ]/ ( *gsl_vector *gsl_vector -- ) gsl_vector_div throw ;
+: ]clone ( *gsl_vector -- *gsl_vector )
+ dup gsl_vector size @ gsl_vector_alloc
+ dup -rot swap gsl_vector_memcpy drop ;
+
+: ]add ( *gsl_vector *gsl_vector -- *gsl_vector )
+ ]clone dup -rot swap ]+ ;
+: ]sub ( *gsl_vector *gsl_vector -- *gsl_vector )
+ swap ]clone dup -rot swap ]- ;
+: ]mul ( *gsl_vector *gsl_vector -- *gsl_vector )
+ swap ]clone dup -rot swap ]e*! ;
+: ]div ( *gsl_vector *gsl_vector -- *gsl_vector )
+ swap ]clone dup -rot swap ]/ ;
+
+: ]*c ( df *gsl_vector -- ) gsl_vector_scale drop ;
+: ]+c ( df *gsl_vector -- ) gsl_vector_add_constant drop ;
+: ]max ( *gsl_vector -- ) gsl_vector_max ;
+: ]min ( *gsl_vector -- ) gsl_vector_min ;
+: ]imax ( *gsl_vector -- ) gsl_vector_max_index ;
+: ]imin ( *gsl_vector -- ) gsl_vector_min_index ;
+: ]copy] ( *gsl_vector_dest *gsl_vector_src -- ) gsl_vector_memcpy drop ;
+: ]negate !-1.0 ]*c ;
+: ]ones ( n -- *gsl_vector ) :] dup 1e ]fill ;
+
+: ]]slice ( *gsl_matrix x y n m -- *gsl_matrix )
+ gsl_matrix_alloc_from_matrix ;
+: ]slice ( *gsl_vector offset length stride -- *gsl_vector )
+ gsl_vector_alloc_from_vector ;
+
+: ]null? ( *gsl_vector -- 0/-1 ) gsl_vector_isnull negate ;
+: ]pos? ( *gsl_vector -- 0/-1 ) gsl_vector_ispos negate ;
+: ]neg? ( *gsl_vector -- 0/-1 ) gsl_vector_isneg negate ;
+
+\ FFT 19jan08sp
+: ]fft! ( *gsl_vector -- )
+ dup ]size >r dup ]stride >r ]data r> r>
+ dup find-fft-cache if
+ dup gsl_fft_precomputes r_wavetable @
+ swap gsl_fft_precomputes workspace @
+ else
+ drop
+ dup cache-fft
+ dup gsl_fft_precomputes r_wavetable @
+ swap gsl_fft_precomputes workspace @
+ then
+ gsl_fft_real_transform throw ;
+: ]fft ( *gsl_vector -- *gsl_vector )
+ ]clone dup ]fft! ;
+: ]ifft! ( *gsl_vector -- )
+ dup ]size >r dup ]stride >r ]data r> r>
+ dup find-fft-cache if
+ dup gsl_fft_precomputes hc_wavetable @
+ swap gsl_fft_precomputes workspace @
+ else
+ drop
+ dup cache-fft
+ dup gsl_fft_precomputes hc_wavetable @
+ swap gsl_fft_precomputes workspace @
+ then
+ gsl_fft_hc_inverse throw ;
+: ]ifft ( *gsl_vector -- *gsl_vector )
+ ]clone dup ]ifft! ;
+\ multiply two half complex vectors
+\ store result in the first
+: ]hc*! ( *gsl_vector *gsl_vector -- )
+ 2dup 0 ]@ 0 ]@ f* over 0 ]!
+ dup ]size dup %1 and not + 1 do
+ 2dup
+ dup i ]@ i 1+ ]@
+ dup i ]@ i 1+ ]@ z*
+ over dup i 1+ ]! i ]!
+ 2 +loop
+ dup ]size %1 and not if
+ 2dup
+ dup ]size 1- dup >r ]@ dup r@ ]@ f* r> ]!
+ then
+ 2drop ;
+
+\ pseudomatrices and vectors
+: pvector ( *data n -- *gsl_vector )
+ sizeof gsl_vector allocate throw
+ dup >r dup 1 swap gsl_vector stride !
+ gsl_vector size ! r@
+ gsl_vector data ! r@
+ 0 swap gsl_vector owner ! r> ;
+
+: pmatrix! ( *data tda n m *pmatrix -- *gsl_matrix )
+ dup >r gsl_matrix size2 !
+ r@ gsl_matrix size1 !
+ r@ gsl_matrix tda !
+ r@ gsl_matrix data !
+ 0 r@ gsl_matrix owner !
+ r> ;
+
+: pmatrix ( *data tda n m -- *gsl_matrix )
+ sizeof gsl_matrix allocate throw
+ dup 0 swap gsl_matrix owner !
+ pmatrix! ;
+
+\ permutations
+
+: fpermutation ( n -- | -- id addr )
+ create
+ gsl_permutation_calloc ,
+ does> @ ;
+: }@ ( *gsl_permutation i -- n ) gsl_permutation_get ;
+: }data ( *gsl_permutation -- *data ) gsl_block data @ ;
+: }size ( *gsl_permutation -- *data ) gsl_block size @ ;
+: }free ( *gsl_permutation -- ) gsl_permutation_free ;
+: }sign ( *gsl_permutation -- 1/-1 )
+ 1 over dup }size 0 do
+ dup i }@ i <> if swap negate swap then
+ loop drop ;
+
+\ matrices
+
+: fmatrix ( n m -- | -- id addr )
+ create
+ gsl_matrix_calloc ,
+ GSL_MATRIX_TYPE ,
+ does> @ ;
+
+: free_pseudomatrix ( pmatrix/pvector -- ) free throw ;
+
+create free_matrix ' free_pseudomatrix , ' gsl_matrix_free ,
+create free_vector ' free_pseudomatrix , ' gsl_vector_free ,
+
+: ]]free ( *gsl_matrix -- )
+ dup gsl_matrix owner @
+ cells free_matrix + @ execute ;
+: ]free ( addr -- )
+ dup gsl_vector owner @
+ cells free_vector + @ execute ;
+: ]]@ ( *gsl_matrix i j -- df ) gsl_matrix_get ;
+: ]]*@ ( *gsl_matrix i j -- *[i,j] ) gsl_matrix_ptr ;
+: ]]! ( *gsl_matrix i j df -- ) gsl_matrix_set ;
+: ]]fill ( addr df -- ) gsl_matrix_set_all ;
+: ]]size1 gsl_matrix size1 @ ;
+: ]]size2 gsl_matrix size2 @ ;
+: ]]dim ( *gsl_matrix -- m n ) dup ]]size1 swap ]]size2 ;
+: ]]dim. ( *gsl_matrix -- ) ]]dim swap . ." x" . cr ;
+: ]]data ( *gsl_matrix -- addr) gsl_matrix data @ ;
+: ]]tda gsl_matrix tda @ ;
+: ]]block gsl_matrix block @ ;
+: ]]owner gsl_matrix owner @ ;
+: ]]copy]] ( *gsl_matrix_dest *gsl_matrix_src -- ) gsl_matrix_memcpy drop ;
+: ]]'copy]] ( *gsl_matrix_dest *gsl_matrix_src -- ) gsl_matrix_transpose_memcpy drop ;
+\ : ]]row ( *gsl_matrix idx -- *gsl_vector ) gsl_matrix_row ;
+\ : ]]col ( *gsl_matrix idx -- *gsl_vector ) gsl_matrix_column ;
+: ]]>] ( *gsl_vector *gsl_matrix i -- ) gsl_matrix_get_col drop ;
+: ]]>]' ( *gsl_vector *gsl_matrix i -- ) gsl_matrix_get_row drop ;
+: ]>]] ( *gsl_matrix *gsl_vector i -- ) swap gsl_matrix_set_col drop ;
+: ]'>]] ( *gsl_matrix *gsl_vector i -- ) swap gsl_matrix_set_row drop ;
+
+: ]]max gsl_matrix_max ;
+: ]]min gsl_matrix_min ;
+: ]]add! ( *gsl_matrix *gsl_matrix -- )
+ gsl_matrix_add drop ;
+: ]]sub! ( *gsl_matrix *gsl_matrix -- )
+ gsl_matrix_sub drop ;
+: ]]e*! ( *gsl_matrix *gsl_matrix -- )
+ gsl_matrix_mul_elements drop ;
+: ]]*c ( *gsl_matrix df -- )
+ gsl_matrix_scale drop ;
+: ]]+c ( df *gsl_matrix -- ) gsl_matrix_add_constant drop ;
+: ]]clone ( *gsl_matrix -- *gsl_matrix )
+ dup dup gsl_matrix size1 @ swap gsl_matrix size2 @
+ gsl_matrix_alloc
+ dup -rot swap gsl_matrix_memcpy drop ;
+: ]]negate !-1.0 ]]*c ;
+
+: ]]+ ( *gsl_matrix *gsl_matrix -- *gsl_matrix )
+ ]]clone dup -rot swap ]]add! ;
+
+: ]]- ( *gsl_matrix *gsl_matrix -- *gsl_matrix )
+ swap ]]clone dup -rot swap ]]sub! ;
+: ]]null? ( *gsl_matrix -- 0/-1 ) gsl_matrix_isnull negate ;
+: ]]pos? ( *gsl_matrix -- 0/-1 ) gsl_matrix_ispos negate ;
+: ]]neg? ( *gsl_matrix -- 0/-1 ) gsl_matrix_isneg negate ;
+
+\ blas
+
+\ constants
+101 Constant CblasRowMajor
+102 Constant CblasColMajor
+111 Constant CblasNoTrans
+112 Constant CblasTrans
+113 Constant CblasConjTrans
+121 Constant CblasUpper
+122 Constant CblasLower
+131 Constant CblasNonUnit
+132 Constant CblasUnit
+141 Constant CblasLeft
+142 Constant CblasRight
+
+: action? ( *gsl_matrix *gsl_matrix n n n -- )
+ dup 0= if
+ drop
+ 2swap 2dup
+ ]]size2 swap ]]size1 swap
+ exit
+ then
+ dup 1 = if
+ drop
+ 2swap 2dup
+ ]]size2 swap ]]size2 swap
+ exit
+ then
+ 2 = if
+ 2swap 2dup
+ ]]size1 swap ]]size1 swap
+ exit
+ then
+ 3 = if
+ 2swap 2dup
+ ]]size1 swap ]]size2 swap
+ exit
+ then ;
+
+create samemattable ' noop , ' ]]clone ,
+: samemat ( *gsl_matrix *gsl_matrix -- 1/0 *gsl_matrix )
+ dup -rot = abs dup -rot cells samemattable + @ execute ; macro
+
+: ]]mul ( *gsl_matrix *gsl_matrix n n n -- *gsl_matrix )
+ !1 !0 action?
+ gsl_matrix_alloc dup >r
+ gsl_blas_dgemm drop r> ;
+: ]]* ( *gsl_matrix *gsl_matrix -- *gsl_matrix )
+ 2dup samemat dup rot 2>r nip
+ CblasNoTrans CblasNoTrans 0 ]]mul
+ 2r> if ]]free else drop then ;
+: ]]'* ( *gsl_matrix *gsl_matrix -- *gsl_matrix )
+ 2dup samemat dup rot 2>r nip
+ CblasTrans CblasNoTrans 1 ]]mul
+ 2r> if ]]free else drop then ;
+: ]]*' ( *gsl_matrix *gsl_matrix -- *gsl_matrix )
+ 2dup samemat dup rot 2>r nip
+ CblasNoTrans CblasTrans 2 ]]mul
+ 2r> if ]]free else drop then ;
+: ]]'*' ( *gsl_matrix *gsl_matrix -- *gsl_matrix )
+ 2dup samemat dup rot 2>r nip
+ CblasTrans CblasTrans 3 ]]mul
+ 2r> if ]]free else drop then ;
+
+: ]]mul! ( n n *gsl_matrix *gsl_matrix *gsl_matrix -- )
+ !1 !0 gsl_blas_dgemm drop ;
+: ]]*! ( *gsl_matrix *gsl_matrix *gsl_matrix -- )
+ >r CblasNoTrans CblasNoTrans 2swap r> ]]mul! ;
+: ]]'*! ( *gsl_matrix *gsl_matrix *gsl_matrix -- )
+ >r CblasTrans CblasNoTrans 2swap r> ]]mul! ;
+: ]]*'! ( *gsl_matrix *gsl_matrix *gsl_matrix -- )
+ >r CblasNoTrans CblasTrans 2swap r> ]]mul! ;
+
+
+: ]]*] ( *gsl_matrix *gsl_vector -- *gsl_vector )
+ over ]]size1 gsl_vector_alloc >r
+ CblasNoTrans -rot r@ !1 !0 gsl_blas_dgemv drop r> ;
+: ]]'*] ( *gsl_matrix *gsl_vector -- *gsl_vector )
+ over ]]size1 gsl_vector_alloc >r
+ CblasTrans -rot r@ !1 !0 gsl_blas_dgemv drop r> ;
+
+: ]]i ( *gsl_matrix -- )
+ dup dup ]]size1 swap ]]size2 <> if
+ abort" ERROR: Not a square matrix!"
+ then
+ dup ]]size1 0 do
+ dup i i !1 ]]!
+ loop drop ;
+: identity ( n -- *gsl_matrix )
+ dup gsl_matrix_calloc dup ]]i ;
+: min-identity ( *gsl_matrix -- *gsl_matrix )
+ dup ]]size1 swap ]]size2 min identity ;
+: left/right' ( *gsl_matrix *gsl_matrix -- *gsl_matrix )
+ over ]]size1 over ]]size1 > if
+ swap ]]*' exit
+ else
+ ]]'* exit
+ then ;
+
+\ original matrix remains intact
+: ]]' ( *gsl_matrix -- *gsl_matrix )
+ dup min-identity dup >r
+ left/right'
+ r> ]]free ;
+: ]]T! ( *gsl_matrix -- )
+ gsl_matrix_transpose drop ;
+
+: ]]T ( *gsl_matrix -- *gsl_matrix )
+ dup ]]dim swap gsl_matrix_alloc dup rot gsl_matrix_transpose_memcpy drop ;
+
+: ]]2T ( *gsl_matr *gsl_matrix -- )
+ gsl_matrix_transpose_memcpy drop ;
+
+: ]]+! ( *gsl_matrix i j df -- ) >r 2dup r@ ]]@ f+ r> ]]! ;
+: ]]scale! ( *gsl_matrix i j df -- ) >r 2dup r@ ]]@ f* r> ]]! ;
+: ]]data_ij ( *gsl_matrix i j -- addr)
+ rot >r swap r@ ]]tda dfloats * swap dfloats + r> ]]data + ;
+\ Cross product can be either calculated through determinant:
+: ]x ( *gsl_vector *gsl_vector -- *gsl_vector )
+ 3 gsl_vector_alloc
+ { x1[ x2[ x3[ |
+ x1[ 2 ]@ fnegate x2[ 1 ]@ f* x1[ 1 ]@ x2[ 2 ]@ f* f+ x3[ 0 ]!
+ x1[ 2 ]@ x2[ 0 ]@ f* x1[ 0 ]@ fnegate x2[ 2 ]@ f* f+ x3[ 1 ]!
+ x1[ 1 ]@ fnegate x2[ 0 ]@ f* x1[ 0 ]@ x2[ 1 ]@ f* f+ x3[ 2 ]!
+ x3[ } ;
+\ or using algebraic form when first vector in the product is
+\ rewritten in a matrix form:
+\ a x b = [C_a] b
+\ [ 0 -a[2] a[1] ]
+\ [C_a] = [ a[2] 0 -a[0] ]
+\ [-a[1] a[0] 0 ]
+\ a function to convert a vector into such matrix:
+: ]>[x] ( ] -- ]] )
+ [IFDEF] debug
+ dup ]size 3 <> abort" Not a 3D vector!"
+ [THEN]
+ 3 3 :]] dup >r
+ swap 2dup 2 ]@ fdup dup fnegate 0 1 ]]! 1 0 ]]!
+ 2dup 1 ]@ fdup dup fnegate 2 0 ]]! 0 2 ]]!
+ 0 ]@ fdup dup fnegate 1 2 ]]! 2 1 ]]! r> ;
+: ]. ( *gsl_vector *gsl_vector -- f:dot_product )
+ { x1[ x2[ |
+ 0 0 sp@ x1[ x2[ rot gsl_blas_ddot drop fd>f } ;
+: ]total ( *gsl_vector -- f:sum )
+ dup ]size gsl_vector_alloc dup !1 ]fill dup rot ]. ]free ;
+\ probability normalize - assures sum is unity
+: ]pnormalize ( *gsl_vector - )
+ dup ]total 1/f ]*c ;
+: |]| ( *gsl_vector -- f:norm ) dup ]. fsqrt ;
+\ assures vector norm is unity
+: ]normalize ( *gsl_vector - )
+ dup |]| 1/f ]*c ;
+: ]distance ( *gsl-vector *gsl-vector -- f )
+ ]sub dup |]| ]free ;
+: ]+! ( *gsl_vector i df -- )
+ 2dup ]@ f+ ]! ;
+: ]*! ( *gsl_vector i df -- )
+ 2dup ]@ f* ]! ;
+
+: ]]*]m ( *gsl_matrix *gsl_vector -- *gsl_vector )
+ over ]]size1 gsl_vector_calloc
+ { m[[ x[ y[ |
+ m[[ ]]size1 0 do
+ m[[ ]]size2 0 do
+ m[[ j i ]]@ x[ i ]@ f* y[ j ]+!
+ loop
+ loop y[ } ;
+
+: >#rows ( -- )
+ swap ]]size1 >= abort" number of rows is bigger than available!" ;
+: >#cols ( -- )
+ swap ]]size2 >= abort" number of columns is bigger than available!" ;
+
+: ]]row ( *gsl_matrix n -- *gsl_vector )
+ 2dup >#rows
+ sizeof gsl_vector allocate throw
+ dup 1 swap gsl_vector stride ! >r
+ over ]]size2 r@ gsl_vector size !
+ 0 ]]data_ij r@ gsl_vector data !
+ 0 r@ gsl_vector owner ! r> ;
+\ assumes all dimensions are set correctly
+: ]]row! ( *gsl_vector *gsl_matrix n -- )
+ rot >r 2dup >#rows 0 ]]data_ij r> gsl_vector data ! ;
+: ]]col ( *gsl_matrix n -- *gsl_vector )
+ 2dup >#cols
+ sizeof gsl_vector allocate throw >r
+ over ]]tda r@ gsl_vector stride !
+ over ]]size1 r@ gsl_vector size !
+ over ]]block r@ gsl_vector block !
+ 0 swap ]]data_ij r@ gsl_vector data !
+ 0 r@ gsl_vector owner ! r> ;
+: ]]rfill ( f:n *gsl_matrix i -- ) ]]row dup ]fill ]free ;
+: ]]cfill ( f:n *gsl_matrix i -- ) ]]col dup ]fill ]free ;
+
+
+: ]]submat ( *gsl_matrix n1 n2 m1 m2 -- *gsl_matrix )
+ { m[[ n1 n2 m1 m2 |
+ sizeof gsl_matrix allocate throw >r
+ n2 n1 - 1+ r@ gsl_matrix size1 !
+ m2 m1 - 1+ r@ gsl_matrix size2 !
+ m[[ n1 m1 ]]data_ij r@ gsl_matrix data !
+ m[[ ]]tda r@ gsl_matrix tda !
+ 0 r@ gsl_matrix owner ! r> } ;
+
+: ?square ( *gsl_matrix -- )
+ dup ]]size1 swap ]]size2 <> abort" ERROR: Not a square matrix!" ;
+: ]]diag ( *gsl_matrix n1 n2 -- *gsl_vector )
+ rot dup ?square -rot
+ sizeof gsl_vector allocate throw { d[ |
+ over - d[ gsl_vector size !
+ 2dup dup ]]data_ij d[ gsl_vector data ! drop
+ dup ]]tda d[ gsl_vector stride !
+ ]]block d[ gsl_vector block !
+ 0 d[ gsl_vector owner !
+ d[ } ;
+
+\ with input matrix replaced by the result
+: ]]gsl-svd ( *gsl_matrix -- *gsl_matrix *gsl_vector )
+ dup ]]size2 dup dup gsl_matrix_calloc
+ swap dup gsl_vector_calloc swap
+ gsl_vector_calloc
+ { mV vS vW |
+ mV vS vW gsl_linalg_SV_decomp drop
+ vW ]free
+ mV vS } ;
+\ seems to be 30% faster
+: ]]gsl-svdm ( *gsl_matrix -- *gsl_matrix *gsl_vector )
+ dup ]]size2 dup ( a n n -- )
+ dup dup gsl_matrix_calloc swap ( a n a n -- )
+ dup gsl_matrix_calloc rot dup ( a a a n n -- )
+ gsl_vector_calloc swap
+ gsl_vector_calloc
+ { mX mV vS vW |
+ mX mV vS vW gsl_linalg_SV_decomp_mod drop
+ vW ]free mX ]]free
+ mV vS } ;
+
+
+: ]]alu ( *gsl_matrix -- *gsl_permutation ) ( matrix replaced with its lu )
+ { a[[ |
+ CblasRowMajor a[[ ]]size1 a[[ ]]size2 a[[ ]]data a[[ ]]size1 dup
+ gsl_permutation_alloc dup >r }data
+ clapack_dgetrf throw r> } ;
+: ]]ainv ( *gsl_matrix *gsl_permutation -- )
+ \ LU of a matrix replaced with its inverse
+ { a[[ t{ |
+ CblasRowMajor a[[ ]]size2 a[[ ]]data a[[ ]]size1 t{ }data
+ clapack_dgetri throw } ;
+: ]]ainvert ( *gsl_matrix -- *gsl_matrix )
+ [IFDEF] отладка
+ dup ?square
+ [THEN]
+ ]]clone dup dup >r ]]alu dup >r ]]ainv r> }free r> ;
+: ]]det ( *gsl_matrix -- f:determinant )
+ [IFDEF] отладка
+ dup ?square
+ [THEN]
+ ]]clone dup ]]alu >r 1e0
+ dup ]]size1 0 do dup i dup ]]@ f* loop ]]free
+ \ compute permutation sign
+ r> }sign s>f f* }free ;
+\ calculates the work needed for dgesvd_ ( see man dgesvd )
+: lwork ( m n -- c )
+ 2dup max -rot min 3 * over + swap 5 * max ;
+\ this svd returns U MxM so eats a lot of memory
+: ]]asvda ( *gsl_matrix -- *gsl_matrix *gsl_matrix *gsl_vector )
+ ]]clone { A[[ |
+ A[[ ]]size1 dup gsl_matrix_alloc
+ A[[ ]]size2 dup gsl_matrix_alloc
+ A[[ ]]size1 A[[ ]]size2 min gsl_vector_alloc
+ 8 cells allocate throw
+ { U[[ V[[ W[ p[ |
+ ascii A p[ 0 cells + ! p[ 0 cells +
+ ascii A p[ 1 cells + ! p[ 1 cells +
+ A[[ ]]size1 p[ 2 cells + ! p[ 2 cells +
+ A[[ ]]size2 p[ 3 cells + ! p[ 3 cells +
+ A[[ ]]data
+ p[ 2 cells +
+ W[ ]data
+ U[[ ]]data
+ U[[ ]]size1 p[ 4 cells + ! p[ 4 cells +
+ V[[ ]]data
+ V[[ ]]size1 p[ 5 cells + ! p[ 5 cells +
+ A[[ ]]size1 A[[ ]]size2 lwork
+ dup gsl_vector_alloc dup >r
+ ]data swap p[ 6 cells + ! p[ 6 cells +
+ p[ 7 cells +
+ dgesvd_
+ r> ]free p[ free throw A[[ ]]free
+ U[[ V[[ W[ } } ;
+
+\ performs A=U*S*V^T
+\ A = MxN, where M>N, pass it A^T
+\ returns U^T (MxN), V(NxN) and vector of N eigenvalues
+: ]]asvdO ( *gsl_matrix -- *gsl_matrix *gsl_matrix *gsl_vector )
+ { A[[ |
+ A[[ ]]size2 A[[ ]]size1 min dup gsl_matrix_alloc
+ A[[ ]]size1 A[[ ]]size2 min gsl_vector_alloc
+ 8 cells allocate throw
+ { V[[ W[ p[ |
+ ascii O p[ 0 cells + ! p[ 0 cells +
+ ascii S p[ 1 cells + ! p[ 1 cells +
+ A[[ ]]size2 p[ 2 cells + ! p[ 2 cells +
+ A[[ ]]size1 p[ 3 cells + ! p[ 3 cells +
+ A[[ ]]data
+ p[ 2 cells +
+ W[ ]data
+ 0
+ p[ 2 cells +
+ V[[ ]]data
+ V[[ ]]size2 p[ 5 cells + ! p[ 5 cells +
+ A[[ ]]size2 A[[ ]]size1 lwork
+ dup gsl_vector_alloc dup >r
+ ]data swap p[ 6 cells + ! p[ 6 cells +
+ p[ 7 cells +
+ dgesvd_
+ r> ]free p[ free throw
+ A[[ V[[ W[ } } ;
+
+
+: ]diag[[ ( *gsl_vector -- *gsl_matrix )
+ dup ]size dup dup gsl_matrix_calloc swap
+ 0 do
+ 2dup swap i ]@ i i ]]!
+ loop nip ;
+
+: ]print\ ( *gsl_vector -- )
+ dup ]size 0 do dup i ]@ fx. loop drop ;
+: ]print ( *gsl_vector -- ) ]print\ cr ;
+: ]]print ( *gsl_matrix -- )
+ cr precision swap
+ 5 set-precision
+ dup ]]size1 0 do
+ \ i . ." : "
+ dup ]]size2 0 do
+ dup
+ j i ]]@ fs.
+ loop
+ cr
+ loop
+ drop set-precision ;
+: ]]row-print ( *gsl_matrix i -- )
+ cr
+ over gsl_matrix size2 @ 0 do
+ 2dup
+ i ]]@ f.
+ loop
+ cr 2drop ;
+
+: ]]col-print ( *gsl_matrix i -- )
+ cr
+ over gsl_matrix size1 @ 0 do
+ 2dup
+ i swap ]]@ f.
+ loop
+ cr 2drop ;
+
+: ]]nthrow ( *gsl_matrix n -- addr )
+ over ]]tda * dfloats swap ]]data + ;
+
+: ]]randomize ( *gsl_matrix -- )
+ dup dup ]]size1 swap ]]size2 * 0 do
+ dup
+ gsl-randomu
+ ]]data i dfloats + df!
+ loop drop ;
+: ]randomize ( *gsl_vector -- )
+ dup ]size 0 do
+ dup
+ gsl-randomu
+ i ]!
+ loop drop ;
+: ]mean ( *gsl_vector -- f )
+ dup ]stride swap dup ]size swap ]data
+ rot rot gsl_stats_mean ;
+
+: ]variance ( *gsl_vector -- f )
+ dup ]stride swap dup ]size swap ]data
+ rot rot gsl_stats_variance ;
+
+: ]sd ( *gsl_vector -- f )
+ dup ]stride swap dup ]size swap ]data
+ rot rot gsl_stats_sd ;
+
+: ]skew ( *gsl_vector -- f )
+ dup ]stride swap dup ]size swap ]data
+ rot rot gsl_stats_skew ;
+
+: ]kurtosis ( *gsl_vector -- f )
+ dup ]stride swap dup ]size swap ]data
+ rot rot gsl_stats_kurtosis ;
+
+: ]]gsl-lu ( *gsl_matrix -- *gsl_matrix *gsl_permutation )
+ 1 sp@ rot ]]clone dup >r dup ]]size1 gsl_permutation_calloc dup >r rot
+ gsl_linalg_LU_decomp drop r> r> swap rot drop ;
+
+: ]]gsl-invert ( *gsl_matrix -- *gsl_matrix )
+ ]]clone dup dup ]]gsl-lu 2dup >r >r rot
+ gsl_linalg_LU_invert drop r> ]]free r> }free ;
+
+' ]]ainvert alias ]]invert
+' ]]asvdO alias ]]svd
+
+: ]]save ( *gsl_matrix *gsl_matrix_cfa fid -- )
+ -rot { m[[ name[[ |
+ >r
+ name[[ >name count 1+ nip 0 m[[ ]]size2 m[[ ]]size1 0
+ sp@ 5 cells r@ write-file throw
+ 2drop 2drop drop
+ name[[ >name count 1+ r@ write-file throw
+ m[[ ]]size1 m[[ ]]size2 * dfloats m[[ ]]T dup s>f ]]data swap
+ r> write-file throw f>s ]]free } ;
+
+\ these words do not work with float matrices but are needed for
+\ scientific calculations, that's why they are in this module
+
+: _hmatrix ( n m size -- addr )
+ rot over * 2 pick * [ 2 cells ] literal +
+ allocate throw dup [ 2 cells ] literal + >r
+ rot over ! [ 1 cells ] literal + ! r> ;
+: hmatrix ( n m size -- )
+ create
+ rot over * 2 pick * [ 2 cells ] literal + allocate throw dup ,
+ rot over ! [ 1 cells ] literal + !
+ does> @ [ 2 cells ] literal + ;
+: }}row-size ( hmatrix -- ) [ 2 cells ] literal - @ ;
+: freeHmatrix ( hmatrix -- ) [ 2 cells ] literal - free throw ;
+: }} ( addr i j -- addr[i][j] ) \ word to fetch 2-D array addresses
+ >R >R \ indices to return stack temporarily
+ DUP CELL- CELL- 2@ \ &a[0][0] size m
+ R> * R> + *
+ +
+ ALIGNED ;
+: h->[[ ( hmatrix -- gsl_matrix )
+ dup }}row-size 3 swap gsl_matrix_alloc
+ dup ]]size2 0 do
+ 3 0 do
+ 2dup swap i j }} w@ s>f i j ]]!
+ loop
+ loop nip ;
+
+\ some sequencing code
+: arange ( f:start f:end f:step -- x[ )
+ f-rot
+ fswap fdup f>r f- fover f/ f>s :] fr>
+ dup ]size 0 do
+ dup fover i s>f f* fover f+ i ]!
+ loop ;
+: product ( x[ -- f:P )
+ !1 dup ]size 0 do
+ dup i ]@ f*
+ loop drop ;
+
+\ initializing random number generator to some value in order to have
+\ it available upon loading of gsl
+mt19937
+: )randperm ( *v( -- )
+ gsl_rng_default swap
+ dup )size over )type 8 / gsl_ran_shuffle ;
+
+previous previous previous previous previous
+
+Module;
--- /dev/null
+Module mathgl
+also dos
+
+library libmgl libmgl.so
+library libmgl-glut libmgl-glut.so
+library libmgl-fltk libmgl-fltk.so
+library libmgl-qt libmgl-qt.so
+library libmgl-wx libmgl-wx.so
+
+legacy off
+
+libmgl mgl_create_graph_gl (ptr) mgl_create_graph_gl
+libmgl mgl_create_graph_zb int int (ptr) mgl_create_graph_zb
+libmgl mgl_create_graph_ps int int (ptr) mgl_create_graph_ps
+libmgl mgl_fortran_func ptr ptr (int) mgl_fortran_func
+libmgl-glut mgl_create_graph_glut ptr ptr ptr (ptr) mgl_create_graph_glut
+libmgl-fltk mgl_create_graph_fltk ptr ptr ptr (ptr) mgl_create_graph_fltk
+libmgl-qt mgl_create_graph_qt ptr ptr ptr (ptr) mgl_create_graph_qt
+\ libmgl-glut mgl_create_graph_glut_dr ptr ptr (ptr) mgl_create_graph_glut_dr
+\ libmgl-fltk mgl_create_graph_fltk_dr ptr ptr (ptr) mgl_create_graph_fltk_dr
+\ libmgl-qt mgl_create_graph_qt_dr ptr ptr (ptr) mgl_create_graph_qt_dr
+libmgl mgl_create_graph_idtf (ptr) mgl_create_graph_idtf
+libmgl-fltk mgl_fltk_run (void) mgl_fltk_run
+libmgl-qt mgl_qt_run (void) mgl_qt_run
+libmgl mgl_set_show_mouse_pos int ptr (void) mgl_set_show_mouse_pos
+libmgl mgl_get_last_mouse_pos sf sf sf ptr (void) mgl_get_last_mouse_pos
+libmgl mgl_update ptr (void) mgl_update
+libmgl mgl_delete_graph ptr (void) mgl_delete_graph
+libmgl mgl_create_data (ptr) mgl_create_data
+libmgl mgl_create_data_size int int int (ptr) mgl_create_data_size
+libmgl mgl_create_data_file ptr (ptr) mgl_create_data_file
+libmgl mgl_delete_data ptr (void) mgl_delete_data
+libmgl mgl_create_parser (ptr) mgl_create_parser
+libmgl mgl_delete_parser ptr (void) mgl_delete_parser
+libmgl mgl_add_param ptr int ptr (void) mgl_add_param
+libmgl mgl_add_paramw ptr int ptr (void) mgl_add_paramw
+libmgl mgl_add_var ptr ptr (ptr) mgl_add_var
+libmgl mgl_find_var ptr ptr (ptr) mgl_find_var
+libmgl mgl_parse int ptr ptr ptr (int) mgl_parse
+libmgl mgl_parsew int ptr ptr ptr (int) mgl_parsew
+libmgl mgl_parse_text ptr ptr ptr (void) mgl_parse_text
+libmgl mgl_parsew_text ptr ptr ptr (void) mgl_parsew_text
+libmgl mgl_restore_once ptr (void) mgl_restore_once
+libmgl mgl_parser_allow_setsize int ptr (void) mgl_parser_allow_setsize
+libmgl mgl_set_def_param ptr (void) mgl_set_def_param
+libmgl mgl_set_palette ptr ptr (void) mgl_set_palette
+libmgl mgl_set_pal_color sf sf sf int ptr (void) mgl_set_pal_color
+libmgl mgl_set_pal_num int ptr (void) mgl_set_pal_num
+libmgl mgl_set_rotated_text int ptr (void) mgl_set_rotated_text
+libmgl mgl_set_cut int ptr (void) mgl_set_cut
+libmgl mgl_set_cut_box sf sf sf sf sf sf ptr (void) mgl_set_cut_box
+libmgl mgl_set_tick_len sf ptr (void) mgl_set_tick_len
+libmgl mgl_set_bar_width sf ptr (void) mgl_set_bar_width
+libmgl mgl_set_base_line_width sf ptr (void) mgl_set_base_line_width
+libmgl mgl_set_mark_size sf ptr (void) mgl_set_mark_size
+libmgl mgl_set_arrow_size sf ptr (void) mgl_set_arrow_size
+libmgl mgl_set_font_size sf ptr (void) mgl_set_font_size
+libmgl mgl_set_font_def ptr ptr (void) mgl_set_font_def
+libmgl mgl_set_alpha_default sf ptr (void) mgl_set_alpha_default
+libmgl mgl_set_size int int ptr (void) mgl_set_size
+libmgl mgl_set_axial_dir ptr ptr (void) mgl_set_axial_dir
+libmgl mgl_set_meshnum int ptr (void) mgl_set_meshnum
+libmgl mgl_set_zoom sf sf sf sf ptr (void) mgl_set_zoom
+libmgl mgl_set_plotfactor sf ptr (void) mgl_set_plotfactor
+libmgl mgl_set_draw_face int ptr (void) mgl_set_draw_face
+libmgl mgl_set_scheme ptr ptr (void) mgl_set_scheme
+libmgl mgl_load_font ptr ptr ptr (void) mgl_load_font
+libmgl mgl_copy_font ptr ptr (void) mgl_copy_font
+libmgl mgl_restore_font ptr (void) mgl_restore_font
+libmgl mgl_show_image int ptr ptr (void) mgl_show_image
+libmgl mgl_write_frame ptr ptr ptr (void) mgl_write_frame
+libmgl mgl_write_bmp ptr ptr ptr (void) mgl_write_bmp
+libmgl mgl_write_jpg ptr ptr ptr (void) mgl_write_jpg
+libmgl mgl_write_png ptr ptr ptr (void) mgl_write_png
+libmgl mgl_write_png_solid ptr ptr ptr (void) mgl_write_png_solid
+libmgl mgl_write_eps ptr ptr ptr (void) mgl_write_eps
+libmgl mgl_write_svg ptr ptr ptr (void) mgl_write_svg
+libmgl mgl_write_idtf ptr ptr ptr (void) mgl_write_idtf
+libmgl mgl_write_gif ptr ptr ptr (void) mgl_write_gif
+libmgl mgl_start_gif int ptr ptr (void) mgl_start_gif
+libmgl mgl_close_gif ptr (void) mgl_close_gif
+libmgl mgl_get_rgb ptr (ptr) mgl_get_rgb
+libmgl mgl_get_rgba ptr (ptr) mgl_get_rgba
+libmgl mgl_get_width ptr (int) mgl_get_width
+libmgl mgl_get_height ptr (int) mgl_get_height
+libmgl mgl_new_frame ptr (int) mgl_new_frame
+libmgl mgl_end_frame ptr (void) mgl_end_frame
+libmgl mgl_get_num_frame ptr (int) mgl_get_num_frame
+libmgl mgl_reset_frames ptr (void) mgl_reset_frames
+libmgl mgl_set_transp_type int ptr (void) mgl_set_transp_type
+libmgl mgl_set_transp int ptr (void) mgl_set_transp
+libmgl mgl_set_alpha int ptr (void) mgl_set_alpha
+libmgl mgl_set_fog sf sf ptr (void) mgl_set_fog
+libmgl mgl_set_light int ptr (void) mgl_set_light
+libmgl mgl_set_light_n int int ptr (void) mgl_set_light_n
+libmgl mgl_add_light ptr sf sf sf int ptr (void) mgl_add_light
+libmgl mgl_add_light_rgb sf sf sf sf int sf sf sf int ptr (void) mgl_add_light_rgb
+libmgl mgl_set_ambbr sf ptr (void) mgl_set_ambbr
+libmgl mgl_identity ptr (void) mgl_identity
+libmgl mgl_clf ptr (void) mgl_clf
+libmgl mgl_flush ptr (void) mgl_flush
+libmgl mgl_clf_rgb sf sf sf ptr (void) mgl_clf_rgb
+libmgl mgl_subplot int int int ptr (void) mgl_subplot
+libmgl mgl_subplot_d sf sf int int int ptr (void) mgl_subplot_d
+libmgl mgl_inplot sf sf sf sf ptr (void) mgl_inplot
+libmgl mgl_relplot sf sf sf sf ptr (void) mgl_relplot
+libmgl mgl_columnplot int int ptr (void) mgl_columnplot
+libmgl mgl_aspect sf sf sf ptr (void) mgl_aspect
+libmgl mgl_rotate sf sf sf ptr (void) mgl_rotate
+libmgl mgl_rotate_vector sf sf sf sf ptr (void) mgl_rotate_vector
+libmgl mgl_perspective sf ptr (void) mgl_perspective
+libmgl mgl_set_ticks sf sf sf ptr (void) mgl_set_ticks
+libmgl mgl_set_subticks int int int ptr (void) mgl_set_subticks
+libmgl mgl_set_ticks_dir sf int sf ptr ptr (void) mgl_set_ticks_dir
+\ libmgl mgl_set_ticks_val ... ptr double val int ptr ptr (void) mgl_set_ticks_val
+libmgl mgl_set_ticks_vals ptr sf int ptr ptr (void) mgl_set_ticks_vals
+libmgl mgl_set_caxis sf sf ptr (void) mgl_set_caxis
+libmgl mgl_set_axis sf sf sf sf sf sf sf sf sf ptr (void) mgl_set_axis
+libmgl mgl_set_axis_3d sf sf sf sf sf sf ptr (void) mgl_set_axis_3d
+libmgl mgl_set_axis_2d sf sf sf sf ptr (void) mgl_set_axis_2d
+libmgl mgl_set_origin sf sf sf ptr (void) mgl_set_origin
+libmgl mgl_set_tick_origin sf sf sf ptr (void) mgl_set_tick_origin
+libmgl mgl_set_crange int ptr ptr (void) mgl_set_crange
+libmgl mgl_set_xrange int ptr ptr (void) mgl_set_xrange
+libmgl mgl_set_yrange int ptr ptr (void) mgl_set_yrange
+libmgl mgl_set_zrange int ptr ptr (void) mgl_set_zrange
+libmgl mgl_set_auto sf sf sf sf sf sf ptr (void) mgl_set_auto
+libmgl mgl_set_func ptr ptr ptr ptr (void) mgl_set_func
+libmgl mgl_set_ternary int ptr (void) mgl_set_ternary
+libmgl mgl_set_cutoff ptr ptr (void) mgl_set_cutoff
+libmgl mgl_box int ptr (void) mgl_box
+libmgl mgl_box_str int ptr ptr (void) mgl_box_str
+libmgl mgl_box_rgb int sf sf sf ptr (void) mgl_box_rgb
+libmgl mgl_axis ptr ptr (void) mgl_axis
+libmgl mgl_axis_grid ptr ptr ptr (void) mgl_axis_grid
+libmgl mgl_label ptr ptr ptr (void) mgl_label
+libmgl mgl_label_ext sf sf int ptr ptr ptr (void) mgl_label_ext
+libmgl mgl_tune_ticks sf int ptr (void) mgl_tune_ticks
+libmgl mgl_set_xttw ptr ptr (void) mgl_set_xttw
+libmgl mgl_set_yttw ptr ptr (void) mgl_set_yttw
+libmgl mgl_set_zttw ptr ptr (void) mgl_set_zttw
+libmgl mgl_set_cttw ptr ptr (void) mgl_set_cttw
+libmgl mgl_set_xtt ptr ptr (void) mgl_set_xtt
+libmgl mgl_set_ytt ptr ptr (void) mgl_set_ytt
+libmgl mgl_set_ztt ptr ptr (void) mgl_set_ztt
+libmgl mgl_set_ctt ptr ptr (void) mgl_set_ctt
+libmgl mgl_ball sf sf sf ptr (void) mgl_ball
+libmgl mgl_ball_rgb sf sf sf sf sf sf sf ptr (void) mgl_ball_rgb
+libmgl mgl_ball_str ptr sf sf sf ptr (void) mgl_ball_str
+libmgl mgl_line int ptr sf sf sf sf sf sf ptr (void) mgl_line
+libmgl mgl_facex sf sf ptr sf sf sf sf sf ptr (void) mgl_facex
+libmgl mgl_facey sf sf ptr sf sf sf sf sf ptr (void) mgl_facey
+libmgl mgl_facez sf sf ptr sf sf sf sf sf ptr (void) mgl_facez
+libmgl mgl_curve int ptr sf sf sf sf sf sf sf sf sf sf sf sf ptr (void) mgl_curve
+libmgl mgl_puts ptr sf sf sf ptr (void) mgl_puts
+libmgl mgl_putsw ptr sf sf sf ptr (void) mgl_putsw
+libmgl mgl_puts_dir sf ptr sf sf sf sf sf sf ptr (void) mgl_puts_dir
+libmgl mgl_putsw_dir sf ptr sf sf sf sf sf sf ptr (void) mgl_putsw_dir
+libmgl mgl_text ptr sf sf sf ptr (void) mgl_text
+libmgl mgl_title sf ptr ptr ptr (void) mgl_title
+libmgl mgl_titlew sf ptr ptr ptr (void) mgl_titlew
+libmgl mgl_putsw_ext ptr sf ptr ptr sf sf sf ptr (void) mgl_putsw_ext
+libmgl mgl_puts_ext ptr sf ptr ptr sf sf sf ptr (void) mgl_puts_ext
+libmgl mgl_text_ext ptr sf ptr ptr sf sf sf ptr (void) mgl_text_ext
+libmgl mgl_colorbar int ptr ptr (void) mgl_colorbar
+libmgl mgl_colorbar_ext sf sf sf sf int ptr ptr (void) mgl_colorbar_ext
+libmgl mgl_simple_plot ptr int ptr ptr (void) mgl_simple_plot
+libmgl mgl_add_legend ptr ptr ptr (void) mgl_add_legend
+libmgl mgl_add_legendw ptr ptr ptr (void) mgl_add_legendw
+libmgl mgl_clear_legend ptr (void) mgl_clear_legend
+libmgl mgl_legend_xy sf sf ptr sf sf ptr (void) mgl_legend_xy
+libmgl mgl_legend sf sf ptr int ptr (void) mgl_legend
+libmgl mgl_set_legend_box int ptr (void) mgl_set_legend_box
+libmgl mgl_fplot int ptr ptr ptr (void) mgl_fplot
+libmgl mgl_fplot_xyz int ptr ptr ptr ptr ptr (void) mgl_fplot_xyz
+libmgl mgl_plot_xyz ptr ptr ptr ptr ptr (void) mgl_plot_xyz
+libmgl mgl_plot_xy ptr ptr ptr ptr (void) mgl_plot_xy
+libmgl mgl_plot ptr ptr ptr (void) mgl_plot
+libmgl mgl_plot_2 ptr ptr ptr (void) mgl_plot_2
+libmgl mgl_plot_3 ptr ptr ptr (void) mgl_plot_3
+libmgl mgl_tens_xyz ptr ptr ptr ptr ptr ptr (void) mgl_tens_xyz
+libmgl mgl_tens_xy ptr ptr ptr ptr ptr (void) mgl_tens_xy
+libmgl mgl_tens ptr ptr ptr ptr (void) mgl_tens
+libmgl mgl_area_xyz ptr ptr ptr ptr ptr (void) mgl_area_xyz
+libmgl mgl_area_xy ptr ptr ptr ptr (void) mgl_area_xy
+libmgl mgl_area_xys ptr ptr ptr ptr (void) mgl_area_xys
+libmgl mgl_area ptr ptr ptr (void) mgl_area
+libmgl mgl_area_2 ptr ptr ptr (void) mgl_area_2
+libmgl mgl_area_3 ptr ptr ptr (void) mgl_area_3
+libmgl mgl_region_xy int ptr ptr ptr ptr ptr (void) mgl_region_xy
+libmgl mgl_region int ptr ptr ptr ptr (void) mgl_region
+libmgl mgl_mark ptr sf sf sf ptr (void) mgl_mark
+libmgl mgl_stem_xyz ptr ptr ptr ptr ptr (void) mgl_stem_xyz
+libmgl mgl_stem_xy ptr ptr ptr ptr (void) mgl_stem_xy
+libmgl mgl_stem ptr ptr ptr (void) mgl_stem
+libmgl mgl_stem_2 ptr ptr ptr (void) mgl_stem_2
+libmgl mgl_stem_3 ptr ptr ptr (void) mgl_stem_3
+libmgl mgl_step_xyz ptr ptr ptr ptr ptr (void) mgl_step_xyz
+libmgl mgl_step_xy ptr ptr ptr ptr (void) mgl_step_xy
+libmgl mgl_step ptr ptr ptr (void) mgl_step
+libmgl mgl_step_2 ptr ptr ptr (void) mgl_step_2
+libmgl mgl_step_3 ptr ptr ptr (void) mgl_step_3
+libmgl mgl_bars_xyz ptr ptr ptr ptr ptr (void) mgl_bars_xyz
+libmgl mgl_bars_xy ptr ptr ptr ptr (void) mgl_bars_xy
+libmgl mgl_bars ptr ptr ptr (void) mgl_bars
+libmgl mgl_bars_2 ptr ptr ptr (void) mgl_bars_2
+libmgl mgl_bars_3 ptr ptr ptr (void) mgl_bars_3
+libmgl mgl_barh_yx ptr ptr ptr ptr (void) mgl_barh_yx
+libmgl mgl_barh ptr ptr ptr (void) mgl_barh
+libmgl mgl_torus ptr ptr ptr ptr (void) mgl_torus
+libmgl mgl_torus_2 ptr ptr ptr (void) mgl_torus_2
+libmgl mgl_text_xyz sf ptr ptr ptr ptr ptr ptr (void) mgl_text_xyz
+libmgl mgl_text_xy sf ptr ptr ptr ptr ptr (void) mgl_text_xy
+libmgl mgl_text_y sf ptr ptr ptr ptr (void) mgl_text_y
+libmgl mgl_chart ptr ptr ptr (void) mgl_chart
+libmgl mgl_error ptr ptr ptr ptr (void) mgl_error
+libmgl mgl_error_xy ptr ptr ptr ptr ptr (void) mgl_error_xy
+libmgl mgl_error_exy ptr ptr ptr ptr ptr ptr (void) mgl_error_exy
+libmgl mgl_mark_xyz ptr ptr ptr ptr ptr ptr (void) mgl_mark_xyz
+libmgl mgl_mark_xy ptr ptr ptr ptr ptr (void) mgl_mark_xy
+libmgl mgl_mark_y ptr ptr ptr ptr (void) mgl_mark_y
+libmgl mgl_tube_xyzr ptr ptr ptr ptr ptr ptr (void) mgl_tube_xyzr
+libmgl mgl_tube_xyr ptr ptr ptr ptr ptr (void) mgl_tube_xyr
+libmgl mgl_tube_r ptr ptr ptr ptr (void) mgl_tube_r
+libmgl mgl_tube_xyz ptr sf ptr ptr ptr ptr (void) mgl_tube_xyz
+libmgl mgl_tube_xy ptr sf ptr ptr ptr (void) mgl_tube_xy
+libmgl mgl_tube ptr sf ptr ptr (void) mgl_tube
+libmgl mgl_textmark_xyzr ptr ptr ptr ptr ptr ptr ptr (void) mgl_textmark_xyzr
+libmgl mgl_textmark_xyr ptr ptr ptr ptr ptr ptr (void) mgl_textmark_xyr
+libmgl mgl_textmark_yr ptr ptr ptr ptr ptr (void) mgl_textmark_yr
+libmgl mgl_textmark ptr ptr ptr ptr (void) mgl_textmark
+libmgl mgl_textmarkw_xyzr ptr ptr ptr ptr ptr ptr ptr (void) mgl_textmarkw_xyzr
+libmgl mgl_textmarkw_xyr ptr ptr ptr ptr ptr ptr (void) mgl_textmarkw_xyr
+libmgl mgl_textmarkw_yr ptr ptr ptr ptr ptr (void) mgl_textmarkw_yr
+libmgl mgl_textmarkw ptr ptr ptr ptr (void) mgl_textmarkw
+libmgl mgl_fsurf int ptr ptr ptr (void) mgl_fsurf
+libmgl mgl_fsurf_xyz int ptr ptr ptr ptr ptr (void) mgl_fsurf_xyz
+libmgl mgl_grid_xy sf ptr ptr ptr ptr ptr (void) mgl_grid_xy
+libmgl mgl_grid sf ptr ptr ptr (void) mgl_grid
+libmgl mgl_mesh_xy ptr ptr ptr ptr ptr (void) mgl_mesh_xy
+libmgl mgl_mesh ptr ptr ptr (void) mgl_mesh
+libmgl mgl_fall_xy ptr ptr ptr ptr ptr (void) mgl_fall_xy
+libmgl mgl_fall ptr ptr ptr (void) mgl_fall
+libmgl mgl_belt_xy ptr ptr ptr ptr ptr (void) mgl_belt_xy
+libmgl mgl_belt ptr ptr ptr (void) mgl_belt
+libmgl mgl_surf_xy ptr ptr ptr ptr ptr (void) mgl_surf_xy
+libmgl mgl_surf ptr ptr ptr (void) mgl_surf
+libmgl mgl_dens_xy sf ptr ptr ptr ptr ptr (void) mgl_dens_xy
+libmgl mgl_dens sf ptr ptr ptr (void) mgl_dens
+libmgl mgl_boxs_xy sf ptr ptr ptr ptr ptr (void) mgl_boxs_xy
+libmgl mgl_boxs sf ptr ptr ptr (void) mgl_boxs
+libmgl mgl_tile_xy ptr ptr ptr ptr ptr (void) mgl_tile_xy
+libmgl mgl_tile ptr ptr ptr (void) mgl_tile
+libmgl mgl_tiles_xy ptr ptr ptr ptr ptr ptr (void) mgl_tiles_xy
+libmgl mgl_tiles ptr ptr ptr ptr (void) mgl_tiles
+libmgl mgl_cont_xy_val sf ptr ptr ptr ptr ptr ptr (void) mgl_cont_xy_val
+libmgl mgl_cont_val sf ptr ptr ptr ptr (void) mgl_cont_val
+libmgl mgl_cont_xy sf int ptr ptr ptr ptr ptr (void) mgl_cont_xy
+libmgl mgl_cont sf int ptr ptr ptr (void) mgl_cont
+libmgl mgl_contf_xy_val sf ptr ptr ptr ptr ptr ptr (void) mgl_contf_xy_val
+libmgl mgl_contf_val sf ptr ptr ptr ptr (void) mgl_contf_val
+libmgl mgl_contf_xy sf int ptr ptr ptr ptr ptr (void) mgl_contf_xy
+libmgl mgl_contf sf int ptr ptr ptr (void) mgl_contf
+libmgl mgl_axial_xy_val ptr ptr ptr ptr ptr ptr (void) mgl_axial_xy_val
+libmgl mgl_axial_val ptr ptr ptr ptr (void) mgl_axial_val
+libmgl mgl_axial_xy int ptr ptr ptr ptr ptr (void) mgl_axial_xy
+libmgl mgl_axial int ptr ptr ptr (void) mgl_axial
+libmgl mgl_surfc_xy ptr ptr ptr ptr ptr ptr (void) mgl_surfc_xy
+libmgl mgl_surfc ptr ptr ptr ptr (void) mgl_surfc
+libmgl mgl_surfa_xy ptr ptr ptr ptr ptr ptr (void) mgl_surfa_xy
+libmgl mgl_surfa ptr ptr ptr ptr (void) mgl_surfa
+libmgl mgl_stfa_xy sf ptr int ptr ptr ptr ptr ptr (void) mgl_stfa_xy
+libmgl mgl_stfa sf ptr int ptr ptr ptr (void) mgl_stfa
+libmgl mgl_vect_xy sf ptr ptr ptr ptr ptr ptr (void) mgl_vect_xy
+libmgl mgl_vect_2d sf ptr ptr ptr ptr (void) mgl_vect_2d
+libmgl mgl_vectl_xy sf ptr ptr ptr ptr ptr ptr (void) mgl_vectl_xy
+libmgl mgl_vectl_2d sf ptr ptr ptr ptr (void) mgl_vectl_2d
+libmgl mgl_vectc_xy sf ptr ptr ptr ptr ptr ptr (void) mgl_vectc_xy
+libmgl mgl_vectc_2d sf ptr ptr ptr ptr (void) mgl_vectc_2d
+libmgl mgl_vect_xyz ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_vect_xyz
+libmgl mgl_vect_3d ptr ptr ptr ptr ptr (void) mgl_vect_3d
+libmgl mgl_vectl_xyz ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_vectl_xyz
+libmgl mgl_vectl_3d ptr ptr ptr ptr ptr (void) mgl_vectl_3d
+libmgl mgl_vectc_xyz ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_vectc_xyz
+libmgl mgl_vectc_3d ptr ptr ptr ptr ptr (void) mgl_vectc_3d
+libmgl mgl_map_xy int int ptr ptr ptr ptr ptr ptr (void) mgl_map_xy
+libmgl mgl_map int int ptr ptr ptr ptr (void) mgl_map
+libmgl mgl_surf3a_xyz_val ptr ptr ptr ptr ptr ptr sf ptr (void) mgl_surf3a_xyz_val
+libmgl mgl_surf3a_val ptr ptr ptr sf ptr (void) mgl_surf3a_val
+libmgl mgl_surf3a_xyz int ptr ptr ptr ptr ptr ptr ptr (void) mgl_surf3a_xyz
+libmgl mgl_surf3a int ptr ptr ptr ptr (void) mgl_surf3a
+libmgl mgl_surf3c_xyz_val ptr ptr ptr ptr ptr ptr sf ptr (void) mgl_surf3c_xyz_val
+libmgl mgl_surf3c_val ptr ptr ptr sf ptr (void) mgl_surf3c_val
+libmgl mgl_surf3c_xyz (void) mgl_surf3c_xyz
+libmgl mgl_surf3c int ptr ptr ptr ptr (void) mgl_surf3c
+libmgl mgl_flow_xy sf int int ptr ptr ptr ptr ptr ptr (void) mgl_flow_xy
+libmgl mgl_flow_2d sf int int ptr ptr ptr ptr (void) mgl_flow_2d
+libmgl mgl_flow_xyz int int ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_flow_xyz
+libmgl mgl_flow_3d int int ptr ptr ptr ptr ptr (void) mgl_flow_3d
+libmgl mgl_pipe_xy sf int int sf ptr ptr ptr ptr ptr ptr (void) mgl_pipe_xy
+libmgl mgl_pipe_2d sf int int sf ptr ptr ptr ptr (void) mgl_pipe_2d
+libmgl mgl_pipe_xyz int int sf ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_pipe_xyz
+libmgl mgl_pipe_3d int int sf ptr ptr ptr ptr ptr (void) mgl_pipe_3d
+libmgl mgl_dew_xy sf ptr ptr ptr ptr ptr ptr (void) mgl_dew_xy
+libmgl mgl_dew_2d sf ptr ptr ptr ptr (void) mgl_dew_2d
+libmgl mgl_grid3_xyz ptr int ptr ptr ptr ptr ptr ptr (void) mgl_grid3_xyz
+libmgl mgl_grid3 ptr int ptr ptr ptr (void) mgl_grid3
+libmgl mgl_grid3_all_xyz ptr ptr ptr ptr ptr ptr (void) mgl_grid3_all_xyz
+libmgl mgl_grid3_all ptr ptr ptr (void) mgl_grid3_all
+libmgl mgl_dens3_xyz ptr int ptr ptr ptr ptr ptr ptr (void) mgl_dens3_xyz
+libmgl mgl_dens3 ptr int ptr ptr ptr (void) mgl_dens3
+libmgl mgl_dens3_all_xyz ptr ptr ptr ptr ptr ptr (void) mgl_dens3_all_xyz
+libmgl mgl_dens3_all ptr ptr ptr (void) mgl_dens3_all
+libmgl mgl_surf3_xyz_val ptr ptr ptr ptr ptr sf ptr (void) mgl_surf3_xyz_val
+libmgl mgl_surf3_val ptr ptr sf ptr (void) mgl_surf3_val
+libmgl mgl_surf3_xyz int ptr ptr ptr ptr ptr ptr (void) mgl_surf3_xyz
+libmgl mgl_surf3 int ptr ptr ptr (void) mgl_surf3
+libmgl mgl_cont3_xyz_val ptr int ptr ptr ptr ptr ptr ptr ptr (void) mgl_cont3_xyz_val
+libmgl mgl_cont3_val ptr int ptr ptr ptr ptr (void) mgl_cont3_val
+libmgl mgl_cont3_xyz int ptr int ptr ptr ptr ptr ptr ptr (void) mgl_cont3_xyz
+libmgl mgl_cont3 int ptr int ptr ptr ptr (void) mgl_cont3
+libmgl mgl_cont_all_xyz int ptr ptr ptr ptr ptr ptr (void) mgl_cont_all_xyz
+libmgl mgl_cont_all int ptr ptr ptr (void) mgl_cont_all
+libmgl mgl_cloudp_xyz sf ptr ptr ptr ptr ptr ptr (void) mgl_cloudp_xyz
+libmgl mgl_cloudp sf ptr ptr ptr (void) mgl_cloudp
+libmgl mgl_cloud_xyz sf ptr ptr ptr ptr ptr ptr (void) mgl_cloud_xyz
+libmgl mgl_cloud sf ptr ptr ptr (void) mgl_cloud
+libmgl mgl_contf3_xyz_val ptr int ptr ptr ptr ptr ptr ptr ptr (void) mgl_contf3_xyz_val
+libmgl mgl_contf3_val ptr int ptr ptr ptr ptr (void) mgl_contf3_val
+libmgl mgl_contf3_xyz int ptr int ptr ptr ptr ptr ptr ptr (void) mgl_contf3_xyz
+libmgl mgl_contf3 int ptr int ptr ptr ptr (void) mgl_contf3
+libmgl mgl_contf_all_xyz int ptr ptr ptr ptr ptr ptr (void) mgl_contf_all_xyz
+libmgl mgl_contf_all int ptr ptr ptr (void) mgl_contf_all
+libmgl mgl_beam_val int ptr sf ptr ptr ptr ptr sf ptr (void) mgl_beam_val
+libmgl mgl_beam int int ptr sf ptr ptr ptr ptr ptr (void) mgl_beam
+libmgl mgl_triplot_xyzc ptr ptr ptr ptr ptr ptr ptr (void) mgl_triplot_xyzc
+libmgl mgl_triplot_xyz ptr ptr ptr ptr ptr ptr (void) mgl_triplot_xyz
+libmgl mgl_triplot_xy sf ptr ptr ptr ptr ptr (void) mgl_triplot_xy
+libmgl mgl_dots ptr ptr ptr ptr ptr (void) mgl_dots
+libmgl mgl_dots_tr ptr ptr ptr (void) mgl_dots_tr
+libmgl mgl_crust sf ptr ptr ptr ptr ptr (void) mgl_crust
+libmgl mgl_crust_tr sf ptr ptr ptr (void) mgl_crust_tr
+libmgl mgl_dens_x sf ptr ptr ptr (void) mgl_dens_x
+libmgl mgl_dens_y sf ptr ptr ptr (void) mgl_dens_y
+libmgl mgl_dens_z sf ptr ptr ptr (void) mgl_dens_z
+libmgl mgl_cont_x int sf ptr ptr ptr (void) mgl_cont_x
+libmgl mgl_cont_y int sf ptr ptr ptr (void) mgl_cont_y
+libmgl mgl_cont_z int sf ptr ptr ptr (void) mgl_cont_z
+libmgl mgl_cont_x_val sf ptr ptr ptr ptr (void) mgl_cont_x_val
+libmgl mgl_cont_y_val sf ptr ptr ptr ptr (void) mgl_cont_y_val
+libmgl mgl_cont_z_val sf ptr ptr ptr ptr (void) mgl_cont_z_val
+libmgl mgl_contf_x int sf ptr ptr ptr (void) mgl_contf_x
+libmgl mgl_contf_y int sf ptr ptr ptr (void) mgl_contf_y
+libmgl mgl_contf_z int sf ptr ptr ptr (void) mgl_contf_z
+libmgl mgl_contf_x_val sf ptr ptr ptr ptr (void) mgl_contf_x_val
+libmgl mgl_contf_y_val sf ptr ptr ptr ptr (void) mgl_contf_y_val
+libmgl mgl_contf_z_val sf ptr ptr ptr ptr (void) mgl_contf_z_val
+libmgl mgl_data_rearrange int int int ptr (void) mgl_data_rearrange
+libmgl mgl_data_set_float int int int sf ptr (void) mgl_data_set_float
+libmgl mgl_data_set_double int int int df ptr (void) mgl_data_set_double
+libmgl mgl_data_set_float2 int int sf ptr (void) mgl_data_set_float2
+libmgl mgl_data_set_double2 int int df ptr (void) mgl_data_set_double2
+libmgl mgl_data_set_float3 int int int sf ptr (void) mgl_data_set_float3
+libmgl mgl_data_set_double3 int int int ptr ptr (void) mgl_data_set_double3
+libmgl mgl_data_set ptr ptr (void) mgl_data_set
+libmgl mgl_data_set_vector ptr ptr (void) mgl_data_set_vector
+libmgl mgl_data_set_matrix ptr ptr (void) mgl_data_set_matrix
+libmgl mgl_data_get_value int int int ptr (fp) mgl_data_get_value
+libmgl mgl_data_get_nx ptr (int) mgl_data_get_nx
+libmgl mgl_data_get_ny ptr (int) mgl_data_get_ny
+libmgl mgl_data_get_nz ptr (int) mgl_data_get_nz
+libmgl mgl_data_set_value int int int sf ptr (void) mgl_data_set_value
+libmgl mgl_data_set_values int int int ptr ptr (void) mgl_data_set_values
+libmgl mgl_data_read ptr ptr (int) mgl_data_read
+libmgl mgl_data_read_mat int ptr ptr (int) mgl_data_read_mat
+libmgl mgl_data_read_dim int int int ptr ptr (int) mgl_data_read_dim
+libmgl mgl_data_save int ptr ptr (void) mgl_data_save
+libmgl mgl_data_export int sf sf ptr ptr ptr (void) mgl_data_export
+libmgl mgl_data_import sf sf ptr ptr ptr (void) mgl_data_import
+libmgl mgl_data_create int int int ptr (void) mgl_data_create
+libmgl mgl_data_transpose ptr ptr (void) mgl_data_transpose
+libmgl mgl_data_norm int int sf sf ptr (void) mgl_data_norm
+libmgl mgl_data_norm_slice int int ptr sf sf ptr (void) mgl_data_norm_slice
+libmgl mgl_data_subdata int int int ptr (ptr) mgl_data_subdata
+libmgl mgl_data_column ptr ptr (ptr) mgl_data_column
+libmgl mgl_data_set_id ptr ptr (void) mgl_data_set_id
+libmgl mgl_data_fill ptr sf sf ptr (void) mgl_data_fill
+libmgl mgl_data_fill_eq ptr ptr ptr ptr ptr (void) mgl_data_fill_eq
+libmgl mgl_data_put_val int int int sf ptr (void) mgl_data_put_val
+libmgl mgl_data_put_dat int int int ptr ptr (void) mgl_data_put_dat
+libmgl mgl_data_modify int ptr ptr (void) mgl_data_modify
+libmgl mgl_data_modify_vw ptr ptr ptr ptr (void) mgl_data_modify_vw
+libmgl mgl_data_squeeze int int int int ptr (void) mgl_data_squeeze
+libmgl mgl_data_max ptr (fp) mgl_data_max
+libmgl mgl_data_min ptr (fp) mgl_data_min
+libmgl mgl_data_value int int int ptr (fp) mgl_data_value
+libmgl mgl_data_combine ptr ptr (ptr) mgl_data_combine
+libmgl mgl_data_extend int int ptr (void) mgl_data_extend
+libmgl mgl_data_insert int int ptr ptr (void) mgl_data_insert
+libmgl mgl_data_delete int int ptr ptr (void) mgl_data_delete
+libmgl mgl_data_smooth ptr sf int ptr (void) mgl_data_smooth
+libmgl mgl_data_sum ptr ptr (ptr) mgl_data_sum
+libmgl mgl_data_max_dir ptr ptr (ptr) mgl_data_max_dir
+libmgl mgl_data_min_dir ptr ptr (ptr) mgl_data_min_dir
+libmgl mgl_data_cumsum ptr ptr (void) mgl_data_cumsum
+libmgl mgl_data_integral ptr ptr (void) mgl_data_integral
+libmgl mgl_data_diff ptr ptr (void) mgl_data_diff
+libmgl mgl_data_diff_par ptr ptr ptr ptr (void) mgl_data_diff_par
+libmgl mgl_data_diff2 ptr ptr (void) mgl_data_diff2
+libmgl mgl_data_swap ptr ptr (void) mgl_data_swap
+libmgl mgl_data_mirror ptr ptr (void) mgl_data_mirror
+libmgl mgl_data_spline sf sf sf ptr (fp) mgl_data_spline
+libmgl mgl_data_spline1 sf sf sf ptr (fp) mgl_data_spline1
+libmgl mgl_data_linear sf sf sf ptr (fp) mgl_data_linear
+libmgl mgl_data_linear1 sf sf sf ptr (fp) mgl_data_linear1
+libmgl mgl_data_resize int int int ptr (ptr) mgl_data_resize
+libmgl mgl_data_resize_box (ptr) mgl_data_resize_box
+libmgl mgl_data_hist int sf sf int ptr (ptr) mgl_data_hist
+libmgl mgl_data_hist_w int sf sf int ptr ptr (ptr) mgl_data_hist_w
+libmgl mgl_data_momentum ptr ptr ptr (ptr) mgl_data_momentum
+libmgl mgl_data_evaluate_i int ptr ptr (ptr) mgl_data_evaluate_i
+libmgl mgl_data_evaluate_ij int ptr ptr ptr (ptr) mgl_data_evaluate_ij
+libmgl mgl_data_evaluate_ijk int ptr ptr ptr ptr (ptr) mgl_data_evaluate_ijk
+libmgl mgl_data_envelop ptr ptr (void) mgl_data_envelop
+libmgl mgl_data_sew sf ptr ptr (void) mgl_data_sew
+libmgl mgl_data_crop ptr int int ptr (void) mgl_data_crop
+libmgl mgl_data_mul_dat ptr ptr (void) mgl_data_mul_dat
+libmgl mgl_data_div_dat ptr ptr (void) mgl_data_div_dat
+libmgl mgl_data_add_dat ptr ptr (void) mgl_data_add_dat
+libmgl mgl_data_sub_dat ptr ptr (void) mgl_data_sub_dat
+libmgl mgl_data_mul_num sf ptr (void) mgl_data_mul_num
+libmgl mgl_data_div_num sf ptr (void) mgl_data_div_num
+libmgl mgl_data_add_num sf ptr (void) mgl_data_add_num
+libmgl mgl_data_sub_num sf ptr (void) mgl_data_sub_num
+libmgl mgl_fit_1 sf ptr ptr ptr ptr ptr (fp) mgl_fit_1
+libmgl mgl_fit_2 sf ptr ptr ptr ptr ptr (fp) mgl_fit_2
+libmgl mgl_fit_3 sf ptr ptr ptr ptr ptr (fp) mgl_fit_3
+libmgl mgl_fit_xy sf ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xy
+libmgl mgl_fit_xyz sf ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyz
+libmgl mgl_fit_xyza sf ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyza
+libmgl mgl_fit_ys sf ptr ptr ptr ptr ptr ptr (fp) mgl_fit_ys
+libmgl mgl_fit_xys sf ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xys
+libmgl mgl_fit_xyzs sf ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyzs
+libmgl mgl_fit_xyzas sf ptr ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyzas
+libmgl mgl_fit_1_d ptr ptr ptr ptr ptr ptr (fp) mgl_fit_1_d
+libmgl mgl_fit_2_d ptr ptr ptr ptr ptr ptr (fp) mgl_fit_2_d
+libmgl mgl_fit_3_d ptr ptr ptr ptr ptr ptr (fp) mgl_fit_3_d
+libmgl mgl_fit_xy_d ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xy_d
+libmgl mgl_fit_xyz_d ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyz_d
+libmgl mgl_fit_xyza_d ptr ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyza_d
+libmgl mgl_fit_ys_d ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_ys_d
+libmgl mgl_fit_xys_d ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xys_d
+libmgl mgl_fit_xyzs_d ptr ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyzs_d
+libmgl mgl_fit_xyzas_d ptr ptr ptr ptr ptr ptr ptr ptr ptr ptr (fp) mgl_fit_xyzas_d
+libmgl mgl_puts_fit sf ptr ptr sf sf sf ptr (void) mgl_puts_fit
+libmgl mgl_sphere ptr sf sf sf sf ptr (void) mgl_sphere
+libmgl mgl_drop sf sf ptr sf sf sf sf sf sf sf ptr (void) mgl_drop
+libmgl mgl_cone int ptr sf sf sf sf sf sf sf sf ptr (void) mgl_cone
+libmgl mgl_pde_solve sf sf ptr ptr ptr ptr (ptr) mgl_pde_solve
+libmgl mgl_qo2d_solve ptr ptr sf sf ptr ptr ptr ptr (ptr) mgl_qo2d_solve
+libmgl mgl_af2d_solve ptr ptr sf sf ptr ptr ptr ptr (ptr) mgl_af2d_solve
+libmgl mgl_ray_trace sf sf sf sf sf sf sf sf ptr (ptr) mgl_ray_trace
+libmgl mgl_jacobian_2d ptr ptr (ptr) mgl_jacobian_2d
+libmgl mgl_jacobian_3d ptr ptr ptr (ptr) mgl_jacobian_3d
+libmgl mgl_transform_a ptr ptr ptr (ptr) mgl_transform_a
+libmgl mgl_transform ptr ptr ptr (ptr) mgl_transform
+libmgl mgl_data_stfa ptr int ptr ptr (ptr) mgl_data_stfa
+
+legacy on
+
+previous
+Module;
--- /dev/null
+\ Mathgl library wrapper
+\ Copyright (C) 2008-2013, Sergey Plis, Alexey Balakin
+\
+\ 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.
+
+Module mathgl
+library libmgl libmgl.so
+library libmgl-glut libmgl-glut.so
+library libmgl-fltk libmgl-fltk.so
+library libmgl-qt libmgl-qt.so
+library libmgl-wx libmgl-wx.so
+legacy off
+
+libmgl mgl_create_graph_gl (ptr) mgl_create_graph_gl
+libmgl-glut mgl_create_graph_glut ptr ptr ptr (ptr) mgl_create_graph_glut
+libmgl-fltk mgl_create_graph_fltk ptr ptr ptr (ptr) mgl_create_graph_fltk
+libmgl-fltk mgl_fltk_run (void) mgl_fltk_run
+libmgl-qt mgl_create_graph_qt ptr ptr ptr (ptr) mgl_create_graph_qt
+libmgl-qt mgl_qt_run (void) mgl_qt_run
+
+libmgl mgl_get_warn ptr (int) mgl_get_warn
+libmgl mgl_set_warn ptr int ptr (void) mgl_set_warn
+libmgl gl_get_mess ptr (ptr) gl_get_mess
+libmgl mgl_set_plotid ptr ptr (void) mgl_set_plotid
+libmgl gl_get_plotid ptr (ptr) gl_get_plotid
+libmgl mgl_get_quality ptr (int) mgl_get_quality
+libmgl mgl_set_quality int ptr (void) mgl_set_quality
+libmgl mgl_set_draw_reg int int int ptr (void) mgl_set_draw_reg
+libmgl mgl_is_frames ptr (int) mgl_is_frames
+libmgl mgl_get_flag int ptr (int) mgl_get_flag
+libmgl mgl_set_flag int int ptr (void) mgl_set_flag
+libmgl mgl_use_graph int ptr (int) mgl_use_graph
+libmgl mgl_start_group ptr ptr (void) mgl_start_group
+libmgl mgl_end_group ptr (void) mgl_end_group
+libmgl mgl_highlight int ptr (void) mgl_highlight
+libmgl mgl_set_palette ptr ptr (void) mgl_set_palette
+libmgl mgl_set_color double double double char (void) mgl_set_color
+libmgl mgl_set_def_sch ptr ptr (void) mgl_set_def_sch
+libmgl mgl_set_mask ptr char (void) mgl_set_mask
+libmgl mgl_set_mask_angle int ptr (void) mgl_set_mask_angle
+libmgl mgl_set_alpha_default double ptr (void) mgl_set_alpha_default
+libmgl mgl_set_bar_width double ptr (void) mgl_set_bar_width
+libmgl mgl_set_meshnum int ptr (void) mgl_set_meshnum
+libmgl mgl_set_facenum int ptr (void) mgl_set_facenum
+libmgl mgl_clear_unused ptr (void) mgl_clear_unused
+libmgl mgl_set_ambbr double ptr (void) mgl_set_ambbr
+libmgl mgl_set_difbr double ptr (void) mgl_set_difbr
+libmgl mgl_set_light_dif int ptr (void) mgl_set_light_dif
+libmgl mgl_set_cut int ptr (void) mgl_set_cut
+libmgl mgl_set_cut_box double double double double double double ptr (void) mgl_set_cut_box
+libmgl mgl_set_cutoff ptr ptr (void) mgl_set_cutoff
+libmgl mgl_set_ranges double double double double double double ptr (void) mgl_set_ranges
+libmgl mgl_set_range_val double double char ptr (void) mgl_set_range_val
+libmgl mgl_set_range_dat int ptr char ptr (void) mgl_set_range_dat
+libmgl mgl_set_auto_ranges double double double double double double double double ptr (void) mgl_set_auto_ranges
+libmgl mgl_zoom_axis double double double double double double double double ptr (void) mgl_zoom_axis
+libmgl mgl_set_origin double double double ptr (void) mgl_set_origin
+libmgl mgl_set_func ptr ptr ptr ptr ptr (void) mgl_set_func
+libmgl mgl_set_coor int ptr (void) mgl_set_coor
+libmgl mgl_set_ternary int ptr (void) mgl_set_ternary
+libmgl mgl_set_tick_rotate int ptr (void) mgl_set_tick_rotate
+libmgl mgl_set_tick_skip int ptr (void) mgl_set_tick_skip
+libmgl mgl_def_font ptr ptr (void) mgl_def_font
+libmgl mgl_set_mark_size double ptr (void) mgl_set_mark_size
+libmgl mgl_set_arrow_size double ptr (void) mgl_set_arrow_size
+libmgl mgl_set_font_size double ptr (void) mgl_set_font_size
+libmgl mgl_set_font_def ptr ptr (void) mgl_set_font_def
+libmgl mgl_set_rotated_text int ptr (void) mgl_set_rotated_text
+libmgl mgl_load_font ptr ptr ptr (void) mgl_load_font
+libmgl mgl_copy_font ptr ptr (void) mgl_copy_font
+libmgl mgl_restore_font ptr (void) mgl_restore_font
+libmgl mgl_srnd int (void) mgl_srnd
+libmgl mgl_rnd (double) mgl_rnd
+libmgl mgl_ipow int double (double) mgl_ipow
+libmgl mgl_get_time ptr ptr (double) mgl_get_time
+libmgl mgl_create_data (ptr) mgl_create_data
+libmgl mgl_create_data_size int int int (ptr) mgl_create_data_size
+libmgl mgl_create_data_file ptr (ptr) mgl_create_data_file
+libmgl mgl_delete_data ptr (void) mgl_delete_data
+libmgl gl_data_info ptr (ptr) gl_data_info
+libmgl mgl_data_rearrange int int int ptr (void) mgl_data_rearrange
+libmgl mgl_data_link int int int ptr ptr (void) mgl_data_link
+libmgl mgl_data_set_float int int int ptr ptr (void) mgl_data_set_float
+libmgl mgl_data_set_double int int int ptr ptr (void) mgl_data_set_double
+libmgl mgl_data_set ptr ptr (void) mgl_data_set
+libmgl mgl_data_set_vector ptr ptr (void) mgl_data_set_vector
+libmgl mgl_data_set_matrix ptr ptr (void) mgl_data_set_matrix
+libmgl mgl_data_set_value int int int sf ptr (void) mgl_data_set_value
+libmgl mgl_data_get_value int int int ptr (sf) mgl_data_get_value
+libmgl mgl_data_set_values int int int ptr ptr (void) mgl_data_set_values
+libmgl mgl_data_read_hdf ptr ptr ptr (int) mgl_data_read_hdf
+libmgl mgl_data_save_hdf int ptr ptr ptr (void) mgl_data_save_hdf
+libmgl mgl_datas_hdf int ptr ptr (int) mgl_datas_hdf
+libmgl mgl_data_read ptr ptr (int) mgl_data_read
+libmgl mgl_data_read_mat int ptr ptr (int) mgl_data_read_mat
+libmgl mgl_data_read_dim int int int ptr ptr (int) mgl_data_read_dim
+libmgl mgl_data_read_range int double double double ptr ptr (int) mgl_data_read_range
+libmgl mgl_data_read_all int ptr ptr (int) mgl_data_read_all
+libmgl mgl_data_save int ptr ptr (void) mgl_data_save
+libmgl mgl_data_export int sf sf ptr ptr ptr (void) mgl_data_export
+libmgl mgl_data_import sf sf ptr ptr ptr (void) mgl_data_import
+libmgl mgl_data_create int int int ptr (void) mgl_data_create
+libmgl mgl_data_transpose ptr ptr (void) mgl_data_transpose
+libmgl mgl_data_norm int int sf sf ptr (void) mgl_data_norm
+libmgl mgl_data_norm_slice int int char sf sf ptr (void) mgl_data_norm_slice
+libmgl mgl_data_subdata int int int ptr (ptr) mgl_data_subdata
+libmgl mgl_data_subdata_ext ptr ptr ptr ptr (ptr) mgl_data_subdata_ext
+libmgl mgl_data_column ptr ptr (ptr) mgl_data_column
+libmgl mgl_data_set_id ptr ptr (void) mgl_data_set_id
+libmgl mgl_data_fill char sf sf ptr (void) mgl_data_fill
+libmgl mgl_data_fill_eq ptr ptr ptr ptr ptr ptr (void) mgl_data_fill_eq
+libmgl mgl_data_refill_x int sf sf ptr ptr ptr (void) mgl_data_refill_x
+libmgl mgl_data_refill_xy int sf sf sf sf ptr ptr ptr ptr (void) mgl_data_refill_xy
+libmgl mgl_data_refill_xyz sf sf sf sf sf sf ptr ptr ptr ptr ptr (void) mgl_data_refill_xyz
+libmgl mgl_data_refill_gr ptr int ptr ptr ptr ptr ptr ptr (void) mgl_data_refill_gr
+libmgl mgl_data_grid ptr ptr ptr ptr ptr ptr (void) mgl_data_grid
+libmgl mgl_data_grid_xy sf sf sf sf ptr ptr ptr ptr (void) mgl_data_grid_xy
+libmgl mgl_data_put_val int int int sf ptr (void) mgl_data_put_val
+libmgl mgl_data_put_dat int int int ptr ptr (void) mgl_data_put_dat
+libmgl mgl_data_modify int ptr ptr (void) mgl_data_modify
+libmgl mgl_data_modify_vw ptr ptr ptr ptr (void) mgl_data_modify_vw
+libmgl mgl_data_squeeze int int int int ptr (void) mgl_data_squeeze
+libmgl mgl_data_max ptr (sf) mgl_data_max
+libmgl mgl_data_min ptr (sf) mgl_data_min
+libmgl gl_data_value int int int ptr (ptr) gl_data_value
+libmgl gl_data_data ptr (ptr) gl_data_data
+libmgl mgl_data_get_nx ptr (int) mgl_data_get_nx
+libmgl mgl_data_get_ny ptr (int) mgl_data_get_ny
+libmgl mgl_data_get_nz ptr (int) mgl_data_get_nz
+libmgl mgl_data_first ptr ptr ptr ptr ptr (sf) mgl_data_first
+libmgl mgl_data_last ptr ptr ptr ptr ptr (sf) mgl_data_last
+libmgl mgl_data_find int int int char ptr ptr (int) mgl_data_find
+libmgl mgl_data_find_any ptr ptr (int) mgl_data_find_any
+libmgl mgl_data_max_int ptr ptr ptr ptr (sf) mgl_data_max_int
+libmgl mgl_data_max_real ptr ptr ptr ptr (sf) mgl_data_max_real
+libmgl mgl_data_min_int ptr ptr ptr ptr (sf) mgl_data_min_int
+libmgl mgl_data_min_real ptr ptr ptr ptr (sf) mgl_data_min_real
+libmgl mgl_data_momentum_val ptr ptr ptr ptr char ptr (sf) mgl_data_momentum_val
+libmgl mgl_data_combine ptr ptr (ptr) mgl_data_combine
+libmgl mgl_data_extend int int ptr (void) mgl_data_extend
+libmgl mgl_data_insert int int char ptr (void) mgl_data_insert
+libmgl mgl_data_delete int int char ptr (void) mgl_data_delete
+libmgl mgl_data_join ptr ptr (void) mgl_data_join
+libmgl mgl_data_smooth sf ptr ptr (void) mgl_data_smooth
+libmgl mgl_data_sum ptr ptr (ptr) mgl_data_sum
+libmgl mgl_data_max_dir ptr ptr (ptr) mgl_data_max_dir
+libmgl mgl_data_min_dir ptr ptr (ptr) mgl_data_min_dir
+libmgl mgl_data_cumsum ptr ptr (void) mgl_data_cumsum
+libmgl mgl_data_integral ptr ptr (void) mgl_data_integral
+libmgl mgl_data_diff ptr ptr (void) mgl_data_diff
+libmgl mgl_data_diff_par ptr ptr ptr ptr (void) mgl_data_diff_par
+libmgl mgl_data_diff2 ptr ptr (void) mgl_data_diff2
+libmgl mgl_data_swap ptr ptr (void) mgl_data_swap
+libmgl mgl_data_roll int char ptr (void) mgl_data_roll
+libmgl mgl_data_mirror ptr ptr (void) mgl_data_mirror
+libmgl mgl_data_sort int int ptr (void) mgl_data_sort
+libmgl mgl_data_hankel ptr ptr (void) mgl_data_hankel
+libmgl mgl_data_sinfft ptr ptr (void) mgl_data_sinfft
+libmgl mgl_data_cosfft ptr ptr (void) mgl_data_cosfft
+libmgl mgl_data_fill_sample ptr ptr (void) mgl_data_fill_sample
+libmgl mgl_data_correl ptr ptr ptr (ptr) mgl_data_correl
+libmgl mgl_clear_fft (void) mgl_clear_fft
+libmgl mgl_data_spline sf sf sf ptr (sf) mgl_data_spline
+libmgl mgl_data_linear sf sf sf ptr (sf) mgl_data_linear
+libmgl mgl_data_spline_ext ptr ptr ptr sf sf sf ptr (sf) mgl_data_spline_ext
+libmgl mgl_data_linear_ext ptr ptr ptr sf sf sf ptr (sf) mgl_data_linear_ext
+libmgl mgl_data_solve_1d int int sf ptr (sf) mgl_data_solve_1d
+libmgl mgl_data_solve int ptr char sf ptr (ptr) mgl_data_solve
+libmgl mgl_data_trace ptr (ptr) mgl_data_trace
+libmgl mgl_data_resize int int int ptr (ptr) mgl_data_resize
+libmgl mgl_data_resize_box sf sf sf sf sf sf int int int ptr (ptr) mgl_data_resize_box
+libmgl mgl_data_hist int sf sf int ptr (ptr) mgl_data_hist
+libmgl mgl_data_hist_w int sf sf int ptr ptr (ptr) mgl_data_hist_w
+libmgl mgl_data_momentum ptr char ptr (ptr) mgl_data_momentum
+libmgl mgl_data_evaluate int ptr ptr ptr ptr (ptr) mgl_data_evaluate
+libmgl mgl_data_envelop char ptr (void) mgl_data_envelop
+libmgl mgl_data_sew sf ptr ptr (void) mgl_data_sew
+libmgl mgl_data_crop char int int ptr (void) mgl_data_crop
+libmgl mgl_data_clean int ptr (void) mgl_data_clean
+libmgl mgl_data_mul_dat ptr ptr (void) mgl_data_mul_dat
+libmgl mgl_data_div_dat ptr ptr (void) mgl_data_div_dat
+libmgl mgl_data_add_dat ptr ptr (void) mgl_data_add_dat
+libmgl mgl_data_sub_dat ptr ptr (void) mgl_data_sub_dat
+libmgl mgl_data_mul_num sf ptr (void) mgl_data_mul_num
+libmgl mgl_data_div_num sf ptr (void) mgl_data_div_num
+libmgl mgl_data_add_num sf ptr (void) mgl_data_add_num
+libmgl mgl_data_sub_num sf ptr (void) mgl_data_sub_num
+libmgl mgl_transform_a ptr ptr ptr (ptr) mgl_transform_a
+libmgl mgl_transform ptr ptr ptr (ptr) mgl_transform
+libmgl mgl_data_fourier ptr ptr ptr (void) mgl_data_fourier
+libmgl mgl_data_stfa char int ptr ptr (ptr) mgl_data_stfa
+libmgl mgl_triangulation_3d ptr ptr ptr (ptr) mgl_triangulation_3d
+libmgl mgl_triangulation_2d ptr ptr (ptr) mgl_triangulation_2d
+libmgl mgl_find_root_txt char sf ptr (sf) mgl_find_root_txt
+libmgl mgl_data_roots char ptr ptr (ptr) mgl_data_roots
+libmgl mgl_datac_save int ptr ptr (void) mgl_datac_save
+libmgl mgl_datac_save_hdf int ptr ptr ptr (void) mgl_datac_save_hdf
+libmgl mgl_datac_real ptr (ptr) mgl_datac_real
+libmgl mgl_datac_imag ptr (ptr) mgl_datac_imag
+libmgl mgl_datac_abs ptr (ptr) mgl_datac_abs
+libmgl mgl_datac_arg ptr (ptr) mgl_datac_arg
+libmgl mgl_text_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_text_xyz
+libmgl mgl_textw_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_textw_xyz
+libmgl mgl_text_xy ptr ptr ptr ptr ptr ptr (void) mgl_text_xy
+libmgl mgl_textw_xy ptr ptr ptr ptr ptr ptr (void) mgl_textw_xy
+libmgl mgl_text_y ptr ptr ptr ptr ptr (void) mgl_text_y
+libmgl mgl_textw_y ptr ptr ptr ptr ptr (void) mgl_textw_y
+libmgl mgl_cont_gen ptr ptr ptr ptr ptr double ptr (void) mgl_cont_gen
+libmgl mgl_contf_gen ptr ptr ptr ptr ptr double double ptr (void) mgl_contf_gen
+libmgl mgl_cont_xy_val ptr ptr ptr ptr ptr ptr ptr (void) mgl_cont_xy_val
+libmgl mgl_cont_val ptr ptr ptr ptr ptr (void) mgl_cont_val
+libmgl mgl_cont_xy ptr ptr ptr ptr ptr ptr (void) mgl_cont_xy
+libmgl mgl_cont ptr ptr ptr ptr (void) mgl_cont
+libmgl mgl_contf_xy_val ptr ptr ptr ptr ptr ptr ptr (void) mgl_contf_xy_val
+libmgl mgl_contf_val ptr ptr ptr ptr ptr (void) mgl_contf_val
+libmgl mgl_contf_xy ptr ptr ptr ptr ptr ptr (void) mgl_contf_xy
+libmgl mgl_contf ptr ptr ptr ptr (void) mgl_contf
+libmgl mgl_contd_xy_val ptr ptr ptr ptr ptr ptr ptr (void) mgl_contd_xy_val
+libmgl mgl_contd_val ptr ptr ptr ptr ptr (void) mgl_contd_val
+libmgl mgl_contd_xy ptr ptr ptr ptr ptr ptr (void) mgl_contd_xy
+libmgl mgl_contd ptr ptr ptr ptr (void) mgl_contd
+libmgl mgl_contv_xy_val ptr ptr ptr ptr ptr ptr ptr (void) mgl_contv_xy_val
+libmgl mgl_contv_val ptr ptr ptr ptr ptr (void) mgl_contv_val
+libmgl mgl_contv_xy ptr ptr ptr ptr ptr ptr (void) mgl_contv_xy
+libmgl mgl_contv ptr ptr ptr ptr (void) mgl_contv
+libmgl mgl_axial_xy_val ptr ptr ptr ptr ptr ptr ptr (void) mgl_axial_xy_val
+libmgl mgl_axial_val ptr ptr ptr ptr ptr (void) mgl_axial_val
+libmgl mgl_axial_xy ptr ptr ptr ptr ptr ptr (void) mgl_axial_xy
+libmgl mgl_axial ptr ptr ptr ptr (void) mgl_axial
+libmgl mgl_torus ptr ptr ptr ptr ptr (void) mgl_torus
+libmgl mgl_grid3_xyz ptr double ptr ptr ptr ptr ptr ptr (void) mgl_grid3_xyz
+libmgl mgl_grid3 ptr double ptr ptr ptr (void) mgl_grid3
+libmgl mgl_dens3_xyz ptr double ptr ptr ptr ptr ptr ptr (void) mgl_dens3_xyz
+libmgl mgl_dens3 ptr double ptr ptr ptr (void) mgl_dens3
+libmgl mgl_cont3_xyz_val ptr double ptr ptr ptr ptr ptr ptr ptr (void) mgl_cont3_xyz_val
+libmgl mgl_cont3_val ptr double ptr ptr ptr ptr (void) mgl_cont3_val
+libmgl mgl_cont3_xyz ptr double ptr ptr ptr ptr ptr ptr (void) mgl_cont3_xyz
+libmgl mgl_cont3 ptr double ptr ptr ptr (void) mgl_cont3
+libmgl mgl_contf3_xyz_val ptr double ptr ptr ptr ptr ptr ptr ptr (void) mgl_contf3_xyz_val
+libmgl mgl_contf3_val ptr double ptr ptr ptr ptr (void) mgl_contf3_val
+libmgl mgl_contf3_xyz ptr double ptr ptr ptr ptr ptr ptr (void) mgl_contf3_xyz
+libmgl mgl_contf3 ptr double ptr ptr ptr (void) mgl_contf3
+libmgl mgl_fit_1 ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_1
+libmgl mgl_fit_2 ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_2
+libmgl mgl_fit_3 ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_3
+libmgl mgl_fit_xy ptr ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_xy
+libmgl mgl_fit_xyz ptr ptr ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_xyz
+libmgl mgl_fit_xyza ptr ptr ptr ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_xyza
+libmgl mgl_fit_ys ptr ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_ys
+libmgl mgl_fit_xys ptr ptr ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_xys
+libmgl mgl_fit_xyzs ptr ptr ptr ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_xyzs
+libmgl mgl_fit_xyzas ptr ptr ptr ptr ptr ptr ptr ptr ptr ptr (ptr) mgl_fit_xyzas
+libmgl gl_get_fit ptr (ptr) gl_get_fit
+libmgl mgl_hist_x ptr ptr ptr ptr (ptr) mgl_hist_x
+libmgl mgl_hist_xy ptr ptr ptr ptr ptr (ptr) mgl_hist_xy
+libmgl mgl_hist_xyz ptr ptr ptr ptr ptr ptr (ptr) mgl_hist_xyz
+libmgl mgl_puts_fit double ptr ptr double double double ptr (void) mgl_puts_fit
+libmgl mgl_fplot ptr ptr ptr ptr (void) mgl_fplot
+libmgl mgl_fplot_xyz ptr ptr ptr ptr ptr ptr (void) mgl_fplot_xyz
+libmgl mgl_radar ptr ptr ptr ptr (void) mgl_radar
+libmgl mgl_plot_xyz ptr ptr ptr ptr ptr ptr (void) mgl_plot_xyz
+libmgl mgl_plot_xy ptr ptr ptr ptr ptr (void) mgl_plot_xy
+libmgl mgl_plot ptr ptr ptr ptr (void) mgl_plot
+libmgl mgl_tens_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_tens_xyz
+libmgl mgl_tens_xy ptr ptr ptr ptr ptr ptr (void) mgl_tens_xy
+libmgl mgl_tens ptr ptr ptr ptr ptr (void) mgl_tens
+libmgl mgl_tape_xyz ptr ptr ptr ptr ptr ptr (void) mgl_tape_xyz
+libmgl mgl_tape_xy ptr ptr ptr ptr ptr (void) mgl_tape_xy
+libmgl mgl_tape ptr ptr ptr ptr (void) mgl_tape
+libmgl mgl_boxplot_xy ptr ptr ptr ptr ptr (void) mgl_boxplot_xy
+libmgl mgl_boxplot ptr ptr ptr ptr (void) mgl_boxplot
+libmgl mgl_area_xyz ptr ptr ptr ptr ptr ptr (void) mgl_area_xyz
+libmgl mgl_area_xy ptr ptr ptr ptr ptr (void) mgl_area_xy
+libmgl mgl_area ptr ptr ptr ptr (void) mgl_area
+libmgl mgl_region_xy ptr ptr ptr ptr ptr ptr (void) mgl_region_xy
+libmgl mgl_region ptr ptr ptr ptr ptr (void) mgl_region
+libmgl mgl_stem_xyz ptr ptr ptr ptr ptr ptr (void) mgl_stem_xyz
+libmgl mgl_stem_xy ptr ptr ptr ptr ptr (void) mgl_stem_xy
+libmgl mgl_stem ptr ptr ptr ptr (void) mgl_stem
+libmgl mgl_step_xyz ptr ptr ptr ptr ptr ptr (void) mgl_step_xyz
+libmgl mgl_step_xy ptr ptr ptr ptr ptr (void) mgl_step_xy
+libmgl mgl_step ptr ptr ptr ptr (void) mgl_step
+libmgl mgl_bars_xyz ptr ptr ptr ptr ptr ptr (void) mgl_bars_xyz
+libmgl mgl_bars_xy ptr ptr ptr ptr ptr (void) mgl_bars_xy
+libmgl mgl_bars ptr ptr ptr ptr (void) mgl_bars
+libmgl mgl_barh_yx ptr ptr ptr ptr ptr (void) mgl_barh_yx
+libmgl mgl_barh ptr ptr ptr ptr (void) mgl_barh
+libmgl mgl_ohlc_x ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_ohlc_x
+libmgl mgl_ohlc ptr ptr ptr ptr ptr ptr ptr (void) mgl_ohlc
+libmgl mgl_chart ptr ptr ptr ptr (void) mgl_chart
+libmgl mgl_error_exy ptr ptr ptr ptr ptr ptr ptr (void) mgl_error_exy
+libmgl mgl_error_xy ptr ptr ptr ptr ptr ptr (void) mgl_error_xy
+libmgl mgl_error ptr ptr ptr ptr ptr (void) mgl_error
+libmgl mgl_mark_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_mark_xyz
+libmgl mgl_mark_xy ptr ptr ptr ptr ptr ptr (void) mgl_mark_xy
+libmgl mgl_mark_y ptr ptr ptr ptr ptr (void) mgl_mark_y
+libmgl mgl_tube_xyzr ptr ptr ptr ptr ptr ptr ptr (void) mgl_tube_xyzr
+libmgl mgl_tube_xyr ptr ptr ptr ptr ptr ptr (void) mgl_tube_xyr
+libmgl mgl_tube_r ptr ptr ptr ptr ptr (void) mgl_tube_r
+libmgl mgl_tube_xyz ptr ptr double ptr ptr ptr ptr (void) mgl_tube_xyz
+libmgl mgl_tube_xy ptr ptr double ptr ptr ptr (void) mgl_tube_xy
+libmgl mgl_tube ptr ptr double ptr ptr (void) mgl_tube
+libmgl mgl_candle_xyv ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_candle_xyv
+libmgl mgl_candle_yv ptr ptr ptr ptr ptr ptr ptr (void) mgl_candle_yv
+libmgl mgl_candle ptr ptr ptr ptr ptr ptr (void) mgl_candle
+libmgl mgl_fsurf ptr ptr ptr ptr (void) mgl_fsurf
+libmgl mgl_fsurf_xyz ptr ptr ptr ptr ptr ptr (void) mgl_fsurf_xyz
+libmgl mgl_grid_xy ptr ptr ptr ptr ptr ptr (void) mgl_grid_xy
+libmgl mgl_grid ptr ptr ptr ptr (void) mgl_grid
+libmgl mgl_mesh_xy ptr ptr ptr ptr ptr ptr (void) mgl_mesh_xy
+libmgl mgl_mesh ptr ptr ptr ptr (void) mgl_mesh
+libmgl mgl_fall_xy ptr ptr ptr ptr ptr ptr (void) mgl_fall_xy
+libmgl mgl_fall ptr ptr ptr ptr (void) mgl_fall
+libmgl mgl_belt_xy ptr ptr ptr ptr ptr ptr (void) mgl_belt_xy
+libmgl mgl_belt ptr ptr ptr ptr (void) mgl_belt
+libmgl mgl_surf_xy ptr ptr ptr ptr ptr ptr (void) mgl_surf_xy
+libmgl mgl_surf ptr ptr ptr ptr (void) mgl_surf
+libmgl mgl_dens_xy ptr ptr ptr ptr ptr ptr (void) mgl_dens_xy
+libmgl mgl_dens ptr ptr ptr ptr (void) mgl_dens
+libmgl mgl_boxs_xy ptr ptr ptr ptr ptr ptr (void) mgl_boxs_xy
+libmgl mgl_boxs ptr ptr ptr ptr (void) mgl_boxs
+libmgl mgl_tile_xy ptr ptr ptr ptr ptr ptr (void) mgl_tile_xy
+libmgl mgl_tile ptr ptr ptr ptr (void) mgl_tile
+libmgl mgl_tiles_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_tiles_xy
+libmgl mgl_tiles ptr ptr ptr ptr ptr (void) mgl_tiles
+libmgl mgl_surfc_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_surfc_xy
+libmgl mgl_surfc ptr ptr ptr ptr ptr (void) mgl_surfc
+libmgl mgl_surfa_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_surfa_xy
+libmgl mgl_surfa ptr ptr ptr ptr ptr (void) mgl_surfa
+libmgl mgl_stfa_xy ptr ptr int ptr ptr ptr ptr ptr (void) mgl_stfa_xy
+libmgl mgl_stfa ptr ptr int ptr ptr ptr (void) mgl_stfa
+libmgl mgl_map_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_map_xy
+libmgl mgl_map ptr ptr ptr ptr ptr (void) mgl_map
+libmgl mgl_surf3_xyz_val ptr ptr ptr ptr ptr ptr double ptr (void) mgl_surf3_xyz_val
+libmgl mgl_surf3_val ptr ptr ptr double ptr (void) mgl_surf3_val
+libmgl mgl_surf3_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_surf3_xyz
+libmgl mgl_surf3 ptr ptr ptr ptr (void) mgl_surf3
+libmgl mgl_surf3a_xyz_val ptr ptr ptr ptr ptr ptr ptr double ptr (void) mgl_surf3a_xyz_val
+libmgl mgl_surf3a_val ptr ptr ptr ptr double ptr (void) mgl_surf3a_val
+libmgl mgl_surf3a_xyz ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_surf3a_xyz
+libmgl mgl_surf3a ptr ptr ptr ptr ptr (void) mgl_surf3a
+libmgl mgl_surf3c_xyz_val ptr ptr ptr ptr ptr ptr ptr double ptr (void) mgl_surf3c_xyz_val
+libmgl mgl_surf3c_val ptr ptr ptr ptr double ptr (void) mgl_surf3c_val
+libmgl mgl_surf3c_xyz ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_surf3c_xyz
+libmgl mgl_surf3c ptr ptr ptr ptr ptr (void) mgl_surf3c
+libmgl mgl_cloud_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_cloud_xyz
+libmgl mgl_cloud ptr ptr ptr ptr (void) mgl_cloud
+libmgl mgl_beam_val int ptr double ptr ptr ptr ptr double ptr (void) mgl_beam_val
+libmgl mgl_beam int int ptr double ptr ptr ptr ptr ptr (void) mgl_beam
+libmgl mgl_traj_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_traj_xy
+libmgl mgl_traj_xyz ptr ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_traj_xyz
+libmgl mgl_vect_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_vect_xy
+libmgl mgl_vect_2d ptr ptr ptr ptr ptr (void) mgl_vect_2d
+libmgl mgl_vect_xyz ptr ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_vect_xyz
+libmgl mgl_vect_3d ptr ptr ptr ptr ptr ptr (void) mgl_vect_3d
+libmgl mgl_flow_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_flow_xy
+libmgl mgl_flow_2d ptr ptr ptr ptr ptr (void) mgl_flow_2d
+libmgl mgl_flow_xyz ptr ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_flow_xyz
+libmgl mgl_flow_3d ptr ptr ptr ptr ptr ptr (void) mgl_flow_3d
+libmgl mgl_flowp_xy ptr ptr ptr ptr ptr ptr double double double ptr (void) mgl_flowp_xy
+libmgl mgl_flowp_2d ptr ptr ptr ptr double double double ptr (void) mgl_flowp_2d
+libmgl mgl_flowp_xyz ptr ptr ptr ptr ptr ptr ptr ptr double double double ptr (void) mgl_flowp_xyz
+libmgl mgl_flowp_3d ptr ptr ptr ptr ptr double double double ptr (void) mgl_flowp_3d
+libmgl mgl_pipe_xy ptr double ptr ptr ptr ptr ptr ptr (void) mgl_pipe_xy
+libmgl mgl_pipe_2d ptr double ptr ptr ptr ptr (void) mgl_pipe_2d
+libmgl mgl_pipe_xyz ptr double ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_pipe_xyz
+libmgl mgl_pipe_3d ptr double ptr ptr ptr ptr ptr (void) mgl_pipe_3d
+libmgl mgl_grad_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_grad_xyz
+libmgl mgl_grad_xy ptr ptr ptr ptr ptr ptr (void) mgl_grad_xy
+libmgl mgl_grad ptr ptr ptr ptr (void) mgl_grad
+libmgl mgl_vect3_xyz ptr double ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_vect3_xyz
+libmgl mgl_vect3 ptr double ptr ptr ptr ptr ptr (void) mgl_vect3
+libmgl mgl_mark ptr double double double ptr (void) mgl_mark
+libmgl mgl_ball double double double ptr (void) mgl_ball
+libmgl mgl_line int ptr double double double double double double ptr (void) mgl_line
+libmgl mgl_curve int ptr double double double double double double double double double double double double ptr (void) mgl_curve
+libmgl mgl_error_box ptr double double double double double double ptr (void) mgl_error_box
+libmgl mgl_face ptr double double double double double double double double double double double double ptr (void) mgl_face
+libmgl mgl_facex double double ptr double double double double double ptr (void) mgl_facex
+libmgl mgl_facey double double ptr double double double double double ptr (void) mgl_facey
+libmgl mgl_facez double double ptr double double double double double ptr (void) mgl_facez
+libmgl mgl_sphere ptr double double double double ptr (void) mgl_sphere
+libmgl mgl_drop double double ptr double double double double double double double ptr (void) mgl_drop
+libmgl mgl_cone ptr double double double double double double double double ptr (void) mgl_cone
+libmgl mgl_ellipse ptr double double double double double double double ptr (void) mgl_ellipse
+libmgl mgl_rhomb ptr double double double double double double double ptr (void) mgl_rhomb
+libmgl mgl_cones_xyz ptr ptr ptr ptr ptr ptr (void) mgl_cones_xyz
+libmgl mgl_cones_xz ptr ptr ptr ptr ptr (void) mgl_cones_xz
+libmgl mgl_cones ptr ptr ptr ptr (void) mgl_cones
+libmgl mgl_dew_xy ptr ptr ptr ptr ptr ptr ptr (void) mgl_dew_xy
+libmgl mgl_dew_2d ptr ptr ptr ptr ptr (void) mgl_dew_2d
+libmgl mgl_puts_dir double ptr ptr double double double double double double ptr (void) mgl_puts_dir
+libmgl mgl_putsw_dir double ptr ptr double double double double double double ptr (void) mgl_putsw_dir
+libmgl mgl_textmark_xyzr ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_textmark_xyzr
+libmgl mgl_textmarkw_xyzr ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_textmarkw_xyzr
+libmgl mgl_textmark_xyr ptr ptr ptr ptr ptr ptr ptr (void) mgl_textmark_xyr
+libmgl mgl_textmarkw_xyr ptr ptr ptr ptr ptr ptr ptr (void) mgl_textmarkw_xyr
+libmgl mgl_textmark_yr ptr ptr ptr ptr ptr ptr (void) mgl_textmark_yr
+libmgl mgl_textmarkw_yr ptr ptr ptr ptr ptr ptr (void) mgl_textmarkw_yr
+libmgl mgl_textmark ptr ptr ptr ptr ptr (void) mgl_textmark
+libmgl mgl_textmarkw ptr ptr ptr ptr ptr (void) mgl_textmarkw
+libmgl mgl_label_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_label_xyz
+libmgl mgl_labelw_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_labelw_xyz
+libmgl mgl_label_xy ptr ptr ptr ptr ptr ptr (void) mgl_label_xy
+libmgl mgl_labelw_xy ptr ptr ptr ptr ptr ptr (void) mgl_labelw_xy
+libmgl mgl_label_y ptr ptr ptr ptr ptr (void) mgl_label_y
+libmgl mgl_labelw_y ptr ptr ptr ptr ptr (void) mgl_labelw_y
+libmgl mgl_table ptr ptr ptr ptr double double ptr (void) mgl_table
+libmgl mgl_tablew ptr ptr ptr ptr double double ptr (void) mgl_tablew
+libmgl mgl_triplot_xyzc ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_triplot_xyzc
+libmgl mgl_triplot_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_triplot_xyz
+libmgl mgl_triplot_xy ptr ptr ptr ptr ptr ptr (void) mgl_triplot_xy
+libmgl mgl_quadplot_xyzc ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_quadplot_xyzc
+libmgl mgl_quadplot_xyz ptr ptr ptr ptr ptr ptr ptr (void) mgl_quadplot_xyz
+libmgl mgl_quadplot_xy ptr ptr ptr ptr ptr ptr (void) mgl_quadplot_xy
+libmgl mgl_tricont_xyzcv ptr ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_tricont_xyzcv
+libmgl mgl_tricont_xycv ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_tricont_xycv
+libmgl mgl_tricont_xyzc ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_tricont_xyzc
+libmgl mgl_tricont_xyc ptr ptr ptr ptr ptr ptr ptr (void) mgl_tricont_xyc
+libmgl mgl_dots ptr ptr ptr ptr ptr ptr (void) mgl_dots
+libmgl mgl_dots_a ptr ptr ptr ptr ptr ptr ptr (void) mgl_dots_a
+libmgl mgl_dots_ca ptr ptr ptr ptr ptr ptr ptr ptr (void) mgl_dots_ca
+libmgl mgl_crust ptr ptr ptr ptr ptr ptr (void) mgl_crust
+libmgl mgl_dens_x ptr double ptr ptr ptr (void) mgl_dens_x
+libmgl mgl_dens_y ptr double ptr ptr ptr (void) mgl_dens_y
+libmgl mgl_dens_z ptr double ptr ptr ptr (void) mgl_dens_z
+libmgl mgl_cont_x ptr double ptr ptr ptr (void) mgl_cont_x
+libmgl mgl_cont_y ptr double ptr ptr ptr (void) mgl_cont_y
+libmgl mgl_cont_z ptr double ptr ptr ptr (void) mgl_cont_z
+libmgl mgl_cont_x_val ptr double ptr ptr ptr ptr (void) mgl_cont_x_val
+libmgl mgl_cont_y_val ptr double ptr ptr ptr ptr (void) mgl_cont_y_val
+libmgl mgl_cont_z_val ptr double ptr ptr ptr ptr (void) mgl_cont_z_val
+libmgl mgl_contf_x ptr double ptr ptr ptr (void) mgl_contf_x
+libmgl mgl_contf_y ptr double ptr ptr ptr (void) mgl_contf_y
+libmgl mgl_contf_z ptr double ptr ptr ptr (void) mgl_contf_z
+libmgl mgl_contf_x_val ptr double ptr ptr ptr ptr (void) mgl_contf_x_val
+libmgl mgl_contf_y_val ptr double ptr ptr ptr ptr (void) mgl_contf_y_val
+libmgl mgl_contf_z_val ptr double ptr ptr ptr ptr (void) mgl_contf_z_val
+libmgl mgl_create_graph int int (ptr) mgl_create_graph
+libmgl mgl_delete_graph ptr (void) mgl_delete_graph
+libmgl mgl_set_size int int ptr (void) mgl_set_size
+libmgl mgl_set_def_param ptr (void) mgl_set_def_param
+libmgl mgl_combine_gr ptr ptr (void) mgl_combine_gr
+libmgl mgl_finish ptr (void) mgl_finish
+libmgl mgl_set_tick_len double double ptr (void) mgl_set_tick_len
+libmgl mgl_set_axis_stl ptr ptr ptr ptr (void) mgl_set_axis_stl
+libmgl mgl_adjust_ticks ptr ptr (void) mgl_adjust_ticks
+libmgl mgl_set_ticks double int double char ptr (void) mgl_set_ticks
+libmgl mgl_set_ticks_str int ptr char ptr (void) mgl_set_ticks_str
+libmgl mgl_set_ticks_wcs int ptr char ptr (void) mgl_set_ticks_wcs
+libmgl mgl_set_ticks_val int ptr ptr char ptr (void) mgl_set_ticks_val
+libmgl mgl_set_ticks_valw int ptr ptr char ptr (void) mgl_set_ticks_valw
+libmgl mgl_tune_ticks double int ptr (void) mgl_tune_ticks
+libmgl mgl_set_tick_templ ptr char ptr (void) mgl_set_tick_templ
+libmgl mgl_set_tick_templw ptr char ptr (void) mgl_set_tick_templw
+libmgl mgl_set_ticks_time ptr double char ptr (void) mgl_set_ticks_time
+libmgl mgl_set_tick_shift double double double double ptr (void) mgl_set_tick_shift
+libmgl mgl_box ptr (void) mgl_box
+libmgl mgl_box_str int ptr ptr (void) mgl_box_str
+libmgl mgl_axis ptr ptr ptr ptr (void) mgl_axis
+libmgl mgl_axis_grid ptr ptr ptr ptr (void) mgl_axis_grid
+libmgl mgl_label ptr double ptr char ptr (void) mgl_label
+libmgl mgl_labelw ptr double ptr char ptr (void) mgl_labelw
+libmgl mgl_colorbar ptr ptr (void) mgl_colorbar
+libmgl mgl_colorbar_ext double double double double ptr ptr (void) mgl_colorbar_ext
+libmgl mgl_colorbar_val ptr ptr ptr (void) mgl_colorbar_val
+libmgl mgl_colorbar_val_ext double double double double ptr ptr ptr (void) mgl_colorbar_val_ext
+libmgl mgl_add_legend ptr ptr ptr (void) mgl_add_legend
+libmgl mgl_add_legendw ptr ptr ptr (void) mgl_add_legendw
+libmgl mgl_clear_legend ptr (void) mgl_clear_legend
+libmgl mgl_legend_pos ptr ptr double double ptr (void) mgl_legend_pos
+libmgl mgl_legend ptr ptr int ptr (void) mgl_legend
+libmgl mgl_set_legend_marks int ptr (void) mgl_set_legend_marks
+libmgl mgl_show_image int ptr ptr (void) mgl_show_image
+libmgl mgl_write_frame ptr ptr ptr (void) mgl_write_frame
+libmgl mgl_write_tga ptr ptr ptr (void) mgl_write_tga
+libmgl mgl_write_bmp ptr ptr ptr (void) mgl_write_bmp
+libmgl mgl_write_jpg ptr ptr ptr (void) mgl_write_jpg
+libmgl mgl_write_png ptr ptr ptr (void) mgl_write_png
+libmgl mgl_write_png_solid ptr ptr ptr (void) mgl_write_png_solid
+libmgl mgl_write_bps ptr ptr ptr (void) mgl_write_bps
+libmgl mgl_write_eps ptr ptr ptr (void) mgl_write_eps
+libmgl mgl_write_svg ptr ptr ptr (void) mgl_write_svg
+libmgl mgl_write_tex ptr ptr ptr (void) mgl_write_tex
+libmgl mgl_write_obj int ptr ptr ptr (void) mgl_write_obj
+libmgl mgl_write_obj_old int ptr ptr ptr (void) mgl_write_obj_old
+libmgl mgl_write_stl ptr ptr ptr (void) mgl_write_stl
+libmgl mgl_write_off int ptr ptr ptr (void) mgl_write_off
+libmgl mgl_write_xyz ptr ptr ptr (void) mgl_write_xyz
+libmgl mgl_write_prc int ptr ptr ptr (void) mgl_write_prc
+libmgl mgl_write_gif ptr ptr ptr (void) mgl_write_gif
+libmgl mgl_start_gif int ptr ptr (void) mgl_start_gif
+libmgl mgl_close_gif ptr (void) mgl_close_gif
+libmgl mgl_export_mgld ptr ptr ptr (void) mgl_export_mgld
+libmgl mgl_import_mgld int ptr ptr (void) mgl_import_mgld
+libmgl mgl_write_json ptr ptr ptr (void) mgl_write_json
+libmgl mgl_write_json_z ptr ptr ptr (void) mgl_write_json_z
+libmgl gl_get_json ptr (ptr) gl_get_json
+libmgl gl_get_rgb ptr (ptr) gl_get_rgb
+libmgl gl_get_rgba ptr (ptr) gl_get_rgba
+libmgl mgl_set_obj_id int ptr (void) mgl_set_obj_id
+libmgl mgl_get_obj_id int int ptr (int) mgl_get_obj_id
+libmgl mgl_get_spl_id int int ptr (int) mgl_get_spl_id
+libmgl mgl_get_width ptr (int) mgl_get_width
+libmgl mgl_get_height ptr (int) mgl_get_height
+libmgl mgl_calc_xyz ptr ptr ptr int int ptr (void) mgl_calc_xyz
+libmgl mgl_calc_scr ptr ptr double double double ptr (void) mgl_calc_scr
+libmgl mgl_is_active int int int ptr (int) mgl_is_active
+libmgl mgl_new_frame ptr (int) mgl_new_frame
+libmgl mgl_end_frame ptr (void) mgl_end_frame
+libmgl mgl_get_num_frame ptr (int) mgl_get_num_frame
+libmgl mgl_reset_frames ptr (void) mgl_reset_frames
+libmgl mgl_get_frame int ptr (void) mgl_get_frame
+libmgl mgl_set_frame int ptr (void) mgl_set_frame
+libmgl mgl_show_frame int ptr (void) mgl_show_frame
+libmgl mgl_del_frame int ptr (void) mgl_del_frame
+libmgl mgl_set_transp_type int ptr (void) mgl_set_transp_type
+libmgl mgl_set_alpha int ptr (void) mgl_set_alpha
+libmgl mgl_set_fog double double ptr (void) mgl_set_fog
+libmgl mgl_set_light int ptr (void) mgl_set_light
+libmgl mgl_set_light_n int int ptr (void) mgl_set_light_n
+libmgl mgl_add_light double double double int ptr (void) mgl_add_light
+libmgl mgl_add_light_ext double double char double double double int ptr (void) mgl_add_light_ext
+libmgl mgl_add_light_loc double double char double double double double double double int ptr (void) mgl_add_light_loc
+libmgl mgl_mat_pop ptr (void) mgl_mat_pop
+libmgl mgl_mat_push ptr (void) mgl_mat_push
+libmgl mgl_clf ptr (void) mgl_clf
+libmgl mgl_clf_rgb double double double ptr (void) mgl_clf_rgb
+libmgl mgl_clf_chr char ptr (void) mgl_clf_chr
+libmgl mgl_subplot ptr int int int ptr (void) mgl_subplot
+libmgl mgl_subplot_d double double ptr int int int ptr (void) mgl_subplot_d
+libmgl mgl_multiplot ptr int int int int int ptr (void) mgl_multiplot
+libmgl mgl_inplot double double double double ptr (void) mgl_inplot
+libmgl mgl_relplot double double double double ptr (void) mgl_relplot
+libmgl mgl_columnplot double int int ptr (void) mgl_columnplot
+libmgl mgl_gridplot double int int int ptr (void) mgl_gridplot
+libmgl mgl_stickplot double double int int ptr (void) mgl_stickplot
+libmgl mgl_title double ptr ptr ptr (void) mgl_title
+libmgl mgl_titlew double ptr ptr ptr (void) mgl_titlew
+libmgl mgl_set_plotfactor double ptr (void) mgl_set_plotfactor
+libmgl mgl_aspect double double double ptr (void) mgl_aspect
+libmgl mgl_rotate double double double ptr (void) mgl_rotate
+libmgl mgl_rotate_vector double double double double ptr (void) mgl_rotate_vector
+libmgl mgl_perspective double ptr (void) mgl_perspective
+libmgl mgl_view double double double ptr (void) mgl_view
+libmgl mgl_zoom double double double double ptr (void) mgl_zoom
+libmgl mgl_wnd_set_delay double ptr (void) mgl_wnd_set_delay
+libmgl mgl_wnd_get_delay ptr (double) mgl_wnd_get_delay
+libmgl mgl_setup_window int int ptr (void) mgl_setup_window
+libmgl mgl_wnd_toggle_alpha ptr (void) mgl_wnd_toggle_alpha
+libmgl mgl_wnd_toggle_light ptr (void) mgl_wnd_toggle_light
+libmgl mgl_wnd_toggle_zoom ptr (void) mgl_wnd_toggle_zoom
+libmgl mgl_wnd_toggle_rotate ptr (void) mgl_wnd_toggle_rotate
+libmgl mgl_wnd_toggle_no ptr (void) mgl_wnd_toggle_no
+libmgl mgl_wnd_update ptr (void) mgl_wnd_update
+libmgl mgl_wnd_reload ptr (void) mgl_wnd_reload
+libmgl mgl_wnd_adjust ptr (void) mgl_wnd_adjust
+libmgl mgl_wnd_next_frame ptr (void) mgl_wnd_next_frame
+libmgl mgl_wnd_prev_frame ptr (void) mgl_wnd_prev_frame
+libmgl mgl_wnd_animation ptr (void) mgl_wnd_animation
+libmgl mgl_get_last_mouse_pos ptr ptr ptr ptr (void) mgl_get_last_mouse_pos
+libmgl mgl_create_parser (ptr) mgl_create_parser
+libmgl mgl_use_parser int ptr (int) mgl_use_parser
+libmgl mgl_delete_parser ptr (void) mgl_delete_parser
+libmgl mgl_parser_add_param ptr int ptr (void) mgl_parser_add_param
+libmgl mgl_parser_add_paramw ptr int ptr (void) mgl_parser_add_paramw
+libmgl mgl_parser_add_var ptr ptr (ptr) mgl_parser_add_var
+libmgl mgl_parser_add_varw ptr ptr (ptr) mgl_parser_add_varw
+libmgl mgl_parser_find_var ptr ptr (ptr) mgl_parser_find_var
+libmgl mgl_parser_find_varw ptr ptr (ptr) mgl_parser_find_varw
+libmgl mgl_parser_del_var ptr ptr (void) mgl_parser_del_var
+libmgl mgl_parser_del_varw ptr ptr (void) mgl_parser_del_varw
+libmgl mgl_parser_del_all ptr (void) mgl_parser_del_all
+libmgl mgl_parse_line int ptr ptr ptr (int) mgl_parse_line
+libmgl mgl_parse_linew int ptr ptr ptr (int) mgl_parse_linew
+libmgl mgl_parse_text ptr ptr ptr (void) mgl_parse_text
+libmgl mgl_parse_textw ptr ptr ptr (void) mgl_parse_textw
+libmgl mgl_parser_restore_once ptr (void) mgl_parser_restore_once
+libmgl mgl_parser_allow_setsize int ptr (void) mgl_parser_allow_setsize
+libmgl mgl_parser_allow_file_io int ptr (void) mgl_parser_allow_file_io
+libmgl mgl_parser_stop ptr (void) mgl_parser_stop
+libmgl mgl_parser_cmd_type ptr ptr (int) mgl_parser_cmd_type
+libmgl gl_parser_cmd_desc ptr ptr (ptr) gl_parser_cmd_desc
+libmgl gl_parser_cmd_frmt ptr ptr (ptr) gl_parser_cmd_frmt
+libmgl gl_parser_cmd_name int ptr (ptr) gl_parser_cmd_name
+libmgl mgl_parser_cmd_num ptr (int) mgl_parser_cmd_num
+libmgl mgl_parser_calc ptr ptr (ptr) mgl_parser_calc
+libmgl mgl_parser_calcw ptr ptr (ptr) mgl_parser_calcw
+libmgl mgl_create_expr ptr (ptr) mgl_create_expr
+libmgl mgl_delete_expr ptr (void) mgl_delete_expr
+libmgl mgl_expr_eval double double double ptr (double) mgl_expr_eval
+libmgl mgl_expr_eval_v ptr ptr (double) mgl_expr_eval_v
+libmgl mgl_expr_diff double double double char ptr (double) mgl_expr_diff
+libmgl mgl_expr_diff_v ptr char ptr (double) mgl_expr_diff_v
+libmgl mgl_gauss_rnd (double) mgl_gauss_rnd
+libmgl mgl_fft_freq int ptr (void) mgl_fft_freq
+libmgl mgl_strcls ptr (void) mgl_strcls
+libmgl mgl_strpos ptr ptr (int) mgl_strpos
+libmgl mgl_chrpos char ptr (int) mgl_chrpos
+libmgl mgl_istrue char (int) mgl_istrue
/***************************************************************************\r
* mgl.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/// Set axis range scaling -- simplified way to shift/zoom axis range -- need to replot whole image!\r
inline void ZoomAxis(mglPoint p1=mglPoint(0,0,0,0), mglPoint p2=mglPoint(1,1,1,1))\r
{ mgl_zoom_axis(gr, p1.x,p1.y,p1.z,p1.c, p2.x,p2.y,p2.z,p2.c); }\r
+ /// Add [v1, v2] to the current range in direction dir\r
+ inline void AddRange(char dir, double v1, double v2)\r
+ { mgl_add_range_val(gr, dir, v1, v2); }\r
/// Set range in direction dir as [v1, v2]\r
inline void SetRange(char dir, double v1, double v2)\r
{ mgl_set_range_val(gr, dir, v1, v2); }\r
{ mgl_crust(gr, &x, &y, &z, sch, opt); }\r
\r
/// Fit data along x-direction for each data row. Return array with values for found formula.\r
- inline mglData Fit(const mglDataA &y, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_1(gr, &y, eq,var,0, opt)); }\r
- inline mglData Fit(const mglDataA &y, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_1(gr, &y, eq, var, &ini, opt)); }\r
+ inline mglData Fit(const mglDataA &y, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_1(gr, &y, eq,vars,0, opt)); }\r
+ inline mglData Fit(const mglDataA &y, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_1(gr, &y, eq, vars, &ini, opt)); }\r
/// Fit data along x-, y-directions for each data slice. Return array with values for found formula.\r
- inline mglData Fit2(const mglDataA &z, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_2(gr, &z, eq, var,0, opt)); }\r
- inline mglData Fit2(const mglDataA &z, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_2(gr, &z, eq, var, &ini, opt)); }\r
+ inline mglData Fit2(const mglDataA &z, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_2(gr, &z, eq, vars,0, opt)); }\r
+ inline mglData Fit2(const mglDataA &z, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_2(gr, &z, eq, vars, &ini, opt)); }\r
/// Fit data along along all directions. Return array with values for found formula.\r
- inline mglData Fit3(const mglDataA &a, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_3(gr, &a, eq, var,0, opt)); }\r
- inline mglData Fit3(const mglDataA &a, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_3(gr, &a, eq, var, &ini, opt)); }\r
+ inline mglData Fit3(const mglDataA &a, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_3(gr, &a, eq, vars,0, opt)); }\r
+ inline mglData Fit3(const mglDataA &a, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_3(gr, &a, eq, vars, &ini, opt)); }\r
/// Fit data along x-direction for each data row. Return array with values for found formula.\r
- inline mglData Fit(const mglDataA &x, const mglDataA &y, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_xy(gr, &x, &y, eq, var,0, opt)); }\r
- inline mglData Fit(const mglDataA &x, const mglDataA &y, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_xy(gr, &x, &y, eq, var, &ini, opt)); }\r
+ inline mglData Fit(const mglDataA &x, const mglDataA &y, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_xy(gr, &x, &y, eq, vars,0, opt)); }\r
+ inline mglData Fit(const mglDataA &x, const mglDataA &y, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_xy(gr, &x, &y, eq, vars, &ini, opt)); }\r
/// Fit data along x-, y-directions for each data slice. Return array with values for found formula.\r
- inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_xyz(gr, &x, &y, &z, eq, var,0, opt)); }\r
- inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_xyz(gr, &x, &y, &z, eq, var, &ini, opt)); }\r
+ inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyz(gr, &x, &y, &z, eq, vars,0, opt)); }\r
+ inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyz(gr, &x, &y, &z, eq, vars, &ini, opt)); }\r
/// Fit data along along all directions. Return array with values for found formula.\r
- inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_xyza(gr, &x, &y, &z, &a, eq, var,0, opt)); }\r
- inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_xyza(gr, &x, &y, &z, &a, eq,var, &ini, opt)); }\r
+ inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyza(gr, &x, &y, &z, &a, eq, vars,0, opt)); }\r
+ inline mglData Fit(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyza(gr, &x, &y, &z, &a, eq,vars, &ini, opt)); }\r
/// Fit data with dispersion s along x-direction for each data row. Return array with values for found formula.\r
- inline mglData FitS(const mglDataA &y, const mglDataA &s, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_ys(gr, &y, &s, eq, var,0, opt)); }\r
- inline mglData FitS(const mglDataA &y, const mglDataA &s, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_ys(gr, &y, &s, eq, var, &ini, opt)); }\r
- inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &s, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_xys(gr, &x, &y, &s, eq, var,0, opt)); }\r
- inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &s, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_xys(gr, &x, &y, &s, eq, var, &ini, opt)); }\r
+ inline mglData FitS(const mglDataA &y, const mglDataA &s, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_ys(gr, &y, &s, eq, vars,0, opt)); }\r
+ inline mglData FitS(const mglDataA &y, const mglDataA &s, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_ys(gr, &y, &s, eq, vars, &ini, opt)); }\r
+ inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &s, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_xys(gr, &x, &y, &s, eq, vars,0, opt)); }\r
+ inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &s, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_xys(gr, &x, &y, &s, eq, vars, &ini, opt)); }\r
/// Fit data with dispersion s along x-, y-directions for each data slice. Return array with values for found formula.\r
- inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &s, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_xyzs(gr, &x, &y, &z, &s, eq, var,0, opt)); }\r
- inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &s, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_xyzs(gr, &x, &y, &z, &s, eq, var, &ini, opt)); }\r
+ inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &s, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyzs(gr, &x, &y, &z, &s, eq, vars,0, opt)); }\r
+ inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &s, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyzs(gr, &x, &y, &z, &s, eq, vars, &ini, opt)); }\r
/// Fit data with dispersion s along all directions. Return array with values for found formula.\r
- inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &s, const char *eq, const char *var, const char *opt="")\r
- { return mglData(true,mgl_fit_xyzas(gr, &x, &y, &z, &a, &s, eq, var,0, opt)); }\r
- inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &s, const char *eq, const char *var, mglData &ini, const char *opt="")\r
- { return mglData(true,mgl_fit_xyzas(gr, &x, &y, &z, &a, &s, eq, var, &ini, opt)); }\r
+ inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &s, const char *eq, const char *vars, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyzas(gr, &x, &y, &z, &a, &s, eq, vars,0, opt)); }\r
+ inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &s, const char *eq, const char *vars, mglData &ini, const char *opt="")\r
+ { return mglData(true,mgl_fit_xyzas(gr, &x, &y, &z, &a, &s, eq, vars, &ini, opt)); }\r
/// Print fitted last formula (with coefficients)\r
inline void PutsFit(mglPoint p, const char *prefix=0, const char *font="", double size=-1)\r
{ mgl_puts_fit(gr, p.x, p.y, p.z, prefix, font, size); }\r
// inline void TextureColor(bool){} // NOTE: Add later -- IDTF\r
};\r
//-----------------------------------------------------------------------------\r
-#ifndef SWIG\r
-/// Structure for handling named mglData (used by mglParse class).\r
-class MGL_EXPORT mglVar : public mglData\r
-{\r
-public:\r
- std::wstring s; ///< Data name\r
- void *o; ///< Pointer to external object\r
- mglVar *next; ///< Pointer to next instance in list\r
- mglVar *prev; ///< Pointer to previous instance in list\r
- bool temp; ///< This is temporary variable\r
- void (*func)(void *); ///< Callback function for destroying\r
-\r
- mglVar():mglData() { o=0; next=prev=0; func=0; temp=false; }\r
- virtual ~mglVar()\r
- {\r
- if(func) func(o);\r
- if(prev) prev->next = next;\r
- if(next) next->prev = prev;\r
- }\r
- /// Move variable after var and copy func from var (if func is 0)\r
- void MoveAfter(mglVar *var)\r
- {\r
- if(prev) prev->next = next;\r
- if(next) next->prev = prev;\r
- prev = next = 0;\r
- if(var)\r
- {\r
- prev = var; next = var->next;\r
- var->next = this;\r
- if(func==0) func = var->func;\r
- }\r
- if(next) next->prev = this;\r
- }\r
-};\r
-#endif\r
-//-----------------------------------------------------------------------------\r
/// Wrapper class for MGL parsing\r
class MGL_EXPORT mglParse\r
{\r
void DeleteAll() { mgl_parser_del_all(pr); }\r
};\r
//-----------------------------------------------------------------------------\r
-/// Wrapper class expression evaluating\r
-class MGL_EXPORT mglExpr\r
-{\r
- HMEX ex;\r
-public:\r
- mglExpr(const char *expr) { ex = mgl_create_expr(expr); }\r
- ~mglExpr() { mgl_delete_expr(ex); }\r
- /// Return value of expression for given x,y,z variables\r
- inline double Eval(double x, double y=0, double z=0)\r
- { return mgl_expr_eval(ex,x,y,z); }\r
- /// Return value of expression differentiation over variable dir for given x,y,z variables\r
- inline double Diff(char dir, double x, double y=0, double z=0)\r
- { return mgl_expr_diff(ex,dir, x,y,z); }\r
-#ifndef SWIG\r
- /// Return value of expression for given variables\r
- inline double Eval(mreal var[26])\r
- { return mgl_expr_eval_v(ex,var); }\r
- /// Return value of expression differentiation over variable dir for given variables\r
- inline double Diff(char dir, mreal var[26])\r
- { return mgl_expr_diff_v(ex,dir, var); }\r
-#endif\r
-};\r
-//-----------------------------------------------------------------------------\r
-#ifndef SWIG\r
-/// Wrapper class expression evaluating\r
-class MGL_EXPORT mglExprC\r
-{\r
- HAEX ex;\r
-public:\r
- mglExprC(const char *expr) { ex = mgl_create_cexpr(expr); }\r
- ~mglExprC() { mgl_delete_cexpr(ex); }\r
- /// Return value of expression for given x,y,z variables\r
- inline dual Eval(dual x, dual y=0, dual z=0)\r
- { return mgl_cexpr_eval(ex,x,y,z); }\r
- /// Return value of expression for given x,y,z,u,v,w variables\r
- inline dual Eval(dual x, dual y, dual z, dual u, dual v, dual w)\r
- {\r
- dual var[26];\r
- var['x'-'a']=x; var['y'-'a']=y; var['z'-'a']=z;\r
- var['u'-'a']=u; var['v'-'a']=v; var['w'-'a']=w;\r
- return mgl_cexpr_eval_v(ex,var); }\r
- /// Return value of expression for given variables\r
- inline dual Eval(dual var[26])\r
- { return mgl_cexpr_eval_v(ex,var); }\r
-};\r
-#endif\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
#endif\r
#endif
\ No newline at end of file
/***************************************************************************\r
* MGL_EXPORT mgl_cf.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
--- /dev/null
+//**************************************************************************
+// mgl_pas.pas is part of Math Graphic Library *
+// Copyright (C) 2008-2013 Mikhail Barg, Alexey Balakin *
+// *
+// This program is free software; you can redistribute it and/or modify *
+// it under the terms of the GNU Library 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 Library 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. *
+//**************************************************************************
+
+unit mgl_pas;
+
+{$IFDEF FPC}
+{$MODE DELPHI }
+{$PACKENUM 4} (* use 4-byte enums *)
+{$PACKRECORDS C} (* C/C++-compatible record packing *)
+{$ELSE}
+{$MINENUMSIZE 4} (* use 4-byte enums *)
+{$ENDIF}
+
+{$IFDEF DARWIN}
+{$linklib libmgl}
+{$ENDIF}
+
+interface
+
+uses
+{$IFDEF MSWINDOWS}
+Windows, Graphics,
+{$ENDIF}
+Math;
+
+const MGL_VER2 = 2.2;
+//* This define enables double precision in MathGL */
+MGL_USE_DOUBLE = 1;
+
+const
+{$IFDEF MSWINDOWS}
+//win - .dll
+libmgl = 'libmgl.dll';
+libmglglut = 'libmgl-glut.dll';
+libmglfltk = 'libmgl-fltk.dll';
+libmglqt = 'libmgl-qt.dll';
+{$ELSE}
+{$IFDEF LINUX}
+//linux - .so
+libmgl = 'libmgl.so';
+libmglglut = 'libmgl-glut.so';
+libmglfltk = 'libmgl-fltk.so';
+libmglqt = 'libmgl-qt.so';
+{$ELSE}
+{$IFDEF DARWIN}
+//darwin - .dylib
+libmgl = 'libmgl.dylib';
+libmglglut = 'libmgl-glut.dylib';
+libmglfltk = 'libmgl-fltk.dylib';
+libmglqt = 'libmgl-qt.dylib';
+{$ELSE}
+// other platforms?
+
+{$ENDIF}
+{$ENDIF}
+{$ENDIF}
+
+{$IF (MGL_USE_DOUBLE = 0)}
+type mreal = double;
+{$ELSE}
+type mreal = real;
+{$IFEND}
+{$IFDEF FPC}
+{$ELSE}
+type QWord = Int64;
+{$ENDIF}
+
+Pmreal = ^mreal;
+
+type TNGLDraw = record
+end;
+type TMGLGraph = record
+end;
+type TMGLData = record
+end;
+type TMGLParse = record
+end;
+type TMGLFormula = record
+end;
+type TMGLFormulaC = record
+end;
+type TMGLDataC = record
+end;
+type HMDR = ^TNGLDraw;
+type HMGL = ^TMGLGraph;
+type HMDT = ^TMGLData;
+type HMPR = ^TMGLParse;
+type PPChar = ^PChar;
+type HMEX = ^TMGLFormula;
+type HAEX = ^TMGLFormulaC;
+type HADT = ^TMGLDataC;
+
+type Preal = ^single;
+type Pdouble = ^double;
+type Pint = ^integer;
+type dual = record
+re, im: mreal;
+end;
+type Pdual = ^dual;
+type TGSLVector = record
+end;
+type TGSLMatrix = record
+end;
+type PGSLVector = ^TGSLVector;
+type PGSLMatrix = ^TGSLMatrix;
+
+type TMglDrawFunction = function (gr: HMGL; p: pointer): integer; cdecl;
+function mgl_create_graph_gl(): HMGL; cdecl; external libmgl;
+function mgl_create_graph_glut(draw: TMglDrawFunction; const title: PChar; par: pointer): HMGL; cdecl; external libmglglut;
+function mgl_create_graph_fltk(draw: TMglDrawFunction; const title: PChar; par: pointer): HMGL; cdecl; external libmglfltk;
+procedure mgl_fltk_run(); cdecl; external libmglfltk;
+function mgl_create_graph_qt(draw: TMglDrawFunction; const title: PChar; par: pointer): HMGL; cdecl; external libmglqt;
+procedure mgl_qt_run(); cdecl; external libmglqt;
+
+{== ../include/mgl2/base_cf.h ==}
+//-----------------------------------------------------------------------------
+/// Get last warning code
+function mgl_get_warn(gr: HMGL): integer; cdecl; external libmgl;
+/// Set warning code ant fill message
+procedure mgl_set_warn(gr: HMGL;code: integer;const text: PChar); cdecl; external libmgl;
+/// Set buffer for warning messages
+function mgl_get_mess(gr: HMGL): PChar; cdecl; external libmgl;
+/// Set name of plot for saving filename
+procedure mgl_set_plotid(gr: HMGL;const id: PChar); cdecl; external libmgl;
+/// Get name of plot for saving filename
+function mgl_get_plotid(gr: HMGL): PChar; cdecl; external libmgl;
+/// Get plot quality
+function mgl_get_quality(gr: HMGL): integer; cdecl; external libmgl;
+/// Set plot quality
+procedure mgl_set_quality(gr: HMGL;qual: integer); cdecl; external libmgl;
+/// Set drawing region for Quality&4
+procedure mgl_set_draw_reg(gr: HMGL;nx: integer;ny: integer;m: integer); cdecl; external libmgl;
+/// Is frames
+function mgl_is_frames(gr: HMGL): integer; cdecl; external libmgl;
+/// Get bit-value flag of HMGL state (for advanced users only)
+function mgl_get_flag(gr: HMGL;flag: LongWord): integer; cdecl; external libmgl;
+/// Set bit-value flag of HMGL state (for advanced users only)
+procedure mgl_set_flag(gr: HMGL;val: integer;flag: LongWord); cdecl; external libmgl;
+/// Change counter of HMGL uses (for advanced users only). Non-zero counter prevent automatic object removing.
+function mgl_use_graph(gr: HMGL;inc: integer): integer; cdecl; external libmgl;
+/// Start group of objects
+procedure mgl_start_group(gr: HMGL;const name: PChar); cdecl; external libmgl;
+/// End group of objects
+procedure mgl_end_group(gr: HMGL); cdecl; external libmgl;
+/// Highlight objects with given id
+procedure mgl_highlight(gr: HMGL;id: integer); cdecl; external libmgl;
+/// Set default palette
+procedure mgl_set_palette(gr: HMGL;const colors: PChar); cdecl; external libmgl;
+/// Sets RGB values for color with given id
+procedure mgl_set_color(id: char;r: double;g: double;b: double); cdecl; external libmgl;
+/// Set default color scheme
+procedure mgl_set_def_sch(gr: HMGL;const sch: PChar); cdecl; external libmgl;
+/// Set mask for face coloring as array of type 'unsigned char[8]'
+procedure mgl_set_mask(id: char;const mask: PChar); cdecl; external libmgl;
+/// Set mask for face coloring as unsigned long number
+procedure mgl_set_mask_val(id: char;mask: QWord); cdecl; external libmgl;
+/// Set default mask rotation angle
+procedure mgl_set_mask_angle(gr: HMGL;angle: integer); cdecl; external libmgl;
+/// Set default value of alpha-channel
+procedure mgl_set_alpha_default(gr: HMGL;alpha: double); cdecl; external libmgl;
+/// Set relative width of rectangles in Bars, Barh, BoxPlot
+procedure mgl_set_bar_width(gr: HMGL;width: double); cdecl; external libmgl;
+/// Set number of mesh lines (use 0 to draw all of them)
+procedure mgl_set_meshnum(gr: HMGL;num: integer); cdecl; external libmgl;
+/// Set number of visible faces (use 0 to draw all of them)
+procedure mgl_set_facenum(gr: HMGL;num: integer); cdecl; external libmgl;
+/// Clear unused points and primitives. Useful only in combination with mgl_set_facenum().
+procedure mgl_clear_unused(gr: HMGL); cdecl; external libmgl;
+/// Set ambient light brightness
+procedure mgl_set_ambbr(gr: HMGL;i: double); cdecl; external libmgl;
+/// Set diffusive light brightness
+procedure mgl_set_difbr(gr: HMGL;i: double); cdecl; external libmgl;
+/// Use diffusive light (only for local light sources) -- OBSOLETE
+procedure mgl_set_light_dif(gr: HMGL;enable: integer); cdecl; external libmgl;
+/// Set cutting for points outside of bounding box
+procedure mgl_set_cut(gr: HMGL;cut: integer); cdecl; external libmgl;
+/// Set additional cutting box
+procedure mgl_set_cut_box(gr: HMGL;x1: double;y1: double;z1: double;x2: double;y2: double;z2: double); cdecl; external libmgl;
+/// Set the cutting off condition (formula)
+procedure mgl_set_cutoff(gr: HMGL;const EqC: PChar); cdecl; external libmgl;
+/// Set values of axis range
+procedure mgl_set_ranges(gr: HMGL;x1: double;x2: double;y1: double;y2: double;z1: double;z2: double); cdecl; external libmgl;
+/// Set range in direction dir as [v1, v2]
+procedure mgl_set_range_val(gr: HMGL;dir: char;v1: double;v2: double); cdecl; external libmgl;
+/// Set range in direction dir as minimal and maximal values of data a
+procedure mgl_set_range_dat(gr: HMGL;dir: char;const a: HMDT;add: integer); cdecl; external libmgl;
+/// Set ranges for automatic variables
+procedure mgl_set_auto_ranges(gr: HMGL;x1: double;x2: double;y1: double;y2: double;z1: double;z2: double;c1: double;c2: double); cdecl; external libmgl;
+/// Set axis range scaling -- simplified way to shift/zoom axis range -- need to redraw whole image!
+procedure mgl_zoom_axis(gr: HMGL;x1: double;y1: double;z1: double;c1: double;x2: double;y2: double;z2: double;c2: double); cdecl; external libmgl;
+/// Set axis origin
+procedure mgl_set_origin(gr: HMGL;x0: double;y0: double;z0: double); cdecl; external libmgl;
+/// Set the transformation formulas for coordinate
+procedure mgl_set_func(gr: HMGL;const EqX: PChar;const EqY: PChar;const EqZ: PChar;const EqA: PChar); cdecl; external libmgl;
+/// Set one of predefined transformation rule
+procedure mgl_set_coor(gr: HMGL;how: integer); cdecl; external libmgl;
+/// Set to draw Ternary axis (triangle like axis, grid and so on)
+procedure mgl_set_ternary(gr: HMGL;enable: integer); cdecl; external libmgl;
+/// Set to use or not tick labels rotation
+procedure mgl_set_tick_rotate(gr: HMGL;enable: integer); cdecl; external libmgl;
+/// Set to use or not tick labels skipping
+procedure mgl_set_tick_skip(gr: HMGL;enable: integer); cdecl; external libmgl;
+/// Set default font for all new HMGL objects
+procedure mgl_def_font(const name: PChar;const path: PChar); cdecl; external libmgl;
+/// Set default size of marks (locally you can use "size" option)
+procedure mgl_set_mark_size(gr: HMGL;size: double); cdecl; external libmgl;
+/// Set default size of arrows (locally you can use "size" option)
+procedure mgl_set_arrow_size(gr: HMGL;size: double); cdecl; external libmgl;
+/// Set default font size
+procedure mgl_set_font_size(gr: HMGL;size: double); cdecl; external libmgl;
+/// Set default font style and color
+procedure mgl_set_font_def(gr: HMGL;const fnt: PChar); cdecl; external libmgl;
+/// Set to use or not text rotation
+procedure mgl_set_rotated_text(gr: HMGL;enable: integer); cdecl; external libmgl;
+/// Load font from file
+procedure mgl_load_font(gr: HMGL;const name: PChar;const path: PChar); cdecl; external libmgl;
+/// Copy font from another mglGraph instance
+procedure mgl_copy_font(gr: HMGL;gr_from: HMGL); cdecl; external libmgl;
+/// Restore font (load default font for new HMGL objects)
+procedure mgl_restore_font(gr: HMGL); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/data_cf.h ==}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/// Set seed for random numbers
+procedure mgl_srnd(seed: integer); cdecl; external libmgl;
+/// Get random number
+function mgl_rnd(): double; cdecl; external libmgl;
+/// Get integer power of x
+function mgl_ipow(x: double;n: integer): double; cdecl; external libmgl;
+/// Get number of seconds since 1970 for given string
+function mgl_get_time(const time: PChar;const fmt: PChar): double; cdecl; external libmgl;
+/// Create HMDT object
+function mgl_create_data(): HMDT; cdecl; external libmgl;
+/// Create HMDT object with specified sizes
+function mgl_create_data_size(nx: integer;ny: integer;nz: integer): HMDT; cdecl; external libmgl;
+/// Create HMDT object with data from file
+function mgl_create_data_file(const fname: PChar): HMDT; cdecl; external libmgl;
+/// Delete HMDT object
+procedure mgl_delete_data(dat: HMDT); cdecl; external libmgl;
+/// Get information about the data (sizes and momentum) to string
+function mgl_data_info(const dat: HMDT): PChar; cdecl; external libmgl;
+/// Rearange data dimensions
+procedure mgl_data_rearrange(dat: HMDT;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Link external data array (don't delete it at exit)
+procedure mgl_data_link(dat: HMDT;A: Pmreal;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Allocate memory and copy the data from the (float *) array
+procedure mgl_data_set_float(dat: HMDT;const A: Preal;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Allocate memory and copy the data from the (double *) array
+procedure mgl_data_set_double(dat: HMDT;const A: Pdouble;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Allocate memory and copy the data from the (float **) array
+/// Allocate memory and copy the data from the (double **) array
+/// Allocate memory and copy the data from the (float ***) array
+/// Allocate memory and copy the data from the (double ***) array
+/// Import data from abstract type
+procedure mgl_data_set(dat: HMDT;const a: HMDT); cdecl; external libmgl;
+/// Allocate memory and copy the data from the gsl_vector
+procedure mgl_data_set_vector(dat: HMDT;v: PGSLVector); cdecl; external libmgl;
+/// Allocate memory and copy the data from the gsl_matrix
+procedure mgl_data_set_matrix(dat: HMDT;m: PGSLMatrix); cdecl; external libmgl;
+/// Set value of data element [i,j,k]
+procedure mgl_data_set_value(dat: HMDT;v: mreal;i: integer;j: integer;k: integer); cdecl; external libmgl;
+/// Get value of data element [i,j,k]
+function mgl_data_get_value(const dat: HMDT;i: integer;j: integer;k: integer): mreal; cdecl; external libmgl;
+/// Allocate memory and scanf the data from the string
+procedure mgl_data_set_values(dat: HMDT;const val: PChar;nx: integer;ny: integer;nz: integer); cdecl; external libmgl;
+/// Read data array from HDF file (parse HDF4 and HDF5 files)
+function mgl_data_read_hdf(d: HMDT;const fname: PChar;const data: PChar): integer; cdecl; external libmgl;
+/// Save data to HDF file
+procedure mgl_data_save_hdf(const d: HMDT;const fname: PChar;const data: PChar;rewrite: integer); cdecl; external libmgl;
+/// Put HDF data names into buf as '\t' separated.
+function mgl_datas_hdf(const fname: PChar;buf: PChar;size: integer): integer; cdecl; external libmgl;
+/// Read data from tab-separated text file with auto determining size
+function mgl_data_read(dat: HMDT;const fname: PChar): integer; cdecl; external libmgl;
+/// Read data from text file with size specified at beginning of the file
+function mgl_data_read_mat(dat: HMDT;const fname: PChar;dim: integer): integer; cdecl; external libmgl;
+/// Read data from text file with specifeid size
+function mgl_data_read_dim(dat: HMDT;const fname: PChar;mx: integer;my: integer;mz: integer): integer; cdecl; external libmgl;
+/// Read data from tab-separated text files with auto determining size which filenames are result of sprintf(fname,templ,t) where t=from:step:to
+function mgl_data_read_range(d: HMDT;const templ: PChar;n1: double;n2: double;step: double;as_slice: integer): integer; cdecl; external libmgl;
+/// Read data from tab-separated text files with auto determining size which filenames are satisfied to template (like "t_*.dat")
+function mgl_data_read_all(dat: HMDT;const templ: PChar;as_slice: integer): integer; cdecl; external libmgl;
+/// Save whole data array (for ns=-1) or only ns-th slice to text file
+procedure mgl_data_save(const dat: HMDT;const fname: PChar;ns: integer); cdecl; external libmgl;
+/// Export data array (for ns=-1) or only ns-th slice to PNG file according color scheme
+procedure mgl_data_export(const dat: HMDT;const fname: PChar;const scheme: PChar;v1: mreal;v2: mreal;ns: integer); cdecl; external libmgl;
+/// Import data array from PNG file according color scheme
+procedure mgl_data_import(dat: HMDT;const fname: PChar;const scheme: PChar;v1: mreal;v2: mreal); cdecl; external libmgl;
+/// Create or recreate the array with specified size and fill it by zero
+procedure mgl_data_create(dat: HMDT;nx: integer;ny: integer;nz: integer); cdecl; external libmgl;
+/// Transpose dimensions of the data (generalization of Transpose)
+procedure mgl_data_transpose(dat: HMDT;const dim: PChar); cdecl; external libmgl;
+/// Normalize the data to range [v1,v2]
+procedure mgl_data_norm(dat: HMDT;v1: mreal;v2: mreal;sym: integer;dim: integer); cdecl; external libmgl;
+/// Normalize the data to range [v1,v2] slice by slice
+procedure mgl_data_norm_slice(dat: HMDT;v1: mreal;v2: mreal;dir: char;keep_en: integer;sym: integer); cdecl; external libmgl;
+/// Get sub-array of the data with given fixed indexes
+function mgl_data_subdata(const dat: HMDT;xx: integer;yy: integer;zz: integer): HMDT; cdecl; external libmgl;
+/// Get sub-array of the data with given fixed indexes (like indirect access)
+function mgl_data_subdata_ext(const dat: HMDT;const xx: HMDT;const yy: HMDT;const zz: HMDT): HMDT; cdecl; external libmgl;
+/// Get column (or slice) of the data filled by formulas of named columns
+function mgl_data_column(const dat: HMDT;const eq: PChar): HMDT; cdecl; external libmgl;
+/// Set names for columns (slices)
+procedure mgl_data_set_id(d: HMDT;const id: PChar); cdecl; external libmgl;
+/// Equidistantly fill the data to range [x1,x2] in direction dir
+procedure mgl_data_fill(dat: HMDT;x1: mreal;x2: mreal;dir: char); cdecl; external libmgl;
+/// Modify the data by specified formula assuming x,y,z in range [r1,r2]
+procedure mgl_data_fill_eq(gr: HMGL;dat: HMDT;const eq: PChar;const vdat: HMDT;const wdat: HMDT;const opt: PChar); cdecl; external libmgl;
+/// Fill dat by interpolated values of vdat parametrically depended on xdat for x in range [x1,x2]
+procedure mgl_data_refill_x(dat: HMDT;const xdat: HMDT;const vdat: HMDT;x1: mreal;x2: mreal;sl: integer); cdecl; external libmgl;
+/// Fill dat by interpolated values of vdat parametrically depended on xdat,ydat for x,y in range [x1,x2]*[y1,y2]
+procedure mgl_data_refill_xy(dat: HMDT;const xdat: HMDT;const ydat: HMDT;const vdat: HMDT;x1: mreal;x2: mreal;y1: mreal;y2: mreal;sl: integer); cdecl; external libmgl;
+/// Fill dat by interpolated values of vdat parametrically depended on xdat,ydat,zdat for x,y,z in range [x1,x2]*[y1,y2]*[z1,z2]
+procedure mgl_data_refill_xyz(dat: HMDT;const xdat: HMDT;const ydat: HMDT;const zdat: HMDT;const vdat: HMDT;x1: mreal;x2: mreal;y1: mreal;y2: mreal;z1: mreal;z2: mreal); cdecl; external libmgl;
+/// Fill dat by interpolated values of vdat parametrically depended on xdat,ydat,zdat for x,y,z in axis range
+procedure mgl_data_refill_gr(gr: HMGL;dat: HMDT;const xdat: HMDT;const ydat: HMDT;const zdat: HMDT;const vdat: HMDT;sl: integer;const opt: PChar); cdecl; external libmgl;
+/// Set the data by triangulated surface values assuming x,y,z in range [r1,r2]
+procedure mgl_data_grid(gr: HMGL;d: HMDT;const xdat: HMDT;const ydat: HMDT;const zdat: HMDT;const opt: PChar); cdecl; external libmgl;
+/// Set the data by triangulated surface values assuming x,y,z in range [x1,x2]*[y1,y2]
+procedure mgl_data_grid_xy(d: HMDT;const xdat: HMDT;const ydat: HMDT;const zdat: HMDT;x1: mreal;x2: mreal;y1: mreal;y2: mreal); cdecl; external libmgl;
+/// Put value to data element(s)
+procedure mgl_data_put_val(dat: HMDT;val: mreal;i: integer;j: integer;k: integer); cdecl; external libmgl;
+/// Put array to data element(s)
+procedure mgl_data_put_dat(dat: HMDT;const val: HMDT;i: integer;j: integer;k: integer); cdecl; external libmgl;
+/// Modify the data by specified formula
+procedure mgl_data_modify(dat: HMDT;const eq: PChar;dim: integer); cdecl; external libmgl;
+/// Modify the data by specified formula
+procedure mgl_data_modify_vw(dat: HMDT;const eq: PChar;const vdat: HMDT;const wdat: HMDT); cdecl; external libmgl;
+/// Reduce size of the data
+procedure mgl_data_squeeze(dat: HMDT;rx: integer;ry: integer;rz: integer;smooth: integer); cdecl; external libmgl;
+/// Get maximal value of the data
+function mgl_data_max(const dat: HMDT): mreal; cdecl; external libmgl;
+/// Get minimal value of the data
+function mgl_data_min(const dat: HMDT): mreal; cdecl; external libmgl;
+/// Returns pointer to data element [i,j,k]
+function mgl_data_value(dat: HMDT;i: integer;j: integer;k: integer): Pmreal; cdecl; external libmgl;
+/// Returns pointer to internal data array
+function mgl_data_data(dat: HMDT): Pmreal; cdecl; external libmgl;
+/// Gets the x-size of the data.
+function mgl_data_get_nx(const d: HMDT): integer; cdecl; external libmgl;
+/// Gets the y-size of the data.
+function mgl_data_get_ny(const d: HMDT): integer; cdecl; external libmgl;
+/// Gets the z-size of the data.
+function mgl_data_get_nz(const d: HMDT): integer; cdecl; external libmgl;
+/// Find position (after specified in i,j,k) of first nonzero value of formula
+function mgl_data_first(const dat: HMDT;const cond: PChar;i: Pint;j: Pint;k: Pint): mreal; cdecl; external libmgl;
+/// Find position (before specified in i,j,k) of last nonzero value of formula
+function mgl_data_last(const dat: HMDT;const cond: PChar;i: Pint;j: Pint;k: Pint): mreal; cdecl; external libmgl;
+/// Find position of first in direction 'dir' nonzero value of formula
+function mgl_data_find(const dat: HMDT;const cond: PChar;dir: char;i: integer;j: integer;k: integer): integer; cdecl; external libmgl;
+/// Find if any nonzero value of formula
+function mgl_data_find_any(const dat: HMDT;const cond: PChar): integer; cdecl; external libmgl;
+/// Get maximal value of the data and its position
+function mgl_data_max_int(const dat: HMDT;i: Pint;j: Pint;k: Pint): mreal; cdecl; external libmgl;
+/// Get maximal value of the data and its approximated position
+function mgl_data_max_real(const dat: HMDT;x: Pmreal;y: Pmreal;z: Pmreal): mreal; cdecl; external libmgl;
+/// Get minimal value of the data and its position
+function mgl_data_min_int(const dat: HMDT;i: Pint;j: Pint;k: Pint): mreal; cdecl; external libmgl;
+/// Get minimal value of the data and its approximated position
+function mgl_data_min_real(const dat: HMDT;x: Pmreal;y: Pmreal;z: Pmreal): mreal; cdecl; external libmgl;
+/// Get "energy and find 4 momenta of data: median, width, skewness, kurtosis
+function mgl_data_momentum_val(const d: HMDT;dir: char;m: Pmreal;w: Pmreal;s: Pmreal;k: Pmreal): mreal; cdecl; external libmgl;
+/// Get the data which is direct multiplication (like, d[i,j] = this[i]*a[j] and so on)
+function mgl_data_combine(const dat1: HMDT;const dat2: HMDT): HMDT; cdecl; external libmgl;
+/// Extend data dimensions
+procedure mgl_data_extend(dat: HMDT;n1: integer;n2: integer); cdecl; external libmgl;
+/// Insert data rows/columns/slices
+procedure mgl_data_insert(dat: HMDT;dir: char;at: integer;num: integer); cdecl; external libmgl;
+/// Delete data rows/columns/slices
+procedure mgl_data_delete(dat: HMDT;dir: char;at: integer;num: integer); cdecl; external libmgl;
+/// Joind another data array
+procedure mgl_data_join(dat: HMDT;const d: HMDT); cdecl; external libmgl;
+/// Smooth the data on specified direction or directions
+procedure mgl_data_smooth(d: HMDT;const dirs: PChar;delta: mreal); cdecl; external libmgl;
+/// Get array which is result of summation in given direction or directions
+function mgl_data_sum(const dat: HMDT;const dir: PChar): HMDT; cdecl; external libmgl;
+/// Get array which is result of maximal values in given direction or directions
+function mgl_data_max_dir(const dat: HMDT;const dir: PChar): HMDT; cdecl; external libmgl;
+/// Get array which is result of minimal values in given direction or directions
+function mgl_data_min_dir(const dat: HMDT;const dir: PChar): HMDT; cdecl; external libmgl;
+/// Cumulative summation the data in given direction or directions
+procedure mgl_data_cumsum(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Integrate (cumulative summation) the data in given direction or directions
+procedure mgl_data_integral(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Differentiate the data in given direction or directions
+procedure mgl_data_diff(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Differentiate the parametrically specified data along direction v1 with v2,v3=const (v3 can be NULL)
+procedure mgl_data_diff_par(dat: HMDT;const v1: HMDT;const v2: HMDT;const v3: HMDT); cdecl; external libmgl;
+/// Double-differentiate (like Laplace operator) the data in given direction
+procedure mgl_data_diff2(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Swap left and right part of the data in given direction (useful for Fourier spectrum)
+procedure mgl_data_swap(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Roll data along direction dir by num slices
+procedure mgl_data_roll(dat: HMDT;dir: char;num: integer); cdecl; external libmgl;
+/// Mirror the data in given direction (useful for Fourier spectrum)
+procedure mgl_data_mirror(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Sort rows (or slices) by values of specified column
+procedure mgl_data_sort(dat: HMDT;idx: integer;idy: integer); cdecl; external libmgl;
+/// Apply Hankel transform
+procedure mgl_data_hankel(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Apply Sin-Fourier transform
+procedure mgl_data_sinfft(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Apply Cos-Fourier transform
+procedure mgl_data_cosfft(dat: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Fill data by 'x'/'k' samples for Hankel ('h') or Fourier ('f') transform
+procedure mgl_data_fill_sample(dat: HMDT;const how: PChar); cdecl; external libmgl;
+/// Find correlation between 2 data arrays
+function mgl_data_correl(const dat1: HMDT;const dat2: HMDT;const dir: PChar): HMDT; cdecl; external libmgl;
+/// Allocate and prepare data for Fourier transform by nthr threads
+/// Free data for Fourier transform
+/// Make Fourier transform of data x of size n and step s between points
+/// Clear internal data for speeding up FFT and Hankel transforms
+procedure mgl_clear_fft(); cdecl; external libmgl;
+/// Interpolate by cubic spline the data to given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_data_spline(const dat: HMDT;x: mreal;y: mreal;z: mreal): mreal; cdecl; external libmgl;
+/// Interpolate by linear function the data to given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_data_linear(const dat: HMDT;x: mreal;y: mreal;z: mreal): mreal; cdecl; external libmgl;
+/// Interpolate by cubic spline the data and return its derivatives at given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_data_spline_ext(const dat: HMDT;x: mreal;y: mreal;z: mreal;dx: Pmreal;dy: Pmreal;dz: Pmreal): mreal; cdecl; external libmgl;
+/// Interpolate by linear function the data and return its derivatives at given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_data_linear_ext(const dat: HMDT;x: mreal;y: mreal;z: mreal;dx: Pmreal;dy: Pmreal;dz: Pmreal): mreal; cdecl; external libmgl;
+/// Return an approximated x-value (root) when dat(x) = val
+function mgl_data_solve_1d(const dat: HMDT;val: mreal;spl: integer;i0: integer): mreal; cdecl; external libmgl;
+/// Return an approximated value (root) when dat(x) = val
+function mgl_data_solve(const dat: HMDT;val: mreal;dir: char;const i0: HMDT;norm: integer): HMDT; cdecl; external libmgl;
+/// Get trace of the data array
+function mgl_data_trace(const d: HMDT): HMDT; cdecl; external libmgl;
+/// Resize the data to new sizes
+function mgl_data_resize(const dat: HMDT;mx: integer;my: integer;mz: integer): HMDT; cdecl; external libmgl;
+/// Resize the data to new sizes of box [x1,x2]*[y1,y2]*[z1,z2]
+function mgl_data_resize_box(const dat: HMDT;mx: integer;my: integer;mz: integer;x1: mreal;x2: mreal;y1: mreal;y2: mreal;z1: mreal;z2: mreal): HMDT; cdecl; external libmgl;
+/// Create n-th points distribution of this data values in range [v1, v2]
+function mgl_data_hist(const dat: HMDT;n: integer;v1: mreal;v2: mreal;nsub: integer): HMDT; cdecl; external libmgl;
+/// Create n-th points distribution of this data values in range [v1, v2] with weight w
+function mgl_data_hist_w(const dat: HMDT;const weight: HMDT;n: integer;v1: mreal;v2: mreal;nsub: integer): HMDT; cdecl; external libmgl;
+/// Get momentum (1D-array) of data along direction 'dir'. String looks like "x1" for median in x-direction, "x2" for width in x-dir and so on.
+function mgl_data_momentum(const dat: HMDT;dir: char;const how: PChar): HMDT; cdecl; external libmgl;
+/// Get array which values is result of interpolation this for coordinates from other arrays
+function mgl_data_evaluate(const dat: HMDT;const idat: HMDT;const jdat: HMDT;const kdat: HMDT;norm: integer): HMDT; cdecl; external libmgl;
+/// Set as the data envelop
+procedure mgl_data_envelop(dat: HMDT;dir: char); cdecl; external libmgl;
+/// Remove phase jump
+procedure mgl_data_sew(dat: HMDT;const dirs: PChar;da: mreal); cdecl; external libmgl;
+/// Crop the data
+procedure mgl_data_crop(dat: HMDT;n1: integer;n2: integer;dir: char); cdecl; external libmgl;
+/// Remove rows with duplicate values in column id
+procedure mgl_data_clean(dat: HMDT;id: integer); cdecl; external libmgl;
+/// Multiply the data by other one for each element
+procedure mgl_data_mul_dat(dat: HMDT;const d: HMDT); cdecl; external libmgl;
+/// Divide the data by other one for each element
+procedure mgl_data_div_dat(dat: HMDT;const d: HMDT); cdecl; external libmgl;
+/// Add the other data
+procedure mgl_data_add_dat(dat: HMDT;const d: HMDT); cdecl; external libmgl;
+/// Subtract the other data
+procedure mgl_data_sub_dat(dat: HMDT;const d: HMDT); cdecl; external libmgl;
+/// Multiply each element by the number
+procedure mgl_data_mul_num(dat: HMDT;d: mreal); cdecl; external libmgl;
+/// Divide each element by the number
+procedure mgl_data_div_num(dat: HMDT;d: mreal); cdecl; external libmgl;
+/// Add the number
+procedure mgl_data_add_num(dat: HMDT;d: mreal); cdecl; external libmgl;
+/// Subtract the number
+procedure mgl_data_sub_num(dat: HMDT;d: mreal); cdecl; external libmgl;
+/// Integral data transformation (like Fourier 'f' or 'i', Hankel 'h' or None 'n') for amplitude and phase
+function mgl_transform_a(const am: HMDT;const ph: HMDT;const tr: PChar): HMDT; cdecl; external libmgl;
+/// Integral data transformation (like Fourier 'f' or 'i', Hankel 'h' or None 'n') for real and imaginary parts
+function mgl_transform(const re: HMDT;const im: HMDT;const tr: PChar): HMDT; cdecl; external libmgl;
+/// Apply Fourier transform for the data and save result into it
+procedure mgl_data_fourier(re: HMDT;im: HMDT;const dir: PChar); cdecl; external libmgl;
+/// Short time Fourier analysis for real and imaginary parts. Output is amplitude of partial Fourier (result will have size {dn, floor(nx/dn), ny} for dir='x'
+function mgl_data_stfa(const re: HMDT;const im: HMDT;dn: integer;dir: char): HMDT; cdecl; external libmgl;
+/// Do something like Delone triangulation for 3d points
+function mgl_triangulation_3d(const x: HMDT;const y: HMDT;const z: HMDT): HMDT; cdecl; external libmgl;
+/// Do Delone triangulation for 2d points
+function mgl_triangulation_2d(const x: HMDT;const y: HMDT): HMDT; cdecl; external libmgl;
+/// Find root for nonlinear equation
+/// Find root for nonlinear equation defined by textual formula
+function mgl_find_root_txt(const func: PChar;ini: mreal;var_id: char): mreal; cdecl; external libmgl;
+/// Find roots for nonlinear equation defined by textual formula
+function mgl_data_roots(const func: PChar;const ini: HMDT;var_id: char): HMDT; cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/datac_cf.h ==}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/// Create HMDT object
+function mgl_create_datac(): HADT; cdecl; external libmgl;
+/// Create HMDT object with specified sizes
+function mgl_create_datac_size(nx: integer;ny: integer;nz: integer): HADT; cdecl; external libmgl;
+/// Create HMDT object with data from file
+function mgl_create_datac_file(const fname: PChar): HADT; cdecl; external libmgl;
+/// Delete HMDT object
+procedure mgl_delete_datac(dat: HADT); cdecl; external libmgl;
+/// Rearange data dimensions
+procedure mgl_datac_rearrange(dat: HADT;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Link external data array (don't delete it at exit)
+procedure mgl_datac_link(dat: HADT;A: Pdual;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Allocate memory and copy the data from the (float *) array
+procedure mgl_datac_set_float(dat: HADT;const A: Preal;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Allocate memory and copy the data from the (double *) array
+procedure mgl_datac_set_double(dat: HADT;const A: Pdouble;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Allocate memory and copy the data from the (dual *) array
+procedure mgl_datac_set_complex(dat: HADT;const A: Pdual;mx: integer;my: integer;mz: integer); cdecl; external libmgl;
+/// Import data from abstract type
+procedure mgl_datac_set(dat: HADT;const a: HMDT); cdecl; external libmgl;
+/// Allocate memory and copy the data from the gsl_vector
+procedure mgl_datac_set_vector(dat: HADT;v: PGSLVector); cdecl; external libmgl;
+/// Allocate memory and copy the data from the gsl_matrix
+procedure mgl_datac_set_matrix(dat: HADT;m: PGSLMatrix); cdecl; external libmgl;
+/// Set value of data element [i,j,k]
+procedure mgl_datac_set_value(dat: HADT;v: dual;i: integer;j: integer;k: integer); cdecl; external libmgl;
+/// Get value of data element [i,j,k]
+function mgl_datac_get_value(const dat: HMDT;i: integer;j: integer;k: integer): dual; cdecl; external libmgl;
+/// Allocate memory and scanf the data from the string
+procedure mgl_datac_set_values(dat: HADT;const val: PChar;nx: integer;ny: integer;nz: integer); cdecl; external libmgl;
+/// Returns pointer to internal data array
+function mgl_datac_data(dat: HADT): PDual; cdecl; external libmgl;
+/// Returns pointer to data element [i,j,k]
+function mgl_datac_value(dat: HADT;i: integer;j: integer;k: integer): PDual; cdecl; external libmgl;
+/// Set the data from HCDT objects for real and imaginary parts
+procedure mgl_datac_set_ri(dat: HADT;const re: HMDT;const im: HMDT); cdecl; external libmgl;
+/// Set the data from HCDT objects as amplitude and phase of complex data
+procedure mgl_datac_set_ap(dat: HADT;const abs: HMDT;const phi: HMDT); cdecl; external libmgl;
+/// Read data from tab-separated text file with auto determining size
+function mgl_datac_read(dat: HADT;const fname: PChar): integer; cdecl; external libmgl;
+/// Read data from text file with size specified at beginning of the file
+function mgl_datac_read_mat(dat: HADT;const fname: PChar;dim: integer): integer; cdecl; external libmgl;
+/// Read data from text file with specifeid size
+function mgl_datac_read_dim(dat: HADT;const fname: PChar;mx: integer;my: integer;mz: integer): integer; cdecl; external libmgl;
+/// Read data from tab-separated text files with auto determining size which filenames are result of sprintf(fname,templ,t) where t=from:step:to
+function mgl_datac_read_range(d: HADT;const templ: PChar;from: double;to_: double;step: double;as_slice: integer): integer; cdecl; external libmgl;
+/// Read data from tab-separated text files with auto determining size which filenames are satisfied to template (like "t_*.dat")
+function mgl_datac_read_all(dat: HADT;const templ: PChar;as_slice: integer): integer; cdecl; external libmgl;
+/// Save whole data array (for ns=-1) or only ns-th slice to text file
+procedure mgl_datac_save(const dat: HMDT;const fname: PChar;ns: integer); cdecl; external libmgl;
+/// Read data array from HDF file (parse HDF4 and HDF5 files)
+function mgl_datac_read_hdf(d: HADT;const fname: PChar;const data: PChar): integer; cdecl; external libmgl;
+/// Save data to HDF file
+procedure mgl_datac_save_hdf(const d: HMDT;const fname: PChar;const data: PChar;rewrite: integer); cdecl; external libmgl;
+/// Create or recreate the array with specified size and fill it by zero
+procedure mgl_datac_create(dat: HADT;nx: integer;ny: integer;nz: integer); cdecl; external libmgl;
+/// Transpose dimensions of the data (generalization of Transpose)
+procedure mgl_datac_transpose(dat: HADT;const dim: PChar); cdecl; external libmgl;
+/// Set names for columns (slices)
+procedure mgl_datac_set_id(d: HADT;const id: PChar); cdecl; external libmgl;
+/// Equidistantly fill the data to range [x1,x2] in direction dir
+procedure mgl_datac_fill(dat: HADT;x1: dual;x2: dual;dir: char); cdecl; external libmgl;
+/// Modify the data by specified formula assuming x,y,z in range [r1,r2]
+procedure mgl_datac_fill_eq(gr: HMGL;dat: HADT;const eq: PChar;const vdat: HMDT;const wdat: HMDT;const opt: PChar); cdecl; external libmgl;
+/// Modify the data by specified formula
+procedure mgl_datac_modify(dat: HADT;const eq: PChar;dim: integer); cdecl; external libmgl;
+/// Modify the data by specified formula
+procedure mgl_datac_modify_vw(dat: HADT;const eq: PChar;const vdat: HMDT;const wdat: HMDT); cdecl; external libmgl;
+/// Put value to data element(s)
+procedure mgl_datac_put_val(dat: HADT;val: dual;i: integer;j: integer;k: integer); cdecl; external libmgl;
+/// Put array to data element(s)
+procedure mgl_datac_put_dat(dat: HADT;const val: HMDT;i: integer;j: integer;k: integer); cdecl; external libmgl;
+/// Reduce size of the data
+procedure mgl_datac_squeeze(dat: HADT;rx: integer;ry: integer;rz: integer;smooth: integer); cdecl; external libmgl;
+/// Extend data dimensions
+procedure mgl_datac_extend(dat: HADT;n1: integer;n2: integer); cdecl; external libmgl;
+/// Insert data rows/columns/slices
+procedure mgl_datac_insert(dat: HADT;dir: char;at: integer;num: integer); cdecl; external libmgl;
+/// Delete data rows/columns/slices
+procedure mgl_datac_delete(dat: HADT;dir: char;at: integer;num: integer); cdecl; external libmgl;
+/// Joind another data array
+procedure mgl_datac_join(dat: HADT;const d: HMDT); cdecl; external libmgl;
+/// Smooth the data on specified direction or directions
+procedure mgl_datac_smooth(d: HADT;const dirs: PChar;delta: mreal); cdecl; external libmgl;
+/// Cumulative summation the data in given direction or directions
+procedure mgl_datac_cumsum(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Integrate (cumulative summation) the data in given direction or directions
+procedure mgl_datac_integral(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Differentiate the data in given direction or directions
+procedure mgl_datac_diff(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Double-differentiate (like Laplace operator) the data in given direction
+procedure mgl_datac_diff2(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Swap left and right part of the data in given direction (useful for Fourier spectrum)
+procedure mgl_datac_swap(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Roll data along direction dir by num slices
+procedure mgl_datac_roll(dat: HADT;dir: char;num: integer); cdecl; external libmgl;
+/// Mirror the data in given direction (useful for Fourier spectrum)
+procedure mgl_datac_mirror(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Crop the data
+procedure mgl_datac_crop(dat: HADT;n1: integer;n2: integer;dir: char); cdecl; external libmgl;
+/// Apply Hankel transform
+procedure mgl_datac_hankel(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Apply Fourier transform
+procedure mgl_datac_fft(dat: HADT;const dir: PChar); cdecl; external libmgl;
+/// Find correlation between 2 data arrays
+function mgl_datac_correl(const dat1: HMDT;const dat2: HMDT;const dir: PChar): HADT; cdecl; external libmgl;
+function mgl_datac_real(const dat: HMDT): HMDT; cdecl; external libmgl;
+function mgl_datac_imag(const dat: HMDT): HMDT; cdecl; external libmgl;
+function mgl_datac_abs(const dat: HMDT): HMDT; cdecl; external libmgl;
+function mgl_datac_arg(const dat: HMDT): HMDT; cdecl; external libmgl;
+/// Interpolate by linear function the data to given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_datac_linear(const d: HMDT;x: mreal;y: mreal;z: mreal): dual; cdecl; external libmgl;
+/// Interpolate by linear function the data and return its derivatives at given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_datac_linear_ext(const d: HMDT;x: mreal;y: mreal;z: mreal;dx: Pdual;dy: Pdual;dz: Pdual): dual; cdecl; external libmgl;
+/// Interpolate by cubic spline the data to given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_datac_spline(const dat: HMDT;x: mreal;y: mreal;z: mreal): dual; cdecl; external libmgl;
+/// Interpolate by cubic spline the data and return its derivatives at given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]
+function mgl_datac_spline_ext(const dat: HMDT;x: mreal;y: mreal;z: mreal;dx: Pdual;dy: Pdual;dz: Pdual): dual; cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/cont.h ==}
+//-----------------------------------------------------------------------------
+/// Print text along the curve in parametric form {x,y,z}
+procedure mgl_text_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const text: PChar;const font: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_textw_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const text: PWideChar;const font: PChar;const opt: PChar); cdecl; external libmgl;
+/// Print text along the curve in parametric form {x,y}
+procedure mgl_text_xy(gr: HMGL;const x: HMDT;const y: HMDT;const text: PChar;const font: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_textw_xy(gr: HMGL;const x: HMDT;const y: HMDT;const text: PWideChar;const font: PChar;const opt: PChar); cdecl; external libmgl;
+/// Print text along the curve
+procedure mgl_text_y(gr: HMGL;const y: HMDT;const text: PChar;const font: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_textw_y(gr: HMGL;const y: HMDT;const text: PWideChar;const font: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_cont_gen(gr: HMGL;val: double;const a: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const stl: PChar); cdecl; external libmgl;
+procedure mgl_contf_gen(gr: HMGL;v1: double;v2: double;const a: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const stl: PChar); cdecl; external libmgl;
+//void MGL_EXPORT mgl_contv_gen(HMGL gr, double v1, double v2, HCDT a, HCDT x, HCDT y, HCDT z, const char *stl)
+//void MGL_EXPORT mgl_axial_gen(HMGL gr, double v1, double v2, HCDT a, HCDT x, HCDT y, HCDT z, const char *stl)
+/// Draw manual contour lines for 2d data specified parametrically
+procedure mgl_cont_xy_val(gr: HMGL;const v: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines for 2d data
+procedure mgl_cont_val(gr: HMGL;const v: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines for 2d data specified parametrically
+procedure mgl_cont_xy(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines for 2d data
+procedure mgl_cont(gr: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours for 2d data specified parametrically
+procedure mgl_contf_xy_val(gr: HMGL;const v: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours for 2d data
+procedure mgl_contf_val(gr: HMGL;const v: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours for 2d data specified parametrically
+procedure mgl_contf_xy(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours for 2d data
+procedure mgl_contf(gr: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours for 2d data specified parametrically with manual colors
+procedure mgl_contd_xy_val(gr: HMGL;const v: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours for 2d data with manual colors
+procedure mgl_contd_val(gr: HMGL;const v: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours for 2d data specified parametrically with manual colors
+procedure mgl_contd_xy(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours for 2d data with manual colors
+procedure mgl_contd(gr: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour tubes for 2d data specified parametrically
+procedure mgl_contv_xy_val(gr: HMGL;const v: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour tubes for 2d data
+procedure mgl_contv_val(gr: HMGL;const v: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw contour tubes for 2d data specified parametrically
+procedure mgl_contv_xy(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw contour tubes for 2d data
+procedure mgl_contv(gr: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual axial-symmetric isosurfaces for 2d data specified parametrically
+procedure mgl_axial_xy_val(gr: HMGL;const v: HMDT;const x: HMDT;const y: HMDT;const a: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual axial-symmetric isosurfaces for 2d data
+procedure mgl_axial_val(gr: HMGL;const v: HMDT;const a: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw axial-symmetric isosurfaces for 2d data specified parametrically
+procedure mgl_axial_xy(gr: HMGL;const x: HMDT;const y: HMDT;const a: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw axial-symmetric isosurfaces for 2d data
+procedure mgl_axial(gr: HMGL;const a: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface of curve {r,z} rotatation around axis
+procedure mgl_torus(gr: HMGL;const r: HMDT;const z: HMDT;const col: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw grid lines for density plot at slice for 3d data specified parametrically
+procedure mgl_grid3_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw grid lines for density plot at slice for 3d data
+procedure mgl_grid3(gr: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot at slice for 3d data specified parametrically
+procedure mgl_dens3_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot at slice for 3d data
+procedure mgl_dens3(gr: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines at slice for 3d data specified parametrically
+procedure mgl_cont3_xyz_val(gr: HMGL;const v: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines at slice for 3d data
+procedure mgl_cont3_val(gr: HMGL;const v: HMDT;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines at slice for 3d data specified parametrically
+procedure mgl_cont3_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines at slice for 3d data
+procedure mgl_cont3(gr: HMGL;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours at slice for 3d data specified parametrically
+procedure mgl_contf3_xyz_val(gr: HMGL;const v: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours at slice for 3d data
+procedure mgl_contf3_val(gr: HMGL;const v: HMDT;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours at slice for 3d data specified parametrically
+procedure mgl_contf3_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours at slice for 3d data
+procedure mgl_contf3(gr: HMGL;const a: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/fit.h ==}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+function mgl_fit_1(gr: HMGL;const y: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_2(gr: HMGL;const z: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_3(gr: HMGL;const a: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_xy(gr: HMGL;const x: HMDT;const y: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_xyza(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_ys(gr: HMGL;const y: HMDT;const s: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_xys(gr: HMGL;const x: HMDT;const y: HMDT;const s: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_xyzs(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const s: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_fit_xyzas(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const s: HMDT;const eq: PChar;const vars: PChar;ini: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_get_fit(gr: HMGL): PChar; cdecl; external libmgl;
+function mgl_hist_x(gr: HMGL;const x: HMDT;const a: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_hist_xy(gr: HMGL;const x: HMDT;const y: HMDT;const a: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+function mgl_hist_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const opt: PChar): HMDT; cdecl; external libmgl;
+procedure mgl_puts_fit(gr: HMGL;x: double;y: double;z: double;const prefix: PChar;const font: PChar;size: double); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/plot.h ==}
+//-----------------------------------------------------------------------------
+/// Draw curve for formula with x in x-axis range
+procedure mgl_fplot(gr: HMGL;const eqY: PChar;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw curve for formulas parametrically depended on t in range [0,1]
+procedure mgl_fplot_xyz(gr: HMGL;const eqX: PChar;const eqY: PChar;const eqZ: PChar;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw radar chart (plot in curved coordinates)
+procedure mgl_radar(graph: HMGL;const a: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw usual curve {x,y,z}
+procedure mgl_plot_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw usual curve {x,y}
+procedure mgl_plot_xy(graph: HMGL;const x: HMDT;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw usual curve {x,y} with x in x-axis range
+procedure mgl_plot(graph: HMGL;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw curve {x,y,z} which is colored by c (like tension plot)
+procedure mgl_tens_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw curve {x,y} which is colored by c (like tension plot)
+procedure mgl_tens_xy(graph: HMGL;const x: HMDT;const y: HMDT;const c: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw curve {x,y} with x in x-axis range which is colored by c (like tension plot)
+procedure mgl_tens(graph: HMGL;const y: HMDT;const c: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tape(s) which rotates as (bi-)normales of curve {x,y,z}
+procedure mgl_tape_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tape(s) which rotates as (bi-)normales of curve {x,y}
+procedure mgl_tape_xy(graph: HMGL;const x: HMDT;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tape(s) which rotates as (bi-)normales of curve {x,y} with x in x-axis range
+procedure mgl_tape(graph: HMGL;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw box-plot (special 5-value plot used in statistic) for data specified parametrically
+procedure mgl_boxplot_xy(graph: HMGL;const x: HMDT;const a: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw box-plot (special 5-value plot used in statistic)
+procedure mgl_boxplot(graph: HMGL;const a: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Fill area between curve {x,y,z} and axis plane
+procedure mgl_area_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Fill area between curve {x,y} and axis plane
+procedure mgl_area_xy(graph: HMGL;const x: HMDT;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Fill area between curve {x,y} with x in x-axis range and axis plane
+procedure mgl_area(graph: HMGL;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Fill area between curves {x,y1} and {x,y2}
+procedure mgl_region_xy(graph: HMGL;const x: HMDT;const y1: HMDT;const y2: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Fill area between curves {x,y1} and {x,y2} with x in x-axis range
+procedure mgl_region(graph: HMGL;const y1: HMDT;const y2: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical lines from points {x,y,z} to axis plane
+procedure mgl_stem_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical lines from points {x,y} to axis plane
+procedure mgl_stem_xy(graph: HMGL;const x: HMDT;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical lines from points {x,y} with x in x-axis range to axis plane
+procedure mgl_stem(graph: HMGL;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw stairs for points in arrays {x,y,z}
+procedure mgl_step_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw stairs for points in arrays {x,y}
+procedure mgl_step_xy(graph: HMGL;const x: HMDT;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw stairs for points in arrays {x,y} with x in x-axis range
+procedure mgl_step(graph: HMGL;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical bars from points {x,y,z} to axis plane
+procedure mgl_bars_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical bars from points {x,y} to axis plane
+procedure mgl_bars_xy(graph: HMGL;const x: HMDT;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical bars from points {x,y} with x in x-axis range to axis plane
+procedure mgl_bars(graph: HMGL;const y: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw horizontal bars from points {v,y} to axis plane
+procedure mgl_barh_yx(graph: HMGL;const y: HMDT;const v: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw horizontal bars from points {v,y} with y in y-axis range to axis plane
+procedure mgl_barh(graph: HMGL;const v: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw Open-High-Low-Close (OHLC) diagram
+procedure mgl_ohlc_x(graph: HMGL;const x: HMDT;const open: HMDT;const high: HMDT;const low: HMDT;const close: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw Open-High-Low-Close (OHLC) diagram with x in x-axis range
+procedure mgl_ohlc(graph: HMGL;const open: HMDT;const high: HMDT;const low: HMDT;const close: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw chart for data a
+procedure mgl_chart(graph: HMGL;const a: HMDT;const col: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw error boxes {ex,ey} at points {x,y}
+procedure mgl_error_exy(graph: HMGL;const x: HMDT;const y: HMDT;const ex: HMDT;const ey: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw error boxes {ey} at points {x,y}
+procedure mgl_error_xy(graph: HMGL;const x: HMDT;const y: HMDT;const ey: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw error boxes {ey} at points {x,y} with x in x-axis range
+procedure mgl_error(graph: HMGL;const y: HMDT;const ey: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw marks with size r at points {x,y,z}
+procedure mgl_mark_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const r: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw marks with size r at points {x,y}
+procedure mgl_mark_xy(graph: HMGL;const x: HMDT;const y: HMDT;const r: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw marks with size r at points {x,y} with x in x-axis range
+procedure mgl_mark_y(graph: HMGL;const y: HMDT;const r: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tube with variable radius r around curve {x,y,z}
+procedure mgl_tube_xyzr(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const r: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tube with variable radius r around curve {x,y}
+procedure mgl_tube_xyr(graph: HMGL;const x: HMDT;const y: HMDT;const r: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tube with variable radius r around curve {x,y} with x in x-axis range
+procedure mgl_tube_r(graph: HMGL;const y: HMDT;const r: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tube with constant radius r around curve {x,y,z}
+procedure mgl_tube_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;r: double;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tube with constant radius r around curve {x,y}
+procedure mgl_tube_xy(graph: HMGL;const x: HMDT;const y: HMDT;r: double;const penl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw tube with constant radius r around curve {x,y} with x in x-axis range
+procedure mgl_tube(graph: HMGL;const y: HMDT;r: double;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw candle plot for data specified parametrically
+procedure mgl_candle_xyv(gr: HMGL;const x: HMDT;const v1: HMDT;const v2: HMDT;const y1: HMDT;const y2: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw candle plot
+procedure mgl_candle_yv(gr: HMGL;const v1: HMDT;const v2: HMDT;const y1: HMDT;const y2: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw candle plot with v1=v[i], v2=v[i+1]
+procedure mgl_candle(gr: HMGL;const v: HMDT;const y1: HMDT;const y2: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/surf.h ==}
+//-----------------------------------------------------------------------------
+/// Draw surface by formula with x,y in axis range
+procedure mgl_fsurf(graph: HMGL;const fz: PChar;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface by formulas parametrically depended on u,v in range [0,1]
+procedure mgl_fsurf_xyz(graph: HMGL;const fx: PChar;const fy: PChar;const fz: PChar;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw grid lines for density plot of 2d data specified parametrically
+procedure mgl_grid_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw grid lines for density plot of 2d data
+procedure mgl_grid(graph: HMGL;const a: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw mesh lines for 2d data specified parametrically
+procedure mgl_mesh_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw mesh lines for 2d data
+procedure mgl_mesh(graph: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw mesh lines for 2d data specified parametrically
+procedure mgl_fall_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw mesh lines for 2d data
+procedure mgl_fall(graph: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw belts for 2d data specified parametrically
+procedure mgl_belt_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw belts for 2d data
+procedure mgl_belt(graph: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface for 2d data specified parametrically with color proportional to z
+procedure mgl_surf_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface for 2d data with color proportional to z
+procedure mgl_surf(graph: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot for 2d data specified parametrically
+procedure mgl_dens_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot for 2d data
+procedure mgl_dens(graph: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical boxes for 2d data specified parametrically
+procedure mgl_boxs_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical boxes for 2d data
+procedure mgl_boxs(graph: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical tiles for 2d data specified parametrically
+procedure mgl_tile_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical tiles for 2d data
+procedure mgl_tile(graph: HMGL;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical tiles with variable size r for 2d data specified parametrically
+procedure mgl_tiles_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const r: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vertical tiles with variable size r for 2d data
+procedure mgl_tiles(graph: HMGL;const z: HMDT;const r: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface for 2d data specified parametrically with color proportional to c
+procedure mgl_surfc_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface for 2d data with color proportional to c
+procedure mgl_surfc(graph: HMGL;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface for 2d data specified parametrically with alpha proportional to c
+procedure mgl_surfa_xy(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface for 2d data with alpha proportional to c
+procedure mgl_surfa(graph: HMGL;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot for spectra-gramm specified parametrically
+procedure mgl_stfa_xy(graph: HMGL;const x: HMDT;const y: HMDT;const re: HMDT;const im: HMDT;dn: integer;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot for spectra-gramm
+procedure mgl_stfa(graph: HMGL;const re: HMDT;const im: HMDT;dn: integer;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Color map of matrix a to matrix b, both matrix can parametrically depend on coordinates
+procedure mgl_map_xy(graph: HMGL;const x: HMDT;const y: HMDT;const a: HMDT;const b: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Color map of matrix a to matrix b
+procedure mgl_map(graph: HMGL;const a: HMDT;const b: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/volume.h ==}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/// Draw isosurface for 3d data specified parametrically
+procedure mgl_surf3_xyz_val(graph: HMGL;Val: double;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurface for 3d data
+procedure mgl_surf3_val(graph: HMGL;Val: double;const a: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurfaces for 3d data specified parametrically
+procedure mgl_surf3_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurfaces for 3d data
+procedure mgl_surf3(graph: HMGL;const a: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurface for 3d data specified parametrically with alpha proportional to b
+procedure mgl_surf3a_xyz_val(graph: HMGL;Val: double;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurface for 3d data with alpha proportional to b
+procedure mgl_surf3a_val(graph: HMGL;Val: double;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurfaces for 3d data specified parametrically with alpha proportional to b
+procedure mgl_surf3a_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurfaces for 3d data with alpha proportional to b
+procedure mgl_surf3a(graph: HMGL;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurface for 3d data specified parametrically with color proportional to b
+procedure mgl_surf3c_xyz_val(graph: HMGL;Val: double;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurface for 3d data with color proportional to b
+procedure mgl_surf3c_val(graph: HMGL;Val: double;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurfaces for 3d data specified parametrically with color proportional to b
+procedure mgl_surf3c_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurfaces for 3d data with color proportional to b
+procedure mgl_surf3c(graph: HMGL;const a: HMDT;const b: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw a semi-transparent cloud for 3d data specified parametrically
+procedure mgl_cloud_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw a semi-transparent cloud for 3d data
+procedure mgl_cloud(graph: HMGL;const a: HMDT;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw isosurface for 3d beam in curvilinear coordinates
+procedure mgl_beam_val(graph: HMGL;Val: double;const tr: HMDT;const g1: HMDT;const g2: HMDT;const a: HMDT;r: double;const stl: PChar;norm: integer); cdecl; external libmgl;
+/// Draw several isosurfaces for 3d beam in curvilinear coordinates
+procedure mgl_beam(graph: HMGL;const tr: HMDT;const g1: HMDT;const g2: HMDT;const a: HMDT;r: double;const stl: PChar;norm: integer;num: integer); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/vect.h ==}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/// Plot vectors at position {x,y} along {ax,ay} with length/color proportional to |a|
+procedure mgl_traj_xy(gr: HMGL;const x: HMDT;const y: HMDT;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot vectors at position {x,y,z} along {ax,ay,az} with length/color proportional to |a|
+procedure mgl_traj_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot vector field {ax,ay} parametrically depended on coordinate {x,y} with length/color proportional to |a|
+procedure mgl_vect_xy(gr: HMGL;const x: HMDT;const y: HMDT;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot vector field {ax,ay} with length/color proportional to |a|
+procedure mgl_vect_2d(gr: HMGL;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot vector field {ax,ay,az} parametrically depended on coordinate {x,y,z} with length/color proportional to |a|
+procedure mgl_vect_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot vector field {ax,ay,az} with length/color proportional to |a|
+procedure mgl_vect_3d(gr: HMGL;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flows for vector field {ax,ay} parametrically depended on coordinate {x,y} with color proportional to |a|
+procedure mgl_flow_xy(gr: HMGL;const x: HMDT;const y: HMDT;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flows for vector field {ax,ay} with color proportional to |a|
+procedure mgl_flow_2d(gr: HMGL;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flows for vector field {ax,ay,az} parametrically depended on coordinate {x,y,z} with color proportional to |a|
+procedure mgl_flow_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flows for vector field {ax,ay,az} with color proportional to |a|
+procedure mgl_flow_3d(gr: HMGL;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flow from point p for vector field {ax,ay} parametrically depended on coordinate {x,y} with color proportional to |a|
+procedure mgl_flowp_xy(gr: HMGL;x0: double;y0: double;z0: double;const x: HMDT;const y: HMDT;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flow from point p for vector field {ax,ay} with color proportional to |a|
+procedure mgl_flowp_2d(gr: HMGL;x0: double;y0: double;z0: double;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flow from point p for vector field {ax,ay,az} parametrically depended on coordinate {x,y,z} with color proportional to |a|
+procedure mgl_flowp_xyz(gr: HMGL;x0: double;y0: double;z0: double;const x: HMDT;const y: HMDT;const z: HMDT;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flow from point p for vector field {ax,ay,az} with color proportional to |a|
+procedure mgl_flowp_3d(gr: HMGL;x0: double;y0: double;z0: double;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flow pipes for vector field {ax,ay} parametrically depended on coordinate {x,y} with color and radius proportional to |a|
+procedure mgl_pipe_xy(gr: HMGL;const x: HMDT;const y: HMDT;const ax: HMDT;const ay: HMDT;const sch: PChar;r0: double;const opt: PChar); cdecl; external libmgl;
+/// Plot flow pipes for vector field {ax,ay} with color and radius proportional to |a|
+procedure mgl_pipe_2d(gr: HMGL;const ax: HMDT;const ay: HMDT;const sch: PChar;r0: double;const opt: PChar); cdecl; external libmgl;
+/// Plot flow pipes for vector field {ax,ay,az} parametrically depended on coordinate {x,y,z} with color and radius proportional to |a|
+procedure mgl_pipe_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;r0: double;const opt: PChar); cdecl; external libmgl;
+/// Plot flow pipes for vector field {ax,ay,az} with color and radius proportional to |a|
+procedure mgl_pipe_3d(gr: HMGL;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;r0: double;const opt: PChar); cdecl; external libmgl;
+/// Plot flows for gradient of scalar field phi parametrically depended on coordinate {x,y,z}
+procedure mgl_grad_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const ph: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flows for gradient of scalar field phi parametrically depended on coordinate {x,y}
+procedure mgl_grad_xy(gr: HMGL;const x: HMDT;const y: HMDT;const ph: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot flows for gradient of scalar field phi
+procedure mgl_grad(gr: HMGL;const ph: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw vector plot at slice for 3d data specified parametrically
+procedure mgl_vect3_xyz(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw vector plot at slice for 3d data
+procedure mgl_vect3(gr: HMGL;const ax: HMDT;const ay: HMDT;const az: HMDT;const sch: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/prim.h ==}
+//-----------------------------------------------------------------------------
+/// Draws the mark at position {x,y,z}
+procedure mgl_mark(gr: HMGL;x: double;y: double;z: double;const mark: PChar); cdecl; external libmgl;
+/// Draws red point (ball) at position {x,y,z}
+procedure mgl_ball(gr: HMGL;x: double;y: double;z: double); cdecl; external libmgl;
+/// Draws the line between 2 points by specified pen
+procedure mgl_line(gr: HMGL;x1: double;y1: double;z1: double;x2: double;y2: double;z2: double;const pen: PChar;n: integer); cdecl; external libmgl;
+/// Draws the spline curve between 2 points by specified pen
+procedure mgl_curve(gr: HMGL;x1: double;y1: double;z1: double;dx1: double;dy1: double;dz1: double;x2: double;y2: double;z2: double;dx2: double;dy2: double;dz2: double;const pen: PChar;n: integer); cdecl; external libmgl;
+/// Draws the 3d error box {ex,ey,ez} for point {x,y,z}
+procedure mgl_error_box(gr: HMGL;x: double;y: double;z: double;ex: double;ey: double;ez: double;const pen: PChar); cdecl; external libmgl;
+/// Draws the face between points with color stl (include interpolation up to 4 colors).
+procedure mgl_face(gr: HMGL;x0: double;y0: double;z0: double;x1: double;y1: double;z1: double;x2: double;y2: double;z2: double;x3: double;y3: double;z3: double;const stl: PChar); cdecl; external libmgl;
+/// Draws the face in y-z plane at point p with color stl (include interpolation up to 4 colors).
+procedure mgl_facex(gr: HMGL;x0: double;y0: double;z0: double;wy: double;wz: double;const stl: PChar;dx: double;dy: double); cdecl; external libmgl;
+/// Draws the face in x-z plane at point p with color stl (include interpolation up to 4 colors).
+procedure mgl_facey(gr: HMGL;x0: double;y0: double;z0: double;wx: double;wz: double;const stl: PChar;dx: double;dy: double); cdecl; external libmgl;
+/// Draws the face in x-y plane at point p with color stl (include interpolation up to 4 colors).
+procedure mgl_facez(gr: HMGL;x0: double;y0: double;z0: double;wx: double;wy: double;const stl: PChar;dx: double;dy: double); cdecl; external libmgl;
+/// Draws the sphere at point {x,y,z} with color stl and radius r
+procedure mgl_sphere(gr: HMGL;x: double;y: double;z: double;r: double;const stl: PChar); cdecl; external libmgl;
+/// Draws the drop at point {x,y,z} in direction {dx,dy,dz} with color stl and radius r
+procedure mgl_drop(gr: HMGL;x: double;y: double;z: double;dx: double;dy: double;dz: double;r: double;const stl: PChar;shift: double;ap: double); cdecl; external libmgl;
+/// Draws the cone between points p1,p2 with radius r1,r2 and with style stl
+procedure mgl_cone(gr: HMGL;x1: double;y1: double;z1: double;x2: double;y2: double;z2: double;r1: double;r2: double;const stl: PChar); cdecl; external libmgl;
+/// Draws the ellipse between points p1,p2 with color stl and width r
+procedure mgl_ellipse(gr: HMGL;x1: double;y1: double;z1: double;x2: double;y2: double;z2: double;r: double;const stl: PChar); cdecl; external libmgl;
+/// Draws the rhomb between points p1,p2 with color stl and width r
+procedure mgl_rhomb(gr: HMGL;x1: double;y1: double;z1: double;x2: double;y2: double;z2: double;r: double;const stl: PChar); cdecl; external libmgl;
+/// Draw cones from points {x,y,z} to axis plane
+procedure mgl_cones_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw cones from points {x,z} to axis plane
+procedure mgl_cones_xz(graph: HMGL;const x: HMDT;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw cones from points {x,z} with x in x-axis range to axis plane
+procedure mgl_cones(graph: HMGL;const z: HMDT;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot dew drops for vector field {ax,ay} parametrically depended on coordinate {x,y}
+procedure mgl_dew_xy(gr: HMGL;const x: HMDT;const y: HMDT;const ax: HMDT;const ay: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Plot dew drops for vector field {ax,ay}
+procedure mgl_dew_2d(gr: HMGL;const ax: HMDT;const ay: HMDT;const sch: PChar;const optl: PChar); cdecl; external libmgl;
+/// Print text in position {x,y,z} with specified font
+procedure mgl_puts_dir(graph: HMGL;x: double;y: double;z: double;dx: double;dy: double;dz: double;const text: PChar;const font: PChar;size: double); cdecl; external libmgl;
+procedure mgl_putsw_dir(graph: HMGL;x: double;y: double;z: double;dx: double;dy: double;dz: double;const text: PWideChar;const font: PChar;size: double); cdecl; external libmgl;
+/// Draw textual marks with size r at points {x,y,z}
+procedure mgl_textmark_xyzr(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const r: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_textmarkw_xyzr(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const r: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw textual marks with size r at points {x,y}
+procedure mgl_textmark_xyr(graph: HMGL;const x: HMDT;const y: HMDT;const r: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_textmarkw_xyr(graph: HMGL;const x: HMDT;const y: HMDT;const r: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw textual marks with size r at points {x,y} with x in x-axis range
+procedure mgl_textmark_yr(graph: HMGL;const y: HMDT;const r: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_textmarkw_yr(graph: HMGL;const y: HMDT;const r: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw textual marks with size r=1 at points {x,y} with x in x-axis range
+procedure mgl_textmark(graph: HMGL;const y: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_textmarkw(graph: HMGL;const y: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw labels for points coordinate(s) at points {x,y,z}
+procedure mgl_label_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_labelw_xyz(graph: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw labels for points coordinate(s) at points {x,y}
+procedure mgl_label_xy(graph: HMGL;const x: HMDT;const y: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_labelw_xy(graph: HMGL;const x: HMDT;const y: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw labels for points coordinate(s) at points {x,y} with x in x-axis range
+procedure mgl_label_y(graph: HMGL;const y: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_labelw_y(graph: HMGL;const y: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw table for values val along given direction with row labels text at position {x,y}
+procedure mgl_table(gr: HMGL;x: double;y: double;const val: HMDT;const text: PChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+procedure mgl_tablew(gr: HMGL;x: double;y: double;const val: HMDT;const text: PWideChar;const fnt: PChar;const opt: PChar); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/other.h ==}
+//-----------------------------------------------------------------------------
+/// Draw triangle mesh for points in arrays {x,y,z} with specified color c.
+procedure mgl_triplot_xyzc(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw triangle mesh for points in arrays {x,y,z} with color proportional to z.
+procedure mgl_triplot_xyz(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw triangle mesh for points in arrays {x,y}
+procedure mgl_triplot_xy(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw quad mesh for points in arrays {x,y,z} with specified color c.
+procedure mgl_quadplot_xyzc(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw quad mesh for points in arrays {x,y,z} with color proportional to z.
+procedure mgl_quadplot_xyz(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw quad mesh for points in arrays {x,y}.
+procedure mgl_quadplot_xy(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines for triangle mesh for points in arrays {x,y,z} with specified color c.
+procedure mgl_tricont_xyzcv(gr: HMGL;const v: HMDT;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines for triangle mesh for points in arrays {x,y,z}.
+procedure mgl_tricont_xycv(gr: HMGL;const v: HMDT;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines for triangle mesh for points in arrays {x,y,z} with specified color c.
+procedure mgl_tricont_xyzc(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines for triangle mesh for points in arrays {x,y,z}.
+procedure mgl_tricont_xyc(gr: HMGL;const nums: HMDT;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw dots in points {x,y,z}.
+procedure mgl_dots(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw semitransparent dots in points {x,y,z} with specified alpha a.
+procedure mgl_dots_a(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const a: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw semitransparent dots in points {x,y,z} with specified color c and alpha a.
+procedure mgl_dots_ca(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const c: HMDT;const a: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw surface reconstructed for points in arrays {x,y,z}.
+procedure mgl_crust(gr: HMGL;const x: HMDT;const y: HMDT;const z: HMDT;const sch: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot for data at x = sVal
+procedure mgl_dens_x(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot for data at y = sVal
+procedure mgl_dens_y(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw density plot for data at z = sVal
+procedure mgl_dens_z(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines for data at x = sVal
+procedure mgl_cont_x(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines for data at y = sVal
+procedure mgl_cont_y(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw contour lines for data at z = sVal
+procedure mgl_cont_z(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines for data at x = sVal
+procedure mgl_cont_x_val(graph: HMGL;const v: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines for data at y = sVal
+procedure mgl_cont_y_val(graph: HMGL;const v: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual contour lines for data at z = sVal
+procedure mgl_cont_z_val(graph: HMGL;const v: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours for data at x = sVal
+procedure mgl_contf_x(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours for data at y = sVal
+procedure mgl_contf_y(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw solid contours for data at z = sVal
+procedure mgl_contf_z(graph: HMGL;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours for data at x = sVal
+procedure mgl_contf_x_val(graph: HMGL;const v: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours for data at y = sVal
+procedure mgl_contf_y_val(graph: HMGL;const v: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+/// Draw manual solid contours for data at z = sVal
+procedure mgl_contf_z_val(graph: HMGL;const v: HMDT;const a: HMDT;const stl: PChar;sVal: double;const opt: PChar); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/canvas_cf.h ==}
+//-----------------------------------------------------------------------------
+/// Create HMGL object with specified sizes
+function mgl_create_graph(width: integer;height: integer): HMGL; cdecl; external libmgl;
+/// Delete HMGL object
+procedure mgl_delete_graph(gr: HMGL); cdecl; external libmgl;
+/// Set size of frame in pixels. Normally this function is called internally.
+procedure mgl_set_size(gr: HMGL;width: integer;height: integer); cdecl; external libmgl;
+/// Set default parameters for plotting
+procedure mgl_set_def_param(gr: HMGL); cdecl; external libmgl;
+/// Combine plots from 2 canvases. Result will be saved into gr
+procedure mgl_combine_gr(gr: HMGL;gr2: HMGL); cdecl; external libmgl;
+/// Force preparing the image. It can be useful for OpenGL mode mostly.
+procedure mgl_finish(gr: HMGL); cdecl; external libmgl;
+/// Set tick length
+procedure mgl_set_tick_len(gr: HMGL;len: double;stt: double); cdecl; external libmgl;
+/// Set axis and ticks style
+procedure mgl_set_axis_stl(gr: HMGL;const stl: PChar;const tck: PChar;const sub: PChar); cdecl; external libmgl;
+/// Auto adjust ticks
+procedure mgl_adjust_ticks(gr: HMGL;const dir: PChar); cdecl; external libmgl;
+/// Set the ticks parameters
+procedure mgl_set_ticks(gr: HMGL;dir: char;d: double;ns: integer;org: double); cdecl; external libmgl;
+/// Set ticks text (\n separated). Use "" to disable this feature.
+procedure mgl_set_ticks_str(gr: HMGL;dir: char;const lbl: PChar;add: integer); cdecl; external libmgl;
+procedure mgl_set_ticks_wcs(gr: HMGL;dir: char;const lbl: PWideChar;add: integer); cdecl; external libmgl;
+/// Set ticks position and text (\n separated). Use "" to disable this feature.
+procedure mgl_set_ticks_val(gr: HMGL;dir: char;const val: HMDT;const lbl: PChar;add: integer); cdecl; external libmgl;
+procedure mgl_set_ticks_valw(gr: HMGL;dir: char;const val: HMDT;const lbl: PWideChar;add: integer); cdecl; external libmgl;
+/// Tune ticks
+procedure mgl_tune_ticks(gr: HMGL;tune: integer;fact_pos: double); cdecl; external libmgl;
+/// Set templates for ticks
+procedure mgl_set_tick_templ(gr: HMGL;dir: char;const templ: PChar); cdecl; external libmgl;
+procedure mgl_set_tick_templw(gr: HMGL;dir: char;const templ: PWideChar); cdecl; external libmgl;
+/// Set time templates for ticks
+procedure mgl_set_ticks_time(gr: HMGL;dir: char;d: double;const t: PChar); cdecl; external libmgl;
+/// Set additional shift of tick labels
+procedure mgl_set_tick_shift(gr: HMGL;sx: double;sy: double;sz: double;sc: double); cdecl; external libmgl;
+/// Draws bounding box outside the plotting volume
+procedure mgl_box(gr: HMGL); cdecl; external libmgl;
+/// Draws bounding box outside the plotting volume with color c
+procedure mgl_box_str(gr: HMGL;const col: PChar;ticks: integer); cdecl; external libmgl;
+/// Draw axises with ticks in direction(s) dir.
+procedure mgl_axis(gr: HMGL;const dir: PChar;const stl: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw grid lines perpendicular to direction(s) dir.
+procedure mgl_axis_grid(gr: HMGL;const dir: PChar;const pen: PChar;const opt: PChar); cdecl; external libmgl;
+/// Print the label text for axis dir.
+procedure mgl_label(gr: HMGL;dir: char;const text: PChar;pos: double;const opt: PChar); cdecl; external libmgl;
+procedure mgl_labelw(gr: HMGL;dir: char;const text: PWideChar;pos: double;const opt: PChar); cdecl; external libmgl;
+/// Draw colorbar at edge of axis
+procedure mgl_colorbar(gr: HMGL;const sch: PChar); cdecl; external libmgl;
+/// Draw colorbar at manual position
+procedure mgl_colorbar_ext(gr: HMGL;const sch: PChar;x: double;y: double;w: double;h: double); cdecl; external libmgl;
+/// Draw colorbar with manual colors at edge of axis
+procedure mgl_colorbar_val(gr: HMGL;const dat: HMDT;const sch: PChar); cdecl; external libmgl;
+/// Draw colorbar with manual colors at manual position
+procedure mgl_colorbar_val_ext(gr: HMGL;const dat: HMDT;const sch: PChar;x: double;y: double;w: double;h: double); cdecl; external libmgl;
+/// Add string to legend
+procedure mgl_add_legend(gr: HMGL;const text: PChar;const style: PChar); cdecl; external libmgl;
+procedure mgl_add_legendw(gr: HMGL;const text: PWideChar;const style: PChar); cdecl; external libmgl;
+/// Clear saved legend string
+procedure mgl_clear_legend(gr: HMGL); cdecl; external libmgl;
+/// Draw legend of accumulated strings at position {x,y}
+procedure mgl_legend_pos(gr: HMGL;x: double;y: double;const font: PChar;const opt: PChar); cdecl; external libmgl;
+/// Draw legend of accumulated strings
+procedure mgl_legend(gr: HMGL;where: integer;const font: PChar;const opt: PChar); cdecl; external libmgl;
+/// Set number of marks in legend sample
+procedure mgl_set_legend_marks(gr: HMGL;num: integer); cdecl; external libmgl;
+/// Show current image
+procedure mgl_show_image(gr: HMGL;const viewer: PChar;keep: integer); cdecl; external libmgl;
+/// Write the frame in file (depending extension, write current frame if fname is empty)
+procedure mgl_write_frame(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using BMP format
+procedure mgl_write_tga(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using BMP format
+procedure mgl_write_bmp(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using JPEG format
+procedure mgl_write_jpg(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using PNG format with transparency
+procedure mgl_write_png(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using PNG format without transparency
+procedure mgl_write_png_solid(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using PostScript format as bitmap
+procedure mgl_write_bps(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using PostScript format
+procedure mgl_write_eps(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using SVG format
+procedure mgl_write_svg(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using LaTeX format
+procedure mgl_write_tex(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using OBJ format
+procedure mgl_write_obj(gr: HMGL;const fname: PChar;const descr: PChar;use_png: integer); cdecl; external libmgl;
+/// Write the frame in file using OBJ format (old version)
+procedure mgl_write_obj_old(gr: HMGL;const fname: PChar;const descr: PChar;use_png: integer); cdecl; external libmgl;
+/// Write the frame in file using STL format (faces only)
+procedure mgl_write_stl(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using OFF format
+procedure mgl_write_off(gr: HMGL;const fname: PChar;const descr: PChar;colored: integer); cdecl; external libmgl;
+/// Write the frame in file using XYZ format
+procedure mgl_write_xyz(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Write the frame in file using PRC format
+procedure mgl_write_prc(gr: HMGL;const fname: PChar;const descr: PChar;make_pdf: integer); cdecl; external libmgl;
+/// Write the frame in file using GIF format (only for current frame!)
+procedure mgl_write_gif(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Start write frames to cinema using GIF format
+procedure mgl_start_gif(gr: HMGL;const fname: PChar;ms: integer); cdecl; external libmgl;
+/// Stop writing cinema using GIF format
+procedure mgl_close_gif(gr: HMGL); cdecl; external libmgl;
+/// Export points and primitives in file using MGLD format
+procedure mgl_export_mgld(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+/// Import points and primitives from file using MGLD format
+procedure mgl_import_mgld(gr: HMGL;const fname: PChar;add: integer); cdecl; external libmgl;
+/// Export in JSON format suitable for later drawing by JavaScript
+procedure mgl_write_json(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+procedure mgl_write_json_z(gr: HMGL;const fname: PChar;const descr: PChar); cdecl; external libmgl;
+function mgl_get_json(gr: HMGL): PChar; cdecl; external libmgl;
+/// Get RGB values of current bitmap
+function mgl_get_rgb(gr: HMGL): PByte; cdecl; external libmgl;
+/// Get RGBA values of current bitmap
+function mgl_get_rgba(gr: HMGL): PByte; cdecl; external libmgl;
+/// Set object/subplot id
+procedure mgl_set_obj_id(gr: HMGL;id: integer); cdecl; external libmgl;
+/// Get object id
+function mgl_get_obj_id(gr: HMGL;x: integer;y: integer): integer; cdecl; external libmgl;
+/// Get subplot id
+function mgl_get_spl_id(gr: HMGL;x: integer;y: integer): integer; cdecl; external libmgl;
+/// Get width of the image
+function mgl_get_width(gr: HMGL): integer; cdecl; external libmgl;
+/// Get height of the image
+function mgl_get_height(gr: HMGL): integer; cdecl; external libmgl;
+/// Calculate 3D coordinate {x,y,z} for screen point {xs,ys}
+procedure mgl_calc_xyz(gr: HMGL;xs: integer;ys: integer;x: Pmreal;y: Pmreal;z: Pmreal); cdecl; external libmgl;
+/// Calculate screen point {xs,ys} for 3D coordinate {x,y,z}
+procedure mgl_calc_scr(gr: HMGL;x: double;y: double;z: double;xs: Pint;ys: Pint); cdecl; external libmgl;
+/// Check if {xs,ys} is close to active point with accuracy d, and return its position or -1
+function mgl_is_active(gr: HMGL;xs: integer;ys: integer;d: integer): integer; cdecl; external libmgl;
+/// Create new frame.
+function mgl_new_frame(gr: HMGL): integer; cdecl; external libmgl;
+/// Finish frame drawing
+procedure mgl_end_frame(gr: HMGL); cdecl; external libmgl;
+/// Get the number of created frames
+function mgl_get_num_frame(gr: HMGL): integer; cdecl; external libmgl;
+/// Reset frames counter (start it from zero)
+procedure mgl_reset_frames(gr: HMGL); cdecl; external libmgl;
+/// Get drawing data for i-th frame (work if MGL_VECT_FRAME is set on)
+procedure mgl_get_frame(gr: HMGL;i: integer); cdecl; external libmgl;
+/// Set drawing data for i-th frame (work if MGL_VECT_FRAME is set on)
+procedure mgl_set_frame(gr: HMGL;i: integer); cdecl; external libmgl;
+/// Append drawing data from i-th frame (work if MGL_VECT_FRAME is set on)
+procedure mgl_show_frame(gr: HMGL;i: integer); cdecl; external libmgl;
+/// Delete primitives for i-th frame (work if MGL_VECT_FRAME is set on)
+procedure mgl_del_frame(gr: HMGL;i: integer); cdecl; external libmgl;
+/// Set the transparency type (0 - usual, 1 - glass, 2 - lamp)
+procedure mgl_set_transp_type(gr: HMGL;kind: integer); cdecl; external libmgl;
+/// Set the transparency on/off.
+procedure mgl_set_alpha(gr: HMGL;enable: integer); cdecl; external libmgl;
+/// Set the fog distance or switch it off (if d=0).
+procedure mgl_set_fog(gr: HMGL;d: double;dz: double); cdecl; external libmgl;
+/// Set the using of light on/off.
+procedure mgl_set_light(gr: HMGL;enable: integer); cdecl; external libmgl;
+/// Switch on/off the specified light source.
+procedure mgl_set_light_n(gr: HMGL;n: integer;enable: integer); cdecl; external libmgl;
+/// Add white light source at infinity.
+procedure mgl_add_light(gr: HMGL;n: integer;x: double;y: double;z: double); cdecl; external libmgl;
+/// Add light source at infinity (more settings).
+procedure mgl_add_light_ext(gr: HMGL;n: integer;x: double;y: double;z: double;c: char;br: double;ap: double); cdecl; external libmgl;
+/// Add local light source.
+procedure mgl_add_light_loc(gr: HMGL;n: integer;x: double;y: double;z: double;dx: double;dy: double;dz: double;c: char;br: double;ap: double); cdecl; external libmgl;
+/// Pop transformation matrix from stack
+procedure mgl_mat_pop(gr: HMGL); cdecl; external libmgl;
+/// Push transformation matrix into stack
+procedure mgl_mat_push(gr: HMGL); cdecl; external libmgl;
+/// Clear up the frame
+procedure mgl_clf(gr: HMGL); cdecl; external libmgl;
+/// Clear up the frame and fill background by specified color
+procedure mgl_clf_rgb(gr: HMGL;r: double;g: double;b: double); cdecl; external libmgl;
+/// Clear up the frame and fill background by specified color
+procedure mgl_clf_chr(gr: HMGL;col: char); cdecl; external libmgl;
+/// Put further plotting in some region of whole frame.
+procedure mgl_subplot(gr: HMGL;nx: integer;ny: integer;m: integer;const style: PChar); cdecl; external libmgl;
+/// Put further plotting in some region of whole frame and shift it by distance {dx,dy}.
+procedure mgl_subplot_d(gr: HMGL;nx: integer;ny: integer;m: integer;const style: PChar;dx: double;dy: double); cdecl; external libmgl;
+/// Like MGL_EXPORT mgl_subplot() but "join" several cells
+procedure mgl_multiplot(gr: HMGL;nx: integer;ny: integer;m: integer;dx: integer;dy: integer;const style: PChar); cdecl; external libmgl;
+/// Put further plotting in a region of whole frame.
+procedure mgl_inplot(gr: HMGL;x1: double;x2: double;y1: double;y2: double); cdecl; external libmgl;
+/// Put further plotting in a region of current subplot/inplot.
+procedure mgl_relplot(gr: HMGL;x1: double;x2: double;y1: double;y2: double); cdecl; external libmgl;
+/// Put further plotting in column cell of previous subplot/inplot.
+procedure mgl_columnplot(gr: HMGL;num: integer;ind: integer;d: double); cdecl; external libmgl;
+/// Put further plotting in matrix cell of previous subplot/inplot.
+procedure mgl_gridplot(gr: HMGL;nx: integer;ny: integer;m: integer;d: double); cdecl; external libmgl;
+/// Put further plotting in cell of stick rotated on angles tet, phi.
+procedure mgl_stickplot(gr: HMGL;num: integer;ind: integer;tet: double;phi: double); cdecl; external libmgl;
+/// Add title for current subplot/inplot.
+procedure mgl_title(gr: HMGL;const title: PChar;const stl: PChar;size: double); cdecl; external libmgl;
+procedure mgl_titlew(gr: HMGL;const title: PWideChar;const stl: PChar;size: double); cdecl; external libmgl;
+/// Set factor of plot size
+procedure mgl_set_plotfactor(gr: HMGL;val: double); cdecl; external libmgl;
+/// Set aspect ratio for further plotting.
+procedure mgl_aspect(gr: HMGL;Ax: double;Ay: double;Az: double); cdecl; external libmgl;
+/// Rotate a further plotting.
+procedure mgl_rotate(gr: HMGL;TetX: double;TetZ: double;TetY: double); cdecl; external libmgl;
+/// Rotate a further plotting around vector {x,y,z}.
+procedure mgl_rotate_vector(gr: HMGL;Tet: double;x: double;y: double;z: double); cdecl; external libmgl;
+/// Set perspective (in range [0,1)) for plot. Set to zero for switching off.
+procedure mgl_perspective(gr: HMGL;val: double); cdecl; external libmgl;
+/// Set angle of view independently from Rotate().
+procedure mgl_view(gr: HMGL;TetX: double;TetZ: double;TetY: double); cdecl; external libmgl;
+/// Zoom in/out a part of picture (use mgl_zoom(0, 0, 1, 1) for restore default)
+procedure mgl_zoom(gr: HMGL;x1: double;y1: double;x2: double;y2: double); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+/// Callback function for mouse click
+/// Set delay for animation in seconds
+procedure mgl_wnd_set_delay(gr: HMGL;dt: double); cdecl; external libmgl;
+/// Get delay for animation in seconds
+function mgl_wnd_get_delay(gr: HMGL): double; cdecl; external libmgl;
+/// Set window properties
+procedure mgl_setup_window(gr: HMGL;clf_upd: integer;showpos: integer); cdecl; external libmgl;
+/// Switch on/off transparency (do not overwrite user settings)
+procedure mgl_wnd_toggle_alpha(gr: HMGL); cdecl; external libmgl;
+/// Switch on/off lighting (do not overwrite user settings)
+procedure mgl_wnd_toggle_light(gr: HMGL); cdecl; external libmgl;
+/// Switch on/off zooming by mouse
+procedure mgl_wnd_toggle_zoom(gr: HMGL); cdecl; external libmgl;
+/// Switch on/off rotation by mouse
+procedure mgl_wnd_toggle_rotate(gr: HMGL); cdecl; external libmgl;
+/// Switch off all zooming and rotation
+procedure mgl_wnd_toggle_no(gr: HMGL); cdecl; external libmgl;
+/// Update picture by calling user drawing function
+procedure mgl_wnd_update(gr: HMGL); cdecl; external libmgl;
+/// Reload user data and update picture
+procedure mgl_wnd_reload(gr: HMGL); cdecl; external libmgl;
+/// Adjust size of bitmap to window size
+procedure mgl_wnd_adjust(gr: HMGL); cdecl; external libmgl;
+/// Show next frame (if one)
+procedure mgl_wnd_next_frame(gr: HMGL); cdecl; external libmgl;
+/// Show previous frame (if one)
+procedure mgl_wnd_prev_frame(gr: HMGL); cdecl; external libmgl;
+/// Run slideshow (animation) of frames
+procedure mgl_wnd_animation(gr: HMGL); cdecl; external libmgl;
+/// Get last mouse position
+procedure mgl_get_last_mouse_pos(gr: HMGL;x: Pmreal;y: Pmreal;z: Pmreal); cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+/// Create HMPR object for parsing MGL scripts
+function mgl_create_parser(): HMPR; cdecl; external libmgl;
+/// Change counter of HMPR uses (for advanced users only). Non-zero counter prevent automatic object removing.
+function mgl_use_parser(p: HMPR;inc: integer): integer; cdecl; external libmgl;
+/// Delete HMPR object
+procedure mgl_delete_parser(p: HMPR); cdecl; external libmgl;
+/// Set value for parameter $N
+procedure mgl_parser_add_param(p: HMPR;id: integer;const str: PChar); cdecl; external libmgl;
+procedure mgl_parser_add_paramw(p: HMPR;id: integer;const str: PWideChar); cdecl; external libmgl;
+/// Find variable with given name or add a new one
+/// NOTE !!! You must not delete obtained data arrays !!!
+function mgl_parser_add_var(p: HMPR;const name: PChar): HMDT; cdecl; external libmgl;
+function mgl_parser_add_varw(p: HMPR;const name: PWideChar): HMDT; cdecl; external libmgl;
+/// Find variable with given name or return NULL if no one
+/// NOTE !!! You must not delete obtained data arrays !!!
+function mgl_parser_find_var(p: HMPR;const name: PChar): HMDT; cdecl; external libmgl;
+function mgl_parser_find_varw(p: HMPR;const name: PWideChar): HMDT; cdecl; external libmgl;
+/// Delete variable with name
+procedure mgl_parser_del_var(p: HMPR;const name: PChar); cdecl; external libmgl;
+procedure mgl_parser_del_varw(p: HMPR;const name: PWideChar); cdecl; external libmgl;
+/// Delete all data variables
+procedure mgl_parser_del_all(p: HMPR); cdecl; external libmgl;
+/// Parse and draw single line of the MGL script
+function mgl_parse_line(gr: HMGL;p: HMPR;const str: PChar;pos: integer): integer; cdecl; external libmgl;
+function mgl_parse_linew(gr: HMGL;p: HMPR;const str: PWideChar;pos: integer): integer; cdecl; external libmgl;
+/// Execute and draw script from the file
+/// Execute MGL script text with '\n' separated lines
+procedure mgl_parse_text(gr: HMGL;p: HMPR;const str: PChar); cdecl; external libmgl;
+procedure mgl_parse_textw(gr: HMGL;p: HMPR;const str: PWideChar); cdecl; external libmgl;
+/// Restore once flag
+procedure mgl_parser_restore_once(p: HMPR); cdecl; external libmgl;
+/// Allow changing size of the picture
+procedure mgl_parser_allow_setsize(p: HMPR;a: integer); cdecl; external libmgl;
+/// Allow reading/saving files
+procedure mgl_parser_allow_file_io(p: HMPR;a: integer); cdecl; external libmgl;
+/// Set flag to stop script parsing
+procedure mgl_parser_stop(p: HMPR); cdecl; external libmgl;
+/// Return type of command: 0 - not found, 1 - data plot, 2 - other plot,
+/// 3 - setup, 4 - data handle, 5 - data create, 6 - subplot, 7 - program
+/// 8 - 1d plot, 9 - 2d plot, 10 - 3d plot, 11 - dd plot, 12 - vector plot
+/// 13 - axis, 14 - primitives, 15 - axis setup, 16 - text/legend, 17 - data transform
+function mgl_parser_cmd_type(pr: HMPR;const name: PChar): integer; cdecl; external libmgl;
+/// Return description of MGL command
+function mgl_parser_cmd_desc(pr: HMPR;const name: PChar): PChar; cdecl; external libmgl;
+/// Return string of command format (command name and its argument[s])
+function mgl_parser_cmd_frmt(pr: HMPR;const name: PChar): PChar; cdecl; external libmgl;
+/// Get name of command with nmber n
+function mgl_parser_cmd_name(pr: HMPR;id: integer): PChar; cdecl; external libmgl;
+/// Get number of defined commands
+function mgl_parser_cmd_num(pr: HMPR): integer; cdecl; external libmgl;
+/// Return result of formula evaluation
+function mgl_parser_calc(pr: HMPR;const formula: PChar): HMDT; cdecl; external libmgl;
+function mgl_parser_calcw(pr: HMPR;const formula: PWideChar): HMDT; cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+/// Create HMEX object for expression evaluating
+function mgl_create_expr(const expr: PChar): HMEX; cdecl; external libmgl;
+function mgl_create_cexpr(const expr: PChar): HAEX; cdecl; external libmgl;
+/// Delete HMEX object
+procedure mgl_delete_expr(ex: HMEX); cdecl; external libmgl;
+procedure mgl_delete_cexpr(ex: HAEX); cdecl; external libmgl;
+/// Return value of expression for given x,y,z variables
+function mgl_expr_eval(ex: HMEX;x: double;y: double;z: double): double; cdecl; external libmgl;
+function mgl_cexpr_eval(ex: HAEX;x: dual;y: dual;z: dual): dual; cdecl; external libmgl;
+/// Return value of expression for given variables
+function mgl_expr_eval_v(ex: HMEX;vars: Pmreal): double; cdecl; external libmgl;
+function mgl_cexpr_eval_v(ex: HAEX;vars: Pdual): dual; cdecl; external libmgl;
+/// Return value of expression differentiation over variable dir for given x,y,z variables
+function mgl_expr_diff(ex: HMEX;dir: char;x: double;y: double;z: double): double; cdecl; external libmgl;
+/// Return value of expression differentiation over variable dir for given variables
+function mgl_expr_diff_v(ex: HMEX;dir: char;vars: Pmreal): double; cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+{== ../include/mgl2/addon.h ==}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/// Get integer power of x
+function mgl_ipowc(x: dual;n: integer): dual; cdecl; external libmgl;
+/// Get exp(i*a)
+function mgl_expi(a: dual): dual; cdecl; external libmgl;
+overload;
+/// Get exp(i*a)
+function mgl_expi(a: double): dual; cdecl; external libmgl;
+overload;
+/// Explicit scheme for 1 step of axial diffraction
+function mgl_difr_axial(a: Pdual;n: integer;q: dual;Border: integer;b: Pdual;d: Pdual;kk: integer;di: double): integer; cdecl; external libmgl;
+/// Explicit scheme for 1 step of plane diffraction
+function mgl_difr_grid(a: Pdual;n: integer;q: dual;Border: integer;b: Pdual;d: Pdual;kk: integer): integer; cdecl; external libmgl;
+//-----------------------------------------------------------------------------
+/// Get random number with Gaussian distribution
+function mgl_gauss_rnd(): double; cdecl; external libmgl;
+/// Fill frequencies for FFT
+procedure mgl_fft_freq(freq: Pdouble;nn: integer); cdecl; external libmgl;
+/// Remove double spaces from the string
+procedure mgl_strcls(str: PChar); cdecl; external libmgl;
+/// Get position of substring or return -1 if not found
+function mgl_strpos(const str: PChar;fnd: PChar): integer; cdecl; external libmgl;
+/// Get position of symbol or return -1 if not found
+function mgl_chrpos(const str: PChar;fnd: char): integer; cdecl; external libmgl;
+/// Get uncommented string from file (NOTE: it is not thread safe!!!)
+/// Get parameters from uncommented strings of file (NOTE: it is not thread safe!!!)
+/// Check if symbol denote true
+function mgl_istrue(ch: char): integer; cdecl; external libmgl;
+/// Print test message
+/// Print info message
+/// Locate next data block (block started by -----)
+
+
+{$IFDEF MSWINDOWS}
+//*****************************************************************************/
+// Delphi - specific
+//*****************************************************************************/
+procedure mgl_begin();
+procedure mgl_end();
+
+procedure mgl_draw_on_canvas(gr: HMGL; width, height: integer; canvas: TCanvas; switchXY: boolean = false);
+
+implementation
+
+var _FPUCW: word;
+
+procedure mgl_begin();
+ begin
+ _FPUCW := Get8087CW(); // backup current FPU CW
+ Set8087CW(_FPUCW or $3F); // masking all FPU exceptions
+ end;
+
+procedure mgl_end();
+ begin
+ Set8087CW(_FPUCW); // restore old FPU CW
+ end;
+
+procedure mgl_draw_on_canvas(gr: HMGL; width, height: integer; canvas: TCanvas; switchXY: boolean = false);
+ var i, j: integer;
+ bytes: PByte;
+ col: TColor;
+ begin
+ bytes := mgl_get_rgb(gr);
+
+ if (not switchXY) then
+ for j := 0 to height - 1 do
+ for i := 0 to width - 1 do
+ begin
+ col := 0;
+ col := col or (bytes^);
+ inc(bytes);
+ col := col or (bytes^) shl 8;
+ inc(bytes);
+ col := col or (bytes^) shl 16;
+ inc(bytes);
+ canvas.Pixels[i, j] := col;
+ end
+ else
+ for j := height - 1 downto 0 do
+ for i := 0 to width - 1 do
+ begin
+ col := 0;
+ col := col or (bytes^);
+ inc(bytes);
+ col := col or (bytes^) shl 8;
+ inc(bytes);
+ col := col or (bytes^) shl 16;
+ inc(bytes);
+ canvas.Pixels[j, i] := col;
+ end;
+ end;
+
+{$ENDIF}
+end.
+
--- /dev/null
+\ Mathgl library wrapper Thu Feb 21 12:33:02 MST 2008
+\ Copyright (C) 2008, Sergey Plis
+\
+\ 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.
+
+\needs gsl include gsl.fs
+\needs mathgl include mathgl.fs
+\needs vectors include vectors.fs
+\needs $! include string.fs
+
+Module mglplot
+
+also minos also vectors also gsl also mathgl also float
+
+\ ------------------------------------------------------------------------
+\ structures
+\ ------------------------------------------------------------------------
+struct{
+ cell transp?
+ cell transp_type
+ cell alpha?
+ cell light
+ cell box
+ cell grid
+ double ambient
+ cell axis?
+ cell axis_str
+ cell rotation[
+ cell aspect[
+ cell colorbar
+ double linewidth
+ double fontsize
+ cell labelx$
+ cell labely$
+ cell labelz$
+ cell textrotate
+} mgl-params
+
+struct{
+ cell next \ next plot in the list of current figure
+ cell prev
+ cell xrange \
+ cell yrange \
+ cell zrange \
+ cell hmdtlist \ vector of all data objects used in the plot
+ cell params \ vector of parameters to the plotting function
+ cell ops \ vector of xt's of operations to place params
+ \ list on the stack so the plotting function can
+ \ be executed
+ cell plotfunc \ the plotting function
+} a_plot
+
+struct{
+ cell next \ next figure in the figure structure
+ cell #
+ cell active? \ True/False
+ cell figure \ plot object
+} a_figure
+
+: dispose-hmdtlist ( v( -- )
+ dup )size 0 do
+ dup i )@
+ mgl_delete_data
+ loop drop ;
+
+: dispose-a-plot ( *a_plot -- )
+ dup a_plot hmdtlist @ dispose-hmdtlist
+ dup a_plot params @ )free
+ dup a_plot ops @ )free
+ dup a_plot xrange @ ]free
+ dup a_plot yrange @ ]free
+ dup a_plot zrange @ ]free
+ free throw ;
+
+: dispose-all-plots ( *a_plot -- )
+ dup begin while
+ dup a_plot next @
+ swap dispose-a-plot
+ dup
+ repeat drop ;
+
+\ simple aux words
+| : ]@s ( x[ -- f: x[0] .. x[n] )
+ dup ]size 0 do dup i ]@ loop drop ;
+| : ]!s ( x[ f: x[0] .. x[n] -- )
+ dup ]size 0 do dup i ]! loop drop ;
+| create axis-param 0 c, 0 c, 0 c, 0 c, 0 c,
+| create mglstrbuff $FF allot
+: default-rotation ( -- r[ ) 3 :] dup 0e 0e 0e ]!s ;
+: clear-axis-param
+ axis-param dup 'x swap c! 1+ dup 'y swap c! 1+ 'z swap c! ;
+
+: NAN ( -- f: NAN) $7FC00000 sp@ sf@ drop ;
+\ ------------------------------------------------------------------------
+\ GUI
+\ ------------------------------------------------------------------------
+
+component class mathplot
+ private:
+ method fill-pixmap
+ method mgl_settings_reset
+ cell var mhold
+ public:
+ early open
+ early dialog
+ early open-app
+
+ method generate-plot
+ method addplot
+ method clear-pixmap
+ method #plots
+ method clf
+ method mgl-rotation!
+ method mgl-colorbar
+
+ method mgl-hold
+ method mgl-holdoff
+ method mgl-holdon
+ method hold@
+ method hold!
+ method mgl-grid
+ method fontsize
+
+ method mgl-xlabel
+ method mgl-ylabel
+ method mgl-zlabel
+
+ canvas ptr mCanvas
+ ( [varstart] )
+ \ memory-pixmap ptr pxmap \ the pixmap on the canvas
+ cell var pxmap
+ cell var graph \ the graph to display
+ cell var plotlist \ list of plots to display
+ cell var parameters \ parameter structure
+ ( [varend] )
+ how:
+ : params DF[ 0 ]DF s" figure" ;
+ : hold@ mhold @ ;
+ : hold! mhold ! ;
+ : mgl-hold mhold @ not mhold ! ;
+ : mgl-holdoff mhold off ;
+ : mgl-holdon mhold on ;
+
+ : open self DF[ 0 ]DF s" bigforth Plot" open-component ;
+ : dialog new DF[ 0 ]DF s" bigforth Plot" open-dialog ;
+ : open-app new DF[ 0 ]DF s" bigforth Plot" open-application ;
+ : clear-pixmap pxmap @ if pxmap @ >o dispose o> 0 pxmap ! then ;
+ : #plots ( -- )
+ 0
+ plotlist @ begin dup while
+ swap 1+ swap
+ a_plot next @
+ repeat
+ drop ;
+
+ : assign
+ &600 &400 mgl_create_graph_zb graph !
+ sizeof mgl-params allocate throw parameters !
+ parameters @ sizeof mgl-params erase
+ mgl_settings_reset
+
+ \ 0 0
+ parameters @ mgl-params labelx$ dup @ if $off else drop then
+ \ 0 0
+ parameters @ mgl-params labely$ dup @ if $off else drop then
+ \ 0 0
+ parameters @ mgl-params labelz$ dup @ if $off else drop then
+
+ 0 pxmap !
+ 0 plotlist !
+ mhold off ;
+
+ : fontsize ( f: size -- ) parameters @ mgl-params fontsize sf! ;
+
+ : mgl-set-params ( -- )
+ graph @
+ dup parameters @ mgl-params rotation[ @ ]@s mgl_rotate
+ dup parameters @ mgl-params ambient sf@ mgl_set_ambbr
+ dup parameters @ mgl-params fontsize sf@ mgl_set_font_size
+ dup parameters @ mgl-params linewidth sf@ mgl_set_base_line_width
+ dup parameters @ mgl-params aspect[ @ ]@s mgl_aspect
+ dup parameters @ mgl-params transp? @ mgl_set_transp
+ dup parameters @ mgl-params transp_type @ mgl_set_transp_type
+ dup parameters @ mgl-params alpha? @ mgl_set_alpha
+ dup parameters @ mgl-params light @ mgl_set_light
+ dup parameters @ mgl-params textrotate @ mgl_set_rotated_text
+ dup parameters @ mgl-params box @ mgl_box
+ parameters @ mgl-params grid @ if
+ dup 0" xyz" 0 mgl_axis_grid
+ then
+ drop ;
+ : mgl-post-params ( -- )
+ graph @ 1 mgl_set_rotated_text
+ parameters @ mgl-params labelx$ @ if
+ parameters @ mgl-params labelx$ $@ mglstrbuff 0place
+ parameters @ mgl-params fontsize sf@ 0e0
+ graph @ 'x mglstrbuff 0 mgl_label_ext
+ then
+ parameters @ mgl-params labely$ @ if
+ parameters @ mgl-params labely$ $@ mglstrbuff 0place
+ parameters @ mgl-params fontsize sf@ 0e0
+ graph @ 'y mglstrbuff 0 mgl_label_ext
+ then
+ parameters @ mgl-params labelz$ @ drop 0 if
+ parameters @ mgl-params labelz$ $@ mglstrbuff 0place
+ parameters @ mgl-params fontsize sf@ 0e0
+ graph @ 'z mglstrbuff 0 mgl_label_ext
+ then
+ parameters @ mgl-params colorbar @ drop 0 if
+ dup 0 0 mgl_colorbar
+ then ;
+ : mgl_settings_reset
+ 1 parameters @ mgl-params transp? !
+ 1 parameters @ mgl-params transp_type !
+ 0 parameters @ mgl-params alpha? !
+ 0 parameters @ mgl-params box !
+ 0 parameters @ mgl-params colorbar !
+ 0 parameters @ mgl-params light !
+ 1 parameters @ mgl-params axis? !
+ axis-param parameters @ mgl-params axis_str !
+ clear-axis-param
+ parameters @ mgl-params labelx$ dup @ if $off else drop then
+ parameters @ mgl-params labely$ dup @ if $off else drop then
+ parameters @ mgl-params labelz$ dup @ if $off else drop then
+ \ parameters @ mgl-params textrotate off
+ !0.9 parameters @ mgl-params ambient sf!
+ !2.5 parameters @ mgl-params fontsize sf!
+ !1.2 parameters @ mgl-params linewidth sf!
+ parameters @ mgl-params rotation[ @ dup if ]free else drop then
+ default-rotation parameters @ mgl-params rotation[ !
+ parameters @ mgl-params aspect[ @ dup if ]free else drop then
+ 3 :] parameters @ mgl-params aspect[ !
+ ;
+
+ : mgl_settings_free
+ parameters @ mgl-params labelx$ dup @ if $off else drop then
+ parameters @ mgl-params labely$ dup @ if $off else drop then
+ parameters @ mgl-params labelz$ dup @ if $off else drop then
+ parameters @ mgl-params rotation[ @ dup if ]free else drop then
+ parameters @ mgl-params aspect[ @ dup if ]free else drop then
+ ;
+
+ : addplot ( *a_plot -- )
+ mhold @ if
+ >r plotlist @ r@ a_plot next ! r>
+ plotlist @ if
+ dup plotlist @ a_plot prev !
+ then
+ else
+ plotlist @ dispose-all-plots
+ then
+ plotlist !
+ generate-plot
+ mcanvas draw ;
+ : display_a_plot ( *a_plot -- )
+ >r graph @
+ r@ a_plot ops @
+ r@ a_plot params @
+ dup )size 0 do
+ i -rot
+ 2>r
+ 2r@ rot dup >r *) swap r> )@ F execute
+ 2r>
+ loop 2drop
+ r> a_plot plotfunc @
+ F execute ;
+ : xmin ( -- f: xmin )
+ 1e20 plotlist @ begin dup while
+ dup a_plot xrange @ ]min fmin
+ a_plot next @
+ repeat
+ drop ;
+ : xmax ( -- f: xmax )
+ -1e20 plotlist @ begin dup while
+ dup a_plot xrange @ ]max fmax
+ a_plot next @
+ repeat
+ drop ;
+ : ymin ( -- f: ymin )
+ 1e20 plotlist @ begin dup while
+ dup a_plot yrange @ ]min fmin
+ a_plot next @
+ repeat
+ drop ;
+ : ymax ( -- f: ymax )
+ -1e20 plotlist @ begin dup while
+ dup a_plot yrange @ ]max fmax
+ a_plot next @
+ repeat
+ drop ;
+
+ : zmin ( -- f: zmin )
+ 1e20 plotlist @ begin dup while
+ dup a_plot zrange @ ]min fmin
+ a_plot next @
+ repeat
+ drop ;
+ : zmax ( -- f: ymax )
+ -1e20 plotlist @ begin dup while
+ dup a_plot zrange @ ]max fmax
+ a_plot next @
+ repeat
+ drop ;
+
+ : display_plots ( -- )
+ 0 plotlist @ begin dup while
+ nip dup a_plot next @
+ repeat
+ drop
+ begin dup while
+ dup display_a_plot
+ a_plot prev @
+ repeat drop ;
+
+ : create-figure ( -- )
+ graph @ mgl_identity
+ graph @ mgl_clf
+ graph @ mCanvas with w @ h @ endwith mgl_set_size
+
+\ parameters @ mgl-params rotation[ @ ]null? if
+\ graph @
+\ [ 1e 3e fsqrt f/ 1e fswap f- 2e f/ 0.7e f* ] fliteral
+\ fdup
+\ fdup fdup 1e fswap f- fswap 1e fswap f-
+\ mgl_set_zoom
+\ else
+ graph @ 0e 0e 0e 0e mgl_set_zoom
+\ parameters @ mgl-params fontsize sf@
+\ 1.2e f* parameters @ mgl-params fontsize sf!
+\ then
+ graph @ xmin ymin zmin xmax ymax zmax mgl_set_axis_3d
+\ graph @ xmin ymin zmin mgl_set_origin
+ graph @ NAN NAN NAN mgl_set_origin
+ mgl-set-params
+ mgl-post-params
+ display_plots
+ ;
+ : fill-pixmap
+ clear-pixmap
+ graph @ mgl_get_rgb
+ mCanvas with w @ h @ endwith * 4 * dup allocate throw
+ dup >r
+ swap 4 / 3 * move r@
+ mCanvas with w @ h @ endwith memory-pixmap new pxmap !
+ r> free throw ;
+ : generate-plot ( -- )
+ create-figure
+ fill-pixmap ;
+
+ : freeplots plotlist @ dispose-all-plots 0 plotlist ! ;
+
+ : clf freeplots clear-pixmap draw ;
+
+ : mgl-rotation! ( f: x y z )
+ fswap frot parameters @ mgl-params rotation[ @ ]!s
+ generate-plot
+ mcanvas draw ;
+ : mgl-rotation@ ( -- f: x y z )
+ parameters @ mgl-params rotation[ @ ]@s ;
+ : mgl-colorbar ( -- )
+ parameters @ mgl-params colorbar @
+ not
+ parameters @ mgl-params colorbar !
+ generate-plot mcanvas draw ;
+ : mgl-grid parameters @ mgl-params grid dup @ not swap !
+ generate-plot mcanvas draw ;
+ : mgl-xlabel ( addr u -- )
+ parameters @ mgl-params labelx$ dup @
+ if dup $off $! else $! then
+ generate-plot mcanvas draw ;
+ : mgl-ylabel ( addr u -- )
+ parameters @ mgl-params labely$ dup @
+ if dup $off $! else $! then
+ generate-plot mcanvas draw ;
+ : mgl-zlabel ( addr u -- )
+ parameters @ mgl-params labelz$ dup @
+ if dup $off $! else $! then
+ generate-plot mcanvas draw ;
+
+ : dispose
+ clear-pixmap
+ plotlist @ dispose-all-plots
+ graph @ mgl_delete_graph
+ mgl_settings_free
+ parameters @ sizeof mgl-params erase
+ parameters @ free throw
+ super dispose ;
+ : widget
+ CV[
+ outer with pxmap @ endwith 0<> if
+ outer with pxmap @ endwith icon
+ then
+ ]CV
+ ^^ CK[ 2drop 2drop ]CK
+ $258 $1 *hfil $190 $1 *vfil canvas new ^^bind mCanvas
+ $10 $1 *hfill *hglue new
+ ^^ S[ s" not done" mCanvas text ]S X" Save " button new
+ ^^ S[ close ]S X" Close " button new
+ &3 habox new vfixbox panel
+ &2 vabox new ;
+class;
+
+sizeof a_figure allocate throw constant current-figure
+
+current-figure sizeof a_figure erase
+
+actor class clear-pointer
+ how:
+ : dispose
+ current-figure a_figure active? off
+ current-figure sizeof a_figure erase
+ super dispose ;
+class;
+
+: init-plot
+ current-figure a_figure active? @ not if
+ screen self mathplot new
+ current-figure a_figure figure !
+ current-figure a_figure active? on
+ clear-pointer new
+ current-figure a_figure figure @
+ mathplot with >callback open endwith
+ then ;
+
+: s>range[] ( fmin fmax -- :] ) 2 :] dup 1 ]! dup 0 ]! ;
+
+: []plot ( x[ str0 xt -- *a_plot )
+ >r >r dup >r
+ mgl_create_data dup rot mgl_data_set_vector
+ sizeof a_plot allocate throw
+ dup r@ dup ]min ]max s>range[] swap a_plot yrange !
+ dup r> ]size 0e s>f s>range[] swap a_plot xrange !
+ dup 0e 0e s>range[] swap a_plot zrange !
+ dup 0 swap a_plot next !
+ dup 0 swap a_plot prev !
+ over 1 ivector* over a_plot hmdtlist !
+ over r> 2 ivector* over a_plot params !
+ ['] @ ['] @ 2 ivector* over a_plot ops !
+ nip r> over a_plot plotfunc ! ;
+: addplot ( *a_plot -- )
+ init-plot
+ current-figure a_figure figure @
+ mathplot with addplot endwith ;
+: ]plot ( *gsl_vector 0"" -- ) ['] mgl_plot []plot addplot ;
+: ]stem ( *gsl_vector 0"" -- ) ['] mgl_stem []plot addplot ;
+: ]bars ( *gsl_vector 0"" -- ) ['] mgl_bars []plot addplot ;
+: ]step ( *gsl_vector 0"" -- ) ['] mgl_step []plot addplot ;
+: ]area ( *gsl_vector 0"" -- ) ['] mgl_area []plot addplot ;
+
+: [[]]plot ( x[[ str0 xt -- *a_plot )
+ >r >r dup >r
+ mgl_create_data dup rot mgl_data_set_matrix
+ sizeof a_plot allocate throw
+ dup r@ dup ]]min ]]max s>range[] swap a_plot zrange !
+ dup r@ ]]size1 0e s>f s>range[] swap a_plot xrange !
+ dup r> ]]size2 0e s>f s>range[] swap a_plot yrange !
+ dup 0 swap a_plot next !
+ dup 0 swap a_plot prev !
+ over 1 ivector* over a_plot hmdtlist !
+ over r> 2 ivector* over a_plot params !
+ ['] @ ['] @ 2 ivector* over a_plot ops !
+ nip r> over a_plot plotfunc ! ;
+: ]]surf ( *gsl_matrix 0"" -- ) ['] mgl_surf [[]]plot addplot ;
+: ]]tile ( *gsl_matrix 0"" -- ) ['] mgl_tile [[]]plot addplot ;
+: ]]belt ( *gsl_matrix 0"" -- ) ['] mgl_belt [[]]plot addplot ;
+: ]]fall ( *gsl_matrix 0"" -- ) ['] mgl_fall [[]]plot addplot ;
+: ]]mesh ( *gsl_matrix 0"" -- ) ['] mgl_mesh [[]]plot addplot ;
+: ]]msurf ( *gsl_matrix 0"" -- )
+ init-plot
+ 2dup ]]surf
+ current-figure a_figure figure @
+ mathplot with hold@ mgl-holdon endwith
+ >r
+ ]]mesh
+ r>
+ current-figure a_figure figure @
+ mathplot with hold! endwith ;
+
+: [[]]plotf ( f:v x[[ str0 xt -- *a_plot )
+ >r >r dup >r
+ mgl_create_data dup rot mgl_data_set_matrix
+ sizeof a_plot allocate throw
+ dup r@ dup ]]min ]]max s>range[] swap a_plot zrange !
+ dup r@ ]]size1 0e s>f s>range[] swap a_plot xrange !
+ dup r> ]]size2 0e s>f s>range[] swap a_plot yrange !
+ dup 0 swap a_plot next !
+ dup 0 swap a_plot prev !
+ over 1 ivector* over a_plot hmdtlist !
+ over r> f>fs 3 ivector* over a_plot params !
+ ['] @ ['] @ ['] sf@ 3 ivector* over a_plot ops !
+ nip r> over a_plot plotfunc ! ;
+: ]]boxs ( f:v *gsl_matrix 0"" -- ) ['] mgl_boxs [[]]plotf addplot ;
+
+: clf current-figure a_figure active? @ if
+ current-figure a_figure figure @ >o mathplot clf o>
+ then ;
+
+: fontsize! ( f:size -- ) current-figure a_figure active? @ if
+ current-figure a_figure figure @ >o mathplot fontsize o>
+ then ;
+
+: rotation ( F: x y z -- )
+ current-figure a_figure active? @ if
+ current-figure a_figure figure @ >o mathplot mgl-rotation! o>
+ else
+ fdrop fdrop fdrop
+ then ;
+: colorbar current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-colorbar o>
+ then ;
+
+
+: mglhold current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-hold o>
+ then ;
+
+: mglholdon current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-holdon o>
+ then ;
+: mglholdoff current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-holdoff o>
+ then ;
+
+: mglgrid current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-grid o>
+ then ;
+
+: xlabel ( addr u -- ) current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-xlabel o>
+ then ;
+: ylabel ( addr u -- ) current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-ylabel o>
+ then ;
+: zlabel ( addr u -- ) current-figure a_figure active? @ if
+ current-figure a_figure figure @
+ >o mathplot mgl-zlabel o>
+ then ;
+
+
+clear
+previous previous previous previous previous
+Module;
+
+\\\
+also mglplot also minos also gsl
+100 fvector x[ x[ ]randomize
+x[ 0 ]plot
/***************************************************************************\r
* mgl.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/***************************************************************************\r
* opengl.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* other.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* parser.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************
* data_cf.h is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
extern "C" {
#endif
+/// Saves result of PDE solving (|u|^2) for "Hamiltonian" ham with initial conditions ini
+HADT MGL_EXPORT mgl_pde_solve_c(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, mreal dz, mreal k0,const char *opt);
+uintptr_t MGL_EXPORT mgl_pde_solve_c_(uintptr_t* gr, const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, mreal *dz, mreal *k0,const char *opt,int,int);
/// Saves result of PDE solving (|u|^2) for "Hamiltonian" ham with initial conditions ini
HMDT MGL_EXPORT mgl_pde_solve(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, mreal dz, mreal k0,const char *opt);
uintptr_t MGL_EXPORT mgl_pde_solve_(uintptr_t* gr, const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, mreal *dz, mreal *k0,const char *opt,int,int);
/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)
+HADT MGL_EXPORT mgl_qo2d_solve_c(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy);
+HADT MGL_EXPORT mgl_qo2d_func_c(dual (*ham)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy);
+uintptr_t MGL_EXPORT mgl_qo2d_solve_c_(const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, uintptr_t* ray, mreal *r, mreal *k0, uintptr_t* xx, uintptr_t* yy, int);
+/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)
HMDT MGL_EXPORT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy);
HMDT MGL_EXPORT mgl_qo2d_func(dual (*ham)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy);
uintptr_t MGL_EXPORT mgl_qo2d_solve_(const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, uintptr_t* ray, mreal *r, mreal *k0, uintptr_t* xx, uintptr_t* yy, int);
/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)
+HADT MGL_EXPORT mgl_qo3d_solve_c(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz);
+HADT MGL_EXPORT mgl_qo3d_func_c(dual (*ham)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz);
+uintptr_t MGL_EXPORT mgl_qo3d_solve_c_(const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, uintptr_t* ray, mreal *r, mreal *k0, uintptr_t* xx, uintptr_t* yy, uintptr_t* zz, int);
+/// Saves result of PDE solving for "Hamiltonian" ham with initial conditions ini along a curve ray (must have nx>=7 - x,y,z,px,py,pz,tau or nx=5 - x,y,px,py,tau)
HMDT MGL_EXPORT mgl_qo3d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz);
HMDT MGL_EXPORT mgl_qo3d_func(dual (*ham)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz);
uintptr_t MGL_EXPORT mgl_qo3d_solve_(const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, uintptr_t* ray, mreal *r, mreal *k0, uintptr_t* xx, uintptr_t* yy, uintptr_t* zz, int);
/***************************************************************************\r
* plot.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* prim.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* window.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
#define _MGL_QMATHGL_H_\r
//-----------------------------------------------------------------------------\r
#include <string>\r
-#include <QtGui/QWidget>\r
-#include <QtGui/QPixmap>\r
+#include <QWidget>\r
+#include <QPixmap>\r
#include <mgl2/wnd.h>\r
//-----------------------------------------------------------------------------\r
class QTextEdit;\r
void setViewYZ(bool v); ///< Switch on/off rotation around Y and Z axis\r
\r
void setCustZoom(bool a); ///< Switch on/off using custom zoom\r
+ void setCustDraw(bool a); ///< Switch on/off using custom draw\r
void setZoom(bool z); ///< Switch on/off mouse zooming\r
void setRotate(bool r); ///< Switch on/off mouse rotation\r
void zoomIn(); ///< Zoom in graphics\r
void askStyle(int id); ///< Update style\r
/// user can define its own zooming function\r
void customZoom(double x1, double y1, double x2, double y2, double tet, double phi, double per);\r
+ /// user can define its own drawing/setting function which will be called before main drawing\r
+ void customDraw(double x1, double y1, double x2, double y2, bool draw);\r
\r
protected:\r
void paintEvent(QPaintEvent *);\r
bool alpha; ///< Transparency state\r
bool light; ///< Lightning state\r
bool custZoom; ///< Use custom zoom instead of built in\r
+ bool custDraw; ///< Use custom draw before main drawing\r
bool zoom; ///< Mouse zoom state\r
bool grid; ///< Grid drawing state\r
bool rotate; ///< Mouse rotation state\r
/***************************************************************************\r
* window.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* surf.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************
* thread.h is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
/***************************************************************************
* type.h is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
/***************************************************************************\r
* vect.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
--- /dev/null
+\ Integer vectors library Thu Feb 21 12:46:01 MST 2008
+\ Copyright (C) 2008, Sergey Plis
+\
+\ 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.
+
+\needs float import float
+
+\ vector variables better have names ending with "(" for readability
+Module vectors
+also float
+
+\ fetches
+| create fetch_operations ' c@ , ' w@ , ' @ , 0 , ' 2@ , ' f@ ,
+
+\ stores
+| create store_operations ' c! , ' w! , ' ! , 0 , ' 2! , ' f! ,
+| : type-idx ( cell_size -- idx ) 4 >> ; macro
+| : f-op ( cell-size -- cfa ) type-idx cells fetch_operations + @ ;
+| : s-op ( cell-size -- cfa ) type-idx cells store_operations + @ ;
+
+: ^)! ( *vector -- addr ) [ 3 cells ] literal - @ ;
+: ^)@ ( *vector -- addr ) [ 4 cells ] literal - @ ;
+
+\ number of elements
+: )size ( *vector -- size ) [ 1 cells ] literal - @ ;
+
+\ set number of elements - useful for temporal size adjustments in
+\ datastructures such as heaps
+: )size! ( sz *vector -- ) [ 1 cells ] literal - ! ;
+
+\ size of an element in bytes
+: )type ( *vector -- size ) [ 2 cells ] literal - @ ;
+
+: )free ( *vector -- ) [ 4 cells ] literal - free throw ;
+
+\ header | fetch_cfa | store_cfa | el_size | #els |
+\ cell-size in bits
+\ unnamed vector
+: _vector ( n cell-size -- addr )
+ 2dup * [ 4 cells ] literal + allocate throw
+ dup >r over f-op swap !
+ r@ cell+ over s-op swap !
+ r@ [ 2 cells ] literal + ! \ cell size store
+ r@ [ 3 cells ] literal + ! \ #els store
+ r> [ 4 cells ] literal + ;
+
+\ named vector
+: vector ( n cell-size -- )
+ create
+ 2dup * [ 4 cells ] literal + allocate throw dup ,
+ dup >r over f-op swap !
+ r@ cell+ over s-op swap !
+ r@ [ 2 cells ] literal + ! \ cell size store
+ r@ [ 3 cells ] literal + ! \ #els store
+ r> dup
+ \ erasing the content
+ [ 2 cells ] literal + @ over [ 3 cells ] literal + @ *
+ swap [ 4 cells ] literal + swap erase
+ does> @ [ 4 cells ] literal + ;
+
+\ vector of pointers
+: vector* ( # -- *vector ) cell 8 * _vector ;
+
+| : ?idx-in-range ( *vector idx -- 1/0 ) dup rot )size < swap 0>= and ;
+| : check-range ( *vector idx -- *vector idx | fail )
+ 2dup ?idx-in-range not abort" Index is out of range! " ;
+
+\ addr of ith element of the vector
+: *) ( *vector i -- addr ) over )type 3 >> * + ;
+: )@ ( *vector index -- )
+ [IFDEF] отладка
+ check-range
+ [THEN]
+ over dup ^)@ >r )type 3 >> * + r> execute ;
+: )! ( value *vector index -- )
+ [IFDEF] отладка
+ check-range
+ [THEN]
+ over dup ^)! >r )type 3 >> * + r> execute ;
+\ : test! cell * + ! ;
+| create print-funcs ' . , ' . , ' . , 0 , ' d. , ' f. ,
+: )print ( *v -- cfa ) )type type-idx cells print-funcs + @ execute ;
+: )map ( *v xt -- ) swap dup )size 0 do 2dup i )@ swap execute loop 2drop ;
+: map ( *v -- ) ( word-to-map ) ' swap dup )size 0 do 2dup i )@ swap execute loop 2drop ;
+: )initperm ( v( -- )
+ dup )size 0 do
+ dup
+ i swap over )!
+ loop drop ;
+: ). ( *vector -- ) dup )size 0 do dup i )@ over )print loop drop ;
+\ does arbitrary vector contain this element ?
+: )in? ( *v value -- 1/0 )
+ swap dup )size 0 do
+ 2dup i )@ = if 2drop True unloop exit then
+ loop 2drop False ;
+: )find ( *v value -- i True/False )
+ swap dup )size 0 do
+ 2dup i )@ = if 2drop i True unloop exit then
+ loop 2drop False ;
+: vector->stack ( *v -- n1 n2 .. n# # )
+ dup )size 0 do dup i )@ swap loop )size ;
+\ initialized cell vector
+\ preserve order
+: ivector* ( n1 n2 .. n# # -- *vector )
+ dup vector* swap 1- 0 swap do
+ swap over i )!
+ -1 +loop ;
+\ reversed order
+: irvector* ( n1 n2 .. n# # -- *vector )
+ dup vector* swap 0 do
+ swap over i )!
+ loop ;
+\ does not take care of duplicate elements
+| : overlap ( v1( v2( -- n1 .. n2 # / 0 ) depth 2- >r
+ dup )size 0 do
+ 2dup i )@ )in? if
+ dup i )@ -rot
+ then
+ loop 2drop depth r> - ;
+| : notoverlap ( v1( v2( -- n1 .. n2 # )
+ depth 2- >r
+ dup )size 0 do
+ 2dup i )@ )in? not if
+ dup i )@ -rot
+ then
+ loop 2drop depth r> - ;
+: )union ( *v1( *v2( -- *v3( )
+ over >r
+ notoverlap
+ r> swap >r vector->stack r> +
+ dup 0= abort" empty union!"
+ ivector* ;
+: )intersection ( *v1( *v2( -- *v3(/0 )
+ overlap dup 0<> if ivector* then ;
+\ elementwise comparison of two vectors
+: )= ( *v1( *v2( -- 1/0 ) dup )size >r over )size r>
+ <> if 2drop 0 exit then
+ dup )size 0 do
+ 2dup i )@ swap i )@ <> if
+ 2drop unloop 0 exit
+ then
+ loop 2drop -1 ;
+: subset? ( *v( *s( -- 1/0 )
+ 2dup )intersection dup 0= if -rot 2drop exit then
+ dup >r )= swap drop r> )free ;
+: )clone ( *v -- *cv )
+ vector->stack ivector* ;
+: )erase ( *v -- ) dup )size over )type 3 >> * erase ;
+: _last ( *v -- *v idx-of-last-element ) dup )size 1- ;
+
+clear
+previous
+Module;
\ No newline at end of file
/***************************************************************************\r
* volume.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* window.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* wnd.h is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* wx.h.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
pr.AllowSetSize(true);
setlocale(LC_CTYPE, "");
setlocale(LC_NUMERIC, "C");
- pr.Execute(&gr,text.toAscii());
+ pr.Execute(&gr,text.toStdWString().c_str());
gr.WriteJSON(tmp);
setlocale(LC_NUMERIC, "");
pr.AllowSetSize(true);
setlocale(LC_CTYPE, "");
setlocale(LC_NUMERIC, "C");
- pr.Execute(&gr,text.toAscii());
+ pr.Execute(&gr,text.toStdWString().c_str());
gr.Finish();
int x = (int)xy.section(" ",0,0).toDouble();
pr.AllowSetSize(true);
setlocale(LC_CTYPE, "");
setlocale(LC_NUMERIC, "C");
- pr.Execute(&gr,mgl.toAscii());
+ pr.Execute(&gr,mgl.toStdWString().c_str());
gr.WriteJSON(tmp);
setlocale(LC_NUMERIC, "");
#pragma once
-#include <QtCore/QStringList>
-#include <QtCore/QObject>
+#include <QStringList>
class Backend : public QObject
{
-if(MGL_HAVE_QT)
+if(enable-qt)
set(json_src Backend.cpp MainWindow.cpp)
set(json_moc_hdr Backend.hpp MainWindow.hpp)
-include(${QT_USE_FILE})
include_directories(${MathGL_BINARY_DIR}/json)
-
-qt4_wrap_ui(json_ui_src MainWindow.ui)
-qt4_wrap_cpp(json_moc_src ${json_moc_hdr} )
+if(enable-qt5)
+ include(../cmake-qt5.txt)
+ qt5_wrap_ui(json_ui_src MainWindow.ui)
+ qt5_wrap_cpp(json_moc_src ${json_moc_hdr} )
+else(enable-qt5)
+ include(../cmake-qt4.txt)
+ qt4_wrap_ui(json_ui_src MainWindow.ui)
+ qt4_wrap_cpp(json_moc_src ${json_moc_hdr} )
+endif(enable-qt5)
add_executable(MglForJsTestBench ${json_src} ${json_moc_src} ${json_ui_src})
-target_link_libraries(MglForJsTestBench mgl-qt ${QT_LIBRARIES})
+if(enable-qt5)
+ add_definitions( -DMGL_USE_QT5)
+ target_link_libraries(MglForJsTestBench mgl-qt5)
+ qt5_use_modules(MglForJsTestBench Core Widgets Gui Network WebKit WebKitWidgets PrintSupport)
+else(enable-qt5)
+ target_link_libraries(MglForJsTestBench mgl-qt ${QT_LIBRARIES})
+endif(enable-qt5)
-endif(MGL_HAVE_QT)
+endif(enable-qt)
#include "MainWindow.hpp"
#include "ui_MainWindow.h"
+#include "mgl2/config.h"
-#include <QtWebKit/QWebFrame>
-#include <QtNetwork/QNetworkDiskCache>
-#include <QtGui/QDesktopServices>
+#include <QWebFrame>
+#include <QNetworkDiskCache>
+#include <QDesktopServices>
//-----------------------------------------------------------------------------
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
-
return a.exec();
}
//-----------------------------------------------------------------------------
// create non-cached QNetworkAccessManager and assign to webview
QNetworkAccessManager* manager = new QNetworkAccessManager(this);
QNetworkDiskCache* diskCache = new QNetworkDiskCache();
+#ifdef MGL_USE_QT5
+ const QString location = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
+#else
const QString location = QDesktopServices::storageLocation(QDesktopServices::CacheLocation);
+#endif
diskCache->setCacheDirectory(location);
diskCache->setMaximumCacheSize(0);
manager->setCache(diskCache);
// inject backend object each time javascript object is cleared
connect(ui->webView->page()->mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(injectBackendObject()));
-
// set url to load
-// ui->webView->load(QUrl(QString("file:///%1/%2").arg(qApp->applicationDirPath()).arg("index.html")));
- ui->webView->load(QUrl("index.html"));
+ ui->webView->load(QUrl(QString("file:///%1/../../json/%2").arg(qApp->applicationDirPath()).arg("index.html")));
}
//-----------------------------------------------------------------------------
void MainWindow::injectBackendObject()
{
- ui->webView->page()->mainFrame()->addToJavaScriptWindowObject("globalBackend", &_backend, QScriptEngine::QtOwnership);
+ ui->webView->page()->mainFrame()->addToJavaScriptWindowObject("globalBackend", &_backend);
}
//-----------------------------------------------------------------------------
MainWindow::~MainWindow() { delete ui; }
#pragma once
#include "Backend.hpp"
-#include <QtGui/QMainWindow>
-#include <QtCore/QObject>
+#include <QMainWindow>
+//#include <QObject>
namespace Ui { class MainWindow; }
<button type="button" onclick="graph.zoomIn()">Zoom in</button>
<button type="button" onclick="graph.zoomOut()">Zoom out</button>
<button type="button" onclick="graph.moveDown()">Down</button>
- <button type="button" onclick="graph.moveRight()">Right</button>
+ <button type="button" onclick="graph.moveRight()">Right</button><br>
<canvas id="canvas" width="800" height="600" style="border:1px solid #d3d3d3;">
</canvas>
</center>
var makeSampleScript = function() {
var mgl = "origintick off\n";
- mgl += "ranges -2 2 -2 2 -2 2:" // NOTE: Ranges MUST BE specified for correctly work of zoomaxis feature
+ mgl += "title 'qqq' '@k':ranges -2 2 -2 2 -2 2:colorbar '>'\n" // NOTE: Ranges MUST BE specified for correctly work of zoomaxis feature
mgl += "facenum 50:";
mgl += "origin 0 0 0:axis :xlabel 'x':ylabel 'y':zlabel 'z':"
mgl += "box:fplot 'sin(x^2)'\n"; // This is just for testing zoomaxis features
- mgl += "fplot 'sin(2*pi*t)' '2*t-1' 'cos(2*pi*t)' 'm2o':";
+ mgl += "fplot 'sin(2*pi*t)' '2*t-1' 'cos(2*pi*t)' 'm2o':fsurf 'sin(pi*x*y)':";
mgl += "text 0 0 'aaa'";
return mgl;
}
this.__draftFinishedTimestamp = new Date();
this.__backgroundFillStyle = '#EEEEFF';
this.__preciseRenderingDelay = 700;
- // TODO add setters/getters
- this.__maxDraftPoints = 9000;
+
+ this.__maxDraftPoints = 30000;
+ this.__asp_scl=0; // inertia of aspect scaling
+ this.__fov = 0; // perspective
this.__x1 = 0; this.__y1 = 0; this.__z1 = 0;
this.__x2 = 1; this.__y2 = 1; this.__z2 = 1;
}
var zoom = "zoom "+(0.5-obj.pf/2)+" "+(0.5-obj.pf/2)+" "+(0.5+obj.pf/2)+" "+(0.5+obj.pf/2)+"\n";
var view1 = "view 0 "+this.__view.__pitch*180/Math.PI+" 0"+"\n";
var view2 = "view 0 0 "+(-this.__view.__yaw)*180/Math.PI+"\n";
+ var persp = "perspective "+(-this.__fov)+"\n";
// now ask server side for proper coordinates
- var res = this.__backend.coor(xy, zoom+view1+view2+obj.mgl);
+ var res = this.__backend.coor(xy, zoom+view1+view2+persp+obj.mgl);
}
// var vvv = $M([[1,0,0,1]]);
var obj = this.__geometry;
var h = this.__canvas.height;
- var dy = h / obj.height;
+ var fy = h / obj.height;
var w = this.__canvas.width;
- var dx = w / obj.width;
+ var fx = w / obj.width;
+// var df=dx<dy?dx:dy;
+ var dx, dy;
+ if(fx<fy) { dx=fx; dy=fx+(fy-fx)*this.__asp_scl; }
+ else { dy=fy; dx=fy+(fx-fy)*this.__asp_scl; }
obj.pf = -m.e(4,3);
obj.b = [dx*m.e(1,1), dx*m.e(2,1), dx*m.e(3,1),
dy*m.e(1,2), dy*m.e(2,2), dy*m.e(3,2),
m.e(1,3), m.e(2,3), m.e(3,3),
- w/2, h/2, obj.depth/2];
-
+ w/2, h/2, obj.depth/2,
+ fx, fy, 1];
+/* obj.b = [dx*m.e(1,1), dx*m.e(2,1), dx*m.e(3,1),
+ dy*m.e(1,2), dy*m.e(2,2), dy*m.e(3,2),
+ m.e(1,3), m.e(2,3), m.e(3,3),
+ w/2, h/2, obj.depth/2,
+ dx, dy, 1]; */
this.__drawBackground();
if (!isPrecise) {
mathgl.Graph.prototype.__mgl_draw_fast = function(obj, ctx, skip) {
if(obj.fast==0) return;
this.__mgl_prepare(obj,skip); // update coordinates
- var i,n1,n2;
+ var di = 1 + Math.round(obj.nprim / this.__maxDraftPoints);
// for each primitive skipping superfluous
- for(var i=0;i<obj.nprim;i += 1 + Math.round(obj.nprim / this.__maxDraftPoints))
+ for(var i=0;i<obj.nprim;i ++)
{
- n1 = obj.prim[i][1]; n2 = obj.prim[i][2];
- if(obj.prim[i][0]==1)
- {
- ctx.strokeStyle = obj.prim[i][10];
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineWidth = obj.prim[i][7]/100;
- ctx.stroke();
- }
- else
+ var prim = obj.prim[i];
+ var n1 = prim[1], nn = obj.pp[n1];
+ if(prim[0]==1 || obj.pnts[n1][3]<0)
+ this.__mgl_draw_prim(obj,ctx,prim,Math.abs(obj.b[12]));
+ else if(obj.prim[i][0]<4 && i%di==0)
{
ctx.fillStyle = obj.prim[i][10];
- ctx.fillRect(obj.pp[n1][0], obj.pp[n1][1], 2, 2);
+ ctx.fillRect(nn[0], nn[1], 2, 2);
}
}
}
// var scl = 1/Math.abs(obj.z[1]-obj.z[0]);
// NOTE: this valid only for current zoom/view. In general case it should be more complicated
var s1 = Math.sqrt(obj.b[0]*obj.b[0]+obj.b[1]*obj.b[1]+obj.b[2]*obj.b[2]);
- var deg = Math.PI/180; //0.017453293;
+ var s2 = Math.abs(obj.b[12]);
for(var i=0;i<obj.nprim;i++) // for each primitive
{
- var scl = s1*this.__mgl_pf(obj, obj.prim[i][9]);
- var n1 = obj.prim[i][1], n2 = obj.prim[i][2];
- var n3 = obj.prim[i][3], n4 = obj.prim[i][4];
- ctx.strokeStyle = obj.prim[i][10];
- ctx.fillStyle = obj.prim[i][10];
- ctx.lineWidth = 1;
- switch(obj.prim[i][0]) // draw it depending on its type
+ var prim = obj.prim[i];
+ var scl = s1*this.__mgl_pf(obj, prim[9]);
+ if(obj.pnts[prim[1]][3]) scl = s2;
+ this.__mgl_draw_prim(obj,ctx,prim,scl);
+ }
+}
+
+/** perform high-quality drawing */
+mathgl.Graph.prototype.__mgl_draw_prim = function(obj, ctx, prim, scl) {
+ var n1 = prim[1], n2 = prim[2];
+ var n3 = prim[3], n4 = prim[4];
+ var pp = obj.pp;
+ var deg = Math.PI/180; //0.017453293;
+
+ ctx.strokeStyle = prim[10];
+ ctx.fillStyle = prim[10];
+ ctx.lineWidth = 1;
+ switch(prim[0]) // draw it depending on its type
+ {
+ case 0: // marks
+ ctx.lineWidth = prim[7]*prim[6]*5e-4;
+ this.__mgl_draw_mark(ctx, pp[n1][0], pp[n1][1], n4, prim[6]/100, scl);
+ break;
+ case 1: // lines
+ ctx.beginPath();
+ ctx.moveTo(pp[n1][0],pp[n1][1]);
+ ctx.lineTo(pp[n2][0],pp[n2][1]);
+ ctx.lineWidth = prim[7]/100;
+ ctx.stroke(); break;
+ case 2: // triangles
+ ctx.beginPath();
+ ctx.moveTo(pp[n1][0],pp[n1][1]);
+ ctx.lineTo(pp[n2][0],pp[n2][1]);
+ ctx.lineTo(pp[n3][0],pp[n3][1]);
+ ctx.closePath(); ctx.fill(); break;
+ case 3: // quadrangles
+ ctx.beginPath();
+ ctx.moveTo(pp[n1][0],pp[n1][1]);
+ ctx.lineTo(pp[n2][0],pp[n2][1]);
+ ctx.lineTo(pp[n4][0],pp[n4][1]);
+ ctx.lineTo(pp[n3][0],pp[n3][1]);
+ ctx.closePath();
+ // NOTE: look as alpha is disabled for lines
+ // So, next code should be only for the case alpha=false
+ if(prim[10].charAt(0)=='#') ctx.stroke();
+ ctx.fill(); break;
+ case 4: // glyphs
+ var t=prim[7]*deg/100;
+ var xx=obj.coor[n2][2]/100,yy=-obj.coor[n2][3]/100,zz=obj.coor[n2][4]/100;
+ var xc = obj.b[0]*xx + obj.b[1]*yy + obj.b[2]*zz;
+ var yc = obj.b[3]*xx + obj.b[4]*yy + obj.b[5]*zz;
+// var zc = obj.b[6]*xx + obj.b[7]*yy + obj.b[8]*zz;
+ if(obj.pnts[n1][3]<0) { xc=xx; yc=yy; }
+ var ll = xc*xc+yc*yc;
+ if(ll < 1e-10) break;
+ if(ll<1e10 && t/deg<1e4)
{
- case 0: // marks
-// ctx.lineWidth = obj.prim[i][7]*obj.prim[i][6]*50;
- ctx.lineWidth = obj.prim[i][7]*obj.prim[i][6]*5e-4;
- this.__mgl_draw_mark(ctx, obj.pp[n1][0], obj.pp[n1][1], n4, obj.prim[i][6]/100, scl);
- break;
- case 1: // lines
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineWidth = obj.prim[i][7]/100;
- ctx.stroke(); break;
- case 2: // triangles
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineTo(obj.pp[n3][0],obj.pp[n3][1]);
- ctx.closePath(); ctx.fill(); break;
- case 3: // quadrangles
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineTo(obj.pp[n4][0],obj.pp[n4][1]);
- ctx.lineTo(obj.pp[n3][0],obj.pp[n3][1]);
- ctx.closePath();
- // NOTE: look as alpha is disabled for lines
- // So, next code should be only for the case alpha=false
- if(obj.prim[i][10].charAt(0)=='#') ctx.stroke();
- ctx.fill(); break;
- case 4: // glyphs
- var t=obj.prim[i][7]*deg/100;
- var xx=obj.coor[n2][2]/100,yy=-obj.coor[n2][3]/100,zz=obj.coor[n2][4]/100;
- var xc = obj.b[0]*xx + obj.b[1]*yy + obj.b[2]*zz;
- var yc = obj.b[3]*xx + obj.b[4]*yy + obj.b[5]*zz;
-// var zc = obj.b[6]*xx + obj.b[7]*yy + obj.b[8]*zz;
- var ll = xc*xc+yc*yc;
- if(ll < 1e-10) break;
- if(ll<1e10 && t/deg<1e4)
- {
- t = Math.atan2(yc,xc);
- if(Math.abs(t)>Math.PI/2) t += Math.PI;
- }
- else t=0;
- var c=Math.cos(t), s=Math.sin(t), d=obj.prim[i][6]/200;
-
- var b=[d*c, d*s, d*s, -d*c, obj.pp[n1][0],obj.pp[n1][1]];
- var x=obj.coor[n2][0]*scl/100, y=obj.coor[n2][1]*scl/100, f=obj.prim[i][8]*scl/1e5;
- if(n3&8)
- {
- if(!(n3&4)) this.__mgl_line_glyph(ctx, x,y, f,1,b);
- else this.__mgl_line_glyph(ctx, x,y, f,0,b);
- }
- else
- {
- if(!(n3&4)) this.__mgl_fill_glyph(ctx, x,y, f,obj.glfs[n4],b);
- else this.__mgl_wire_glyph(ctx, x,y, f,obj.glfs[n4],b);
- }
- break;
+ t = Math.atan2(yc,xc);
+ if(Math.abs(t)>Math.PI/2) t += Math.PI;
+ }
+ else t=0;
+ var c=Math.cos(t), s=Math.sin(t), d=prim[6]/200;
+
+ var b=[d*c, d*s, d*s, -d*c, pp[n1][0],pp[n1][1]];
+ var x=obj.coor[n2][0]*scl/100, y=obj.coor[n2][1]*scl/100, f=prim[8]*scl/1e5;
+ if(n3&8)
+ {
+ if(!(n3&4)) this.__mgl_line_glyph(ctx, x,y, f,1,b);
+ else this.__mgl_line_glyph(ctx, x,y, f,0,b);
+ }
+ else
+ {
+ if(!(n3&4)) this.__mgl_fill_glyph(ctx, x,y, f,obj.glfs[n4],b);
+ else this.__mgl_wire_glyph(ctx, x,y, f,obj.glfs[n4],b);
}
+ break;
}
}
-
mathgl.Graph.prototype.__mgl_pf = function(obj, z) {
- return 1/obj.pf;
+// return 1/obj.pf;
+ return (1-this.__fov)/obj.pf/(1-this.__fov*z/obj.depth); // TODO: check calc coordinates!!!
// return 1/(1+obj.pf*(1-z/obj.depth));
}
dy*(cx*sy*sz+cz*sx), dy*(cx*cz-sx*sy*sz), -dy*cy*sz,
sx*sz-cx*cz*sy, cx*sz+cz*sx*sy, cy*cz,
obj.width/2*(1+dx-obj.z[1]-obj.z[0])/dx,
- obj.height/2*(1+dy-obj.z[3]-obj.z[2])/dy, obj.depth/2];
+ obj.height/2*(1+dy-obj.z[3]-obj.z[2])/dy, obj.depth/2, dx,dy,1];
}
// now transform points for found transformation matrix
var b = obj.b, i;
var x = obj.pnts[i][0]-obj.width/2;
var y = obj.pnts[i][1]-obj.height/2;
var z = obj.pnts[i][2]-obj.depth/2;
- obj.pp[i] = [b[9] + b[0]*x + b[1]*y + b[2]*z,
- b[10] + b[3]*x + b[4]*y + b[5]*z,
- b[11] + b[6]*x + b[7]*y + b[8]*z];
+ if(obj.pnts[i][3]==0) // TODO: check later when mglInPlot will be ready
+ obj.pp[i] = [b[9] + b[0]*x + b[1]*y + b[2]*z,
+ b[10] + b[3]*x + b[4]*y + b[5]*z,
+ b[11] + b[6]*x + b[7]*y + b[8]*z];
+ else
+ obj.pp[i] = [b[9]+b[12]*x,b[10]+b[13]*y,b[11]+b[14]*z];
}
- if(obj.pf) for(var i=0;i<obj.npnts;i++) // perspective
+ if(obj.pf || this.__fov) for(var i=0;i<obj.npnts;i++) // perspective
{ // NOTE: it is not supported for coordinate determining now
var d = this.__mgl_pf(obj, obj.pp[i][2]);
- obj.pp[i][0] = d*obj.pp[i][0] + (1-d)*obj.b[9];
- obj.pp[i][1] = d*obj.pp[i][1] + (1-d)*obj.b[10];
+ if(obj.pnts[i][3]==0) // TODO: check later when mglInPlot will be ready
+ {
+ obj.pp[i][0] = d*obj.pp[i][0] + (1-d)*obj.b[9];
+ obj.pp[i][1] = d*obj.pp[i][1] + (1-d)*obj.b[10];
+ }
}
// fill z-coordinates for primitives
if(!obj.fast) for(i=0;i<obj.nprim;i++)
{
- var n1 = obj.prim[i][1], n2 = obj.prim[i][2], n3 = obj.prim[i][3], n4 = obj.prim[i][4];
- switch(obj.prim[i][0])
+ var prim = obj.prim[i];
+ var n1 = prim[1], n2 = prim[2], n3 = prim[3], n4 = prim[4];
+ switch(prim[0])
{
case 1: // lines
- obj.prim[i][9] = (obj.pp[n1][2]+obj.pp[n2][2])/2; break;
+ prim[9] = (obj.pp[n1][2]+obj.pp[n2][2])/2; break;
case 2: // triangles
- obj.prim[i][9] = (obj.pp[n1][2]+obj.pp[n2][2]+obj.pp[n3][2])/3; break;
+ prim[9] = (obj.pp[n1][2]+obj.pp[n2][2]+obj.pp[n3][2])/3; break;
case 3: // quadrangles
- obj.prim[i][9] = (obj.pp[n1][2]+obj.pp[n2][2]+obj.pp[n3][2]+obj.pp[n4][2])/4; break;
+ prim[9] = (obj.pp[n1][2]+obj.pp[n2][2]+obj.pp[n3][2]+obj.pp[n4][2])/4; break;
default:
- obj.prim[i][9] = obj.pp[n1][2]; break;
+ prim[9] = obj.pp[n1][2]; break;
}
}
if(!obj.fast) // sort primitives according its z-coordinate
mathgl.Graph.prototype.zoomOut = function() {
this.zoomAxis(1./1.1);
}
+
+mathgl.Graph.prototype.getView = function(mgl) {
+ return this.__view;
+}
+
+mathgl.Graph.prototype.reloadGeometry = function() {
+ var mgl = this.__geometry.mgl;
+ this.__geometry = this.__backend.geometry(mgl);
+ this.__geometry.mgl = mgl;
+}
+
+mathgl.Graph.prototype.redraw = function() {
+ this.__renderStart();
+}
+
+mathgl.Graph.prototype.destroy = function() {
+ this.__view.destroy();
+ this.__view = null;
+ this.__backend = null;
+ this.__canvas = null;
+ this.__geometry = null;
+}
+
+/** @param type {String} data url type (e.g. "image/png") */
+mathgl.Graph.prototype.toDataURL = function(type) {
+ this.__canvas.toDataURL(type);
+}
+
+/** Set perspective angle of view: @param val - degree of perspective in range 0...1 (0 - use default orthogonal projection) */
+mathgl.Graph.prototype.setPerspective = function(val) {
+ this.__fov = val;
+}
+
+/** Set maximal number of drawable points in draft mode */
+mathgl.Graph.prototype.setMaxDraftPoints = function(count) {
+ this.__maxDraftPoints = count;
+}
+
+mathgl.Graph.prototype.setPreciseRenderingDelay = function(delayMillisec) {
+ this.__preciseRenderingDelay = delayMillisec;
+}
/** @constructor */
mathgl.View = function() {
- this.__canvas = null;
- this.__renderLauncherFunc = null;
- this.__pickPointHandlerFunc = null;
- this.__onMouseMoveFunc = mathgl.bind(this.__onMouseMove, this);
- this.__onMouseDownFunc = mathgl.bind(this.__onMouseDown, this);
- this.__onMouseUpFunc = mathgl.bind(this.__onMouseUp, this);
- this.__onMouseOutFunc = mathgl.bind(this.__onMouseOut, this);
- this.__onDblClickFunc = mathgl.bind(this.__onDblClick, this);
- this.__onMouseWheelFunc = mathgl.bind(this.__onMouseWheel, this);
-
- // mouse state
- this.__isMouseDown = false;
- this.__mouseX = -1;
- this.__mouseY = -1;
-
- // current camera position
- this.__distance = 1.0;
- this.__pitch = 0;
- this.__yaw = 0;
+ this.__canvas = null;
+ this.__renderLauncherFunc = null;
+ this.__pickPointHandlerFunc = null;
+ this.__onCameraChanged = null;
+ this.__onMouseMoveFunc = mathgl.bind(this.__onMouseMove, this);
+ this.__onMouseDownFunc = mathgl.bind(this.__onMouseDown, this);
+ this.__onMouseUpFunc = mathgl.bind(this.__onMouseUp, this);
+ this.__onMouseOutFunc = mathgl.bind(this.__onMouseOut, this);
+ this.__onDblClickFunc = mathgl.bind(this.__onDblClick, this);
+ this.__onMouseWheelFunc = mathgl.bind(this.__onMouseWheel, this);
+
+ // mouse state
+ this.__isMouseDown = false;
+ this.__mouseX = -1;
+ this.__mouseY = -1;
+
+ // current camera position
+ this.__distance = 1.0;
+ this.__pitch = 0;
+ this.__yaw = 0;
}
* @param json {String} string in JSON format with previously saved state
*/
mathgl.View.prototype.load = function(json) {
- throw new Error("not implemented");
+ throw new Error("not implemented");
}
* @return {String} view state serialized to JSON string
*/
mathgl.View.prototype.save = function() {
- throw new Error("not implemented");
+ throw new Error("not implemented");
}
* @param canvas {Canvas} canvas to attach
*/
mathgl.View.prototype.attachCanvas = function(canvas) {
- // remember canvas
- this.__canvas = canvas;
- // connect mouse events
- this.__canvas.addEventListener("mousemove", this.__onMouseMoveFunc, false);
- this.__canvas.addEventListener("mousedown", this.__onMouseDownFunc, false);
- this.__canvas.addEventListener("mouseup", this.__onMouseUpFunc, false);
- this.__canvas.addEventListener("mouseout", this.__onMouseOutFunc, false);
- this.__canvas.addEventListener("dblclick", this.__onDblClickFunc, false);
- this.__canvas.addEventListener("mousewheel", this.__onMouseWheelFunc, false);
-
- // initiare redraw
- this.__renderLauncherFunc();
+ // remember canvas
+ this.__canvas = canvas;
+ // connect mouse events
+ this.__canvas.addEventListener("mousemove", this.__onMouseMoveFunc, false);
+ this.__canvas.addEventListener("mousedown", this.__onMouseDownFunc, false);
+ this.__canvas.addEventListener("mouseup", this.__onMouseUpFunc, false);
+ this.__canvas.addEventListener("mouseout", this.__onMouseOutFunc, false);
+ this.__canvas.addEventListener("dblclick", this.__onDblClickFunc, false);
+ this.__canvas.addEventListener("mousewheel", this.__onMouseWheelFunc, false);
+
+ // initiate redraw
+ this.__renderLauncherFunc();
}
/** Detach any previously attached canvas from this view instance. */
mathgl.View.prototype.detachCanvas = function() {
- // disconnect mouse events
- this.__canvas.removeEventListener("mousemove", this.__onMouseMoveFunc, false);
- this.__canvas.removeEventListener("mousedown", this.__onMouseDownFunc, false);
- this.__canvas.removeEventListener("mouseup", this.__onMouseUpFunc, false);
- this.__canvas.removeEventListener("mouseout", this.__onMouseOutFunc, false);
- this.__canvas.removeEventListener("dblclick", this.__onDblClickFunc, false);
- this.__canvas.removeEventListener("mousewheel", this.__onMouseWheelFunc, false);
-
- // drop canvas
- this.__canvas = null;
+ // disconnect mouse events
+ this.__canvas.removeEventListener("mousemove", this.__onMouseMoveFunc, false);
+ this.__canvas.removeEventListener("mousedown", this.__onMouseDownFunc, false);
+ this.__canvas.removeEventListener("mouseup", this.__onMouseUpFunc, false);
+ this.__canvas.removeEventListener("mouseout", this.__onMouseOutFunc, false);
+ this.__canvas.removeEventListener("dblclick", this.__onDblClickFunc, false);
+ this.__canvas.removeEventListener("mousewheel", this.__onMouseWheelFunc, false);
+
+ // drop canvas
+ this.__canvas = null;
}
* @param renderLauncherFunc {Function} callback function which will be invoked when graph shall be redrawn
*/
mathgl.View.prototype.setRenderLauncher = function(renderLauncherFunc) {
- this.__renderLauncherFunc = renderLauncherFunc;
+ this.__renderLauncherFunc = renderLauncherFunc;
}
* @param pickPointHandler {Function} callback function which will be invoked when user pick the point
*/
mathgl.View.prototype.setPickPointHandler = function(pickPointHandlerFunc) {
- this.__pickPointHandlerFunc = pickPointHandlerFunc;
+ this.__pickPointHandlerFunc = pickPointHandlerFunc;
}
* @return {Matrix} view matrix
*/
mathgl.View.prototype.viewMatrix = function() {
- var d = this.__distance;
- var cp = Math.cos(this.__pitch);
- var sp = Math.sin(this.__pitch);
- var cy = Math.cos(this.__yaw);
- var sy = Math.sin(this.__yaw);
- var lh = true; // coordinate system is left handed
-
- var distanceMatrix = $M([[1, 0, 0, 0],
- [0, 1, 0, 0],
- [0, 0, 1, 0],
- [0, 0, d, 1]]);
- var pitchMatrix = $M([[1, 0, 0, 0],
- [0, cp , lh ? sp : -sp, 0],
- [0, lh ? -sp : sp, cp, 0],
- [0, 0, 0, 1]]);
- var yawMatrix = $M([[ cy, 0, -sy, 0],
- [ 0, 1, 0, 0],
- [ sy, 0, cy, 0],
- [ 0, 0, 0, 1]]);
- var viewMatrix = Matrix.I(4);
- viewMatrix = viewMatrix.x(distanceMatrix);
- viewMatrix = viewMatrix.x(pitchMatrix);
- viewMatrix = viewMatrix.x(yawMatrix);
- return viewMatrix;
+ var d = this.__distance;
+ var cp = Math.cos(this.__pitch);
+ var sp = Math.sin(this.__pitch);
+ var cy = Math.cos(this.__yaw);
+ var sy = Math.sin(this.__yaw);
+ var lh = true; // coordinate system is left handed
+
+ var distanceMatrix = $M([[1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, 0],
+ [0, 0, d, 1]]);
+ var pitchMatrix = $M( [[1, 0, 0, 0],
+ [0, cp , lh ? sp : -sp, 0],
+ [0, lh ? -sp : sp, cp, 0],
+ [0, 0, 0, 1]]);
+ var yawMatrix = $M([[ cy, 0, -sy, 0],
+ [ 0, 1, 0, 0],
+ [ sy, 0, cy, 0],
+ [ 0, 0, 0, 1]]);
+ var viewMatrix = Matrix.I(4);
+ viewMatrix = viewMatrix.x(distanceMatrix);
+ viewMatrix = viewMatrix.x(pitchMatrix);
+ viewMatrix = viewMatrix.x(yawMatrix);
+ return viewMatrix;
}
/** TODO: add function returning current view area in world (model) coordinates */
mathgl.View.prototype.viewArea = function() {
- throw new Error("not implemented");
+ throw new Error("not implemented");
}
mathgl.View.prototype.__onMouseMove = function(e) {
- if (this.__isMouseDown) {
- var x = e.offsetX;
- var y = e.offsetY;
- this.__yaw += 0.5 * (this.__mouseX - x) * Math.PI / 180;
- this.__pitch += 0.5 * (y - this.__mouseY) * Math.PI / 180;
- this.__mouseX = x;
- this.__mouseY = y
- this.__pitch = Math.min(this.__pitch, Math.PI / 2);
- this.__pitch = Math.max(this.__pitch, -Math.PI / 2);
- this.__yaw = Math.min(this.__yaw, Math.PI);
- this.__yaw = Math.max(this.__yaw, -Math.PI);
- this.__renderLauncherFunc();
- }
+ if (this.__isMouseDown) {
+ var x = e.offsetX;
+ var y = e.offsetY;
+ this.__yaw += 0.5 * (this.__mouseX - x) * Math.PI / 180;
+ this.__pitch += 0.5 * (y - this.__mouseY) * Math.PI / 180;
+ this.__mouseX = x;
+ this.__mouseY = y;
+ if(this.__pitch > 63) this.__pitch -= 20*Math.PI;
+ if(this.__pitch < -63) this.__pitch += 20*Math.PI;
+ if(this.__yaw > 63) this.__yaw -= 20*Math.PI;
+ if(this.__yaw <-63) this.__yaw += 20*Math.PI;
+// this.__pitch = Math.min(this.__pitch, Math.PI / 2);
+// this.__pitch = Math.max(this.__pitch, -Math.PI / 2);
+// this.__yaw = Math.min(this.__yaw, Math.PI);
+// this.__yaw = Math.max(this.__yaw, -Math.PI);
+
+ if(this.__onCameraChanged)
+ this.__onCameraChanged(this.getViewpoint());
+ this.__renderLauncherFunc();
+ }
}
mathgl.View.prototype.__onMouseDown = function(e) {
- this.__mouseX = e.offsetX;
- this.__mouseY = e.offsetY;
- this.__isMouseDown = true;
+ this.__mouseX = e.offsetX;
+ this.__mouseY = e.offsetY;
+ this.__isMouseDown = true;
}
mathgl.View.prototype.__onMouseUp = function() {
- this.__isMouseDown = false;
+ this.__isMouseDown = false;
}
mathgl.View.prototype.__onMouseOut = function() {
- this.__isMouseDown = false;
+ this.__isMouseDown = false;
}
mathgl.View.prototype.__onDblClick = function(e) {
- this.__pickPointHandlerFunc(e.offsetX, e.offsetY);
+ this.__pickPointHandlerFunc(e.offsetX, e.offsetY);
}
mathgl.View.prototype.__onMouseWheel = function(e) {
- this.__isMouseDown = false;
- this.__distance -= 0.1 * e.wheelDelta / 120;
- this.__distance = Math.min(this.__distance, 10.0);
- this.__distance = Math.max(this.__distance, 0.5);
- this.__renderLauncherFunc();
+ this.__isMouseDown = false;
+ this.__distance -= 0.1 * e.wheelDelta / 120;
+ this.__distance = Math.min(this.__distance, 10.0);
+ this.__distance = Math.max(this.__distance, 0.2);
+ if(this.__onCameraChanged)
+ this.__onCameraChanged(this.getViewpoint());
+ this.__renderLauncherFunc();
+}
+
+mathgl.View.prototype.getViewpoint = function() {
+ return {
+ distance : this.__distance,
+ pitch : this.__pitch,
+ yaw : this.__yaw,
+ };
+}
+
+mathgl.View.prototype.setViewpoint = function(distance, pitch, yaw) {
+ this.__distance = distance;
+ this.__pitch = pitch;
+ this.__yaw = yaw;
+ this.__renderLauncherFunc();
+}
+
+mathgl.View.prototype.destroy = function() {
+ this.__renderLauncherFunc = null;
+ this.__pickPointHandlerFunc = null;
+ this.detachCanvas();
+}
+
+mathgl.View.prototype.setCameraEventHandler = function(handler) {
+ this.__onCameraChanged = handler;
}
var obj = JSON.parse(geometryData);
obj.pp = new Array();
- for(var i=0;i<obj.npnts;i++) // copy original data for transformation
- obj.pp[i] = [obj.pnts[i][0],obj.pnts[i][1],obj.pnts[i][2]];
-return obj;
+ return obj;
}
/* animate.cpp is part of UDAV
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License
/* data.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* editor.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* grid.cpp is part of UDAV
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License
/* help.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* main.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* mathgl.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* option.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* setup.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* table.cpp is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* udav.h is part of UDAV\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/* write.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru>\r
*\r
* This program is free software; you can redistribute it and/or\r
* modify it under the terms of the GNU Library General Public License\r
/***************************************************************************
* addon.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
#include "mgl2/data.h"
//-----------------------------------------------------------------------------
dual MGL_EXPORT mgl_expi(dual a) { return exp(dual(0,1)*a); }
-dual MGL_EXPORT mgl_expi(double a) { return dual(cos(a),sin(a)); }
//-----------------------------------------------------------------------------
void MGL_EXPORT mgl_strcls(char *str)
{
{
if(!str || !str[0]) return;
long len=strlen(str), *n; double *v;
- char *s, *t, *buf=new char[len+1];
- memcpy(buf,str,len+1);
+ char *s, *t;
va_list lst;
va_start(lst,str);
t = mgl_fgetstr(fp);
return fp;
}
//-----------------------------------------------------------------------------
-bool MGL_EXPORT mgl_difr_grid(dual *a,int n,dual q,int Border,dual *b,dual *d,int kk)
+int MGL_EXPORT mgl_difr_grid(dual *a,int n,dual q,int Border,dual *b,dual *d,int kk)
{
// if(n<=0 || q>=0.5) return false;
dual adt = dual(0.,1.)*q;
return true;
}
//-----------------------------------------------------------------------------
-bool MGL_EXPORT mgl_difr_axial(dual *a, int n, dual q, int Border,dual *b, dual *d, int kk, double di)
+int MGL_EXPORT mgl_difr_axial(dual *a, int n, dual q, int Border,dual *b, dual *d, int kk, double di)
{
int ii = di<0 ? -int(floor(di)) : 0;
dual adt = dual(0.,1.)*q;
/***************************************************************************
* axis.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
long MGL_EXPORT mgl_have_color(const char *stl)
{
register long i,j=0;
- if(stl) for(i=0;stl[i];i++) if(strchr(MGL_COLORS,stl[i])) j++;
+ if(stl) for(i=0;stl[i];i++)
+ {
+ if(strchr(MGL_COLORS,stl[i])) j++;
+ if(stl[i]=='{' && stl[i+1]=='x') j++;
+ }
return j;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void mglCanvas::Axis(const char *dir, const char *stl, const char *opt)
{
- bool text = !mglchr(dir,'_');
+ bool text = !(mglchr(dir,'_') || mglchr(dir,'~'));
bool inv = mglchr(dir,'^');
bool adjust = mglchr(stl,'a');
bool ret = get(MGL_ENABLE_RTEXT);
EndGroup();
}
//-----------------------------------------------------------------------------
-void mglCanvas::DrawLabels(mglAxis &aa, bool inv)
+void mglCanvas::DrawLabels(mglAxis &aa, bool inv, const mglMatrix *M)
{
if(strchr("xyz",aa.ch))
aa.org = mglPoint(GetOrgX(aa.ch,aa.inv), GetOrgY(aa.ch,aa.inv), GetOrgZ(aa.ch,aa.inv));
if(strchr("xyz",aa.ch)) o -= d*(o*d);
mglPoint p,q, s=(Min+Max)/2, nn;
s = s - d*(s*d);
+ if(M==0) M=&B;
register long i,n = aa.txt.size();
char pos[4]="t:C";
for(i=0;i<n;i++)
{
w[i] = TextWidth(aa.txt[i].text.c_str(),FontDef,-1);
- kk[i] = AddPnt(&B, o+d*aa.txt[i].val,-1,d,0,7);
+ kk[i] = AddPnt(M, o+d*aa.txt[i].val,-1,d,0,7);
}
for(l=0,c=1e7,i=0;i<n-1;i++)
Org.z=Min.z; Axis("xy_",col);
Org.x=Min.x; DrawAxis(az,0,0,col);
Org.x=Max.x; Org.y=Min.y; DrawAxis(az,0,0,col);
- if(col && strchr(col,'@'))
+ if(mglchr(col,'@'))
{
// edge points
mglPoint p[8]={Min,Min,Min,Min,Max,Max,Max,Max},nan=mglPoint(NAN),oo[8];
if(p[i].z<zm) { zm=p[i].z; im=i; }
}
// now draw faces
- char color[5]="{y9}";
- register int i; // first color used for faces, last one for edges
- for(i=0;col[i];i++) if(strchr(MGL_COLORS,col[i]))
+ char color[10]="{y9}";
+ for(int i=0;col[i];i++)
+ {
+ if(col[i]=='{' && col[i+1]=='x')
+ { memcpy(color,col+i,9); color[9]=0; break; }
+ if(strchr(MGL_COLORS,col[i]))
+ {
+ if(i>1 && col[i-1]=='{') { color[1]=col[i]; color[2]=col[i+1]; break; }
+ else { color[0]=col[i]; color[1]=0; break; }
+ }
+ }
+ long *pos = new long[3*31*31];
+ SetPenPal(color);
+ mreal dx = (Max.x-Min.x)/30, dy = (Max.y-Min.y)/30, dz = (Max.z-Min.z)/30;
+ for(long i=0;i<31;i++) for(long j=0;j<31;j++)
+ {
+ register long i0=3*(i+31*j);
+ pos[i0] = AddPnt(mglPoint(oo[im].x,Min.y+dy*i,Min.z+dz*j));
+ pos[i0+1] = AddPnt(mglPoint(Min.x+dx*i,oo[im].y,Min.z+dz*j));
+ pos[i0+2] = AddPnt(mglPoint(Min.x+dx*i,Min.y+dy*j,oo[im].z));
+ }
+ for(long i=0;i<30;i++) for(long j=0;j<30;j++)
{
- if(i>1 && col[i-1]=='{') { color[1]=col[i]; color[2]=col[i+1]; break; }
- else { color[0]=col[i]; color[1]=0; break; }
+ register long i0=3*(i+31*j);
+ quad_plot(pos[i0],pos[i0+3],pos[i0+93],pos[i0+96]);
+ quad_plot(pos[i0+1],pos[i0+4],pos[i0+94],pos[i0+97]);
+ quad_plot(pos[i0+2],pos[i0+5],pos[i0+95],pos[i0+98]);
}
- mgl_facex(this, oo[im].x, Min.y, Min.z, Max.y-Min.y, Max.z-Min.z, color,0,0);
- mgl_facey(this, Min.x, oo[im].y, Min.z, Max.x-Min.x, Max.z-Min.z, color,0,0);
- mgl_facez(this, Min.x, Min.y, oo[im].z, Max.x-Min.x, Max.y-Min.y, color,0,0);
+ delete []pos;
+// mgl_facex(this, oo[im].x, Min.y, Min.z, Max.y-Min.y, Max.z-Min.z, color,0,0);
+// mgl_facey(this, Min.x, oo[im].y, Min.z, Max.x-Min.x, Max.z-Min.z, color,0,0);
+// mgl_facez(this, Min.x, Min.y, oo[im].z, Max.x-Min.x, Max.y-Min.y, color,0,0);
}
}
EndGroup();
void mglCanvas::Colorbar(const char *sch, mreal x, mreal y, mreal w, mreal h)
{
bool in = mglchr(sch,'I');
+ bool text = !mglchr(sch,'~');
int where = 0; // ‘0’ - right, ‘1’ - left, ‘2’ - above, ‘3’ - under
if(mglchr(sch,'>')) where = in?1:0;
if(mglchr(sch,'<')) where = in?0:1;
{ v.Fill(log(-Min.c), log(-Max.c)); v.Modify("-exp(u)"); }
mreal *c=new mreal[n];
for(long i=0;i<n;i++) c[i] = GetC(s,v.a[i]);
- colorbar(&v, c, where, x, y, w, h);
+ colorbar(&v, c, where, x, y, w, h, text);
delete []c;
if(mglchr(sch,'A')) Pop();
}
void mglCanvas::Colorbar(HCDT v, const char *sch, mreal x, mreal y, mreal w, mreal h)
{
bool in = mglchr(sch,'I');
+ bool text = !mglchr(sch,'~');
int where = 0;
if(mglchr(sch,'>')) where = in?1:0;
if(mglchr(sch,'<')) where = in?0:1;
int nc = GetNumPal(s*256);
mreal dc = nc>1 ? 1/(MGL_EPSILON*(nc-1)):0;
for(long i=0;i<v->GetNx();i++) c[i] = s+i*dc;
- colorbar(v, c, where, x, y, w, h);
+ colorbar(v, c, where, x, y, w, h, text);
delete []c;
if(mglchr(sch,'A')) Pop();
}
//-----------------------------------------------------------------------------
-void mglCanvas::colorbar(HCDT vv, const mreal *c, int where, mreal x, mreal y, mreal w, mreal h)
+void mglCanvas::colorbar(HCDT vv, const mreal *c, int where, mreal x, mreal y, mreal w, mreal h, bool text)
{
static int cgid=1; StartGroup("Colorbar",cgid++);
long n=vv->GetNx();
long n1,n2,n3,n4;
mreal d,s3=B.pf,ss=1/s3; // NOTE: colorbar was wider ss=0.9;
mglPoint p1,p2;
- mglMatrix M=B1; M.pf=s3;
+ mglMatrix M=B1; M.pf=s3; M.norot=true;
set(MGL_DISABLE_SCALE); // NOTE this make colorbar non-thread-safe!!!
x = s3*(2*x-1); y = s3*(2*y-1); w *= s3; h *= s3;
SetPenPal(AxisStl);
// bool out = fabs(x)>1 && fabs(y)>1;
bool inv = where!=3 && where!=0;
- ac.ns = where; DrawLabels(ac,inv); // NOTE ns isn't used for colorbar
+ ac.ns = where;
+ if(text) DrawLabels(ac,inv,&M); // NOTE ns isn't used for colorbar
clr(MGL_DISABLE_SCALE); EndGroup();
}
//-----------------------------------------------------------------------------
/***************************************************************************\r
* base.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
if(!get(MGL_ENABLE_ALPHA)) { q.a=1; if(txt.Smooth!=2) q.ta=1-gap; }\r
if(norefr) q.v=0;\r
if(!get(MGL_ENABLE_LIGHT) && !(scl&4)) q.u=q.v=NAN;\r
+ if(mat->norot) q.sub=-1; // NOTE: temporary -- later should be mglInPlot here\r
long k;\r
#pragma omp critical(pnt)\r
{MGL_PUSH(Pnt,q,mutexPnt); k=Pnt.size()-1;} return k;\r
{\r
mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
+ CRange(v1,v2,add);\r
+}\r
+void mglBase::CRange(mreal v1,mreal v2,bool add)\r
+{\r
if(v1==v2 && !add) return;\r
if(!add) { Min.c = v1; Max.c = v2; }\r
else if(Min.c<Max.c)\r
}\r
else\r
{\r
- dv = Min.c;\r
+ mreal dv = Min.c;\r
Min.c = v1<Max.c ? v1:Max.c;\r
Max.c = v2>dv ? v2:dv;\r
}\r
{\r
mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
+ XRange(v1,v2,add);\r
+}\r
+void mglBase::XRange(mreal v1,mreal v2,bool add)\r
+{\r
if(v1==v2 && !add) return;\r
if(!add) { Min.x = v1; Max.x = v2; }\r
else if(Min.x<Max.x)\r
}\r
else\r
{\r
- dv = Min.x;\r
+ mreal dv = Min.x;\r
Min.x = v1<Max.x ? v1:Max.x;\r
Max.x = v2>dv ? v2:dv;\r
}\r
{\r
mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
+ YRange(v1,v2,add);\r
+}\r
+void mglBase::YRange(mreal v1,mreal v2,bool add)\r
+{\r
if(v1==v2 && !add) return;\r
if(!add) { Min.y = v1; Max.y = v2; }\r
else if(Min.y<Max.y)\r
}\r
else\r
{\r
- dv = Min.y;\r
+ mreal dv = Min.y;\r
Min.y = v1<Max.y ? v1:Max.y;\r
Max.y = v2>dv ? v2:dv;\r
}\r
{\r
mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
+ ZRange(v1,v2,add);\r
+}\r
+void mglBase::ZRange(mreal v1,mreal v2,bool add)\r
+{\r
if(v1==v2 && !add) return;\r
if(!add) { Min.z = v1; Max.z = v2; }\r
else if(Min.z<Max.z)\r
}\r
else\r
{\r
- dv = Min.z;\r
+ mreal dv = Min.z;\r
Min.z = v1<Max.z ? v1:Max.z;\r
Max.z = v2>dv ? v2:dv;\r
}\r
const char *mglchrs(const char *str, const char *chr)\r
{\r
if(!str || !str[0] || !chr || !chr[0]) return NULL;\r
- size_t l=strlen(str);\r
+ size_t l=strlen(chr);\r
for(size_t i=0;i<l;i++)\r
{\r
const char *res = mglchr(str,chr[i]);\r
/***************************************************************************\r
* base.cpp is part of Math gric Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
void MGL_EXPORT mgl_set_ternary(HMGL gr, int enable) { gr->Ternary(enable); }\r
void MGL_EXPORT mgl_set_range_val(HMGL gr, char dir, double v1,double v2)\r
{\r
- if(dir=='c') gr->CRange(v1,v2);\r
+ if(dir=='c' || dir=='a') gr->CRange(v1,v2);\r
else if(dir=='x') gr->XRange(v1,v2);\r
else if(dir=='y') gr->YRange(v1,v2);\r
else if(dir=='z') gr->ZRange(v1,v2);\r
}\r
+void MGL_EXPORT mgl_add_range_val(HMGL gr, char dir, double v1,double v2)\r
+{\r
+ if(dir=='c' || dir=='a') gr->CRange(v1,v2,true);\r
+ else if(dir=='x') gr->XRange(v1,v2,true);\r
+ else if(dir=='y') gr->YRange(v1,v2,true);\r
+ else if(dir=='z') gr->ZRange(v1,v2,true);\r
+}\r
void MGL_EXPORT mgl_set_range_dat(HMGL gr, char dir, HCDT a, int add)\r
{\r
- if(dir=='c') gr->CRange(a,add);\r
+ if(dir=='c' || dir=='a') gr->CRange(a,add);\r
else if(dir=='x') gr->XRange(a,add);\r
else if(dir=='y') gr->YRange(a,add);\r
else if(dir=='z') gr->ZRange(a,add);\r
void MGL_EXPORT mgl_set_ternary_(uintptr_t *gr, int *enable) { _GR_->Ternary(*enable); }\r
void MGL_EXPORT mgl_set_range_val_(uintptr_t *gr, const char *dir, mreal *v1, mreal *v2,int)\r
{ mgl_set_range_val(_GR_,*dir,*v1,*v2); }\r
+void MGL_EXPORT mgl_add_range_val_(uintptr_t *gr, const char *dir, mreal *v1, mreal *v2,int)\r
+{ mgl_add_range_val(_GR_,*dir,*v1,*v2); }\r
void MGL_EXPORT mgl_set_range_dat_(uintptr_t *gr, const char *dir, uintptr_t *a, int *add,int)\r
{ mgl_set_range_dat(_GR_,*dir,_DA_(a),*add); }\r
void MGL_EXPORT mgl_set_ranges_(uintptr_t *gr, mreal *x1, mreal *x2, mreal *y1, mreal *y2, mreal *z1, mreal *z2)\r
/***************************************************************************\r
* canvas.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
#endif\r
#pragma omp critical(ptx)\r
{\r
- Bt = B;\r
+ Bt = B; Bt.norot=(q.sub<0); // NOTE check this later for mglInPlot\r
inv = inv ^ (strchr(font,'T')!=0);\r
if(inv) shift = 0.2*h-shift;\r
shift += 0.015*h; // Correction for glyph rotation around proper point\r
// shift *= h;\r
\r
- int align; mglGetStyle(font,0,&align); align = align&3;\r
+ int align; \r
+ char cc = mglGetStyle(font,0,&align); align = align&3;\r
+ if(cc) col = -cc;\r
Bt.x = q.x; Bt.y = q.y - shift; Bt.z = q.z;\r
if(ll>0)\r
{\r
add_prim(a);\r
}\r
\r
+ col = col<0 ? AddTexture(char(0.5-col)):col;\r
+ q.c=col; q.t=0; Txt[long(col)].GetC(col,0,q);\r
+ q.u = q.v = NAN;\r
memset(Bt.b,0,9*sizeof(mreal));\r
Bt.b[0] = Bt.b[4] = Bt.b[8] = fscl;\r
register mreal opf = Bt.pf;\r
- Bt.RotateN(ftet,0,0,1); Bt.pf = opf;\r
+ Bt.RotateN(ftet,0,0,1); Bt.pf = Bt.norot?1.55:opf;\r
if(strchr(font,'@')) // draw box around text\r
{\r
long k1,k2,k3,k4; mglPnt pt; mglPoint pp;\r
{MGL_PUSH(Pnt,pt,mutexPnt); k4=Pnt.size()-1;}\r
line_plot(k1,k2); line_plot(k1,k3);\r
line_plot(k4,k2); line_plot(k4,k3);\r
+ mreal bl = AddTexture('w');\r
+ k1 = CopyNtoC(k1,bl); k2 = CopyNtoC(k2,bl);\r
+ k3 = CopyNtoC(k3,bl); k4 = CopyNtoC(k4,bl);\r
+ quad_plot(k1,k2,k3,k4);\r
}\r
fsize *= fnt->Puts(text,font,col)/2;\r
}\r
{\r
if(mgl_isnan(Ax))\r
{\r
- mreal dy = (Max.y-Min.y), dx = (Max.x-Min.x);\r
+ mreal dy = (Max.y-Min.y), dx = (Max.x-Min.x), dz = (Max.z-Min.z);\r
if(islog(Min.x,Max.x) && fx) dx = log10(Max.x/Min.x);\r
if(islog(Min.y,Max.y) && fy) dy = log10(Max.y/Min.y);\r
- mreal f=exp(M_LN10*floor(0.5+log10(fabs(dy/dx))));\r
- if(mgl_isnum(Ay)) f=Ay;\r
- Ax = Height*dx*f; Ay = Width*dy; Az = Depth;\r
+ if(islog(Min.z,Max.z) && fz) dz = log10(Max.z/Min.z);\r
+ mreal fy=exp(M_LN10*floor(0.5+log10(fabs(dy/dx))));\r
+ mreal fz=exp(M_LN10*floor(0.5+log10(fabs(dz/dx))));\r
+ if(Ay>0) fy*=Ay;\r
+ if(Az>0) fz*=Az;\r
+ Ax = Height*dx; Ay = Width*dy*fy; Az = Depth*dz*fz;\r
}\r
mreal a = fabs(Ax) > fabs(Ay) ? fabs(Ax) : fabs(Ay);\r
a = a > fabs(Az) ? a : fabs(Az);\r
mreal c1=AddTexture(char(k1?k1:'w')), c2=AddTexture(char(k2?k2:'k'));\r
if((Flag&3)==2) { mreal cc=c1; c2=c1; c1=cc; }\r
\r
+ mglMatrix M=B; M.norot=true;\r
if(strchr(ff,'#')) // draw bounding box\r
{\r
SetPenPal("k-");\r
- k1=AddPnt(&B,mglPoint(x,y,Depth/MGL_FEPSILON),c1,q,-1,0);\r
- k2=AddPnt(&B,mglPoint(x+w*ncol,y,Depth/MGL_FEPSILON),c1,q,-1,0);\r
- k3=AddPnt(&B,mglPoint(x,y+h*nrow,Depth/MGL_FEPSILON),c1,q,-1,0);\r
- k4=AddPnt(&B,mglPoint(x+w*ncol,y+h*nrow,Depth/MGL_FEPSILON),c1,q,-1,0);\r
+ k1=AddPnt(&M,mglPoint(x,y,Depth/MGL_FEPSILON),c1,q,-1,0);\r
+ k2=AddPnt(&M,mglPoint(x+w*ncol,y,Depth/MGL_FEPSILON),c1,q,-1,0);\r
+ k3=AddPnt(&M,mglPoint(x,y+h*nrow,Depth/MGL_FEPSILON),c1,q,-1,0);\r
+ k4=AddPnt(&M,mglPoint(x+w*ncol,y+h*nrow,Depth/MGL_FEPSILON),c1,q,-1,0);\r
quad_plot(k1,k2,k3,k4);\r
k1=CopyNtoC(k1,c2); k2=CopyNtoC(k2,c2);\r
k3=CopyNtoC(k3,c2); k4=CopyNtoC(k4,c2);\r
{\r
register long iy=nrow-(i%nrow)-1,ix=i/nrow;\r
char m=SetPenPal(leg[i].stl.c_str());\r
- k1=AddPnt(&B,mglPoint(x+ix*w+0.1*ll,y+iy*h+0.45*h,Depth),CDef,q,-1,0);\r
- k2=AddPnt(&B,mglPoint(x+ix*w+0.9*ll,y+iy*h+0.45*h,Depth),CDef,q,-1,0); pPos=0;\r
+ k1=AddPnt(&M,mglPoint(x+ix*w+0.1*ll,y+iy*h+0.45*h,Depth),CDef,q,-1,0);\r
+ k2=AddPnt(&M,mglPoint(x+ix*w+0.9*ll,y+iy*h+0.45*h,Depth),CDef,q,-1,0); pPos=0;\r
if(!leg[i].stl.empty()) line_plot(k1,k2);\r
if(m) for(j=0;j<LegendMarks;j++)\r
{\r
p = mglPoint(x+ix*w+0.1f*ll + (j+1)*0.8f*ll/(1.+LegendMarks),y+iy*h+0.45*h,Depth);\r
- mark_plot(AddPnt(&B,p,CDef,q,-1,0),m);\r
+ mark_plot(AddPnt(&M,p,CDef,q,-1,0),m);\r
}\r
p = mglPoint(x+ix*w+((!leg[i].stl.empty())?ll:0.01*iw), y+iy*h+0.15*h, Depth);\r
- text_plot(AddPnt(&B,p,-1,q,-1,0), leg[i].text.c_str(), ff, size);\r
+ text_plot(AddPnt(&M,p,-1,q,-1,0), leg[i].text.c_str(), ff, size);\r
}\r
Pop(); EndGroup(); delete []ff;\r
}\r
if(h>=inH) { SetWarn(mglWarnSpc,"Title"); return; }\r
static int cgid=1; StartGroup("Title",cgid++);\r
bool box=mglchr(stl,'#');\r
- int align; mglGetStyle(stl,0,&align); align = align&3;\r
+ int align;\r
+ char col = mglGetStyle(stl,0,&align); align = align&3;\r
+ if(col==0) col = 'k';\r
mreal y=inY+inH-h;\r
- mglPoint p(inX + inW*align/2.,y,Depth),q(NAN);\r
- if(title) text_plot(AddPnt(p,-1,q,-1,0),title,stl,size);\r
+ mglPoint p(inX + inW*align/2.,y,3*Depth),q(NAN);\r
+ mglMatrix M=B; M.norot=true;\r
+ if(title) text_plot(AddPnt(&M,p,-1,q,-1,0),title,stl,size);\r
if(box) // draw boungind box\r
{\r
- mreal c1=AddTexture('w'), c2=AddTexture('k');\r
+ mreal c1=AddTexture('w'), c2=AddTexture(col);\r
if((Flag&3)==2) { mreal cc=c1; c2=c1; c1=cc; }\r
long k1,k2,k3,k4;\r
- k1=AddPnt(&B,mglPoint(inX,y,Depth),c1,q,-1,0);\r
- k2=AddPnt(&B,mglPoint(inX+inW,y,Depth),c1,q,-1,0);\r
- k3=AddPnt(&B,mglPoint(inX,y+h,Depth),c1,q,-1,0);\r
- k4=AddPnt(&B,mglPoint(inX+inW,y+h,Depth),c1,q,-1,0);\r
+ k1=AddPnt(&M,mglPoint(inX,y-h*0.4,3*Depth),c1,q,-1,0);\r
+ k2=AddPnt(&M,mglPoint(inX+inW,y-h*0.4,3*Depth),c1,q,-1,0);\r
+ k3=AddPnt(&M,mglPoint(inX,y+h,3*Depth),c1,q,-1,0);\r
+ k4=AddPnt(&M,mglPoint(inX+inW,y+h,3*Depth),c1,q,-1,0);\r
quad_plot(k1,k2,k3,k4);\r
k1=CopyNtoC(k1,c2); k2=CopyNtoC(k2,c2);\r
k3=CopyNtoC(k3,c2); k4=CopyNtoC(k4,c2);\r
/***************************************************************************\r
* canvas_cf.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
void MGL_EXPORT mgl_wnd_set_delay_(uintptr_t *gr, mreal *dt) { _GR_->SetDelay(*dt); }\r
double MGL_EXPORT mgl_wnd_get_delay_(uintptr_t *gr) { return _GR_->GetDelay(); }\r
//-----------------------------------------------------------------------------\r
-HMEX MGL_EXPORT mgl_create_expr(const char *expr) { return new mglFormula(expr); }\r
-void MGL_EXPORT mgl_delete_expr(HMEX ex) { delete ex; }\r
-double MGL_EXPORT mgl_expr_eval(HMEX ex, double x, double y,double z)\r
-{ return ex->Calc(x,y,z); }\r
-double MGL_EXPORT mgl_expr_eval_v(HMEX ex, mreal *var)\r
-{ return ex->Calc(var); }\r
-double MGL_EXPORT mgl_expr_diff(HMEX ex, char dir, double x, double y,double z)\r
-{ return ex->CalcD(dir,x,y,z); }\r
-double MGL_EXPORT mgl_expr_diff_v(HMEX ex, char dir, mreal *var)\r
-{ return ex->CalcD(var, dir); }\r
-//-----------------------------------------------------------------------------\r
-uintptr_t MGL_EXPORT mgl_create_expr_(const char *expr, int l)\r
-{ char *s=new char[l+1]; memcpy(s,expr,l); s[l]=0;\r
- uintptr_t res = uintptr_t(mgl_create_expr(s));\r
- delete []s; return res; }\r
-void MGL_EXPORT mgl_delete_expr_(uintptr_t *ex) { mgl_delete_expr((HMEX)ex); }\r
-double MGL_EXPORT mgl_eval_expr_(uintptr_t *ex, mreal *x, mreal *y, mreal *z)\r
-{ return mgl_expr_eval((HMEX) ex, *x,*y,*z); }\r
-double MGL_EXPORT mgl_diff_expr_(uintptr_t *ex, const char *dir, mreal *x, mreal *y, mreal *z, int)\r
-{ return mgl_expr_diff((HMEX) ex, *dir,*x,*y,*z); }\r
-//-----------------------------------------------------------------------------\r
-HAEX MGL_EXPORT mgl_create_cexpr(const char *expr) { return new mglFormulaC(expr); }\r
-void MGL_EXPORT mgl_delete_cexpr(HAEX ex) { delete ex; }\r
-dual MGL_EXPORT mgl_cexpr_eval(HAEX ex, dual x, dual y,dual z)\r
-{ return ex->Calc(x,y,z); }\r
-dual MGL_EXPORT mgl_cexpr_eval_v(HAEX ex, dual *var)\r
-{ return ex->Calc(var); }\r
-//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_set_plotfactor(HMGL gr, double val)\r
{ mglCanvas *g = dynamic_cast<mglCanvas *>(gr); if(g) g->SetPlotFactor(val); }\r
void MGL_EXPORT mgl_set_plotfactor_(uintptr_t *gr, mreal *val)\r
/***************************************************************************\r
* complex.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* data_io.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
//read first file\r
do{ snprintf(fname,n,templ,t); t+= step; } while(!mgl_datac_read(&d,fname) && t<=to);\r
\r
- if(t>to) return false;\r
+ if(t>to) { delete []fname; return false; }\r
kx = d.nx; ky = d.ny; kz = d.nz;\r
b = (dual *)malloc(kx*ky*kz*sizeof(dual));\r
memcpy(b,d.a,kx*ky*kz*sizeof(dual));\r
/***************************************************************************\r
* cont.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
mglData z(y->GetNx());\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_textw_xyz(gr,x,y,&z,text,font,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_textw_y(HMGL gr, HCDT y, const wchar_t *text, const char *font, const char *opt)\r
x.Fill(gr->Min.x,gr->Max.x);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_textw_xyz(gr,&x,y,&z,text,font,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_text_xyz(HMGL gr, HCDT x, HCDT y, HCDT z,const char *text, const char *font, const char *opt)\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_cont_xy_val(gr,v,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont_xy_val(gr,&v,x,y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont_val(gr,&v,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_contf_xy_val(gr,v,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf_xy_val(gr,&v,x,y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf_val(gr,&v,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_contd_xy_val(gr,v,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contd_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
mglData v(mgl_get_ncol(sch,0)+1);\r
v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contd_xy_val(gr,&v,x,y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contd(HMGL gr, HCDT z, const char *sch, const char *opt)\r
mglData v(mgl_get_ncol(sch,0)+1);\r
v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contd_val(gr,&v,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contd_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_contv_xy_val(gr,v,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contv_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_contv_xy_val(gr,&v,x,y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contv(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_contv_val(gr,&v,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contv_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_cont3_xyz_val(gr,v,&x,&y,&z,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, double sVal, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont3_xyz_val(gr,&v,x,y,z,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont3(HMGL gr, HCDT a, const char *sch, double sVal, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont3_val(gr,&v,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont3_xyz_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_dens3_xyz(gr,&x,&y,&z,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_dens3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_grid3_xyz(gr,&x,&y,&z,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_grid3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_contf3_xyz_val(gr,v,&x,&y,&z,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, double sVal, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf3_xyz_val(gr,&v,x,y,z,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf3(HMGL gr, HCDT a, const char *sch, double sVal, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf3_val(gr,&v,a,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf3_xyz_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
else x.Fill(0,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_axial_xy_val(gr,v,&x,&y,a,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_axial_xy(HMGL gr, HCDT x, HCDT y, HCDT a, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?3:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_axial_xy_val(gr,&v,x,y,a,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_axial(HMGL gr, HCDT a, const char *sch, const char *opt)\r
{\r
mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?3:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); gr->LoadState(); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); return; }\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_axial_val(gr,&v,a,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_axial_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
/***************************************************************************\r
* crust.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
mglData z(x->GetNx());\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_triplot_xyzc(gr,nums,x,y,&z,&z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_triplot_xyzc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int l,int lo)\r
gr->SaveState(opt);\r
mglData z(x->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_quadplot_xyzc(gr,nums,x,y,&z,&z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_quadplot_xyzc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int l,int lo)\r
mglData v(n);\r
for(long i=0;i<n;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(n+1);\r
mgl_tricont_xyzcv(gr,&v,nums,x,y,z,a,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tricont_xyc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
/***************************************************************************\r
* data.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* data_new.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************
* data_gr.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
/***************************************************************************\r
* data_io.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
//-----------------------------------------------------------------------------\r
mreal MGL_EXPORT mgl_data_min(HCDT d)\r
{\r
- mreal m1=1e10;\r
+ mreal m1=0;\r
long nn=d->GetNN();\r
const mglData *b = dynamic_cast<const mglData *>(d);\r
#pragma omp parallel\r
{\r
- register mreal m=1e10, v;\r
+ register mreal m=0, v;\r
if(b)\r
#pragma omp for nowait\r
for(long i=0;i<nn;i++)\r
}\r
mreal MGL_EXPORT mgl_data_min_(uintptr_t *d) { return mgl_data_min(_DT_); }\r
//-----------------------------------------------------------------------------\r
+mreal MGL_EXPORT mgl_data_neg_max(HCDT d)\r
+{\r
+ mreal m1=0;\r
+ long nn=d->GetNN();\r
+ const mglData *b = dynamic_cast<const mglData *>(d);\r
+#pragma omp parallel\r
+ {\r
+ register mreal m=0, v;\r
+ if(b)\r
+#pragma omp for nowait\r
+ for(long i=0;i<nn;i++)\r
+ { v = b->a[i]; m = m<v && v<0 ? v:m; }\r
+ else\r
+#pragma omp for nowait\r
+ for(long i=0;i<nn;i++)\r
+ { v = d->vthr(i); m = m<v && v<0 ? v:m; }\r
+#pragma omp critical(max_dat)\r
+ { m1 = m1>m ? m1:m; }\r
+ }\r
+ return m1;\r
+}\r
+mreal MGL_EXPORT mgl_data_neg_max_(uintptr_t *d) { return mgl_data_neg_max(_DT_); }\r
+//-----------------------------------------------------------------------------\r
+mreal MGL_EXPORT mgl_data_pos_min(HCDT d)\r
+{\r
+ mreal m1=1e10;\r
+ long nn=d->GetNN();\r
+ const mglData *b = dynamic_cast<const mglData *>(d);\r
+#pragma omp parallel\r
+ {\r
+ register mreal m=1e10, v;\r
+ if(b)\r
+#pragma omp for nowait\r
+ for(long i=0;i<nn;i++)\r
+ { v = b->a[i]; m = m>v && v>0 ? v:m; }\r
+ else\r
+#pragma omp for nowait\r
+ for(long i=0;i<nn;i++)\r
+ { v = d->vthr(i); m = m>v && v>0 ? v:m; }\r
+#pragma omp critical(min_dat)\r
+ { m1 = m1<m ? m1:m; }\r
+ }\r
+ return m1;\r
+}\r
+mreal MGL_EXPORT mgl_data_pos_min_(uintptr_t *d) { return mgl_data_pos_min(_DT_); }\r
+//-----------------------------------------------------------------------------\r
mreal MGL_EXPORT mgl_data_max_int(HCDT d, long *i, long *j, long *k)\r
{\r
mreal m1=-1e10;\r
//read first file\r
do{ snprintf(fname,n,templ,t); t+= step; } while(!mgl_data_read(&d,fname) && t<=to);\r
\r
- if(t>to) return false;\r
+ if(t>to) { delete []fname; return false; }\r
kx = d.nx; ky = d.ny; kz = d.nz;\r
b = (mreal *)malloc(kx*ky*kz*sizeof(mreal));\r
memcpy(b,d.a,kx*ky*kz*sizeof(mreal));\r
/***************************************************************************\r
* data_png.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* eval.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
EQ_MOD, // x modulo y\r
EQ_LOG, // logarithm of x on base a, log_a(x) = ln(x)/ln(a)\r
EQ_ARG, // argument of complex number arg(x,y) = atan2(x,y)\r
+EQ_HYPOT, // sqrt(x^2+y^2)=hypot(x,y)\r
// special functions of 2 arguments\r
EQ_BESJ, // regular cylindrical Bessel function of fractional order\r
EQ_BESY, // irregular cylindrical Bessel function of fractional order\r
else if(!strcmp(name+1,"anh")) Kod=EQ_TANH;\r
else if(!strcmp(name+1,"h")) Kod=EQ_TANH;\r
}\r
+ else if(!strcmp(name,"hypot")) Kod=EQ_HYPOT;\r
else if(!strcmp(name,"pow")) Kod=EQ_POW;\r
else if(!strcmp(name,"mod")) Kod=EQ_MOD;\r
else if(!strcmp(name,"i")) Kod=EQ_BESI;\r
,0,0,0,0,0,0,0,0\r
#endif\r
};\r
- func_2 f2[EQ_SIN-EQ_LT] = {clt,cgt,ceq,cor,cand,add,sub,mul,del,ipw,pow,fmod,llg,arg\r
+ func_2 f2[EQ_SIN-EQ_LT] = {clt,cgt,ceq,cor,cand,add,sub,mul,del,ipw,pow,fmod,llg,arg,hypot\r
#if MGL_HAVE_GSL\r
,gsl_sf_bessel_Jnu,gsl_sf_bessel_Ynu,\r
gsl_sf_bessel_Inu,gsl_sf_bessel_Knu,\r
return -1;\r
}\r
//-----------------------------------------------------------------------------\r
+HMEX MGL_EXPORT mgl_create_expr(const char *expr) { return new mglFormula(expr); }\r
+void MGL_EXPORT mgl_delete_expr(HMEX ex) { delete ex; }\r
+double MGL_EXPORT mgl_expr_eval(HMEX ex, double x, double y,double z)\r
+{ return ex->Calc(x,y,z); }\r
+double MGL_EXPORT mgl_expr_eval_v(HMEX ex, mreal *var)\r
+{ return ex->Calc(var); }\r
+double MGL_EXPORT mgl_expr_diff(HMEX ex, char dir, double x, double y,double z)\r
+{ return ex->CalcD(dir,x,y,z); }\r
+double MGL_EXPORT mgl_expr_diff_v(HMEX ex, char dir, mreal *var)\r
+{ return ex->CalcD(var, dir); }\r
+//-----------------------------------------------------------------------------\r
+uintptr_t MGL_EXPORT mgl_create_expr_(const char *expr, int l)\r
+{ char *s=new char[l+1]; memcpy(s,expr,l); s[l]=0;\r
+ uintptr_t res = uintptr_t(mgl_create_expr(s));\r
+ delete []s; return res; }\r
+void MGL_EXPORT mgl_delete_expr_(uintptr_t *ex) { mgl_delete_expr((HMEX)ex); }\r
+double MGL_EXPORT mgl_eval_expr_(uintptr_t *ex, mreal *x, mreal *y, mreal *z)\r
+{ return mgl_expr_eval((HMEX) ex, *x,*y,*z); }\r
+double MGL_EXPORT mgl_diff_expr_(uintptr_t *ex, const char *dir, mreal *x, mreal *y, mreal *z, int)\r
+{ return mgl_expr_diff((HMEX) ex, *dir,*x,*y,*z); }\r
+//-----------------------------------------------------------------------------\r
/***************************************************************************\r
* evalc.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
#include <time.h>\r
-#include "mgl2/data_cf.h"\r
+#include "mgl2/datac_cf.h"\r
#include "mgl2/evalc.h"\r
-#include "mgl2/addon.h"\r
#if MGL_HAVE_GSL\r
#include <gsl/gsl_sf.h>\r
#endif\r
return t;\r
}\r
//-----------------------------------------------------------------------------\r
+HAEX MGL_EXPORT mgl_create_cexpr(const char *expr) { return new mglFormulaC(expr); }\r
+void MGL_EXPORT mgl_delete_cexpr(HAEX ex) { delete ex; }\r
+dual MGL_EXPORT mgl_cexpr_eval(HAEX ex, dual x, dual y,dual z)\r
+{ return ex->Calc(x,y,z); }\r
+dual MGL_EXPORT mgl_cexpr_eval_v(HAEX ex, dual *var)\r
+{ return ex->Calc(var); }\r
+//-----------------------------------------------------------------------------\r
/***************************************************************************
* evalp.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
//-----------------------------------------------------------------------------
std::wstring mgl_trim_ws(const std::wstring &str);
int mglFormulaError;
-mglData MGL_NO_EXPORT mglFormulaCalc(std::wstring string, mglParser *arg);
+mglData MGL_NO_EXPORT mglFormulaCalc(std::wstring string, mglParser *arg, const mglVar *head);
//-----------------------------------------------------------------------------
void mglApplyFunc(mglData &d, double (*func)(double))
{
for(long i=0;i<n;i++) d.a[i] = func(d.a[i]);
}
//-----------------------------------------------------------------------------
-mglData mglApplyOper(std::wstring a1, std::wstring a2, mglParser *arg, double (*func)(double,double))
+mglData mglApplyOper(std::wstring a1, std::wstring a2, mglParser *arg, const mglVar *head, double (*func)(double,double))
{
- const mglData &a = mglFormulaCalc(a1,arg), &b = mglFormulaCalc(a2,arg);
+ const mglData &a = mglFormulaCalc(a1,arg,head), &b = mglFormulaCalc(a2,arg,head);
long n = mgl_max(a.nx,b.nx), m = mgl_max(a.ny,b.ny), l = mgl_max(a.nz,b.nz);
mglData r(n, m, l);
if(b.nx*b.ny*b.nz==1)
dst[j] = 0;
}
//-----------------------------------------------------------------------------
+const mglVar *FindVar(const mglVar *head, std::wstring &name)
+{
+ const mglVar *v=head;
+ while(v)
+ {
+ if(v->s==name) return v;
+ v = v->next;
+ }
+ return 0;
+}
+//-----------------------------------------------------------------------------
/// Parse string and substitute the script argument
// All numbers are presented as mglData(1). Do boundary checking.
// NOTE: In any case where number is required the mglData::a[0] is used.
// String flag is binary 0x1 -> 'x', 0x2 -> 'y', 0x4 -> 'z'
// NOTE: the speed is not a goal (mglFormula is faster). It is true interpreter!
-mglData MGL_NO_EXPORT mglFormulaCalc(std::wstring str, mglParser *arg)
+mglData MGL_NO_EXPORT mglFormulaCalc(std::wstring str, mglParser *arg, const mglVar *head)
{
#if MGL_HAVE_GSL
gsl_set_error_handler_off();
#endif
mglData res;
if(str.empty() || mglFormulaError) return res; // nothing to parse
+ if(!head && arg) head = arg->DataList;
str = mgl_trim_ws(str);
long n,len=str.length();
if(str[0]=='(' && mglCheck(str.substr(1,len-2))) // remove braces
if(str[i]==']' && br>0) br--;
if(str[i]==',' && !br)
{
- a1=mglFormulaCalc(str.substr(j,i-j), arg);
+ a1=mglFormulaCalc(str.substr(j,i-j), arg, head);
if(j==1)
{ res = a1; ar = (a1.nx==1); mt = (a1.nx>1 && a1.ny==1); }
else
j=i+1;
}
}
- a1=mglFormulaCalc(str.substr(j,i-j), arg);
+ a1=mglFormulaCalc(str.substr(j,i-j), arg, head);
if(j==1)
{ res = a1; ar = (a1.nx==1); mt = (a1.nx>1 && a1.ny==1); }
else
n=mglFindInText(str,"&|"); // lowest priority -- logical
if(n>=0)
- return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, str[n]=='|'?cor:cand);
+ return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, str[n]=='|'?cor:cand);
n=mglFindInText(str,"<>="); // low priority -- conditions
if(n>=0)
- return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, str[n]=='<'?clt:(str[n]=='>'?cgt:ceq));
+ return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, str[n]=='<'?clt:(str[n]=='>'?cgt:ceq));
n=mglFindInText(str,"+-"); // normal priority -- additions
if(n>=0 && (n<2 || str[n-1]!='e' || (str[n-2]!='.' && !isdigit(str[n-2]))))
- return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, str[n]=='+'?add:sub);
+ return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, str[n]=='+'?add:sub);
n=mglFindInText(str,"*/"); // high priority -- multiplications
if(n>=0)
- return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, str[n]=='*'?mul:del);
+ return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, str[n]=='*'?mul:del);
n=mglFindInText(str,"@"); // high priority -- combine
if(n>=0)
- return mglFormulaCalc(str.substr(0,n),arg).Combine(mglFormulaCalc(str.substr(n+1),arg));
+ return mglFormulaCalc(str.substr(0,n),arg, head).Combine(mglFormulaCalc(str.substr(n+1),arg, head));
n=mglFindInText(str,"^"); // highest priority -- power
if(n>=0)
- return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, ipw);
+ return mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, ipw);
n=mglFindInText(str,":"); // highest priority -- array
if(n>=0 && str.compare(L":"))
{
- const mglData &a1=mglFormulaCalc(str.substr(0,n), arg);
- const mglData &a2=mglFormulaCalc(str.substr(n+1), arg);
+ const mglData &a1=mglFormulaCalc(str.substr(0,n), arg, head);
+ const mglData &a2=mglFormulaCalc(str.substr(n+1), arg, head);
res.Create(abs(int(a2.a[0]+0.5)-int(a1.a[0]+0.5))+1);
res.Fill(a1.a[0], a2.a[0]);
return res;
if(n>=0)
{
mreal x,y,z,k,v=NAN;
- mglData d = mglFormulaCalc(str.substr(0,n), arg);
+ mglData d = mglFormulaCalc(str.substr(0,n), arg, head);
const std::wstring &p=str.substr(n+1);
if(!p.compare(L"a")) v = d.a[0];
else if(!p.compare(L"fst")) { long i=-1,j=-1,l=-1; v = d.Find(0,i,j,l); }
else if(!p.compare(L"max")) v=d.Maximal();
else if(!p.compare(L"min")) v=d.Minimal();
else if(!p.compare(L"pmax")) { v=d.Maximal(); v = v>0?v:0; }
- else if(!p.compare(L"pmin")) { v=d.Minimal(); v = v>0?v:0; }
+ else if(!p.compare(L"pmin")) { v=d.MinimalPos(); }
+ else if(!p.compare(L"nmax")) { v=d.MaximalNeg(); }
+ else if(!p.compare(L"nmin")) { v=d.Minimal(); v = v<0?v:0; }
else if(!p.compare(L"sum")) v=d.Momentum('x',x,y);
else if(!p.compare(L"mx")) { d.Maximal(x,y,z); v=x/d.nx; }
else if(!p.compare(L"my")) { d.Maximal(x,y,z); v=y/d.ny; }
for(n=0;n<len;n++) if(str[n]=='(') break;
if(n>=len) // this is number or variable
{
- mglVar *v = arg->FindVar(str.c_str());
- mglNum *f = arg->FindNum(str.c_str());
+ const mglVar *v = FindVar(head, str);
+ mglNum *f = arg?arg->FindNum(str.c_str()):0;
if(v) res = v;
else if(f) res.a[0] = f->d;
else if(!str.compare(L"rnd")) res.a[0] = mgl_rnd();
{
std::wstring nm = str.substr(0,n);
str = str.substr(n+1,len-n-2); len -= n+2;
- mglVar *v = arg->FindVar(nm.c_str());
+ const mglVar *v = FindVar(head, nm);
+// mglVar *v = arg->FindVar(nm.c_str());
if(!v && !nm.compare(0,7,L"jacobi_")) nm = nm.substr(7);
if(v) // subdata
{
if(m>0)
{
str[m]=0;
- a1 = mglFormulaCalc(str.substr(0,m), arg);
- a2 = mglFormulaCalc(str.substr(m+1,n-m-1), arg);
- a3 = mglFormulaCalc(str.substr(n+1), arg);
+ a1 = mglFormulaCalc(str.substr(0,m), arg, head);
+ a2 = mglFormulaCalc(str.substr(m+1,n-m-1), arg, head);
+ a3 = mglFormulaCalc(str.substr(n+1), arg, head);
}
else
{
- a1 = mglFormulaCalc(str.substr(0,n), arg);
- a2 = mglFormulaCalc(str.substr(n+1), arg);
+ a1 = mglFormulaCalc(str.substr(0,n), arg, head);
+ a2 = mglFormulaCalc(str.substr(n+1), arg, head);
}
}
- else a1 = mglFormulaCalc(str, arg);
+ else a1 = mglFormulaCalc(str, arg, head);
res = v->SubData(a1,a2,a3);
}
}
else if(nm[0]=='a') // function
{
if(!nm.compare(L"asin"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,asin); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,asin); }
else if(!nm.compare(L"acos"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,acos); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,acos); }
else if(!nm.compare(L"atan"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,atan); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,atan); }
else if(!nm.compare(L"arg"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(n+1),str.substr(0,n),arg, atan2);
+ else res = mglApplyOper(str.substr(n+1),str.substr(0,n),arg, head, atan2);
}
else if(!nm.compare(L"abs"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,fabs); }
+ {
+ n=mglFindInText(str,",");
+ if(n<=0) { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,fabs); }
+ else res = mglApplyOper(str.substr(n+1),str.substr(0,n),arg, head, hypot);
+ }
#if MGL_HAVE_GSL
else if(!nm.compare(L"ai") || !nm.compare(L"airy_ai"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = gsl_sf_airy_Ai(res.a[i],GSL_PREC_SINGLE); }
else if(!nm.compare(L"airy_dai"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = gsl_sf_airy_Ai_deriv(res.a[i],GSL_PREC_SINGLE); }
else if(!nm.compare(L"airy_bi"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = gsl_sf_airy_Bi(res.a[i],GSL_PREC_SINGLE); }
else if(!nm.compare(L"airy_dbi"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = gsl_sf_airy_Bi_deriv(res.a[i],GSL_PREC_SINGLE); }
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_beta);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_beta);
}
else if(!nm.compare(L"bi"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = gsl_sf_airy_Bi(res.a[i],GSL_PREC_SINGLE); }
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Inu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Inu);
}
else if(!nm.compare(L"bessel_j"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Jnu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Jnu);
}
else if(!nm.compare(L"bessel_k"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Knu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Knu);
}
else if(!nm.compare(L"bessel_y"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Ynu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Ynu);
}
#endif
}
else if(nm[0]=='c')
{
if(!nm.compare(L"cos"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,cos); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,cos); }
else if(!nm.compare(L"cosh") || !nm.compare(L"ch"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,cosh); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,cosh); }
#if MGL_HAVE_GSL
else if(!nm.compare(L"ci"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_Ci); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_Ci); }
#endif
}
else if(nm[0]=='e')
{
if(!nm.compare(L"exp"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,exp); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,exp); }
#if MGL_HAVE_GSL
else if(!nm.compare(L"erf"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_erf); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_erf); }
// else if(!nm.compare(L"en")) Kod=EQ_EN; // NOTE: not supported
else if(!nm.compare(L"ee") || !nm.compare(L"elliptic_ec"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = gsl_sf_ellint_Ecomp(res.a[i],GSL_PREC_SINGLE); }
else if(!nm.compare(L"ek") || !nm.compare(L"elliptic_kc"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = gsl_sf_ellint_Kcomp(res.a[i],GSL_PREC_SINGLE); }
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gslEllE);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gslEllE);
}
else if(!nm.compare(L"elliptic_f"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gslEllF);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gslEllF);
}
else if(!nm.compare(L"ei"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_expint_Ei); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_expint_Ei); }
else if(!nm.compare(L"e1"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_expint_E1); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_expint_E1); }
else if(!nm.compare(L"e2"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_expint_E2); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_expint_E2); }
else if(!nm.compare(L"eta"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_eta); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_eta); }
else if(!nm.compare(L"ei3"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_expint_3); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_expint_3); }
#endif
}
else if(nm[0]=='l')
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, llg);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, llg);
}
else if(!nm.compare(L"lg"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,log10); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,log10); }
else if(!nm.compare(L"ln"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,log); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,log); }
#if MGL_HAVE_GSL
else if(!nm.compare(L"li2"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_dilog); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_dilog); }
else if(!nm.compare(L"legendre"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gslLegP);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gslLegP);
}
#endif
}
else if(nm[0]=='s')
{
if(!nm.compare(L"sqrt"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,sqrt); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,sqrt); }
else if(!nm.compare(L"sin"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,sin); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,sin); }
else if(!nm.compare(L"step"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++) res.a[i] = res.a[i]>0?1:0; }
else if(!nm.compare(L"sign"))
- { res=mglFormulaCalc(str, arg);
+ { res=mglFormulaCalc(str, arg, head);
#pragma omp parallel for
for(long i=0;i<res.nx*res.ny*res.nz;i++)
res.a[i] = res.a[i]>0?1:(res.a[i]<0?-1:0); }
else if(!nm.compare(L"sinh") || !nm.compare(L"sh"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,sinh); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,sinh); }
#if MGL_HAVE_GSL
else if(!nm.compare(L"si"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_Si); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_Si); }
else if(!nm.compare(L"sinc"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_sinc); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_sinc); }
#endif
}
else if(nm[0]=='t')
{
if(!nm.compare(L"tg") || !nm.compare(L"tan"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,tan); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,tan); }
else if(!nm.compare(L"tanh") || !nm.compare(L"th"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,tanh); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,tanh); }
}
else if(!nm.compare(L"pow"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, pow);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, pow);
}
else if(!nm.compare(L"mod"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, fmod);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, fmod);
}
else if(!nm.compare(L"int"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,floor); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,floor); }
#if MGL_HAVE_GSL
else if(!nm.compare(L"i"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Inu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Inu);
}
else if(!nm.compare(L"j"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Jnu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Jnu);
}
else if(!nm.compare(L"k"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Knu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Knu);
}
else if(!nm.compare(L"y"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gsl_sf_bessel_Ynu);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gsl_sf_bessel_Ynu);
}
else if(!nm.compare(L"f"))
{
n=mglFindInText(str,",");
if(n<=0) mglFormulaError=true;
- else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, gslEllF);
+ else res = mglApplyOper(str.substr(0,n),str.substr(n+1),arg, head, gslEllF);
+ }
+ else if(!nm.compare(L"hypot"))
+ {
+ n=mglFindInText(str,",");
+ if(n<=0) mglFormulaError=true;
+ else res = mglApplyOper(str.substr(n+1),str.substr(0,n),arg, head, hypot);
}
else if(!nm.compare(L"gamma"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_gamma); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_gamma); }
else if(!nm.compare(L"w0"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_lambert_W0); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_lambert_W0); }
else if(!nm.compare(L"w1"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_lambert_Wm1); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_lambert_Wm1); }
else if(!nm.compare(L"psi"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_psi); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_psi); }
else if(!nm.compare(L"zeta"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_zeta); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_zeta); }
else if(!nm.compare(L"z"))
- { res=mglFormulaCalc(str, arg); mglApplyFunc(res,gsl_sf_dawson); }
+ { res=mglFormulaCalc(str, arg, head); mglApplyFunc(res,gsl_sf_dawson); }
#endif
}
return res;
/***************************************************************************
* exec.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
#include <unistd.h>
#endif
+#include "mgl2/base.h"
#include "mgl2/parser.h"
#define iint(x) long((x)+0.5)
wchar_t *mgl_str_copy(const char *s);
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_ball(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_ball(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nn")) gr->Mark(mglPoint(a[0].v,a[1].v,NAN),"r.");
else if(!strcmp(k,"nns")) gr->Mark(mglPoint(a[0].v,a[1].v,NAN),a[2].s.c_str());
else if(!strcmp(k,"nnn")) gr->Mark(mglPoint(a[0].v,a[1].v,a[2].v),"r.");
else if(!strcmp(k,"nnns")) gr->Mark(mglPoint(a[0].v,a[1].v,a[2].v),a[3].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_box(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_box(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"")) gr->Box();
else if(!strcmp(k,"s")) gr->Box(a[0].s.c_str());
else if(!strcmp(k,"sn")) gr->Box(a[0].s.c_str(), a[1].v);
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_ohlc(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
if(!strcmp(k,"d")) gr->SetRange('c',*(a[0].d));
else if(!strcmp(k,"dn")) gr->SetRange('c',*(a[0].d),a[1].v);
else if(!strcmp(k,"nn")) gr->SetRange('c', a[0].v, a[1].v);
+ else if(!strcmp(k,"nnn"))
+ {
+ if(a[2].v) gr->AddRange('c', a[0].v, a[1].v);
+ else gr->SetRange('c', a[0].v, a[1].v);
+ }
else res = 1; return res;
}
//-----------------------------------------------------------------------------
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_colorbar(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_colorbar(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"")) gr->Colorbar();
else if(!strcmp(k,"s")) gr->Colorbar(a[0].s.c_str());
else if(!strcmp(k,"d")) gr->Colorbar(*(a[0].d));
else if(!strcmp(k,"dsnnn")) gr->Colorbar(*(a[0].d), a[1].s.c_str(), a[2].v, a[3].v, a[4].v,1);
else if(!strcmp(k,"dsnnnn"))
gr->Colorbar(*(a[0].d), a[1].s.c_str(), a[2].v, a[3].v, a[4].v,a[5].v);
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_copy(mglGraph *gr, long , mglArg *a, const char *k, const char *)
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_cone(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_cone(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnnnn")) gr->Cone(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v);
else if(!strcmp(k,"nnnnnnns")) gr->Cone(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v,-1, a[7].s.c_str());
else if(!strcmp(k,"nnnnnnnn")) gr->Cone(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v, a[7].v);
else if(!strcmp(k,"nnnnnnnns")) gr->Cone(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v, a[7].v, a[8].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_ellipse(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_ellipse(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnn"))
gr->Ellipse(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v,NAN), a[4].v);
else if(!strcmp(k,"nnnnns"))
gr->Ellipse(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v);
else if(!strcmp(k,"nnnnnnns"))
gr->Ellipse(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v, a[7].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_circle(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_circle(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnn")) gr->Circle(mglPoint(a[0].v,a[1].v, NAN), a[2].v);
else if(!strcmp(k,"nnns")) gr->Circle(mglPoint(a[0].v,a[1].v, NAN), a[2].v, a[3].s.c_str());
else if(!strcmp(k,"nnnn")) gr->Circle(mglPoint(a[0].v,a[1].v,a[2].v), a[3].v);
else if(!strcmp(k,"nnnns")) gr->Circle(mglPoint(a[0].v,a[1].v,a[2].v), a[3].v, a[4].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_rhomb(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_rhomb(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnn"))
gr->Rhomb(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v,NAN), a[4].v);
else if(!strcmp(k,"nnnnns"))
gr->Rhomb(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v);
else if(!strcmp(k,"nnnnnnns"))
gr->Rhomb(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v, a[7].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_dens(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_drop(mglGraph *gr, long n, mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_drop(mglGraph *gr, long n, mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnn"))
gr->Drop(mglPoint(a[0].v,a[1].v), mglPoint(a[2].v,a[3].v), a[4].v);
else if(!strcmp(k,"nnnnns"))
gr->Drop(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v, a[7].s.c_str(), a[8].v);
else if(!strcmp(k,"nnnnnnnsnn"))
gr->Drop(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].v, a[7].s.c_str(), a[8].v, a[9].v);
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_dew(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_line(mglGraph *gr, long n, mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_line(mglGraph *gr, long n, mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnn"))
gr->Line(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v,NAN));
else if(!strcmp(k,"nnnns"))
gr->Line(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v));
else if(!strcmp(k,"nnnnnns"))
gr->Line(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_errbox(mglGraph *gr, long n, mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_errbox(mglGraph *gr, long n, mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnn"))
gr->Error(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v,NAN));
else if(!strcmp(k,"nnnns"))
gr->Error(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v));
else if(!strcmp(k,"nnnnnns"))
gr->Error(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_legend(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_rect(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_rect(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnn"))
gr->Face(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[0].v,a[3].v,NAN),
mglPoint(a[2].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v,NAN));
mglPoint(a[3].v,a[4].v,a[5].v),
k[6]=='s' ? a[6].s.c_str() : 0);
}
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_face(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_face(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnnnnn"))
gr->Face(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v,NAN),
mglPoint(a[4].v,a[5].v,NAN), mglPoint(a[6].v,a[7].v,NAN));
else if(!strcmp(k,"nnnnnnnnnnnns"))
gr->Face(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v),
mglPoint(a[6].v,a[7].v,a[8].v), mglPoint(a[9].v,a[10].v,a[11].v), a[12].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_resize(mglGraph *, long , mglArg *a, const char *k, const char *)
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_sphere(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_sphere(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnn")) gr->Sphere(mglPoint(a[0].v,a[1].v), a[2].v);
else if(!strcmp(k,"nnns")) gr->Sphere(mglPoint(a[0].v,a[1].v), a[2].v, a[3].s.c_str());
else if(!strcmp(k,"nnnn")) gr->Sphere(mglPoint(a[0].v,a[1].v,a[2].v), a[3].v);
else if(!strcmp(k,"nnnns")) gr->Sphere(mglPoint(a[0].v,a[1].v,a[2].v), a[3].v, a[4].s.c_str());
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_stfa(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_title(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_title(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"s")) gr->Title(a[0].w.c_str());
else if(!strcmp(k,"ss")) gr->Title(a[0].w.c_str(), a[1].s.c_str());
else if(!strcmp(k,"ssn")) gr->Title(a[0].w.c_str(), a[1].s.c_str(),a[2].v);
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_column(mglGraph *, long , mglArg *a, const char *k, const char *)
int MGL_NO_EXPORT mgls_text(mglGraph *gr, long , mglArg *a, const char *k, const char *opt) // NOTE don't use options -- Puts can be part of group
{
int res=0;
- if(!strcmp(k,"nns")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN),a[2].w.c_str());
- else if(!strcmp(k,"nnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN),a[2].w.c_str(), a[3].s.c_str());
- else if(!strcmp(k,"nnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN),a[2].w.c_str(), a[3].s.c_str(),a[4].v);
- else if(!strcmp(k,"nnns")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v),a[3].w.c_str());
- else if(!strcmp(k,"nnnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v),a[3].w.c_str(), a[4].s.c_str());
- else if(!strcmp(k,"nnnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v),a[3].w.c_str(), a[4].s.c_str(),a[5].v);
- else if(!strcmp(k,"nnnns")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v), a[4].w.c_str());
- else if(!strcmp(k,"nnnnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v), a[4].w.c_str(), a[5].s.c_str());
- else if(!strcmp(k,"nnnnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v), a[4].w.c_str(), a[5].s.c_str(),a[6].v);
- else if(!strcmp(k,"nnnnnns")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].w.c_str());
- else if(!strcmp(k,"nnnnnnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].w.c_str(), a[7].s.c_str());
- else if(!strcmp(k,"nnnnnnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].w.c_str(), a[7].s.c_str(),a[8].v);
+ if(k[0]=='n')
+ {
+ gr->Self()->SaveState(opt);
+ if(!strcmp(k,"nns")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN),a[2].w.c_str());
+ else if(!strcmp(k,"nnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN),a[2].w.c_str(), a[3].s.c_str());
+ else if(!strcmp(k,"nnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN),a[2].w.c_str(), a[3].s.c_str(),a[4].v);
+ else if(!strcmp(k,"nnns")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v),a[3].w.c_str());
+ else if(!strcmp(k,"nnnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v),a[3].w.c_str(), a[4].s.c_str());
+ else if(!strcmp(k,"nnnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v),a[3].w.c_str(), a[4].s.c_str(),a[5].v);
+ else if(!strcmp(k,"nnnns")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v), a[4].w.c_str());
+ else if(!strcmp(k,"nnnnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v), a[4].w.c_str(), a[5].s.c_str());
+ else if(!strcmp(k,"nnnnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,NAN), mglPoint(a[2].v,a[3].v), a[4].w.c_str(), a[5].s.c_str(),a[6].v);
+ else if(!strcmp(k,"nnnnnns")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].w.c_str());
+ else if(!strcmp(k,"nnnnnnss")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].w.c_str(), a[7].s.c_str());
+ else if(!strcmp(k,"nnnnnnssn")) gr->Putsw(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v), a[6].w.c_str(), a[7].s.c_str(),a[8].v);
+ else res=1;
+ gr->Self()->LoadState();
+ }
else if(!strcmp(k,"ds")) gr->Text(*(a[0].d),a[1].w.c_str(),"",opt);
else if(!strcmp(k,"dss")) gr->Text(*(a[0].d),a[1].w.c_str(),a[2].s.c_str(),opt);
else if(!strcmp(k,"dds")) gr->Text(*(a[0].d),*(a[1].d),a[2].w.c_str(),"",opt);
if(!strcmp(k,"d")) gr->SetRange('x',*(a[0].d));
else if(!strcmp(k,"dn")) gr->SetRange('x',*(a[0].d),a[1].v);
else if(!strcmp(k,"nn")) gr->SetRange('x', a[0].v, a[1].v);
+ else if(!strcmp(k,"nnn"))
+ {
+ if(a[2].v) gr->AddRange('x', a[0].v, a[1].v);
+ else gr->SetRange('x', a[0].v, a[1].v);
+ }
else res = 1; return res;
}
//-----------------------------------------------------------------------------
if(!strcmp(k,"d")) gr->SetRange('y',*(a[0].d));
else if(!strcmp(k,"dn")) gr->SetRange('y',*(a[0].d),a[1].v);
else if(!strcmp(k,"nn")) gr->SetRange('y', a[0].v, a[1].v);
+ else if(!strcmp(k,"nnn"))
+ {
+ if(a[2].v) gr->AddRange('y', a[0].v, a[1].v);
+ else gr->SetRange('y', a[0].v, a[1].v);
+ }
else res = 1; return res;
}
//-----------------------------------------------------------------------------
if(!strcmp(k,"d")) gr->SetRange('z',*(a[0].d));
else if(!strcmp(k,"dn")) gr->SetRange('z',*(a[0].d),a[1].v);
else if(!strcmp(k,"nn")) gr->SetRange('z', a[0].v, a[1].v);
+ else if(!strcmp(k,"nnn"))
+ {
+ if(a[2].v) gr->AddRange('z', a[0].v, a[1].v);
+ else gr->SetRange('z', a[0].v, a[1].v);
+ }
else res = 1; return res;
}
//-----------------------------------------------------------------------------
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_facex(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_facex(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnn")) gr->FaceX(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v);
else if(!strcmp(k,"nnnnns")) gr->FaceX(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v, a[5].s.c_str());
else if(!strcmp(k,"nnnnnsnn")) gr->FaceX(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v, a[5].s.c_str(),a[6].v,a[7].v);
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_facey(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_facey(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnn")) gr->FaceY(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v);
else if(!strcmp(k,"nnnnns")) gr->FaceY(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v, a[5].s.c_str());
else if(!strcmp(k,"nnnnnsnn")) gr->FaceY(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v, a[5].s.c_str(),a[6].v,a[7].v);
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_facez(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_facez(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nnnnn")) gr->FaceZ(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v);
else if(!strcmp(k,"nnnnns")) gr->FaceZ(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v, a[5].s.c_str());
else if(!strcmp(k,"nnnnnsnn")) gr->FaceZ(mglPoint(a[0].v, a[1].v, a[2].v), a[3].v, a[4].v, a[5].s.c_str(),a[6].v,a[7].v);
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_normsl(mglGraph *, long , mglArg *a, const char *k, const char *)
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_putsfit(mglGraph *gr, long , mglArg *a, const char *k, const char *)
+int MGL_NO_EXPORT mgls_putsfit(mglGraph *gr, long , mglArg *a, const char *k, const char *opt)
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
if(!strcmp(k,"nn")) gr->PutsFit(mglPoint(a[0].v,a[1].v));
else if(!strcmp(k,"nns")) gr->PutsFit(mglPoint(a[0].v,a[1].v), a[2].s.c_str());
else if(!strcmp(k,"nnss")) gr->PutsFit(mglPoint(a[0].v,a[1].v), a[2].s.c_str(),a[3].s.c_str());
else if(!strcmp(k,"nnns")) gr->PutsFit(mglPoint(a[0].v,a[1].v,a[2].v), a[3].s.c_str());
else if(!strcmp(k,"nnnss")) gr->PutsFit(mglPoint(a[0].v,a[1].v,a[2].v), a[3].s.c_str(),a[4].s.c_str());
else if(!strcmp(k,"nnnssn"))gr->PutsFit(mglPoint(a[0].v,a[1].v,a[2].v), a[3].s.c_str(),a[4].s.c_str(),a[5].v);
- else res = 1;
- return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_arrowsize(mglGraph *gr, long , mglArg *a, const char *k, const char *)
else res = 1; return res;
}
//-----------------------------------------------------------------------------
-int MGL_NO_EXPORT mgls_fgets(mglGraph *gr, long , mglArg *a, const char *k, const char *) // NOTE don't use options -- Puts can be part of group
+int MGL_NO_EXPORT mgls_fgets(mglGraph *gr, long , mglArg *a, const char *k, const char *opt) // NOTE don't use options -- Puts can be part of group
{
- int res=0;
+ int res=0; gr->Self()->SaveState(opt);
char buf[1024];
FILE *fp;
if(!strncmp(k,"nns",3))
fclose(fp);
gr->Puts(mglPoint(a[0].v,a[1].v,a[2].v),buf, (k[5]=='s')?a[5].s.c_str():"", k[6]=='n'?a[6].v:-1);
}
- else res = 1; return res;
+ else res = 1; gr->Self()->LoadState(); return res;
}
//-----------------------------------------------------------------------------
int MGL_NO_EXPORT mgls_import(mglGraph *gr, long , mglArg *a, const char *k, const char *)
*(a[0].d) = gr->PDE(a[1].s.c_str(), *(a[2].d), *(a[3].d), a[4].v,100,opt);
else if(!strcmp(k,"dsddnn"))
*(a[0].d) = gr->PDE(a[1].s.c_str(), *(a[2].d), *(a[3].d), a[4].v,a[5].v,opt);
+ else if(!strcmp(k,"ddsdd"))
+ {
+ HADT res = mgl_pde_solve_c(gr->Self(),a[2].s.c_str(), a[3].d, a[4].d, 0.1,100,opt);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsddn"))
+ {
+ HADT res = mgl_pde_solve_c(gr->Self(),a[2].s.c_str(), a[3].d, a[4].d, a[5].v,100,opt);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsddnn"))
+ {
+ HADT res = mgl_pde_solve_c(gr->Self(),a[2].s.c_str(), a[3].d, a[4].d, a[5].v,a[6].v,opt);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
else res = 1; return res;
}
//-----------------------------------------------------------------------------
*(a[0].d) = mglData(true, mgl_qo2d_solve(a[1].s.c_str(), a[2].d, a[3].d, a[4].d, a[5].v,a[6].v, 0,0));
else if(!strcmp(k,"dsdddnndd"))
*(a[0].d) = mglData(true, mgl_qo2d_solve(a[1].s.c_str(), a[2].d, a[3].d, a[4].d, a[5].v,a[6].v, a[7].d,a[8].d));
+ else if(!strcmp(k,"ddsddd"))
+ {
+ HADT res = mgl_qo2d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, 1,100, 0,0);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsdddn"))
+ {
+ HADT res = mgl_qo2d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, a[6].v,100, 0,0);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsdddnn"))
+ {
+ HADT res = mgl_qo2d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, a[6].v,a[7].v, 0,0);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsdddnndd"))
+ {
+ HADT res = mgl_qo2d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, a[6].v,a[7].v, a[8].d,a[9].d);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
else res = 1; return res;
}
//-----------------------------------------------------------------------------
*(a[0].d) = mglData(true, mgl_qo3d_solve(a[1].s.c_str(), a[2].d, a[3].d, a[4].d, a[5].v,a[6].v, 0,0,0));
else if(!strcmp(k,"dsdddnnddd"))
*(a[0].d) = mglData(true, mgl_qo3d_solve(a[1].s.c_str(), a[2].d, a[3].d, a[4].d, a[5].v,a[6].v, a[7].d,a[8].d,a[9].d));
+ else if(!strcmp(k,"ddsddd"))
+ {
+ HADT res = mgl_qo3d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, 1,100, 0,0,0);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsdddn"))
+ {
+ HADT res = mgl_qo3d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, a[6].v,100, 0,0,0);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsdddnn"))
+ {
+ HADT res = mgl_qo3d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, a[6].v,a[7].v, 0,0,0);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
+ else if(!strcmp(k,"ddsdddnnddd"))
+ {
+ HADT res = mgl_qo3d_solve_c(a[2].s.c_str(), a[3].d, a[4].d, a[5].d, a[6].v,a[7].v, a[8].d,a[9].d,a[10].d);
+ *(a[0].d) = res->Abs(); *(a[1].d) = res->Arg();
+ }
else res = 1; return res;
}
//-----------------------------------------------------------------------------
{"copy","Copy data from another variable","copy Dat1 Dat2 ['eq' onaxis]", mgls_copy ,4},
{"correl", "Find correlation between data arrays", "correl Res Adat Bdat 'dir'", mgls_correl ,4},
{"cosfft","Cos-Fourier transform at some direction","cosfft Dat 'dir'", mgls_cosfft ,16},
- {"crange","Set color range","crange Dat [sym] | c1 c2", mgls_crange ,14},
+ {"crange","Set color range","crange Dat [add] | c1 c2 [add]", mgls_crange ,14},
{"crop","Crop edge of data","crop Dat n1 n2 'dir'", mgls_crop ,16},
{"crust","Draw reconstructed surface for arbitrary data points","crust Xdat Ydat Zdat ['fmt']", mgls_crust ,0},
{"ctick","Set ticks for colorbar","ctick 'tmpl' | dx", mgls_ctick ,14},
{"view","Change view angles - use 'rotate' for plot rotation","view tetz tetx [tety]", mgls_view ,5},
{"write","Write current image to graphical file","write 'fname' [solid]", mgls_write ,2},
{"xlabel","Draw label for x-axis","xlabel 'txt' [pos]", mgls_xlabel ,12},
- {"xrange","Set range for x-axis","xrange Dat [add] | x1 x2", mgls_xrange ,14},
+ {"xrange","Set range for x-axis","xrange Dat [add] | x1 x2 [add]", mgls_xrange ,14},
{"xtick","Set ticks for x-axis","xtick dx [sx tx] | 'tmpl' | Xdat 'lbl' [add] | v1 'lbl1' ...", mgls_xtick,14},
{"ylabel","Draw label for y-axis","ylabel 'txt' [pos]", mgls_ylabel,12},
- {"yrange","Set range for y-axis","yrange Dat [add] | y1 y2", mgls_yrange,14},
+ {"yrange","Set range for y-axis","yrange Dat [add] | y1 y2 [add]", mgls_yrange,14},
{"ytick","Set ticks for y-axis","ytick dy [sy ty] | 'tmpl' | Ydat 'lbl' [add] | v1 'lbl1' ...", mgls_ytick,14},
{"zlabel","Draw label for z-axis","zlabel 'txt' [pos]", mgls_zlabel,12},
{"zoom","Zoom plot region","zoom x1 x2 y1 y2", mgls_zoom,5},
{"zoomaxis","Zoom axis range","zoomaxis x1 x2|x1 x2 y1 y2|x1 x2 y1 y2 z1 z2|x1 x2 y1 y2 z1 z2 c1 c2", mgls_zoomaxis,14},
- {"zrange","Set range for z-axis","yrange Dat [add] | z1 z2", mgls_zrange ,14},
+ {"zrange","Set range for z-axis","yrange Dat [add] | z1 z2 [add]", mgls_zrange ,14},
{"ztick","Set ticks for z-axis","ztick dz [sz tz] | 'tmpl' | Zdat 'lbl' [add] | v1 'lbl1' ...", mgls_ztick,14},
{"","","",NULL,0}};
//-----------------------------------------------------------------------------
/***************************************************************************
* export.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
/***************************************************************************
* export_2d.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
/***************************************************************************\r
* export_3d.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
for(long i=0;i<l;i++)\r
{\r
const mglPnt &q=Pnt[i];\r
- tmp[i] = mgl_sprintf("[%ld,%ld,%ld]%c\n", long(factor*q.xx), long(factor*(Height-q.yy)), long(factor*q.zz), i+1<l?',':' ');\r
+ tmp[i] = mgl_sprintf("[%ld,%ld,%ld,%d]%c\n", long(factor*q.xx), long(factor*(Height-q.yy)), long(factor*q.zz),q.sub, i+1<l?',':' ');\r
ll += tmp[i].length();\r
}\r
res.reserve(ll);\r
for(ll=i=0;i<l;i++)\r
{ mglRGBA c; c.c = GetPrmCol(i); if(c.r[3]) ll++; }\r
\r
- res = res + mgl_sprintf("],\t\"nprim\":%ld,\t\"prim\":[\n",ll);\r
+ res = res + mgl_sprintf("],\t\"nprim\":%ld,\t\"prim\":[\n",ll+1);\r
\r
std::vector<mglPoint> xy; // vector for glyphs coordinates (to be separated from pnts)\r
- res.reserve(60*ll);\r
+ res.reserve(60*(ll+1));\r
#pragma omp parallel for private(buf)\r
for(long i=0;i<l;i++)\r
{\r
#pragma omp critical\r
res += buf;\r
}\r
- res += "[0,0,0,0,0,0,0,0,0,0,\"#000000\"]\n"; // need to add this empty block\r
+ res += "[-1,0,0,0,0,0,0,0,0,0,\"#000000\"]\n"; // need to add this empty block\r
\r
l = (long)xy.size();\r
res = res + mgl_sprintf("],\t\"ncoor\":%lu,\t\"coor\":[\n",(unsigned long)l);\r
/***************************************************************************
* fft.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
void MGL_EXPORT mgl_fft_free_thr(void *ws)
{
#if MGL_HAVE_GSL
- gsl_fft_complex_workspace_free((gsl_fft_complex_workspace*)ws);
+ if(ws) gsl_fft_complex_workspace_free((gsl_fft_complex_workspace*)ws);
#else
- delete []((double*)ws);
+ if(ws) delete []((double*)ws);
#endif
}
//-----------------------------------------------------------------------------
{
if(ws && nthr>0) for(long i=0;i<nthr;i++) mgl_fft_free_thr(ws[i]);
#if MGL_HAVE_GSL
- gsl_fft_complex_wavetable_free((gsl_fft_complex_wavetable*)wt);
+ if(wt) gsl_fft_complex_wavetable_free((gsl_fft_complex_wavetable*)wt);
#else
- delete []((double*)wt);
+ if(wt) delete []((double*)wt);
#endif
}
//-----------------------------------------------------------------------------
/***************************************************************************\r
* fit.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* font.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* obj.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
//-----------------------------------------------------------------------------\r
void mglCanvasGL::gl_clf(mglColor Back)\r
{\r
- if(Back!=NC) Back = WC;\r
+ if(Back==NC) Back = WC;\r
// glDepthFunc(GL_LESS);\r
glDepthFunc(GL_GREATER);\r
// back[0]=Back.r; back[1]=Back.g; back[2]=Back.b;\r
/***************************************************************************\r
* other.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont_x_val(gr,&v,a,sch,sv,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont_y(HMGL gr, HCDT a, const char *sch, double sv, const char *opt)\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont_y_val(gr,&v,a,sch,sv,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont_z(HMGL gr, HCDT a, const char *sch, double sv, const char *opt)\r
mglData v(Num);\r
for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont_z_val(gr,&v,a,sch,sv,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cont_x_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf_x_val(gr,&v,a,sch,sv,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf_y(HMGL gr, HCDT a, const char *sch, double sv, const char *opt)\r
long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf_y_val(gr,&v,a,sch,sv,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf_z(HMGL gr, HCDT a, const char *sch, double sv, const char *opt)\r
long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf_z_val(gr,&v,a,sch,sv,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_contf_x_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
/***************************************************************************
* parse.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
for(i=0;i<n;i++)
{
k += id[a[i].type];
- a[i].s.assign(a[i].w.begin(),a[i].w.end());
+ size_t len = wcstombs(NULL,a[i].w.c_str(),0)+1;
+ char *buf = new char[len]; memset(buf,0,len);
+ wcstombs(buf,a[i].w.c_str(),len);
+ a[i].s = buf; delete []buf;
}
mglCommand *rts=FindCommand(com);
if(!rts || rts->type==6) return 2;
}
//-----------------------------------------------------------------------------
// convert substrings to arguments
-mglData MGL_NO_EXPORT mglFormulaCalc(std::wstring str, mglParser *arg);
+mglData MGL_NO_EXPORT mglFormulaCalc(std::wstring str, mglParser *arg, const mglVar *head);
void mglParser::FillArg(mglGraph *gr, int k, std::wstring *arg, mglArg *a)
{
register long n;
for(;i<ll && w[i]!='\'';i++);
if(i>i1)
{
- mglData d = mglFormulaCalc(w.substr(i1,i-i1-(w[i]=='\''?1:0)), this);
+ mglData d = mglFormulaCalc(w.substr(i1,i-i1-(w[i]=='\''?1:0)), this, DataList);
mglprintf(buf,32,L"%g",d.a[0]); a[n-1].w += buf;
}
}
{ a[n-1].type=2; a[n-1].d=0; a[n-1].v=f->d; a[n-1].w = f->s; }
else
{ // parse all numbers and formulas by unified way
- mglData d = mglFormulaCalc(arg[n], this);
+ mglData d = mglFormulaCalc(arg[n], this, DataList);
if(d.nx*d.ny*d.nz==1)
{ a[n-1].type = 2; a[n-1].v = d.a[0]; }
else
if(s[0]=='$' && nn>=0 && nn<='z'-'a'+10)
{
res = 0;
- d = mglFormulaCalc(mgl_trim_ws(s.substr(2)), this).a[0];
+ d = mglFormulaCalc(mgl_trim_ws(s.substr(2)), this, DataList).a[0];
char buf[32]; snprintf(buf,32,"%g",d); AddParam(nn, buf);
}
return res+1;
if(s[0]=='$' && nn>=0 && nn<='z'-'a'+10)
{
res = 0;
- d=mglFormulaCalc(mgl_trim_ws(s.substr(2)), this).a[0];
+ d=mglFormulaCalc(mgl_trim_ws(s.substr(2)), this, DataList).a[0];
wchar_t buf[2]={0,0}; buf[0] = wchar_t(d); AddParam(nn, buf);
}
return res+1;
if(k==3)
{
mglNum *v=AddNum(arg[1].c_str());
- v->d = mglFormulaCalc(arg[2],this).a[0];
+ v->d = mglFormulaCalc(arg[2],this, DataList).a[0];
}
delete []a; return k==3?0:1;
}
int mglParser::ParseDat(mglGraph *gr, std::wstring str, mglData &res)
{
std::wstring arg[32];
- mgl_trim_ws(str);
+ str = mgl_trim_ws(str);
long n,k=0;
for(k=0;k<32;k++) // parse string to substrings (by spaces)
{
n = mglFindArg(str);
if(n<1) { if(n<0) str=str.substr(0,-n); break; }
arg[k] = str.substr(0,n);// k++;
- str = str.substr(n+1); mgl_trim_ws(str);
+ str = str.substr(n+1); str = mgl_trim_ws(str);
}
// try to find last argument
if(!str.empty()) { arg[k] = str; k++; }
return d;
}
HMDT MGL_EXPORT mgl_parser_calcw(HMPR pr, const wchar_t *formula)
-{ mglData *d = new mglData(mglFormulaCalc(formula,pr)); return d; }
+{ mglData *d = new mglData(mglFormulaCalc(formula,pr, pr->DataList)); return d; }
uintptr_t MGL_EXPORT mgl_parser_calc_(uintptr_t *p, const char *str,int l)
{ char *s=new char[l+1]; memcpy(s,str,l); s[l]=0;
uintptr_t d = (uintptr_t)mgl_parser_calc(_PR_, s); delete []s; return d; }
/***************************************************************************\r
* pde.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
#include "mgl2/data.h"\r
+#include "mgl2/datac.h"\r
#include "mgl2/eval.h"\r
#include "mgl2/thread.h"\r
#include "mgl2/base.h"\r
}\r
return 0;\r
}\r
+//-----------------------------------------------------------------------------\r
// Solve equation dx/dz = func(p,q,x,y,z,|u|)[u] where p=d/dx, q=d/dy. At this moment simplified form of ham is supported: ham = f(p,q,z) + g(x,y,z,'u'), where variable 'u'=|u| (for allowing solve nonlinear problems). You may specify imaginary part like ham = p^2 + i*x*(x>0) but only if dependence on variable 'i' is linear (i.e. ham = hre+i*him).\r
-HMDT MGL_EXPORT mgl_pde_solve(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, mreal dz, mreal k0, const char *opt)\r
+HADT MGL_EXPORT mgl_pde_solve_c(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, mreal dz, mreal k0, const char *opt)\r
{\r
gr->SaveState(opt);\r
mglPoint Min=gr->Min, Max=gr->Max;\r
{ gr->SetWarn(mglWarnLow,"PDE"); return 0; }\r
if(ini_im->GetNx()*ini_im->GetNy() != nx*ny)// Wrong dimensions\r
{ gr->SetWarn(mglWarnDim,"PDE"); return 0; }\r
- mglData *res=new mglData(nz, nx, ny);\r
+ mglDataC *res=new mglDataC(nz, nx, ny);\r
\r
mglFormula eqs(ham);\r
dual *a = new dual[4*nx*ny], hh0; // Add "damping" area\r
{\r
register long i0 = i+nx/2+2*nx*(j+ny/2);\r
a[i0] = dual(ini_re->v(i,j), ini_im->v(i,j));\r
- res->a[nz*(i+nx*j)] = abs(a[i0]);\r
+ res->a[nz*(i+nx*j)] = a[i0];\r
}\r
#pragma omp parallel for collapse(2)\r
for(long j=0;j<2*ny;j++) for(long i=0;i<2*nx;i++) // step 1\r
double dd = k0*dz;\r
\r
mgl_pde_ham tmp;tmp.eqs = &eqs;\r
- tmp.nx = nx; tmp.ny = ny; tmp.a=a; tmp.hxy=hxy;\r
- tmp.hxv=hxv; tmp.huy=huy; tmp.huv=huv; tmp.dd = dd;\r
+ tmp.nx = nx; tmp.ny = ny; tmp.dd = dd; tmp.a=a;\r
+ tmp.hxy=hxy; tmp.hxv=hxv; tmp.huy=huy; tmp.huv=huv;\r
tmp.xx = Min.x-dx*(nx/2); tmp.xs = xs; tmp.dx = dx; tmp.dp = dp;\r
tmp.yy = Min.y-dy*(ny/2); tmp.ys = ys; tmp.dy = dy; tmp.dq = dq;\r
\r
// prepare fft. NOTE: slow procedures due to unknown nx, ny.\r
- void *wsx, *wtx = mgl_fft_alloc(2*nx,&wsx,1);\r
- void *wsy, *wty = mgl_fft_alloc(2*ny,&wsy,1);\r
+ void *wtx = mgl_fft_alloc(2*nx,0,0);\r
+ void *wty = mgl_fft_alloc(2*ny,0,0);\r
for(long k=1;k<nz;k++)\r
{\r
if(gr->Stop) continue;\r
#pragma omp parallel for\r
for(long j=0;j<2*ny;j++) { hy[j] = huy[2*nx*j]; hv[j] = huv[2*nx*j];}\r
// rearrange arrays\r
- hh0=hu[0]/2.;\r
+ hh0=hu[0];\r
if(ny>1)\r
#pragma omp parallel for collapse(2)\r
for(long i=0;i<2*nx;i++) for(long j=0;j<2*ny;j++)\r
{\r
- register long i0 = i+2*nx*j;\r
- huy[i0] -= (hu[i]+hy[j]-hh0)/2.; huv[i0] -= (hu[i]+hv[j]-hh0)/2.;\r
- hxy[i0] -= (hx[i]+hy[j]-hh0)/2.; hxv[i0] -= (hx[i]+hv[j]-hh0)/2.;\r
+ register long i0 = i+2*nx*j; huv[i0] -= hh0;\r
+ hxv[i0] -= hx[i]+hv[j]-hh0;\r
+ huy[i0] -= hu[i]+hy[j]-hh0;\r
}\r
- // solve equation\r
-#pragma omp parallel for\r
- for(long i=0;i<4*nx*ny;i++) a[i] *= exp(hxy[i])*exp(-double(dmp[i]*dz));\r
-//#pragma omp parallel for // NOTE I need separate wsx for each thread, but it is too slow to allocate/dealocate it each step\r
- for(long i=0;i<2*ny;i++) mgl_fft((double *)(a+i*2*nx), 1, 2*nx, wtx, wsx, false);\r
+ else\r
#pragma omp parallel for\r
- for(long i=0;i<4*nx*ny;i++) a[i] *= exp(huy[i]);\r
+ for(long i=0;i<4*nx*ny;i++) huv[i] -= hh0;\r
+ // solve equation\r
if(ny>1)\r
-//#pragma omp parallel for\r
+#pragma omp parallel\r
+ {\r
+ void *wsx = mgl_fft_alloc_thr(2*nx), *wsy = mgl_fft_alloc_thr(2*ny);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*ny;i++) a[i] *= exp(hxy[i])*exp(-double(dmp[i]*dz));\r
+#pragma omp for\r
+ for(long i=0;i<2*ny;i++) mgl_fft((double *)(a+i*2*nx), 1, 2*nx, wtx, wsx, false);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*ny;i++) a[i] *= exp(huy[i]);\r
+#pragma omp for\r
for(long i=0;i<2*nx;i++) mgl_fft((double *)(a+i), 2*nx, 2*ny, wty, wsy, false);\r
-#pragma omp parallel for\r
- for(long i=0;i<4*nx*ny;i++) a[i] *= exp(huv[i]);\r
-//#pragma omp parallel for\r
- for(long i=0;i<2*ny;i++) mgl_fft((double *)(a+2*i*nx), 1, 2*nx, wtx, wsx, true);\r
-#pragma omp parallel for\r
- for(long i=0;i<4*nx*ny;i++) a[i] *= exp(hxv[i]);\r
- if(ny>1)\r
-//#pragma omp parallel for\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*ny;i++) a[i] *= exp(huv[i]);\r
+#pragma omp for\r
+ for(long i=0;i<2*ny;i++) mgl_fft((double *)(a+2*i*nx), 1, 2*nx, wtx, wsx, true);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*ny;i++) a[i] *= exp(hxv[i]);\r
+#pragma omp for\r
for(long i=0;i<2*nx;i++) mgl_fft((double *)(a+i), 2*nx, 2*ny, wty, wsy, true);\r
-#pragma omp parallel for collapse(2)\r
- for(long i=0;i<nx;i++) for(long j=0;j<ny;j++) // save result\r
+ mgl_fft_free_thr(wsx); mgl_fft_free_thr(wsy);\r
+ }\r
+ else\r
+#pragma omp parallel\r
{\r
- register long i0 = i+nx/2+2*nx*(j+ny/2);\r
- res->a[k+nz*(i+nx*j)] = abs(a[i0]);\r
+ void *wsx = mgl_fft_alloc_thr(2*nx);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*ny;i++) a[i] *= exp(hxy[i])*exp(-double(dmp[i]*dz));\r
+#pragma omp for\r
+ for(long i=0;i<2*ny;i++) mgl_fft((double *)(a+i*2*nx), 1, 2*nx, wtx, wsx, false);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*ny;i++) a[i] *= exp(huv[i]);\r
+#pragma omp for\r
+ for(long i=0;i<2*ny;i++) mgl_fft((double *)(a+2*i*nx), 1, 2*nx, wtx, wsx, true);\r
+ mgl_fft_free_thr(wsx);\r
}\r
+#pragma omp parallel for collapse(2)\r
+ for(long i=0;i<nx;i++) for(long j=0;j<ny;j++) // save result\r
+ res->a[k+nz*(i+nx*j)] = a[i+nx/2+2*nx*(j+ny/2)];\r
}\r
- mgl_fft_free(wtx,&wsx,1); mgl_fft_free(wty,&wsy,1);\r
+ mgl_fft_free(wtx,0,0); mgl_fft_free(wty,0,0);\r
delete []a; delete []dmp;\r
delete []hxy; delete []hxv; delete []huy; delete []huv;\r
delete []hx; delete []hy; delete []hu; delete []hv;\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_pde_solve(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, mreal dz, mreal k0, const char *opt)\r
+{\r
+ HADT res = mgl_pde_solve_c(gr,ham,ini_re,ini_im,dz,k0,opt);\r
+ HMDT out = mgl_datac_abs(res); delete res; return out;\r
+}\r
+//-----------------------------------------------------------------------------\r
HMDT MGL_EXPORT mgl_ode_solve(void (*func)(const mreal *x, mreal *dx, void *par), int n, mreal *x0, mreal dt, mreal tmax, void *par)\r
{\r
if(tmax<dt) return 0; // nothing to do\r
return 0;\r
}\r
//-----------------------------------------------------------------------------\r
-HMDT MGL_EXPORT mgl_qo2d_func(dual (*ham)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy)\r
+HADT MGL_EXPORT mgl_qo2d_func_c(dual (*ham)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy)\r
{\r
const mglData *ray=dynamic_cast<const mglData *>(ray_dat); // NOTE: Ray must be mglData!\r
if(!ray) return 0;\r
long nx=ini_re->GetNx(), nt=ray->ny, n7=ray->nx;\r
if(nx<2 || ini_im->GetNx()!=nx || nt<2) return 0;\r
- mglData *res=new mglData(nx,nt,1);\r
+ mglDataC *res=new mglDataC(nx,nt,1);\r
\r
dual *a=new dual[2*nx], *hu=new dual[2*nx], *hx=new dual[2*nx];\r
double *dmp=new double[2*nx];\r
{\r
#pragma omp parallel for\r
for(long i=0;i<nx;i++) // "save"\r
- res->a[i+k*nx]=abs(a[i+nx/2])*sqrt(ra[0].ch/ra[k].ch);\r
+ res->a[i+k*nx]=a[i+nx/2]*sqrt(ra[0].ch/ra[k].ch);\r
if(xx && yy)\r
#pragma omp parallel for\r
for(long i=0;i<nx;i++) // prepare xx, yy\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_qo2d_func(dual (*ham)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy)\r
+{\r
+ HADT res = mgl_qo2d_func_c(ham,par,ini_re,ini_im,ray_dat,r,k0,xx,yy);\r
+ HMDT out = mgl_datac_abs(res); delete res; return out;\r
+}\r
+//-----------------------------------------------------------------------------\r
dual MGL_NO_EXPORT mgl_ham2d(mreal u, mreal x, mreal y, mreal px, mreal py, void *par)\r
{\r
mglFormula *h = (mglFormula *)par;\r
return dual(h->Calc(var), -h->CalcD(var,'i'));\r
}\r
//-----------------------------------------------------------------------------\r
-HMDT MGL_EXPORT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy)\r
+HADT MGL_EXPORT mgl_qo2d_solve_c(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy)\r
{\r
mglFormula h(ham);\r
- return mgl_qo2d_func(mgl_ham2d, &h, ini_re, ini_im, ray_dat, r, k0, xx, yy);\r
+ return mgl_qo2d_func_c(mgl_ham2d, &h, ini_re, ini_im, ray_dat, r, k0, xx, yy);\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy)\r
+{\r
+ HADT res = mgl_qo2d_solve_c(ham,ini_re,ini_im,ray_dat,r,k0,xx,yy);\r
+ HMDT out = mgl_datac_abs(res); delete res; return out;\r
}\r
//-----------------------------------------------------------------------------\r
//\r
return 0;\r
}\r
//-----------------------------------------------------------------------------\r
-HMDT MGL_EXPORT mgl_qo3d_func(dual (*ham)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz)\r
+HADT MGL_EXPORT mgl_qo3d_func_c(dual (*ham)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz)\r
{\r
const mglData *ray=dynamic_cast<const mglData *>(ray_dat); // NOTE: Ray must be mglData!\r
if(!ray) return 0;\r
long nx=ini_re->GetNx(), nt=ray->ny, n7=ray->nx; // NOTE: only square grids are supported now (for simplicity)\r
if(nx<2 || ini_re->GetNx()!=nx || ini_im->GetNx()*ini_im->GetNy()!=nx*nx || nt<2) return 0;\r
- mglData *res=new mglData(nx,nx,nt);\r
+ mglDataC *res=new mglDataC(nx,nx,nt);\r
\r
dual *a=new dual[4*nx*nx], *huv=new dual[4*nx*nx], *hxy=new dual[4*nx*nx], *huy=new dual[4*nx*nx], *hxv=new dual[4*nx*nx];\r
dual *hu=new dual[2*nx], *hx=new dual[2*nx], *hy=new dual[2*nx], *hv=new dual[2*nx];\r
#pragma omp parallel for collapse(2)\r
for(long i=0;i<nx;i++) for(long j=0;j<nx;j++) // init\r
a[i+nx/2+2*nx*(j+nx/2)] = dual(ini_re->v(i,j),ini_im->v(i,j));\r
- void *wsx, *wtx = mgl_fft_alloc(2*nx,&wsx,1);\r
+ void *wtx = mgl_fft_alloc(2*nx,0,0);\r
if(xx && yy && zz) { xx->Create(nx,nx,nt); yy->Create(nx,nx,nt); zz->Create(nx,nx,nt); }\r
\r
mgl_qo3d_ham tmp; // parameters for Hamiltonian calculation\r
{\r
#pragma omp parallel for collapse(2)\r
for(long i=0;i<nx;i++) for(long j=0;j<nx;j++) // "save"\r
- res->a[i+nx*(j+k*nx)]=abs(a[i+nx/2+2*nx*(j+nx/2)])*sqrt(ra[0].ch/ra[k].ch);\r
+ res->a[i+nx*(j+k*nx)]=a[i+nx/2+2*nx*(j+nx/2)]*sqrt(ra[0].ch/ra[k].ch);\r
if(xx && yy && zz)\r
#pragma omp parallel for collapse(2)\r
for(long i=0;i<nx;i++) for(long j=0;j<nx;j++) // prepare xx, yy, zz\r
mglStartThread(mgl_qo3d_post,0,2*nx,0,0,0,0,&tmp);\r
// Step for field\r
dual dt = dual(0, -ra[k].dt*k0); // TODO: this part can be paralleled\r
-#pragma omp parallel for\r
- for(long i=0;i<4*nx*nx;i++) a[i] *= exp(hxy[i]*dt); // x-y\r
- for(long i=0;i<2*nx;i++) // x->u\r
- mgl_fft((double *)(a+i*2*nx), 1, 2*nx, wtx, wsx, false);\r
-#pragma omp parallel for\r
- for(long i=0;i<4*nx*nx;i++) a[i] *= exp(huy[i]*dt); // u-y\r
- for(long i=0;i<2*nx;i++) // y->v\r
- mgl_fft((double *)(a+i), 2*nx, 2*nx, wtx, wsx, false);\r
-#pragma omp parallel for\r
- for(long i=0;i<4*nx*nx;i++) a[i] *= exp(huv[i]*dt); // u-v\r
- for(long i=0;i<2*nx;i++) // u->x\r
- mgl_fft((double *)(a+i*2*nx), 1, 2*nx, wtx, wsx, true);\r
-#pragma omp parallel for\r
- for(long i=0;i<4*nx*nx;i++) a[i] *= exp(hxv[i]*dt); // x-v\r
- for(long i=0;i<2*nx;i++) // v->y\r
- mgl_fft((double *)(a+i), 2*nx, 2*nx, wtx, wsx, true);\r
+#pragma omp parallel\r
+ {\r
+ void *wsx = mgl_fft_alloc_thr(2*nx);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*nx;i++) a[i] *= exp(hxy[i]*dt); // x-y\r
+#pragma omp for\r
+ for(long i=0;i<2*nx;i++) // x->u\r
+ mgl_fft((double *)(a+i*2*nx), 1, 2*nx, wtx, wsx, false);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*nx;i++) a[i] *= exp(huy[i]*dt); // u-y\r
+#pragma omp for\r
+ for(long i=0;i<2*nx;i++) // y->v\r
+ mgl_fft((double *)(a+i), 2*nx, 2*nx, wtx, wsx, false);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*nx;i++) a[i] *= exp(huv[i]*dt); // u-v\r
+#pragma omp for\r
+ for(long i=0;i<2*nx;i++) // u->x\r
+ mgl_fft((double *)(a+i*2*nx), 1, 2*nx, wtx, wsx, true);\r
+#pragma omp for\r
+ for(long i=0;i<4*nx*nx;i++) a[i] *= exp(hxv[i]*dt); // x-v\r
+#pragma omp for\r
+ for(long i=0;i<2*nx;i++) // v->y\r
+ mgl_fft((double *)(a+i), 2*nx, 2*nx, wtx, wsx, true);\r
+ mgl_fft_free_thr(wsx);\r
+ }\r
\r
/* // Calculate B1 // TODO make more general scheme later!!!\r
hh = ra[k].pt*(1/sqrt(sqrt(1.041))-1);\r
a1 = sqrt(a1/a2);\r
for(i=0;i<2*nx;i++) a[i] *= a1;*/\r
}\r
- mgl_fft_free(wtx,&wsx,1);\r
+ mgl_fft_free(wtx,0,0);\r
delete []a; delete []ra; delete []dmp;\r
delete []huv; delete []hxy; delete []hxv; delete []huy;\r
delete []hu; delete []hx; delete []hv; delete []hy;\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_qo3d_func(dual (*ham)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par), void *par, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz)\r
+{\r
+ HADT res = mgl_qo3d_func_c(ham,par,ini_re,ini_im,ray_dat,r,k0,xx,yy,zz);\r
+ HMDT out = mgl_datac_abs(res); delete res; return out;\r
+}\r
+//-----------------------------------------------------------------------------\r
dual MGL_NO_EXPORT mgl_ham3d(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par)\r
{\r
mglFormula *h = (mglFormula *)par;\r
return dual(h->Calc(var), -h->CalcD(var,'i'));\r
}\r
//-----------------------------------------------------------------------------\r
-HMDT MGL_EXPORT mgl_qo3d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz)\r
+HADT MGL_EXPORT mgl_qo3d_solve_c(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz)\r
{\r
mglFormula h(ham);\r
- return mgl_qo3d_func(mgl_ham3d, &h, ini_re, ini_im, ray_dat, r, k0, xx, yy, zz);\r
+ return mgl_qo3d_func_c(mgl_ham3d, &h, ini_re, ini_im, ray_dat, r, k0, xx, yy, zz);\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_qo3d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy, HMDT zz)\r
+{\r
+ HADT res = mgl_qo3d_solve_c(ham,ini_re,ini_im,ray_dat,r,k0,xx,yy,zz);\r
+ HMDT out = mgl_datac_abs(res); delete res; return out;\r
}\r
//-----------------------------------------------------------------------------\r
MGL_NO_EXPORT void *mgl_jacob2(void *par)\r
return r;\r
}\r
//-----------------------------------------------------------------------------\r
+uintptr_t MGL_EXPORT mgl_pde_solve_c_(uintptr_t* gr, const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, mreal *dz, mreal *k0, const char *opt, int l, int lo)\r
+{ char *s=new char[l+1]; memcpy(s,ham,l); s[l]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t res = uintptr_t(mgl_pde_solve_c(_GR_, s, _DA_(ini_re), _DA_(ini_im), *dz, *k0, o));\r
+ delete []o; delete []s; return res; }\r
uintptr_t MGL_EXPORT mgl_pde_solve_(uintptr_t* gr, const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, mreal *dz, mreal *k0, const char *opt, int l, int lo)\r
{ char *s=new char[l+1]; memcpy(s,ham,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
/***************************************************************************\r
* pixel.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-// NOTE: Perspective is not support just now !!! Also it use LAST InPlot parameters!!!\r
+// NOTE: Perspective is not fully supported now !!! Also it use LAST InPlot parameters!!!\r
mglPoint mglCanvas::RestorePnt(mglPoint ps, bool norm) const\r
{\r
mreal s3 = 2*B.pf;\r
mreal c8 = B.b[8]*Bp.b[8]+B.b[5]*Bp.b[7]+B.b[2]*Bp.b[6];\r
if(norm) cx=cy=cz=0;\r
\r
+ if(ps.z==ps.z) // try to take into account perspective if z-value is provided\r
+ {\r
+ register float d = (1-Bp.pf)/(1-Bp.pf*ps.z/Depth);\r
+ ps.x = Width/2 + (ps.x-Width/2)/d;\r
+ ps.y = Height/2+ (ps.y-Height/2)/d;\r
+ }\r
mreal xx = ps.x-cx, yy = ps.y-cy, zz = ps.z-cz;\r
mreal d1=c0*c4-c1*c3, d2=c1*c5-c2*c4, d3=c0*c5-c2*c3;\r
\r
for(long i=id;i<n;i+=mglNumThr)\r
{\r
mglPnt &p=Pnt[i];\r
+ if(p.sub) continue;\r
register float x = p.xx-Width/2., y = p.yy-Height/2., z = p.zz-Depth/2.;\r
p.x = Bp.b[0]*x + Bp.b[1]*y + Bp.b[2]*z - Bp.x*Width/2;\r
p.y = Bp.b[3]*x + Bp.b[4]*y + Bp.b[5]*z - Bp.y*Height/2;\r
for(long i=id;i<n;i+=mglNumThr)\r
{\r
const mglPnt &p=Pnt[i];\r
+ if(p.sub) continue;\r
register float x = p.xx-Width/2., y = p.yy-Height/2., z = p.zz-Depth/2.,xx,yy,zz;\r
xx = Bp.b[0]*x + Bp.b[1]*y + Bp.b[2]*z - Bp.x*Width/2;\r
yy = Bp.b[3]*x + Bp.b[4]*y + Bp.b[5]*z - Bp.y*Height/2;\r
// scale direction for new view/zoom\r
float mglCanvas::GetGlyphPhi(const mglPnt &q, float phi)\r
{\r
- float dv = (1-Bp.pf)/(1-Bp.pf*q.z/Depth);\r
- float x,y,z,c=Bp.pf/(1-Bp.pf)/Depth,ll;\r
- x = Bp.b[0]*q.u + Bp.b[1]*q.v + Bp.b[2]*q.w;\r
- y = Bp.b[3]*q.u + Bp.b[4]*q.v + Bp.b[5]*q.w;\r
- z = Bp.b[6]*q.u + Bp.b[7]*q.v + Bp.b[8]*q.w;\r
+ float x,y,z,ll;\r
+ if(q.sub)\r
+ { x = q.u; y = q.v; z = q.w; }\r
+ else\r
+ {\r
+ x = Bp.b[0]*q.u + Bp.b[1]*q.v + Bp.b[2]*q.w;\r
+ y = Bp.b[3]*q.u + Bp.b[4]*q.v + Bp.b[5]*q.w;\r
+ z = Bp.b[6]*q.u + Bp.b[7]*q.v + Bp.b[8]*q.w;\r
\r
- x += (q.x-Width/2)*z*c*dv;\r
- y += (q.y-Height/2)*z*c*dv;\r
+ register float dv = (1-Bp.pf)/(1-Bp.pf*q.z/Depth);\r
+ register float c=Bp.pf/(1-Bp.pf)/Depth;\r
+ x += (q.x-Width/2)*z*c*dv;\r
+ y += (q.y-Height/2)*z*c*dv;\r
+ }\r
ll = x*x+y*y;\r
if(ll < 1e-10) return NAN;\r
if(ll==ll && phi<1e4)\r
\r
if(d) { d->PDef = MGL_SOLID_MASK; d->angle = 0; d->PenWidth=0.6; }\r
mglPnt p=Pnt[P.n1];\r
- mreal pf=sqrt((Bp.b[0]*Bp.b[0]+Bp.b[1]*Bp.b[1]+Bp.b[3]*Bp.b[3]+Bp.b[4]*Bp.b[4])/2), f = P.p*pf;\r
+ // NOTE check this later for mglInPlot\r
+ mreal pf=p.sub<0?1:sqrt((Bp.b[0]*Bp.b[0]+Bp.b[1]*Bp.b[1]+Bp.b[3]*Bp.b[3]+Bp.b[4]*Bp.b[4])/2), f = P.p*pf;\r
\r
mglMatrix M;\r
M.b[0] = M.b[4] = M.b[8] = P.s;\r
/***************************************************************************\r
* plot.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
mglData x(v1->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_candle_xyv(gr,&x,v1,v2,y1,y2,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_candle(HMGL gr, HCDT v1, HCDT y1, HCDT y2, const char *pen, const char *opt)\r
mglData z(y->GetNx());\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_plot_xyz(gr,x,y,&z,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_plot(HMGL gr, HCDT y, const char *pen, const char *opt)\r
x.Fill(gr->Min.x,gr->Max.x);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_plot_xyz(gr,&x,y,&z,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_plot_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
mglData z(y->GetNx());\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tens_xyz(gr,x,y,&z,c,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tens(HMGL gr, HCDT y, HCDT c, const char *pen, const char *opt)\r
x.Fill(gr->Min.x,gr->Max.x);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tens_xyz(gr,&x,y,&z,c,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tens_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *pen, const char *opt,int l,int lo)\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_area_xy(gr,&x,y,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_area_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
mglData x(y1->GetNx());\r
x.Fill(gr->Min.x, gr->Max.x);\r
mgl_region_xy(gr,&x,y1,y2,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_region_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y1, uintptr_t *y2, const char *pen, const char *opt, int l, int lo)\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_step_xy(gr,&x,y,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_step_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
void MGL_EXPORT mgl_stem_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
long m,mx,my,mz,n=y->GetNx(), pal;\r
- if(mgl_check_dim1(gr,x,y,z,0,"Stem")) return;\r
+ if(mgl_check_dim0(gr,x,y,z,0,"Stem")) return;\r
\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Stem3",cgid++);\r
void MGL_EXPORT mgl_stem_xy(HMGL gr, HCDT x, HCDT y, const char *pen, const char *opt)\r
{\r
long m,mx,my,n=y->GetNx(), pal;\r
- if(mgl_check_dim1(gr,x,y,0,0,"Stem")) return;\r
+ if(mgl_check_dim0(gr,x,y,0,0,"Stem")) return;\r
\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Stem",cgid++);\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_stem_xy(gr,&x,y,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_stem_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
mglData x(y->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_bars_xy(gr,&x,y,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_bars_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
mglData y(v->GetNx()+1);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_barh_yx(gr,&y,v,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_barh_yx_(uintptr_t *gr, uintptr_t *y, uintptr_t *v, const char *pen, const char *opt,int l,int lo)\r
mglData x(open->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_ohlc_x(gr,&x,open,high,low,close,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_ohlc_y_(uintptr_t *gr, uintptr_t *x, uintptr_t *open, uintptr_t *high, uintptr_t *low, uintptr_t *close, const char *pen, const char *opt,int l,int lo)\r
mglData x(y->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_boxplot_xy(gr,&x,y,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_boxplot_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, const char *pen, const char *opt,int l,int lo)\r
void MGL_EXPORT mgl_error_exy(HMGL gr, HCDT x, HCDT y, HCDT ex, HCDT ey, const char *pen, const char *opt)\r
{\r
long m,mx,my,m1,m2,n=ey->GetNx(),pal;\r
- if(mgl_check_dim1(gr,x,y,ey,ex,"Error")) return;\r
+ if(mgl_check_dim0(gr,x,y,ey,ex,"Error")) return;\r
\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Error",cgid++);\r
mglData ex(y->GetNx());\r
ex.Fill(NAN,NAN);\r
mgl_error_exy(gr,x,y,&ex,ey,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_error(HMGL gr, HCDT y, HCDT ey, const char *pen, const char *opt)\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_error_xy(gr,&x,y,ey,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_error_(uintptr_t *gr, uintptr_t *y, uintptr_t *ey, const char *pen, const char *opt,int l,int lo)\r
mglData z(y->GetNx());\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_mark_xyz(gr,x,y,&z,r,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_mark_y(HMGL gr, HCDT y, HCDT r, const char *pen, const char *opt)\r
x.Fill(gr->Min.x,gr->Max.x);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_mark_xyz(gr,&x,y,&z,r,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_mark_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *r, const char *pen, const char *opt,int l,int lo)\r
mglData z(y->GetNx());\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,x,y,&z,r,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tube_r(HMGL gr, HCDT y, HCDT r, const char *pen, const char *opt)\r
x.Fill(gr->Min.x,gr->Max.x);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,&x,y,&z,r,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tube(HMGL gr, HCDT y, double rr, const char *pen, const char *opt)\r
r.Fill(rr,rr);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,&x,y,&z,&r,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tube_xy(HMGL gr, HCDT x, HCDT y, double rr, const char *pen, const char *opt)\r
r.Fill(rr,rr);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,x,y,&z,&r,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tube_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, double rr, const char *pen, const char *opt)\r
mglData r(y->GetNx());\r
r.Fill(rr,rr);\r
mgl_tube_xyzr(gr,x,y,z,&r,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tube_xyzr_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *r, const char *pen, const char *opt,int l,int lo)\r
mglData z(y->GetNx());\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tape_xyz(gr,x,y,&z,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tape(HMGL gr, HCDT y, const char *pen, const char *opt)\r
x.Fill(gr->Min.x,gr->Max.x);\r
mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tape_xyz(gr,&x,y,&z,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tape_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
/***************************************************************************\r
* prc.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************\r
* prim.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
mglData y(z);\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_cones_xyz(gr,x,&y,z,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cones(HMGL gr, HCDT z, const char *pen, const char *opt)\r
mglData x(z->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_cones_xz(gr,&x,z,pen,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cones_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_dew_xy(gr,&x,&y,ax,ay,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_dew_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
gr->SaveState(opt);\r
mglData z(y->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_textmarkw_xyzr(gr,x,y,&z,r,text,fnt,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_textmarkw_yr(HMGL gr, HCDT y, HCDT r, const wchar_t *text, const char *fnt, const char *opt)\r
mglData x(n); x.Fill(gr->Min.x,gr->Max.x);\r
mglData z(n); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_textmarkw_xyzr(gr,&x,y,&z,r,text,fnt,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_textmarkw(HMGL gr, HCDT y, const wchar_t *text, const char *fnt, const char *opt)\r
mglData x(n); x.Fill(gr->Min.x,gr->Max.x);\r
mglData z(n); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_textmarkw_xyzr(gr,&x,y,&z,&r,text,fnt,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_textmark_xyzr(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT r, const char *str, const char *fnt, const char *opt)\r
gr->SaveState(opt);\r
mglData z(y->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_labelw_xyz(gr,x,y,&z,text,fnt,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_labelw_y(HMGL gr, HCDT y, const wchar_t *text, const char *fnt, const char *opt)\r
mglData x(n); x.Fill(gr->Min.x,gr->Max.x);\r
mglData z(n); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_labelw_xyz(gr,&x,y,&z,text,fnt,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_label_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *str, const char *fnt, const char *opt)\r
/***************************************************************************\r
* surf.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_mesh_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_mesh_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_fall_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_fall_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_grid_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_grid_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_surf_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_belt_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_belt_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x, gr->Max.x);\r
y.Fill(gr->Min.y, gr->Max.y);\r
mgl_dens_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_dens_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_surfc_xy(gr,&x,&y,z,c,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surfc_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_surfa_xy(gr,&x,&y,z,c,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surfa_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_boxs_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_boxs_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_tile_xy(gr,&x,&y,z,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tile_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_tiles_xy(gr,&x,&y,z,s,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_tiles_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, uintptr_t *r, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_map_xy(gr,&x,&y,ax,ay,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_map_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
/***************************************************************************
* tex_table.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
{0x2021, L"ddagger"},
{0x22f1, L"ddots"},
{0x2a77, L"ddotseq"},
+ {0xb0, L"degree"},
{0x3b4, L"delta"},
{0xf0, L"dh"},
{0x2300, L"diameter"},
/***************************************************************************\r
* vect.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
gr->SaveState(opt);\r
mglData z(x->GetNx()), az(x->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_traj_xyz(gr,x,y,&z,ax,ay,&az,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_traj_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_vect_xy(gr,&x,&y,ax,ay,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_vect_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_vect_xyz(gr,&x,&y,&z,ax,ay,az,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_vect_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_vect3_xyz(gr,&x,&y,&z,ax,ay,az,sch,sVal,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_vect3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_flow_xy(gr,&x,&y,ax,ay,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_flow_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_flowp_xy(gr,x0,y0,z0,&x,&y,ax,ay,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_flowp_xy_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt, int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_flow_xyz(gr,&x,&y,&z,ax,ay,az,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_flow_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_flowp_xyz(gr, x0,y0,z0, &x,&y,&z,ax,ay,az,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_flowp_xyz_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt, int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x); y.Fill(gr->Min.y,gr->Max.y); z.Fill(gr->Min.z,gr->Max.z);\r
if(phi->GetNz()==1) mgl_grad_xy(gr,&x,&y,phi,sch,0);\r
else mgl_grad_xyz(gr,&x,&y,&z,phi,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_grad_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ph, const char *sch, const char *opt, int l,int lo)\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_pipe_xy(gr,&x,&y,ax,ay,sch,r0,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_pipe_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, mreal *r0, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_pipe_xyz(gr,&x,&y,&z,ax,ay,az,sch,r0,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_pipe_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, mreal *r0, const char *opt,int l,int lo)\r
/***************************************************************************\r
* surf.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_cloud_xyz(gr,&x,&y,&z,a,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_cloud_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3_xyz_val(gr,val,&x,&y,&z,a,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
mreal v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
mgl_surf3_xyz_val(gr,v,x,y,z,a,sch,0);\r
}\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf3(HMGL gr, HCDT a, const char *sch, const char *opt)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3_xyz(gr,&x,&y,&z,a,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf3_xyz_val_(uintptr_t *gr, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3a_xyz_val(gr,val,&x,&y,&z,a,b,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf3a_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3a_xyz(gr,&x,&y,&z,a,b,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf3a_xyz_val_(uintptr_t *gr, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3c_xyz_val(gr,val,&x,&y,&z,a,b,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf3c_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3c_xyz(gr,&x,&y,&z,a,b,sch,0);\r
- gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void MGL_EXPORT mgl_surf3c_xyz_val_(uintptr_t *gr, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
/***************************************************************************\r
* window.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
Defines aspect ratio for the plot. The viewable axes will be related one to another as the ratio @var{Ax:Ay:Az}. For the best effect it should be used after @ref{rotate} function. If @var{Ax} is @code{NAN} then function try to select optimal aspect ratio to keep equal ranges for x-y axis. At this, @var{Ay} will specify proportionality factor, or set to use automatic one if @var{Ay}=@code{NAN}.
@end deftypefn
-@anchor{perspective}
-@deftypefn {MGL command} {} perspective @code{val}
-@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Perspective (@code{mreal} a)
-@deftypefnx {C function} @code{void} mgl_perspective (@code{HMGL} gr, @code{mreal} a)
-@end ifclear
-Add (switch on) the perspective to plot. The parameter @math{a ~ 1/z_@{eff@} \in [0,1)}. By default (@code{a=0}) the perspective is off.
-@end deftypefn
-
@ifclear UDAV
@deftypefn {Method on @code{mglGraph}} @code{void} Push ()
@end ifclear
-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. It is not recommended to call them for picture drawning.
+There are 3 functions @code{View()}, @code{Zoom()} and @code{Perspective()} which transform whole image. I.e. they act as secondary transformation matrix. They were introduced for rotating/zooming the whole plot by mouse. It is not recommended to call them for picture drawing.
+
+@anchor{perspective}
+@deftypefn {MGL command} {} perspective @code{val}
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} Perspective (@code{mreal} a)
+@deftypefnx {C function} @code{void} mgl_perspective (@code{HMGL} gr, @code{mreal} a)
+@end ifclear
+Add (switch on) the perspective to plot. The parameter @math{a = Depth/(Depth+dz) \in [0,1)}. By default (@code{a=0}) the perspective is off.
+@end deftypefn
@anchor{view}
@deftypefn {MGL command} {} view @code{tetx tetz [tety=0]}
@deftypefnx {C function} @code{void} mgl_clf_chr (@code{HMGL} gr, @code{char} col)
@deftypefnx {C function} @code{void} mgl_clf_rgb (@code{HMGL} gr, @code{mreal} r, @code{mreal} g, @code{mreal} b)
@end ifclear
-Clear the picture and fill it by color specified color.
+Clear the picture and fill it by specified color.
@end deftypefn
@anchor{ball}
@item
@samp{XYZ} for drawing axis in corresponding direction but with inverted positions of labels;
@item
-@samp{_} for disabling tick labels;
+@samp{~} or @samp{_} for disabling tick labels;
@item
@samp{U} for disabling rotation of tick labels;
@item
@item
@samp{I} for positioning near bounding (by default, is positioned at edges of subplot);
@item
-@samp{A} for using absolute coordinates.
+@samp{A} for using absolute coordinates;
+@item
+@samp{~} for disabling tick labels.
@end itemize
@sref{Colorbars}
@end deftypefn
@deftypefnx {C function} @code{void} mgl_surf3a_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_surf3a_xyz_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws isosurface plot for 3d array specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) at @var{a}(x,y,z)=@var{val}. It is mostly the same as @ref{surf3} function but the color of isosurface depends on values of array @var{c}. If string @var{sch} contain @samp{#} then wire plot is produced. If string @var{sch} have symbol @samp{.} then plot by dots is produced. See also @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3A sample}
+The function draws isosurface plot for 3d array specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) at @var{a}(x,y,z)=@var{val}. It is mostly the same as @ref{surf3} function but the transparency of isosurface depends on values of array @var{c}. If string @var{sch} contain @samp{#} then wire plot is produced. If string @var{sch} have symbol @samp{.} then plot by dots is produced. See also @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3A sample}
@end deftypefn
@deftypefn {MGL command} {} surf3a adat cdat ['sch'='']
Устанавливает соотношение размеров осей в отношении @var{Ax:Ay:Az}. Для лучшего вида следует вызывать после функции @ref{rotate}. Если @var{Ax}=@code{NAN}, то функция выберет оптимальное соотношение размеров, чтобы шаг по осям x-y был одинаков. При этом, @var{Ay} задает фактор пропорциональности шага (обычно 1), или указывает на его автоматический выбор при @var{Ay}=@code{NAN}.
@end deftypefn
-@anchor{perspective}
-@deftypefn {Команда MGL} {} perspective @code{val}
-@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Perspective (@code{mreal} a)
-@deftypefnx {Функция С} @code{void} mgl_perspective (@code{HMGL} gr, @code{mreal} a)
-@end ifclear
-Добавляет (включает) перспективу для графика. Параметр @math{a ~ 1/z_@{eff@} \in [0,1)}. По умолчанию (@code{a=0}) перспектива отключена.
-@end deftypefn
-
@ifclear UDAV
@deftypefn {Метод класса @code{mglGraph}} @code{void} Push ()
@end ifclear
-Также есть 2 функции, которые управляют масштабированием @code{Zoom()} и вращением @code{View()} всего рисунка. Т.е. они действуют как ещё одна матрица трансформации. Они были введены для вращения/приближения графика с помощью мыши. Не рекомендуется вызывать их при рисовании графика.
+Также есть 3 функции, которые управляют перспективой @code{Perspective()}, масштабированием @code{Zoom()} и вращением @code{View()} всего рисунка. Т.е. они действуют как ещё одна матрица трансформации. Они были введены для вращения/приближения графика с помощью мыши. Не рекомендуется вызывать их при рисовании графика.
+
+@anchor{perspective}
+@deftypefn {Команда MGL} {} perspective @code{val}
+@ifclear UDAV
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Perspective (@code{mreal} a)
+@deftypefnx {Функция С} @code{void} mgl_perspective (@code{HMGL} gr, @code{mreal} a)
+@end ifclear
+Добавляет (включает) перспективу для графика. Параметр @math{a = Depth/(Depth+dz) \in [0,1)}. По умолчанию (@code{a=0}) перспектива отключена.
+@end deftypefn
@anchor{view}
@deftypefn {Команда MGL} {} view @code{tetx tetz [tety=0]}
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Axis (@code{const char *}dir=@code{"xyz"}, @code{const char *}stl=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Функция С} @code{void} mgl_axis (@code{HMGL} gr, @code{const char *}dir, @code{const char *}stl, @code{const char *}opt)
@end ifclear
-Рисует оси координат и метки на них (см. @ref{Axis settings}) в направлениях @samp{xyz}, указанных строкой @var{dir}. Заглавные буквы @samp{XYZ} приведут к расположению меток с другой стороны от оси. Если строка содержит символ @samp{_}, то подписи меток отображаться не будут. Если строка содержит символ @samp{^}, то инвертируется положение осей по умолчанию. Если строка содержит символ @samp{AKDTVISO}, то будет нарисована соответствующая стрелка на конце оси. Стиль меток и оси(ей) задается строкой @var{stl}. @sref{Axis and ticks}
+Рисует оси координат и метки на них (см. @ref{Axis settings}) в направлениях @samp{xyz}, указанных строкой @var{dir}. Заглавные буквы @samp{XYZ} приведут к расположению меток с другой стороны от оси. Если строка содержит символ @samp{~} или @samp{_}, то подписи меток отображаться не будут. Если строка содержит символ @samp{^}, то инвертируется положение осей по умолчанию. Если строка содержит символ @samp{AKDTVISO}, то будет нарисована соответствующая стрелка на конце оси. Стиль меток и оси(ей) задается строкой @var{stl}. @sref{Axis and ticks}
@end deftypefn
@anchor{colorbar}
@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
-Рисует полосу соответствия цвета и числовых значений (colorbar) для цветовой схемы @var{sch} (используется текущая для @code{sch=""}) с краю от графика. Если строка @var{sch} содержит @samp{<>^_}, то положение выбирается: @samp{>} -- справа, @samp{<} -- слева, @samp{^} -- сверху, @samp{_} -- снизу. Если строка содержит @samp{A}, то используются абсолютные координаты (относительно рисунка). @sref{Colorbars}
+Рисует полосу соответствия цвета и числовых значений (colorbar) для цветовой схемы @var{sch} (используется текущая для @code{sch=""}) с краю от графика. Если строка @var{sch} содержит @samp{<>^_}, то положение выбирается: @samp{>} -- справа, @samp{<} -- слева, @samp{^} -- сверху, @samp{_} -- снизу. Если строка содержит @samp{A}, то используются абсолютные координаты (относительно рисунка). Если строка содержит @samp{~}, то подписи меток не рисуются. @sref{Colorbars}
@end deftypefn
@deftypefn {Команда MGL} {} colorbar vdat ['sch'='']
@cindex mglExpr
@cindex mglExprC
-MathGL have a special classes @code{mglExpr} and @code{mglExprC} for evaluating of formula specified by the string for real and complex numbers correspondingly. These classes are defined in @code{#include <mgl2/mgl.h>}. It is the fast variant of formula evaluation. At creation it will be recognized and compiled to tree-like internal code. At evaluation stage only fast calculations are performed. There is no difference between lower or upper case in formulas. If argument value lie outside the range of function definition then function returns NaN. @xref{Textual formulas}.
+MathGL have a special classes @code{mglExpr} and @code{mglExprC} for evaluating of formula specified by the string for real and complex numbers correspondingly. These classes are defined in @code{#include <mgl2/data.h>} and @code{#include <mgl2/datac.h>} correspondingly. It is the fast variant of formula evaluation. At creation it will be recognized and compiled to tree-like internal code. At evaluation stage only fast calculations are performed. There is no difference between lower or upper case in formulas. If argument value lie outside the range of function definition then function returns NaN. @xref{Textual formulas}.
@deftypefn {Constructor on @code{mglExpr}} @code{} mglExpr (@code{const char *}expr)
@deftypefnx {Constructor on @code{mglExprC}} @code{} mglExprC (@code{const char *}expr)
@end ifset
@ifclear UDAV
-В MathGL есть специальные классы @code{mglExpr} и @code{mglExprC} для вычисления формул заданных строкой для действительных и комплексных чисел соответственно. Классы определены в @code{#include <mgl2/mgl.h>}. При создании класса происходит разбор формулы в древовидную структуру. А при вычислении только выполняется достаточно быстрый обход по дереву. В данный момент нет различия между верхним и нижним регистром. Если аргумент какой-либо функции лежит вне её области определения, то возвращается NaN. @xref{Textual formulas}.
+В MathGL есть специальные классы @code{mglExpr} и @code{mglExprC} для вычисления формул заданных строкой для действительных и комплексных чисел соответственно. Классы определены в @code{#include <mgl2/data.h>} и @code{#include <mgl2/datac.h>} соответственно. При создании класса происходит разбор формулы в древовидную структуру. А при вычислении только выполняется достаточно быстрый обход по дереву. В данный момент нет различия между верхним и нижним регистром. Если аргумент какой-либо функции лежит вне её области определения, то возвращается NaN. @xref{Textual formulas}.
@deftypefn {Конструктор класса @code{mglExpr}} @code{} mglExpr (@code{const char *}expr)
@deftypefnx {Конструктор класса @code{mglExprC}} @code{} mglExprC (@code{const char *}expr)
@macro external {}
@html
+<br><script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
+<!-- Ref 728x15 -->
+<ins class="adsbygoogle"
+style="display:inline-block;width:728px;height:15px"
+data-ad-client="ca-pub-1128070552722622"
+data-ad-slot="7008431385"></ins>
+<script>
+(adsbygoogle = window.adsbygoogle || []).push({});
+</script><br>
+
<script type="text/javascript"><!--
google_ad_client = "ca-pub-1128070552722622";
/* 728x90, создано 23.12.09 */
@macro external {}
@html
+<br><script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
+<!-- Ref 728x15 -->
+<ins class="adsbygoogle"
+style="display:inline-block;width:728px;height:15px"
+data-ad-client="ca-pub-1128070552722622"
+data-ad-slot="7008431385"></ins>
+<script>
+(adsbygoogle = window.adsbygoogle || []).push({});
+</script><br>
+
<script type="text/javascript"><!--
google_ad_client = "ca-pub-1128070552722622";
/* 728x90, создано 23.12.09 */
<!-- <script type="text/javascript" src="inflate.min.js"></script>-->
</head>
+<!-- Use "chromium-browser --disable-web-security json.html" for debug -->
+
<body onload="main();">
Select sample
***************************************************************************/
var obj;
var ctx;
+var cw,ch;
var deg = Math.PI/180; //0.017453293;
var main = function()
{
ctx = document.getElementById("canvas").getContext("2d");
+ cw = document.getElementById("canvas").width;
+ ch = document.getElementById("canvas").height;
ctx.lineCap="round"; // global setting
mgl_init("json/alpha.json");
var name = document.getElementById("select").value;
mgl_init("json/"+name+".json");
var t1 = new Date();
- ctx.clearRect(0,0,obj.width,obj.height);
+ ctx.clearRect(0,0,cw,ch);
mgl_draw_good(obj, ctx);
// draw_fast(obj, ctx);
var t2 = new Date();
// mouse handling functions
var mglMouseUp = function()
{ obj.button = 0; obj.good = 0;
- ctx.clearRect(0,0,obj.width,obj.height);
+ ctx.clearRect(0,0,cw,ch);
mgl_draw_good(obj, ctx); }
var mglMouseDown = function(event)
{
switch(obj.button)
{
case 1: // rotate
- mgl_rotate_down(obj, y*90/obj.height);
- mgl_rotate_left(obj, x*90/obj.width); break;
+ mgl_rotate_down(obj, y*180/ch);
+ mgl_rotate_left(obj, x*180/cw); break;
case 2: // shift
- mgl_shift_down(obj, y/obj.height);
- mgl_shift_right(obj, x/obj.width); break;
+ mgl_shift_down(obj, y/ch);
+ mgl_shift_right(obj, x/cw); break;
case 3: // zoom
mgl_zoom_in(obj, Math.pow(1.003,x)); break;
}
var mglRestore = function()
{
mgl_restore(obj);
- ctx.clearRect(0,0,obj.width,obj.height);
+ ctx.clearRect(0,0,cw,ch);
mgl_draw_good(obj,ctx);
}
obj.phi= 0; // current phi-angle for rotation
obj.bet= 0; // current beta-angle for rotation
obj.button = 0; // pressed mouse buttons (0-none, 1-left, 2-right)
- obj.mouseX=0;
- obj.mouseY=0;
- obj.fast = 0;
- obj.good = 0;
+ obj.mouseX=0; obj.mouseY=0;
+ obj.fast = 0; obj.good = 0;
+ obj.dx = cw/obj.width;
+ obj.dy = ch/obj.height;
}
// Functions for rotation, shifting and zooming of the picture as whole
// This function make drawing itself
var mgl_draw = function(obj, ctx)
{
- ctx.clearRect(0,0,obj.width,obj.height);
+ ctx.clearRect(0,0,cw,ch);
if(obj.good==0)
{
obj.good = 1;
{
if(obj.fast==0) return;
mgl_prepare(obj,skip); // update coordinates
- var i,n1;
- for(var i=0;i<obj.nprim;i++) // for each primitive
+ // for each primitive skipping superfluous
+ for(var i=0;i<obj.nprim;i ++)
{
- var n1 = obj.prim[i][1], n2 = obj.prim[i][2];
- if(obj.prim[i][0]==1)
- {
- ctx.strokeStyle = obj.prim[i][10];
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineWidth = obj.prim[i][7]/100;
- ctx.stroke();
- }
- else
+ var prim = obj.prim[i];
+ var n1 = prim[1], nn = obj.pp[n1];
+ if(prim[0]==1 || obj.pnts[n1][3]<0)
+ mgl_draw_prim(obj,ctx,prim,Math.abs(obj.b[12]));
+ else if(obj.prim[i][0]<4)
{
ctx.fillStyle = obj.prim[i][10];
- ctx.fillRect(obj.pp[n1][0], obj.pp[n1][1], 2, 2);
+ ctx.fillRect(nn[0], nn[1], 2, 2);
}
}
obj.fast = 0;
obj.fast = 0;
mgl_prepare(obj,skip); // update coordinates
// NOTE: this valid only for current zoom/view. In general case it should be more complicated
- var scl = Math.sqrt(obj.b[0]*obj.b[0]+obj.b[1]*obj.b[1]+obj.b[2]*obj.b[2]);
+ var s1 = Math.sqrt(obj.b[0]*obj.b[0]+obj.b[1]*obj.b[1]+obj.b[2]*obj.b[2]), s2 = Math.abs(obj.b[12]);
for(var i=0;i<obj.nprim;i++) // for each primitive
{
- var n1 = obj.prim[i][1], n2 = obj.prim[i][2];
- var n3 = obj.prim[i][3], n4 = obj.prim[i][4];
- ctx.strokeStyle = obj.prim[i][10];
- ctx.fillStyle = obj.prim[i][10];
- ctx.lineWidth = 1;
- switch(obj.prim[i][0]) // draw it depending on its type
- {
- case 0: // marks
- ctx.lineWidth = obj.prim[i][7]*obj.prim[i][6]*5e-4;
- mgl_draw_mark(ctx, obj.pp[n1][0], obj.pp[n1][1], n4, obj.prim[i][6]/100, scl);
- break;
- case 1: // lines
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineWidth = obj.prim[i][7]/100;
- ctx.stroke(); break;
- case 2: // triangles
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineTo(obj.pp[n3][0],obj.pp[n3][1]);
- ctx.closePath(); ctx.fill(); break;
- case 3: // quadrangles
- ctx.beginPath();
- ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
- ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
- ctx.lineTo(obj.pp[n4][0],obj.pp[n4][1]);
- ctx.lineTo(obj.pp[n3][0],obj.pp[n3][1]);
- ctx.closePath();
- // NOTE: look as alpha is disabled for lines
- // So, next code should be only for the case alpha=false
- if(obj.prim[i][10].charAt(0)=='#') ctx.stroke();
- ctx.fill(); break;
- case 4: // glyphs
- var t=obj.prim[i][7]*deg/100;
- var xx=obj.coor[n2][2]/100,yy=-obj.coor[n2][3]/100,zz=obj.coor[n2][4]/100;
- var xc = obj.b[0]*xx + obj.b[1]*yy + obj.b[2]*zz;
- var yc = obj.b[3]*xx + obj.b[4]*yy + obj.b[5]*zz;
+ var prim = obj.prim[i];
+ mgl_draw_prim(obj,ctx,prim,obj.pnts[prim[1]][3]?s2:s1);
+ }
+ obj.good = 0;
+}
+
+/** perform high-quality drawing */
+var mgl_draw_prim = function(obj, ctx, prim, scl)
+{
+ var n1 = prim[1], n2 = prim[2];
+ var n3 = prim[3], n4 = prim[4];
+ var pp = obj.pp;
+ var deg = Math.PI/180; //0.017453293;
+
+ ctx.strokeStyle = prim[10];
+ ctx.fillStyle = prim[10];
+ ctx.lineWidth = 1;
+ switch(prim[0]) // draw it depending on its type
+ {
+ case 0: // marks
+ ctx.lineWidth = prim[7]*prim[6]*5e-4;
+ mgl_draw_mark(ctx, obj.pp[n1][0], obj.pp[n1][1], n4, prim[6]/100, scl);
+ break;
+ case 1: // lines
+ ctx.beginPath();
+ ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
+ ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
+ ctx.lineWidth = prim[7]/100;
+ ctx.stroke(); break;
+ case 2: // triangles
+ ctx.beginPath();
+ ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
+ ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
+ ctx.lineTo(obj.pp[n3][0],obj.pp[n3][1]);
+ ctx.closePath(); ctx.fill(); break;
+ case 3: // quadrangles
+ ctx.beginPath();
+ ctx.moveTo(obj.pp[n1][0],obj.pp[n1][1]);
+ ctx.lineTo(obj.pp[n2][0],obj.pp[n2][1]);
+ ctx.lineTo(obj.pp[n4][0],obj.pp[n4][1]);
+ ctx.lineTo(obj.pp[n3][0],obj.pp[n3][1]);
+ ctx.closePath();
+ // NOTE: look as alpha is disabled for lines
+ // So, next code should be only for the case alpha=false
+ if(prim[10].charAt(0)=='#') ctx.stroke();
+ ctx.fill(); break;
+ case 4: // glyphs
+ var t=prim[7]*deg/100;
+ var xx=obj.coor[n2][2]/100,yy=-obj.coor[n2][3]/100,zz=obj.coor[n2][4]/100;
+ var xc = obj.b[0]*xx + obj.b[1]*yy + obj.b[2]*zz;
+ var yc = obj.b[3]*xx + obj.b[4]*yy + obj.b[5]*zz;
// var zc = obj.b[6]*xx + obj.b[7]*yy + obj.b[8]*zz;
- var ll = xc*xc+yc*yc;
- if(ll < 1e-10) break;
- if(ll<1e10 && t/deg<1e4)
- {
- t = Math.atan2(yc,xc);
- if(Math.abs(t)>Math.PI/2) t += Math.PI;
- }
- else t=0;
- var c=Math.cos(t), s=Math.sin(t), d=obj.prim[i][6]/200;
+ var ll = xc*xc+yc*yc;
+ if(ll < 1e-10) break;
+ if(ll<1e10 && t/deg<1e4)
+ {
+ t = Math.atan2(yc,xc);
+ if(Math.abs(t)>Math.PI/2) t += Math.PI;
+ }
+ else t=0;
+ var c=Math.cos(t), s=Math.sin(t), d=prim[6]/200;
- var b=[d*c, d*s, d*s, -d*c, obj.pp[n1][0],obj.pp[n1][1]];
- var x=obj.coor[n2][0]*scl/100, y=obj.coor[n2][1]*scl/100, f=obj.prim[i][8]*scl/1e5;
- if(n3&8)
- {
- if(!(n3&4)) mgl_line_glyph(ctx, x,y, f,1,b);
- else mgl_line_glyph(ctx, x,y, f,0,b);
- }
- else
- {
- if(!(n3&4)) mgl_fill_glyph(ctx, x,y, f,obj.glfs[n4],b);
- else mgl_wire_glyph(ctx, x,y, f,obj.glfs[n4],b);
- }
- break;
+ var b=[d*c, d*s, d*s, -d*c, obj.pp[n1][0],obj.pp[n1][1]];
+ var x=obj.coor[n2][0]*scl/100, y=obj.coor[n2][1]*scl/100, f=prim[8]*scl/1e5;
+ if(n3&8)
+ {
+ if(!(n3&4)) mgl_line_glyph(ctx, x,y, f,1,b);
+ else mgl_line_glyph(ctx, x,y, f,0,b);
}
+ else
+ {
+ if(!(n3&4)) mgl_fill_glyph(ctx, x,y, f,obj.glfs[n4],b);
+ else mgl_wire_glyph(ctx, x,y, f,obj.glfs[n4],b);
+ }
+ break;
}
- obj.good = 0;
}
// This function change coordinates according current transformations
var cx=Math.cos(obj.tet*deg), sx=Math.sin(obj.tet*deg); // tetx
var cy=Math.cos(obj.phi*deg), sy=Math.sin(obj.phi*deg); // tety
var cz=Math.cos(obj.bet*deg), sz=Math.sin(obj.bet*deg); // tetz
- obj.b = [dx*cx*cy, -dx*cy*sx, dx*sy,
- dy*(cx*sy*sz+cz*sx), dy*(cx*cz-sx*sy*sz), -dy*cy*sz,
- sx*sz-cx*cz*sy, cx*sz+cz*sx*sy, cy*cz,
- obj.width/2*(1+dx-obj.z[1]-obj.z[0])/dx,
- obj.height/2*(1+dy-obj.z[3]-obj.z[2])/dy, obj.depth/2];
+ obj.b = [obj.dx*dx*cx*cy, -obj.dx*dx*cy*sx, obj.dx*dx*sy,
+ obj.dy*dy*(cx*sy*sz+cz*sx), obj.dy*dy*(cx*cz-sx*sy*sz), -obj.dy*dy*cy*sz,
+ sx*sz-cx*cz*sy, cx*sz+cz*sx*sy, cy*cz,
+ cw/2*(1+dx-obj.z[1]-obj.z[0])/dx,
+ ch/2*(1+dy-obj.z[3]-obj.z[2])/dy, obj.depth/2, obj.dx*dx,obj.dy*dy,1];
}
// now transform points for found transformation matrix
var b = obj.b, i;
var x = obj.pnts[i][0]-obj.width/2;
var y = obj.pnts[i][1]-obj.height/2;
var z = obj.pnts[i][2]-obj.depth/2;
- obj.pp[i] = [b[9] + b[0]*x + b[1]*y + b[2]*z,
- b[10] + b[3]*x + b[4]*y + b[5]*z,
- b[11] + b[6]*x + b[7]*y + b[8]*z];
+ if(obj.pnts[i][3]==0) // TODO: check later when mglInPlot will be ready
+ obj.pp[i] = [b[9] + b[0]*x + b[1]*y + b[2]*z,
+ b[10] + b[3]*x + b[4]*y + b[5]*z,
+ b[11] + b[6]*x + b[7]*y + b[8]*z];
+ else
+ obj.pp[i] = [b[9]+b[12]*x,b[10]+b[13]*y,b[11]+b[14]*z];
}
if(obj.pf) for(var i=0;i<obj.npnts;i++) // perspective
{ // NOTE: it is not supported for coordinate determining now
var d = (1-obj.pf)/(1-obj.pf*obj.pp[i][2]/obj.depth);
- obj.pp[i][0] = d*obj.pp[i][0] + (1-d)/2*obj.width;
- obj.pp[i][1] = d*obj.pp[i][1] + (1-d)/2*obj.height;
+ if(obj.pnts[i][3]==0) // TODO: check later when mglInPlot will be ready
+ {
+ obj.pp[i][0] = d*obj.pp[i][0] + (1-d)/2*obj.width;
+ obj.pp[i][1] = d*obj.pp[i][1] + (1-d)/2*obj.height;
+ }
}
// fill z-coordinates for primitives
if(!obj.fast)
string continuation symbol on next line for @ref{MGL scripts}.
@item ~
+disable drawing of tick labels for @ref{axis} and @ref{colorbar};
+
one of mask for face filling (see @ref{Color scheme}).
@item 0,1,2,3,4,5,6,7,8,9
string continuation symbol on next line for @ref{MGL scripts}.
@item ~
+disable drawing of tick labels for @ref{axis} and @ref{colorbar};
+
one of mask for face filling (see @ref{Color scheme}).
@item 0,1,2,3,4,5,6,7,8,9
-@set VERSION 2.2.0
+@set VERSION 2.2
@set MINVER .1
+@set MINVER
@strong{Latest news}
@itemize
-@item @emph{16 May 2013.}
-Update documentation and add Russian @uref{../doc_ru/doc_ru_toc.html, translation} for chapters 4-8.
-@item @emph{16 May 2013.}
-New version (v.1.4.4) of @uref{http://sourceforge.net/projects/mathgl/files/u3d-1.4.4.tar.gz, U3D} is released. Main changes are: disable use of assembler, fix warnings, update cmake,
-update jpeg, png and zlib libraries.
-@item @emph{8 May 2013.}
-New version (v.@value{VERSION}@value{MINVER}) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor bugfixes for cmake options enable-double=OFF, enable-zlib=OFF and enable mouse actions in @uref{../json.html, JS sample} for Firefox.
-@item @emph{2 May 2013.}
-New version (v.@value{VERSION}) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor bugfixes and improvements, which denoted @ref{News, here}.
-@item @emph{13 December 2012.}
-New version (v.2.1) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are new plots, advanced color schemes, @uref{../json.html, JavaScript drawing}, and many other improvements in both MathGL core and UDAV, which partially denoted @ref{News, here}. Note, there are @strong{incompatible with v.2.0.* changes} in the arguments of some functions.
-@item @emph{I'm sorry for making incompatible changes in v.2.1. It was done for introducing unified interface for all functions. I promise that I will not break API for v.2.* later, i.e. I'll only add new features or bug fixes.}
+@item @emph{22 January 2014.}
+New version (v.@value{VERSION}) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are support of Qt5 and Pascal, improvements in JavaScript interface, bugfixes, and other improvements, which denoted @ref{News, here}.
+@item @emph{11 November 2013.}
+New version (v.2.2) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are speeding up, new plot kinds and data handling functions, new plot styles, masks for bitmap output, wx-widget, Lua interface, and many other improvements, which denoted @ref{News, here}.
@end itemize
There is detailed @ref{News, news list}. Sourceforge project page @uref{http://sourceforge.net/projects/mathgl/, here}.
@nav{}
@itemize
+@item
+@strong{22 January 2014.}
+New version (v.2.2.1) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor improvements and bugfixes:
+@itemize @bullet
+@item Add Qt5 support.
+@item Add Pascal interface.
+@item Improve JavaScript interface.
+@item Add function mglGraph::AddRange(char dir, mreal v1, mreal v2) and extend corresponding MGL commands '[xyzc]range'.
+@item Add 'hypot(x,y)' function for known functions in formula parsing.
+@item Add style '~' to disable colorbar or axis labels. NOTE, axis style '_' is obsolete and should be replaced by '~'.
+@item Change Aspect() if Ax=NAN. Now, Ay and Az set the ratio to optimal aspect (not exact value as previously).
+@item Disable changes by View(),Zoom(),Perspective() for position of Title(), Legend(), Colorbar().
+@item Partial support of perspective in CalcXYZ().
+@item Speed up PDE solving.
+@item Add complex versions of PDE, QO2d, QO3d.
+@item Correct filled background for Box() in curved coordinates.
+@item Allow nx=1 for Stem and Error.
+@item Bugfix for drawing single axis.
+@item Bugfix for missing options parsing for some of MGL commands.
+@item Bugfix for .pmin suffix in MGL. Add mglData::MaximalNeg() and mglData::MinimalPos() functions. Add .nmin and .nmax suffixes.
+@item Bugfix for colorbar labels.
+@item Force using python 2.7 by default due to bug in Ubuntu. Debian sid works well with python 3.* too.
+@item Other minor bugfixes and memory leaks.
+@end itemize
+
@item
@strong{11 November 2013.}
New version (v.2.2) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor bugfixes and improvements:
@strong{Latest news}
@itemize
-@item @emph{16 May 2013.}
-Update documentation and add Russian @uref{../doc_ru/doc_ru_toc.html, translation} for chapters 4-8.
-@item @emph{16 May 2013.}
-New version (v.1.4.4) of @uref{http://sourceforge.net/projects/mathgl/files/u3d-1.4.4.tar.gz, U3D} is released. Main changes are: disable use of assembler, fix warnings, update cmake,
-update jpeg, png and zlib libraries.
-@item @emph{8 May 2013.}
-New version (v.@value{VERSION}@value{MINVER}) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor bugfixes for cmake options enable-double=OFF, enable-zlib=OFF and enable mouse actions in @uref{../json.html, JS sample} for Firefox.
-@item @emph{2 May 2013.}
-New version (v.@value{VERSION}) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor bugfixes and improvements, which denoted @ref{News, here}.
-@item @emph{13 December 2012.}
-New version (v.2.1) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are new plots, advanced color schemes, @uref{../json.html, JavaScript drawing}, and many other improvements in both MathGL core and UDAV, which partially denoted @ref{News, here}. Note, there are @strong{incompatible with v.2.0.* changes} in the arguments of some functions.
-@item @emph{I'm sorry for making incompatible changes in v.2.1. It was done for introducing unified interface for all functions. I promise that I will not break API for v.2.* later, i.e. I'll only add new features or bug fixes.}
+@item @emph{22 January 2014.}
+New version (v.@value{VERSION}) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are support of Qt5 and Pascal, improvements in JavaScript interface, bugfixes, and other improvements, which denoted @ref{News, here}.
+@item @emph{11 November 2013.}
+New version (v.2.2) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are speeding up, new plot kinds and data handling functions, new plot styles, masks for bitmap output, wx-widget, Lua interface, and many other improvements, which denoted @ref{News, here}.
@end itemize
There is detailed @ref{News, news list}. Sourceforge project page @uref{http://sourceforge.net/projects/mathgl/, here}.
@nav{}
@itemize
+@item
+@strong{22 January 2014.}
+New version (v.2.2.1) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor improvements and bugfixes:
+@itemize @bullet
+@item Add Qt5 support.
+@item Add Pascal interface.
+@item Improve JavaScript interface.
+@item Add function mglGraph::AddRange(char dir, mreal v1, mreal v2) and extend corresponding MGL commands '[xyzc]range'.
+@item Add 'hypot(x,y)' function for known functions in formula parsing.
+@item Add style '~' to disable colorbar or axis labels. NOTE, axis style '_' is obsolete and should be replaced by '~'.
+@item Change Aspect() if Ax=NAN. Now, Ay and Az set the ratio to optimal aspect (not exact value as previously).
+@item Disable changes by View(),Zoom(),Perspective() for position of Title(), Legend(), Colorbar().
+@item Partial support of perspective in CalcXYZ().
+@item Speed up PDE solving.
+@item Add complex versions of PDE, QO2d, QO3d.
+@item Correct filled background for Box() in curved coordinates.
+@item Allow nx=1 for Stem and Error.
+@item Bugfix for drawing single axis.
+@item Bugfix for missing options parsing for some of MGL commands.
+@item Bugfix for .pmin suffix in MGL. Add mglData::MaximalNeg() and mglData::MinimalPos() functions. Add .nmin and .nmax suffixes.
+@item Bugfix for colorbar labels.
+@item Force using python 2.7 by default due to bug in Ubuntu. Debian sid works well with python 3.* too.
+@item Other minor bugfixes and memory leaks.
+@end itemize
+
@item
@strong{11 November 2013.}
New version (v.2.2) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are minor bugfixes and improvements:
@item Add style 't' for @ref{cones} to produce tubes (cylinders).
@item Add style '^' for @ref{legend} to left/right align legend if its coordinates are right/left from the center
@item Add style '<', '^', '>' for aligning/centering boxes in @ref{bars}, @ref{barh}, @ref{boxplot}, @ref{cones}. Also this plots become centered by default if nx sizes are the same for all data.
-@item Add @ref{dots} function which set independently both color and alpha of dots.
+@item Add @ref{dots} function which set independently both color and transparency of dots.
@item Improve automatic axis position. Add style '^' for inverse automatic axis position.
@item Improve tick labeling. Add style @ref{tuneticks}&4 for zero filling of tick labels.
@item Add @ref{refill} for filling by interpolation of parametrically dependent data
u. Test FlowP + 3d
11. Check centered curved text (see text2)
-14. Export to X3D
+12. Export to X3D
+
+16. Inplot data should have ranges (add mglInPlot{x1,x2,y1,y2,Bp or something like this} which include mglMatrix instead of mglBase::Bp) + calc coor + JS
+17. 'perspective' command in UDAV
+18. Check octave 3.8
+21. Use mglFormulaCalc() for data transformation/filling (much faster but require more memory) + the same for complex
============= DOCUMENTATION =============
1. Extend Dots sample (add A, CA, Tens)
2. Extend Refill sample (add 2d)
+3. Docs about JS interface
============= UDAV =============
-if(MGL_HAVE_QT)
+if(enable-qt)
#set(mgl_wnd_src window.cpp)
set(udav_src anim_dlg.cpp find_dlg.cpp mem_pnl.cpp prop_dlg.cpp textedit.cpp args_dlg.cpp
include_directories(${GSL_INCLUDE_DIR})
endif(MGL_HAVE_GSL)
-include(${QT_USE_FILE})
-qt4_add_resources(udav_rc_src ${udav_rc} )
-#qt_wrap_cpp(udav udav_moc_src ${udav_moc_hdr} )
-qt4_wrap_cpp(udav_moc_src ${udav_moc_hdr} )
+if(enable-qt5)
+ include(../cmake-qt5.txt)
+ qt5_add_resources(udav_rc_src ${udav_rc} )
+ qt5_wrap_cpp(udav_moc_src ${udav_moc_hdr} )
+else(enable-qt5)
+ include(../cmake-qt4.txt)
+ qt4_add_resources(udav_rc_src ${udav_rc} )
+ qt4_wrap_cpp(udav_moc_src ${udav_moc_hdr} )
+endif(enable-qt5)
add_executable(udav ${udav_src} ${udav_moc_src} ${udav_rc_src})
#set_target_properties(udav PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-target_link_libraries(udav mgl-qt ${QT_LIBRARIES})
+if(enable-qt5)
+ target_link_libraries(udav mgl-qt5)
+ qt5_use_modules(udav Core Widgets Gui Network WebKit PrintSupport)
+else(enable-qt5)
+ target_link_libraries(udav mgl-qt4)
+ target_link_libraries(udav ${QT_LIBRARIES})
+endif(enable-qt5)
if(MGL_HAVE_PTHREAD)
target_link_libraries(udav ${CMAKE_THREAD_LIBS_INIT})
install(FILES udav.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/pixmaps/)
install(FILES udav_ru.qm DESTINATION ${CMAKE_INSTALL_PREFIX}/share/udav/)
-endif(MGL_HAVE_QT)
+endif(enable-qt)
{
bool ok;
QString s = QInputDialog::getText(this, tr("UDAV - Export to PNG"), tr("Enter color scheme for picture"), QLineEdit::Normal, MGL_DEF_SCH, &ok);
- if(ok) var->Export(fn.toAscii().constData(), s.toAscii().constData());
+ if(ok) var->Export(fn.toStdString().c_str(), s.toStdString().c_str());
}
else if(ext=="h5" || ext=="hdf")
{
bool ok;
QString s = QInputDialog::getText(this, tr("UDAV - Save to HDF"), tr("Enter data name"), QLineEdit::Normal, QString::fromStdWString(var->s), &ok);
- if(ok) var->SaveHDF(fn.toAscii().constData(), s.toAscii().constData());
+ if(ok) var->SaveHDF(fn.toStdString().c_str(), s.toStdString().c_str());
}
- else var->Save(fn.toAscii().constData());
+ else var->Save(fn.toStdString().c_str());
}
//-----------------------------------------------------------------------------
void DatPanel::load()
{
bool ok;
QString s = QInputDialog::getText(this, tr("UDAV - Import PNG"), tr("Enter color scheme for picture"), QLineEdit::Normal, MGL_DEF_SCH, &ok);
- if(ok) var->Import(fn.toAscii().constData(), s.toAscii().constData());
+ if(ok) var->Import(fn.toStdString().c_str(), s.toStdString().c_str());
}
else if(ext=="h5" || ext=="hdf")
{
bool ok;
QString s = QInputDialog::getText(this, tr("UDAV - Read from HDF"), tr("Enter data name"), QLineEdit::Normal, QString::fromStdWString(var->s), &ok);
- if(ok) var->ReadHDF(fn.toAscii().constData(), s.toAscii().constData());
+ if(ok) var->ReadHDF(fn.toStdString().c_str(), s.toStdString().c_str());
}
- else var->Read(fn.toAscii().constData());
+ else var->Read(fn.toStdString().c_str());
refresh();
}
//-----------------------------------------------------------------------------
bool res = d->exec();
if(res && !v1->text().isEmpty() && !v2->text().isEmpty() && !id->text().isEmpty())
{
- mglVar *vv = parser.AddVar(id->text().toAscii().constData());
+ mglVar *vv = parser.AddVar(id->text().toStdString().c_str());
if(!vv) return;
vv->Set(var->Hist(nm->value(), v1->text().toDouble(), v2->text().toDouble()));
updateDataItems();
if(!mgl.isEmpty())
{
mglGraph gr;
- parser.Execute(&gr,mgl.toAscii().constData());
+ parser.Execute(&gr,mgl.toStdString().c_str());
opers += mgl+"\n";
updateDataItems();
}
if(!mgl.isEmpty())
{
mglGraph gr;
- parser.Execute(&gr,mgl.toAscii().constData());
+ parser.Execute(&gr,mgl.toStdString().c_str());
opers += mgl+"\n";
updateDataItems();
}
QString name = QInputDialog::getText(this, tr("UDAV - New variable"),
tr("Enter name for new variable"), QLineEdit::Normal, "", &ok);
if(!ok || name.isEmpty()) return;
- mglVar *v = parser.AddVar(name.toAscii().constData());
+ mglVar *v = parser.AddVar(name.toStdString().c_str());
QWidget *t;
if(v->o) t = (QWidget *)v->o;
else t = newDataWnd(infoDlg,wnd,v);
if(tab->rowCount()<1) return;
if(n<0) n = tab->currentRow();
if(n<0) n = 0;
- mglVar *v = parser.FindVar(tab->item(n,0)->text().toAscii().constData());
+ mglVar *v = parser.FindVar(tab->item(n,0)->text().toStdString().c_str());
if(!v) return;
QWidget *t;
if(v->o) t = (QWidget *)v->o;
if(tab->rowCount()<1) return;
int n = tab->currentRow();
if(n<0) n = 0;
- mglVar *v = parser.FindVar(tab->item(n,0)->text().toAscii().constData());
+ mglVar *v = parser.FindVar(tab->item(n,0)->text().toStdString().c_str());
if(!v && v->o) ((QWidget *)v->o)->close();
- parser.DeleteVar(tab->item(n,0)->text().toAscii().constData());
+ parser.DeleteVar(tab->item(n,0)->text().toStdString().c_str());
refresh();
}
//-----------------------------------------------------------------------------
if(tab->rowCount()<1) return;
int n = tab->currentRow();
if(n<0) n = 0;
- mglVar *v = parser.FindVar(tab->item(n,0)->text().toAscii().constData());
+ mglVar *v = parser.FindVar(tab->item(n,0)->text().toStdString().c_str());
if(!v) return;
infoDlg->setVar(v);
QString s = QString::fromStdWString(v->s);
// clear old
kind->clear(); kinds.clear(); for(k=0;k<NUM_CH;k++) argn[k].clear();
// try to find the keyword
- if(!parser.CmdType(n.toAscii().constData())) return;
- info->setText(QString::fromAscii(parser.CmdDesc(n.toAscii().constData())));
+ if(!parser.CmdType(n.toStdString().c_str())) return;
+ info->setText(QString::fromLocal8Bit(parser.CmdDesc(n.toStdString().c_str())));
- par = QString::fromAscii(parser.CmdFormat(n.toAscii().constData()));
+ par = QString::fromLocal8Bit(parser.CmdFormat(n.toStdString().c_str()));
int i0 = par.indexOf(' '); // first space if present
if(i0<0) { kind->addItem(par); return; } // no arguments
// parse kind of arguments
code = ""; numDataOpened++; data = name->text();
// prepare unique value of name for next time
char buf[32]; snprintf(buf,32,"mgl_%d",numDataOpened); name->setText(buf);
- mglVar *v = parser.AddVar(data.toAscii().constData());
+ mglVar *v = parser.AddVar(data.toStdString().c_str());
bool dd=0;
if(rA->isChecked()) // auto sizes
{
- setlocale(LC_NUMERIC, "C"); v->Read(file.toAscii().constData()); setlocale(LC_NUMERIC, "");
+ setlocale(LC_NUMERIC, "C"); v->Read(file.toStdString().c_str()); setlocale(LC_NUMERIC, "");
if(v->nx==1) { v->nx = v->ny; v->ny = v->nz; }
code=QString("#read %1 '%2'\n").arg(data).arg(file);
}
else if(rM->isChecked()) // manual sizes
{
int x=nx->text().toInt(), y=ny->text().toInt(), z=nz->text().toInt();
- setlocale(LC_NUMERIC, "C"); v->Read(file.toAscii().constData(),x,y,z); setlocale(LC_NUMERIC, "");
+ setlocale(LC_NUMERIC, "C"); v->Read(file.toStdString().c_str(),x,y,z); setlocale(LC_NUMERIC, "");
code=QString("#read %1 '%2' %3 %4 %5\n").arg(data).arg(file).arg(x).arg(y).arg(z);
}
else if(r2->isChecked()) // matrix
{
- setlocale(LC_NUMERIC, "C"); v->ReadMat(file.toAscii().constData()); setlocale(LC_NUMERIC, "");
+ setlocale(LC_NUMERIC, "C"); v->ReadMat(file.toStdString().c_str()); setlocale(LC_NUMERIC, "");
code=QString("#readmat %1 '%2'\n").arg(data).arg(file); dd=1;
}
else if(r3->isChecked()) // 3d-data
{
- setlocale(LC_NUMERIC, "C"); v->ReadMat(file.toAscii().constData(),3); setlocale(LC_NUMERIC, "");
+ setlocale(LC_NUMERIC, "C"); v->ReadMat(file.toStdString().c_str(),3); setlocale(LC_NUMERIC, "");
code=QString("#readmat %1 '%2' 3\n").arg(data).arg(file); dd=2;
}
if(scr->lineEdit()->text().isEmpty() || scr->lineEdit()->text()==tr("default"))
void DataOpenDialog::setFile(const QString &fname)
{
file=fname;
- mglData d(file.toAscii().constData());
+ mglData d(file.toStdString().c_str());
rA->setText(tr("Auto detect data sizes (%1 x %2 x %3)").arg(d.nx).arg(d.ny).arg(d.nz));
}
//-----------------------------------------------------------------------------
a = new QAction(QPixmap(":/xpm/alpha.png"), tr("Alpha"), this);
a->setShortcut(Qt::CTRL+Qt::Key_T); a->setCheckable(true);
connect(a, SIGNAL(toggled(bool)), mgl, SLOT(setAlpha(bool)));
- connect(mgl, SIGNAL(alphaChanged(bool)), a, SLOT(setOn(bool)));
+ connect(mgl, SIGNAL(alphaChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(tr("Switch on/off transparency for the graphics (Ctrl+T)."));
o->addAction(a);
bb = new QToolButton(this); l->addWidget(bb); bb->setDefaultAction(a);
a = new QAction(QPixmap(":/xpm/weather-clear.png"), tr("Light"), this);
a->setShortcut(Qt::CTRL+Qt::Key_L); a->setCheckable(true);
connect(a, SIGNAL(toggled(bool)), mgl, SLOT(setLight(bool)));
- connect(mgl, SIGNAL(lightChanged(bool)), a, SLOT(setOn(bool)));
+ connect(mgl, SIGNAL(lightChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(tr("Switch on/off lightning for the graphics (Ctrl+L)."));
o->addAction(a);
bb = new QToolButton(this); l->addWidget(bb); bb->setDefaultAction(a);
a = new QAction(QPixmap(":/xpm/object-rotate-right.png"), tr("Rotate by mouse"), this);
a->setCheckable(true);
connect(a, SIGNAL(toggled(bool)), mgl, SLOT(setRotate(bool)));
- connect(mgl, SIGNAL(rotateChanged(bool)), a, SLOT(setOn(bool)));
+ connect(mgl, SIGNAL(rotateChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(tr("Switch on/off mouse handling of the graphics\n(rotation, shifting, zooming and perspective)."));
bb = new QToolButton(this); l->addWidget(bb); bb->setDefaultAction(a);
/* a = new QAction(QPixmap(":/xpm/zoom-fit-best.png"), tr("Zoom by mouse"), this);
a->setCheckable(true);
connect(a, SIGNAL(toggled(bool)), mgl, SLOT(setZoom(bool)));
- connect(mgl, SIGNAL(zoomChanged(bool)), a, SLOT(setOn(bool)));
+ connect(mgl, SIGNAL(zoomChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(tr("Switch on/off mouse zoom of selected region."));
bb = new QToolButton(this); l->addWidget(bb); bb->setDefaultAction(a);*/
class DatPanel;
class mglVar;
class StyleDialog;
+class QPrinter;
//-----------------------------------------------------------------------------
class PlotPanel : public QWidget
{
#include <QSyntaxHighlighter>
#include <QDialog>
#include <QLineEdit>
+#include <QTextEdit>
//-----------------------------------------------------------------------------
///Syntax highlighter for MGL script language.
class QMGLSyntax : public QSyntaxHighlighter
#include <QCheckBox>
#include <QLineEdit>
#include <QSpinBox>
-#include <QSlider>
#include <QLayout>
#include <QLabel>
#include <QFile>
\r
nline = new QSlider(p); g->addWidget(nline, 2, 2);\r
nline->setRange(1, 9); nline->setValue(5);\r
- nline->setTickPosition(QSlider::TicksAbove);\r
+ nline->setTickPosition(QSlider::TicksBothSides);\r
nline->setTickInterval(1); nline->setPageStep(2);\r
nline->setOrientation(Qt::Horizontal);\r
\r
fillColors(cc[i]);\r
nn[i] = new QSlider(p); g->addWidget(nn[i], i+1, 1);\r
nn[i]->setRange(1, 9); nn[i]->setValue(5);\r
- nn[i]->setTickPosition(QSlider::TicksAbove);\r
+ nn[i]->setTickPosition(QSlider::TicksBothSides);\r
nn[i]->setTickInterval(1); nn[i]->setPageStep(2);\r
nn[i]->setOrientation(Qt::Horizontal);\r
connect(cc[i],SIGNAL(activated(int)), this, SLOT(updatePic()));\r
connect(rbC,SIGNAL(toggled(bool)), this, SLOT(updatePic()));\r
connect(rbR,SIGNAL(toggled(bool)), this, SLOT(updatePic()));\r
tab->addTab(p, tr("Font style"));\r
- connect(tab,SIGNAL(currentChanged(QWidget *)), this, SLOT(updatePic()));\r
+ connect(tab,SIGNAL(currentChanged(int)), this, SLOT(updatePic()));\r
\r
// dialog itself\r
v = new QVBoxLayout(this); v->addWidget(tab);\r
if(i>0)\r
{\r
j = nline->value();\r
- if(j!=5) result += "{"+col[i-1]+char('0'+i)+"}";\r
+ if(j!=5) result += "{"+col[i-1]+char('0'+j)+"}";\r
else result += col[i-1];\r
}\r
i = width->value(); if(i>1) result += char('0'+i);\r
- gr.Plot(x,y,result.toAscii().constData());\r
+ gr.Plot(x,y,result.toStdString().c_str());\r
break;\r
case 1: // color sceheme\r
for(j=0;j<7;j++)\r
if(i==2) result += 'T';\r
i = axial->currentIndex();\r
if(i>0) result = result+':'+char('x'+i-1);\r
- gr.Surf(a,result.toAscii().constData());\r
+ gr.Surf(a,result.toStdString().c_str());\r
break;\r
case 2: // text style\r
i = cfont->currentIndex();\r
if(rbL->isChecked()) result += 'L';\r
if(rbC->isChecked()) result += 'C';\r
if(rbR->isChecked()) result += 'R';\r
- gr.Puts(mglPoint(0,-0.5),"Font test",result.toAscii().constData(),-10);\r
+ gr.Puts(mglPoint(0,-0.5),"Font test",result.toStdString().c_str(),-10);\r
break;\r
}\r
result = "'" + result + "'";\r
if(!files_dlg) files_dlg= new FilesDialog;
register int i,n=parser.GetCmdNum();
- for(i=0;i<n;i++) words<<QString::fromAscii(parser.GetCmdName(i));
+ for(i=0;i<n;i++) words<<QString::fromLocal8Bit(parser.GetCmdName(i));
vars = words;
connect(setupDlg, SIGNAL(putText(const QString &)), this, SLOT(animPutText(const QString &)));
// completer->setCompletionMode(en ? QCompleter::PopupCompletion : QCompleter::InlineCompletion);
}
//-----------------------------------------------------------------------------
-mglData mglFormulaCalc(const wchar_t *string, mglParser *arg);
void TextPanel::insNVal()
{
QString sel=edit->textCursor().selectedText();
hid_t hf,hg,hd,hs,ht;
hsize_t dims[3];
long rank;
- hf = H5Fopen(fileName.toAscii().constData(), H5F_ACC_RDONLY, H5P_DEFAULT);
+ hf = H5Fopen(fileName.toStdString().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
if(!hf) return;
hg = H5Gopen(hf, "/");
hsize_t num, nx, ny, nz, i;
long rank = 3;
H5Eset_auto(0,0);
- hf = H5Fcreate(fileName.toAscii().constData(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+ hf = H5Fcreate(fileName.toStdString().c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if(hf<0)
{
setStatus(tr("Could not write to %1").arg(fileName));
txt += edit->toPlainText();
dims[0] = txt.length()+1;
char *buf = new char[dims[0]+1];
- memcpy(buf, txt.toAscii().constData(), dims[0]);
+ memcpy(buf, txt.toStdString().c_str(), dims[0]);
buf[dims[0]]=0;
hs = H5Screate_simple(1, dims, 0);
hd = H5Dcreate(hf, "mgl_script", H5T_C_S1, hs, H5P_DEFAULT);
#include <QTextCodec>
#include <QTranslator>
#include <QVariant>
+#include <QMimeData>
//-----------------------------------------------------------------------------
#if !defined(WIN32) && !defined(__APPLE__)
#include <X11/Xlib.h>
bool loadInNewWnd = false;
QString pathHelp;
extern mglParse parser;
-extern QColor mglColorScheme[9];
+extern QColor mglColorScheme[10];
extern QString defFontFamily;
extern int defFontSize;
extern QString pathFont;
{
QTextCodec *codec = QTextCodec::codecForLocale();
QString filename = codec->toUnicode(event->mimeData()->data("text/plain"));
- if ( event->provides("text/plain") )
+ /*if ( event->provides("text/plain") )
{
QTextCodec *codec = QTextCodec::codecForLocale();
QString instring = codec->toUnicode(event->mimeData()->data("text/plain"));
event->acceptProposedAction();
setStatus(instring);
}
- }else
- if ( event->mimeData()->hasUrls() )
+ }
+ else */
+ if(event->mimeData()->hasUrls())
{
QList<QUrl> UrlList;
QFileInfo finfo;
if ( UrlList.size() > 0) // if at least one QUrl is present in list
{
filename = UrlList[0].toLocalFile(); // convert first QUrl to local path
- finfo.setFile( filename );
+ finfo.setFile(filename);
if ( finfo.isFile() )
{
- setStatus(filename);
event->acceptProposedAction();
+ setStatus(filename);
}
}
}
for(i=0;i<n;i++) if(dlm.contains(text[i])) break;
text.truncate(i);
- const char *desc = parser.CmdDesc(text.toAscii().constData());
- const char *form = parser.CmdFormat(text.toAscii().constData());
- if(form) setStatus(QString::fromAscii(desc)+": "+QString::fromAscii(form));
+ const char *desc = parser.CmdDesc(text.toStdString().c_str());
+ const char *form = parser.CmdFormat(text.toStdString().c_str());
+ if(form) setStatus(QString::fromLocal8Bit(desc)+": "+QString::fromLocal8Bit(form));
else setStatus(tr("Not recognized"));
}
//-----------------------------------------------------------------------------
void MainWindow::about()
{
QString s = tr("UDAV v. 2.")+QString::number(MGL_VER2)+
- tr("\n(c) Alexey Balakin, 2008-2012\nhttp://mathgl.sf.net/");
+ tr("\n(c) Alexey Balakin, 2007-2014\nhttp://mathgl.sf.net/");
QMessageBox::about(this, tr("UDAV - about"), s);
}
//-----------------------------------------------------------------------------
void MainWindow::setCurrentFile(const QString &fileName)
{
filename = fileName;
- mgl_set_plotid(graph->mgl->getGraph(), fileName.toAscii().constData());
+ mgl_set_plotid(graph->mgl->getGraph(), fileName.toStdString().c_str());
edit->setModified(false);
if(filename.isEmpty())
setWindowTitle(tr("untitled - UDAV"));
RUNTIME DESTINATION ${MGL_CGI_PATH}
)
-if(MGL_HAVE_QT)
- include(${QT_USE_FILE})
+if(enable-qt)
add_executable(mglview mglview.cpp)
- target_link_libraries(mglview mgl-qt)
+ if(enable-qt5)
+ include(../cmake-qt5.txt)
+ target_link_libraries(mglview mgl-qt5)
+ qt5_use_modules(mglview Core Widgets Gui Network WebKit PrintSupport)
+ else(enable-qt5)
+ include(../cmake-qt4.txt)
+ target_link_libraries(mglview mgl-qt4)
+ target_link_libraries(mglview ${QT_LIBRARIES})
+ endif(enable-qt5)
+
install(
TARGETS mglview
RUNTIME DESTINATION bin
)
-endif(MGL_HAVE_QT)
+endif(enable-qt)
--- /dev/null
+#include <stdio.h>
+#include <string.h>
+
+const char *files[]={"../include/mgl2/base_cf.h","../include/mgl2/data_cf.h", "../include/mgl2/datac_cf.h", "../include/mgl2/cont.h", "../include/mgl2/fit.h", "../include/mgl2/plot.h", "../include/mgl2/surf.h", "../include/mgl2/volume.h", "../include/mgl2/vect.h", "../include/mgl2/prim.h", "../include/mgl2/other.h", "../include/mgl2/canvas_cf.h", "../include/mgl2/addon.h", ""};
+
+const char *head="\\ Mathgl library wrapper\n\
+\\ Copyright (C) 2008-2013, Sergey Plis, Alexey Balakin\n\\\n\
+\\ This program is free software; you can redistribute it and/or modify\n\
+\\ it under the terms of the GNU General Public License as published by\n\
+\\ the Free Software Foundation; either version 2 of the License, or\n\
+\\ (at your option) any later version.\n\\\n\
+\\ This program is distributed in the hope that it will be useful,\n\
+\\ but WITHOUT ANY WARRANTY; without even the implied warranty of\n\
+\\ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\
+\\ GNU General Public License for more details.\n\n\
+Module mathgl\n\
+library libmgl libmgl.so\n\
+library libmgl-glut libmgl-glut.so\n\
+library libmgl-fltk libmgl-fltk.so\n\
+library libmgl-qt libmgl-qt.so\n\
+library libmgl-wx libmgl-wx.so\n\
+legacy off\n\n\
+libmgl mgl_create_graph_gl\t\t(ptr)\tmgl_create_graph_gl\n\
+libmgl-glut mgl_create_graph_glut\tptr ptr ptr\t(ptr)\tmgl_create_graph_glut\n\
+libmgl-fltk mgl_create_graph_fltk\tptr ptr ptr\t(ptr)\tmgl_create_graph_fltk\n\
+libmgl-fltk mgl_fltk_run\t\t(void)\tmgl_fltk_run\n\
+libmgl-qt mgl_create_graph_qt\tptr ptr ptr\t(ptr)\tmgl_create_graph_qt\n\
+libmgl-qt mgl_qt_run\t\t\t(void)\tmgl_qt_run\n";
+
+const char *parse_name(char *name, char *fnc)
+{
+ static char res[1024]; memset(res,0,1024);
+ char *ptr,*arg[20],nul=0; // TODO check if 20 arguments is enough
+ unsigned i;
+ for(i=0;name[i]!='(';i++) res[i]=name[i];
+ memcpy(fnc,res,i); fnc[i]=0; // copy name for later
+ res[i]='\t'; i++;
+ for(int j=1;j<=(25-i)/4;j++) res[i+j-1]='\t';
+
+/* static char res[1024];
+ char *ptr,*arg[20],nul=0; // TODO check if 20 arguments is enough
+ unsigned i;
+ for(i=0;name[i]!='(';i++) res[i]=name[i];
+ memcpy(fnc,res,i); fnc[i]=0; // copy name for later
+ res[i]='\t'; res[i+1]=0; i++;*/
+
+ while(name[i]<=' ') i++;
+ for(int j=0;j<20;j++) arg[j]=&nul;
+ for(int j=0;j<20;j++)
+ {
+ arg[j]= name[i]<=' ' ? name+i+1 : name+i;
+ ptr=strchr(name+i,',');
+ if(!ptr) break;
+ *ptr=0; i=ptr-name+1;
+ }
+ ptr=strchr(name+i,')'); if(ptr) *ptr=0;
+ for(int j=19;j>=0;j--)
+ {
+ if(arg[j][0]==0) continue;
+ if(!strncmp(arg[j],"HMGL ",5)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"HADT ",5)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"HCDT ",5)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"HMDT ",5)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"HMPR ",5)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"HMEX ",5)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"const float *",13)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"const double *",14)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"mreal *",7)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"double *",8)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"char *",6)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"int *",5)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"long *",6)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"const char *",12)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"const wchar_t *",15)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"char ",5)) strcat(res, "char ");
+ else if(!strncmp(arg[j],"long ",5)) strcat(res, "int "); // TODO check
+ else if(!strncmp(arg[j],"uint32_t ",9)) strcat(res, "int "); // TODO check
+ else if(!strncmp(arg[j],"int ",4)) strcat(res, "int ");
+ else if(!strncmp(arg[j],"mreal ",6)) strcat(res, "sf "); // TODO check
+ else if(!strncmp(arg[j],"double ",7)) strcat(res, "double ");
+ else if(!strncmp(arg[j],"gsl_vector *",12)) strcat(res, "ptr ");
+ else if(!strncmp(arg[j],"gsl_matrix *",12)) strcat(res, "ptr ");
+ else sprintf(res, " !!! %s;", arg[j]); // NOTE should be never here
+ }
+ return res;
+}
+
+bool parse_file(const char *fname, FILE *out)
+{
+ if(!fname || fname[0]==0) return false;
+ FILE *fp=fopen(fname,"rt");
+ if(!fp) return false;
+
+ char buf[1024], *ptr, fnc[128]="";
+ while(!feof(fp))
+ {
+ fgets(buf,1024,fp);
+ // first filter unwanted strings
+ if(buf[0]==0 || buf[0]=='\n' || buf[1]=='\n') continue;
+ if(buf[0]=='#' || buf[0]=='}') continue;
+ if(!strncmp(buf, "extern",6)) continue;
+ if(!strncmp(buf, "class",5)) continue;
+ if(!strncmp(buf, "struct",6)) continue;
+ if(!strncmp(buf, "typedef",7)) continue;
+ if(strstr(buf, "void *")) continue;
+ if(strstr(buf, "_(")) continue;
+ if(strstr(buf, "FILE")) continue;
+ if(strstr(buf, "TODO")) continue;
+ if(strstr(buf, "//")) continue;
+ if(strstr(buf, "...)")) continue;
+
+ // TODO following 5 lines enable later
+ if(strstr(buf, "* const *")) continue;
+ if(strstr(buf, "uint64_t")) continue;
+ if(strstr(buf, "dual")) continue;
+ if(strstr(buf, "HADT")) continue;
+ if(strstr(buf, "HAEX")) continue;
+
+ // now filter comments
+ if(buf[0]=='/' && buf[1]=='*')
+ {
+ do fgets(buf,1024,fp); while(!strstr(buf,"*/"));
+ continue;
+ }
+ ptr = strchr(buf,';'); if(ptr) *ptr=' ';
+ for(unsigned i=strlen(buf)-1;buf[i]<=' ';i--) buf[i]=0;
+ if(buf[0]=='/' && buf[1]=='/')
+ fprintf(out,"%s\n",buf);
+ else if(!strncmp(buf,"void MGL_EXPORT",15))
+ fprintf(out,"libmgl %s\t(void)\t%s\n",parse_name(buf+16,fnc),fnc);
+ else if(!strncmp(buf,"int MGL_EXPORT",14))
+ fprintf(out,"libmgl %s\t(int)\t%s\n",parse_name(buf+15,fnc),fnc);
+ else if(!strncmp(buf,"double MGL_EXPORT",17))
+ fprintf(out,"libmgl %s\t(double)\t%s\n",parse_name(buf+18,fnc),fnc);
+ else if(!strncmp(buf,"mreal MGL_EXPORT",16))
+ fprintf(out,"libmgl %s\t(sf)\t%s\n",parse_name(buf+17,fnc),fnc);
+ else if(!strncmp(buf,"long MGL_EXPORT",15))
+ fprintf(out,"libmgl %s\t(int)\t%s\n",parse_name(buf+16,fnc),fnc);
+ else if(!strncmp(buf,"HMDT MGL_EXPORT",15))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+16,fnc),fnc);
+ else if(!strncmp(buf,"HMGL MGL_EXPORT",15))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+16,fnc),fnc);
+ else if(!strncmp(buf,"MGL_EXPORT const char *",23))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+24,fnc),fnc);
+ else if(!strncmp(buf,"MGL_EXPORT mreal *",18))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+19,fnc),fnc);
+ else if(!strncmp(buf,"MGL_EXPORT const unsigned char *",32))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+33,fnc),fnc);
+ else if(!strncmp(buf,"HMPR MGL_EXPORT",15))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+16,fnc),fnc);
+ else if(!strncmp(buf,"HMEX MGL_EXPORT",15))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+16,fnc),fnc);
+ else if(!strncmp(buf,"HADT MGL_EXPORT",15))
+ fprintf(out,"libmgl %s\t(ptr)\t%s\n",parse_name(buf+16,fnc),fnc);
+ else fprintf(out,"!!!!\t%s\n",buf); // NOTE should be never here!
+ }
+ fclose(fp);
+ return true;
+}
+
+int main()
+{
+ FILE *fout = fopen("../include/mgl2/mgl.fs","wt");
+ fprintf(fout,"%s\n",head);
+ for(int i=0;parse_file(files[i],fout);i++);
+ fclose(fout);
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <string.h>
+
+const char *files[] =
+{
+ "../include/mgl2/base_cf.h",
+ "../include/mgl2/data_cf.h",
+ "../include/mgl2/datac_cf.h",
+ "../include/mgl2/cont.h",
+ "../include/mgl2/fit.h",
+ "../include/mgl2/plot.h",
+ "../include/mgl2/surf.h",
+ "../include/mgl2/volume.h",
+ "../include/mgl2/vect.h",
+ "../include/mgl2/prim.h",
+ "../include/mgl2/other.h",
+ "../include/mgl2/canvas_cf.h",
+ "../include/mgl2/addon.h",
+ "" };
+
+const char *head =
+ "//**************************************************************************\n\
+// mgl_pas.pas is part of Math Graphic Library *\n\
+// Copyright (C) 2008-2013 Mikhail Barg, Alexey Balakin *\n\
+// *\n\
+// This program is free software; you can redistribute it and/or modify *\n\
+// it under the terms of the GNU Library General Public License as *\n\
+// published by the Free Software Foundation; either version 2 of the *\n\
+// License, or (at your option) any later version. *\n\
+// *\n\
+// This program is distributed in the hope that it will be useful, *\n\
+// but WITHOUT ANY WARRANTY; without even the implied warranty of *\n\
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\n\
+// GNU General Public License for more details. *\n\
+// *\n\
+// You should have received a copy of the GNU Library General Public *\n\
+// License along with this program; if not, write to the *\n\
+// Free Software Foundation, Inc., *\n\
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\n\
+//**************************************************************************\n\n\
+unit mgl_pas;\n\n\
+{$IFDEF FPC}\n\
+{$MODE DELPHI }\n\
+{$PACKENUM 4} (* use 4-byte enums *)\n\
+{$PACKRECORDS C} (* C/C++-compatible record packing *)\n\
+{$ELSE}\n\
+{$MINENUMSIZE 4} (* use 4-byte enums *)\n\
+{$ENDIF}\n\n\
+{$IFDEF DARWIN}\n\
+{$linklib libmgl}\n\
+{$ENDIF}\n\n\
+interface\n\n\
+uses\n\
+{$IFDEF MSWINDOWS}\n\
+Windows, Graphics,\n\
+{$ENDIF}\n\
+Math;\n\n\
+const MGL_VER2 = 2.2;\n\
+//* This define enables double precision in MathGL */\n\
+MGL_USE_DOUBLE = 1;\n\n\
+const\n\
+{$IFDEF MSWINDOWS}\n\
+//win - .dll\n\
+libmgl = 'libmgl.dll';\n\
+libmglglut = 'libmgl-glut.dll';\n\
+libmglfltk = 'libmgl-fltk.dll';\n\
+libmglqt = 'libmgl-qt.dll';\n\
+{$ELSE}\n\
+{$IFDEF LINUX}\n\
+//linux - .so\n\
+libmgl = 'libmgl.so';\n\
+libmglglut = 'libmgl-glut.so';\n\
+libmglfltk = 'libmgl-fltk.so';\n\
+libmglqt = 'libmgl-qt.so';\n\
+{$ELSE}\n\
+{$IFDEF DARWIN}\n\
+//darwin - .dylib\n\
+libmgl = 'libmgl.dylib';\n\
+libmglglut = 'libmgl-glut.dylib';\n\
+libmglfltk = 'libmgl-fltk.dylib';\n\
+libmglqt = 'libmgl-qt.dylib';\n\
+{$ELSE}\n\
+// other platforms?\n\n\
+{$ENDIF}\n\
+{$ENDIF}\n\
+{$ENDIF}\n\n\
+{$IF (MGL_USE_DOUBLE = 0)}\n\
+type mreal = double;\n\
+{$ELSE}\n\
+type mreal = real;\n\
+{$IFEND}\n\
+{$IFDEF FPC}\n\
+{$ELSE}\n\
+type QWord = Int64;\n\
+{$ENDIF}\n\n\
+Pmreal = ^mreal;\n\n\
+type TNGLDraw = record\n\
+end;\n\
+type TMGLGraph = record\n\
+end;\n\
+type TMGLData = record\n\
+end;\n\
+type TMGLParse = record\n\
+end;\n\
+type TMGLFormula = record\n\
+end;\n\
+type TMGLFormulaC = record\n\
+end;\n\
+type TMGLDataC = record\n\
+end;\n\
+type HMDR = ^TNGLDraw;\n\
+type HMGL = ^TMGLGraph;\n\
+type HMDT = ^TMGLData;\n\
+type HMPR = ^TMGLParse;\n\
+type PPChar = ^PChar;\n\
+type HMEX = ^TMGLFormula;\n\
+type HAEX = ^TMGLFormulaC;\n\
+type HADT = ^TMGLDataC;\n\n\
+type Preal = ^single;\n\
+type Pdouble = ^double;\n\
+type Pint = ^integer;\n\
+type dual = record\n\
+re, im: mreal;\n\
+end;\n\
+type Pdual = ^dual;\n\
+type TGSLVector = record\n\
+end;\n\
+type TGSLMatrix = record\n\
+end;\n\
+type PGSLVector = ^TGSLVector;\n\
+type PGSLMatrix = ^TGSLMatrix;\n\n\
+type TMglDrawFunction = function (gr: HMGL; p: pointer): integer; cdecl;\n\
+function mgl_create_graph_gl(): HMGL; cdecl; external libmgl;\n\
+function mgl_create_graph_glut(draw: TMglDrawFunction; const title: PChar; par: pointer): HMGL; cdecl; external libmglglut;\n\
+function mgl_create_graph_fltk(draw: TMglDrawFunction; const title: PChar; par: pointer): HMGL; cdecl; external libmglfltk;\n\
+procedure mgl_fltk_run(); cdecl; external libmglfltk;\n\
+function mgl_create_graph_qt(draw: TMglDrawFunction; const title: PChar; par: pointer): HMGL; cdecl; external libmglqt;\n\
+procedure mgl_qt_run(); cdecl; external libmglqt;\n";
+
+
+const char *footer =
+"\n\
+\n\
+{$IFDEF MSWINDOWS}\n\
+//*****************************************************************************/\n\
+// Delphi - specific\n\
+//*****************************************************************************/\n\
+procedure mgl_begin();\n\
+procedure mgl_end();\n\
+\n\
+procedure mgl_draw_on_canvas(gr: HMGL; width, height: integer; canvas: TCanvas; switchXY: boolean = false);\n\
+\n\
+implementation\n\
+\n\
+var _FPUCW: word;\n\
+\n\
+procedure mgl_begin();\n\
+ begin\n\
+ _FPUCW := Get8087CW(); // backup current FPU CW\n\
+ Set8087CW(_FPUCW or $3F); // masking all FPU exceptions\n\
+ end;\n\
+\n\
+procedure mgl_end();\n\
+ begin\n\
+ Set8087CW(_FPUCW); // restore old FPU CW\n\
+ end;\n\
+\n\
+procedure mgl_draw_on_canvas(gr: HMGL; width, height: integer; canvas: TCanvas; switchXY: boolean = false);\n\
+ var i, j: integer;\n\
+ bytes: PByte;\n\
+ col: TColor;\n\
+ begin\n\
+ bytes := mgl_get_rgb(gr);\n\
+\n\
+ if (not switchXY) then\n\
+ for j := 0 to height - 1 do\n\
+ for i := 0 to width - 1 do\n\
+ begin\n\
+ col := 0;\n\
+ col := col or (bytes^);\n\
+ inc(bytes);\n\
+ col := col or (bytes^) shl 8;\n\
+ inc(bytes);\n\
+ col := col or (bytes^) shl 16;\n\
+ inc(bytes);\n\
+ canvas.Pixels[i, j] := col;\n\
+ end\n\
+ else\n\
+ for j := height - 1 downto 0 do\n\
+ for i := 0 to width - 1 do\n\
+ begin\n\
+ col := 0;\n\
+ col := col or (bytes^);\n\
+ inc(bytes);\n\
+ col := col or (bytes^) shl 8;\n\
+ inc(bytes);\n\
+ col := col or (bytes^) shl 16;\n\
+ inc(bytes);\n\
+ canvas.Pixels[j, i] := col;\n\
+ end;\n\
+ end;\n\
+\n\
+{$ENDIF}\n\
+end.\n";
+
+
+bool processArgument(char *dest, const char *arg, const char *prefix, const char *format)
+{
+ const int prefixLen = strlen(prefix);
+ if ( strncmp(arg, prefix, prefixLen) == 0 )
+ {
+ char argname[32];
+ strcpy(argname, arg + prefixLen);
+ if (strcmp(argname, "to") == 0)
+ {
+ int argNameLen = strlen(argname);
+ argname[argNameLen] = '_';
+ argname[argNameLen + 1] = 0;
+ }
+ sprintf(dest, format, argname);
+ return true;
+ }
+ return false;
+}
+
+const char *parse_name(char *name, bool &needOverload)
+{
+ const int MAX_ARG = 20; // TODO check if 20 arguments is enough
+ static char res[1024];
+ char *ptr, *arg[MAX_ARG], nul = 0;
+ unsigned i, j;
+ needOverload = false;
+ for ( i = 0; name[i] != '('; ++i )
+ {
+ res[i] = name[i];
+ }
+
+// res[i] = 0;
+// printf("'%s'\n", res);
+
+ //TODO: special case, invent some general way to handle overloads, i.e. functions with same names. Still would require re-doing whole parser..
+ if (strncmp(res, " mgl_expi", i - 1) == 0)
+ {
+ needOverload = true;
+ }
+ res[i] = '(';
+ res[i + 1] = 0;
+ ++i;
+ while ( name[i] <= ' ' )
+ {
+ ++i;
+ }
+ for ( j = 0; j < MAX_ARG; ++j )
+ {
+ arg[j] = &nul;
+ }
+ for ( j = 0; j < MAX_ARG; ++j )
+ {
+ arg[j] = (name[i] <= ' ' ? name + i + 1 : name + i);
+ ptr = strchr(name + i, ',');
+ if ( !ptr )
+ {
+ break;
+ }
+ *ptr = 0;
+ i = ptr - name + 1;
+ }
+ ptr = strchr(name + i, ')');
+ if ( ptr )
+ {
+ *ptr = 0;
+ }
+ if ( arg[0][0] == 0 )
+ {
+ strcat(res, " ");
+ }
+ for ( j = 0; j < MAX_ARG; ++j )
+ {
+ if ( arg[j][0] == 0 )
+ {
+ break;
+ }
+ ptr = res + strlen(res);
+ if ( processArgument(ptr, arg[j], "HMGL ", "%s: HMGL;")
+ || processArgument(ptr, arg[j], "HCDT ", "const %s: HMDT;")
+ || processArgument(ptr, arg[j], "HMDT ", "%s: HMDT;")
+ || processArgument(ptr, arg[j], "HADT ", "%s: HADT;")
+ || processArgument(ptr, arg[j], "HAEX ", "%s: HAEX;")
+ || processArgument(ptr, arg[j], "HMPR ", "%s: HMPR;")
+ || processArgument(ptr, arg[j], "HMEX ", "%s: HMEX;")
+ || processArgument(ptr, arg[j], "const float *", "const %s: Preal;")
+ || processArgument(ptr, arg[j], "const double *", "const %s: Pdouble;")
+ || processArgument(ptr, arg[j], "mreal *", "%s: Pmreal;")
+ || processArgument(ptr, arg[j], "double *", "%s: Pdouble;")
+ || processArgument(ptr, arg[j], "char *", "%s: PChar;")
+ || processArgument(ptr, arg[j], "int *", "%s: Pint;")
+ || processArgument(ptr, arg[j], "long *", "%s: Pint;")
+ || processArgument(ptr, arg[j], "const char *", "const %s: PChar;")
+ || processArgument(ptr, arg[j], "const wchar_t *", "const %s: PWideChar;")
+ || processArgument(ptr, arg[j], "char ", "%s: char;")
+ || processArgument(ptr, arg[j], "long ", "%s: integer;")
+ || processArgument(ptr, arg[j], "uint32_t ", "%s: LongWord;")
+ || processArgument(ptr, arg[j], "uint64_t ", "%s: QWord;")
+ || processArgument(ptr, arg[j], "int ", "%s: integer;")
+ || processArgument(ptr, arg[j], "mreal ", "%s: mreal;")
+ || processArgument(ptr, arg[j], "const dual *", "const %s: Pdual;")
+ || processArgument(ptr, arg[j], "dual *", "%s: Pdual;")
+ || processArgument(ptr, arg[j], "dual ", "%s: dual;")
+ || processArgument(ptr, arg[j], "double ", "%s: double;")
+ || processArgument(ptr, arg[j], "gsl_vector *", "%s: PGSLVector;")
+ || processArgument(ptr, arg[j], "gsl_matrix *", "%s: PGSLMatrix;")
+ )
+ {
+ //already procedded in processArgument
+ }
+ else
+ {
+ sprintf(ptr, " !!! %s;", arg[j]);
+ }
+ }
+
+ i = strlen(res);
+ res[i - 1] = ')';
+ return res;
+}
+
+bool processDeclaration(FILE *out, char *declaration, const char *prefix, const char *format)
+{
+ const int prefixLen = strlen(prefix);
+ if ( strncmp(declaration, prefix, prefixLen) == 0 )
+ {
+ bool needOverload = false;
+ fprintf(out, format, parse_name(declaration + prefixLen, needOverload));
+ if (needOverload)
+ {
+ fprintf(out, "overload;\n");
+ }
+ return true;
+ }
+ return false;
+}
+
+bool parse_file(const char *fname, FILE *out)
+{
+ if ( !fname || fname[0] == 0 )
+ {
+ return false;
+ }
+ FILE *fp = fopen(fname, "rt");
+ if ( !fp )
+ {
+ return false;
+ }
+
+ fprintf(out, "{== %s ==}\n", fname);
+
+ char buf[1024], *ptr;
+ while ( !feof(fp) )
+ {
+ fgets(buf, 1024, fp);
+ // first filter unwanted strings
+ if ( buf[0] == 0 || buf[0] == '\n' || buf[1] == '\n' )
+ {
+ continue;
+ }
+ if ( buf[0] == '#' || buf[0] == '}' )
+ {
+ continue;
+ }
+ if ( !strncmp(buf, "extern", 6) )
+ {
+ continue;
+ }
+ if ( !strncmp(buf, "class", 5) )
+ {
+ continue;
+ }
+ if ( !strncmp(buf, "struct", 6) )
+ {
+ continue;
+ }
+ if ( !strncmp(buf, "typedef", 7) )
+ {
+ continue;
+ }
+ if ( strstr(buf, "void *") )
+ {
+ continue;
+ }
+ if ( strstr(buf, "_(") )
+ {
+ continue;
+ }
+ if ( strstr(buf, "FILE") )
+ {
+ continue;
+ }
+ if ( strstr(buf, "TODO") )
+ {
+ continue;
+ }
+ if ( strstr(buf, "...)") )
+ {
+ continue;
+ }
+
+ // TODO enable later
+ if ( strstr(buf, "* const *") )
+ {
+ continue;
+ }
+
+ // now filter comments
+ if ( buf[0] == '/' && buf[1] == '*' )
+ {
+ do
+ {
+ fgets(buf, 1024, fp);
+ }
+ while ( !strstr(buf, "*/") );
+ continue;
+ }
+ ptr = strchr(buf, ';');
+ if ( ptr )
+ {
+ *ptr = ' ';
+ }
+ for ( unsigned i = strlen(buf) - 1; buf[i] <= ' '; i-- )
+ {
+ buf[i] = 0;
+ }
+ if ( buf[0] == '/' && buf[1] == '/' )
+ {
+ fprintf(out, "%s\n", buf);
+ }
+ else if ( processDeclaration(out, buf, "void MGL_EXPORT", "procedure %s; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "int MGL_EXPORT", "function %s: integer; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "double MGL_EXPORT", "function %s: double; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "mreal MGL_EXPORT", "function %s: mreal; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "long MGL_EXPORT", "function %s: integer; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "dual MGL_EXPORT", "function %s: dual; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "MGL_EXPORT dual *", "function %s: PDual; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "HMDT MGL_EXPORT", "function %s: HMDT; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "HMGL MGL_EXPORT", "function %s: HMGL; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "MGL_EXPORT const char *", "function %s: PChar; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "MGL_EXPORT mreal *", "function %s: Pmreal; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "MGL_EXPORT const unsigned char *", "function %s: PByte; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "HMPR MGL_EXPORT", "function %s: HMPR; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "HMEX MGL_EXPORT", "function %s: HMEX; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "HADT MGL_EXPORT", "function %s: HADT; cdecl; external libmgl;\n")
+ || processDeclaration(out, buf, "HAEX MGL_EXPORT", "function %s: HAEX; cdecl; external libmgl;\n")
+ )
+ {
+ //already processed by processDeclaration
+ }
+ else
+ {
+ fprintf(out, "!!!!\t%s\n", buf); // NOTE should be never here!
+ }
+ }
+ fclose(fp);
+ return true;
+}
+
+int main()
+{
+ FILE *fout = fopen("../include/mgl2/mgl_pas.pas", "wt");
+ fprintf(fout, "%s\n", head);
+ for ( int i = 0; parse_file(files[i], fout); i++ ) {}
+ fprintf(fout, "%s\n", footer);
+ fclose(fout);
+ return 0;
+}
/***************************************************************************
* mglcgi.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* 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 *
char *str, *buf;
const char *method = getenv("REQUEST_METHOD");
+ bool alloc=false;
if(method && strcmp(method,"GET"))
{
long len=atol(getenv("CONTENT_LENGTH"));
buf = new char[len+1];
fread(buf,len,1,stdin);
- buf[len]=0;
+ buf[len]=0; alloc=true;
}
else buf = getenv("QUERY_STRING");
if(buf==0) { printf("There is no query. Exit.\n"); return 0; }
printf("</img></body></html>\n");*/
printf("Content-Type: image/png\n\n"); gr.WritePNG("-");
+ if(alloc) delete []buf;
return 0;
}
//-----------------------------------------------------------------------------
/***************************************************************************\r
* mglconv.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU General Public License as published by *\r
/***************************************************************************
* mglview.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* 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 *
)
endif(MGL_HAVE_WX)
-if(MGL_HAVE_QT)
- include(${QT_USE_FILE})
- qt4_wrap_cpp(MGL_MOC_FILES ../include/mgl2/qmathgl.h)
- add_library(mgl-qt SHARED qt.cpp ${MGL_MOC_FILES} ../include/mgl2/qt.h ../include/mgl2/qmathgl.h)
- add_library(mgl-qt-static STATIC qt.cpp ${MGL_MOC_FILES} ../include/mgl2/qt.h ../include/mgl2/qmathgl.h)
- set_target_properties(mgl-qt PROPERTIES SOVERSION ${MathGL_SOVERSION})
- set_target_properties(mgl-qt PROPERTIES CLEAN_DIRECT_OUTPUT 1)
- set_target_properties(mgl-qt PROPERTIES DEFINE_SYMBOL "mgl_EXPORTS")
- set_target_properties(mgl-qt-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
- set_target_properties(mgl-qt-static PROPERTIES COMPILE_FLAGS -DMGL_STATIC_DEFINE)
- target_link_libraries(mgl-qt mgl)
- target_link_libraries(mgl-qt ${QT_LIBRARIES})
-
- if(enable-mgl2)
- set_target_properties(mgl-qt PROPERTIES OUTPUT_NAME "mgl2-qt")
- set_target_properties(mgl-qt-static PROPERTIES OUTPUT_NAME "mgl2-qt")
- else(enable-mgl2)
- set_target_properties(mgl-qt-static PROPERTIES OUTPUT_NAME "mgl-qt")
- endif(enable-mgl2)
-
- install(
- TARGETS mgl-qt mgl-qt-static
- RUNTIME DESTINATION bin
- ARCHIVE DESTINATION ${MGL_LIB_INSTALL_DIR}
- LIBRARY DESTINATION ${MGL_LIB_INSTALL_DIR}
- )
-endif(MGL_HAVE_QT)
-
-
-if(MGL_HAVE_QT AND MGL_HAVE_FLTK)
- include_directories(${FLTK_INCLUDE_DIR})
- include(${QT_USE_FILE})
-
- set(MGL_WND_SRC qt.cpp ../include/mgl2/qt.h ../include/mgl2/qmathgl.h fltk.cpp ../include/mgl2/fltk.h)
-
- add_library(mgl-wnd SHARED ${MGL_WND_SRC} ${MGL_MOC_FILES})
- add_library(mgl-wnd-static STATIC ${MGL_WND_SRC} ${MGL_MOC_FILES})
-
- set_target_properties(mgl-wnd PROPERTIES SOVERSION ${MathGL_SOVERSION})
- set_target_properties(mgl-wnd PROPERTIES CLEAN_DIRECT_OUTPUT 1)
- set_target_properties(mgl-wnd PROPERTIES DEFINE_SYMBOL "mgl_EXPORTS")
- set_target_properties(mgl-wnd-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
- set_target_properties(mgl-wnd-static PROPERTIES COMPILE_FLAGS -DMGL_STATIC_DEFINE)
-
- if(enable-mgl2)
- set_target_properties(mgl-wnd PROPERTIES OUTPUT_NAME "mgl2-wnd")
- set_target_properties(mgl-wnd-static PROPERTIES OUTPUT_NAME "mgl2-wnd")
- else(enable-mgl2)
- set_target_properties(mgl-wnd-static PROPERTIES OUTPUT_NAME "mgl-wnd")
- endif(enable-mgl2)
-
- target_link_libraries(mgl-wnd mgl)
- target_link_libraries(mgl-wnd ${QT_LIBRARIES})
- target_link_libraries(mgl-wnd ${FLTK_LIBRARIES})
-
- install(
- TARGETS mgl-wnd mgl-wnd-static
- RUNTIME DESTINATION bin
- ARCHIVE DESTINATION ${MGL_LIB_INSTALL_DIR}
- LIBRARY DESTINATION ${MGL_LIB_INSTALL_DIR}
- )
-endif(MGL_HAVE_QT AND MGL_HAVE_FLTK)
+add_subdirectory( qt4 )
+add_subdirectory( qt5 )
/***************************************************************************
* fltk.cpp is part of Math Graphic Library
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
/***************************************************************************\r
* glut.cpp is part of Math Graphic Library\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
/***************************************************************************
* qt.cpp is part of Math Graphic Library *
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
popup = 0; grBuf = 0; draw = 0;
phi = tet = per = 0;
x1 = y1 = ax1 = ay1 = 0; x2 = y2 = ax2 = ay2 = 1;
- alpha = light = zoom = rotate = grid = viewYZ = custZoom = false;
+ alpha = light = zoom = rotate = grid = viewYZ = custZoom = custDraw = false;
resize(600, 400); mgl_set_flag(gr, true, MGL_CLF_ON_UPD);
timer = new QTimer(this);
enableWheel = enableMouse = true;
//-----------------------------------------------------------------------------
void QMathGL::setCustZoom(bool z) { custZoom = z; }
//-----------------------------------------------------------------------------
+void QMathGL::setCustDraw(bool z) { custDraw = z; }
+//-----------------------------------------------------------------------------
void QMathGL::shiftDown()
{ mreal d=(y2-y1)/4; y1+=d; y2+=d; refresh(); }
//-----------------------------------------------------------------------------
if(!isHidden()) QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
setlocale(LC_NUMERIC, "C");
// use frames for quickly redrawing while adding/changing primitives
+ if(custDraw) emit customDraw(x1,y1,x2,y2,true);
if(mgl_is_frames(gr)) mgl_new_frame(gr);
if(draw_func) draw_func(gr, draw_par);
else if(draw) { mglGraph g(gr); draw->Draw(&g); }
{
mgl_set_obj_id(gr,i+MGL_MAX_LINES);
QString tst = primitives.section('\n',i,i);
- pr.Parse(&gg,primitives.section('\n',i,i).toAscii().constData(),i+MGL_MAX_LINES);
+ pr.Parse(&gg,primitives.section('\n',i,i).toStdString().c_str(),i+MGL_MAX_LINES);
}
gg.SetRanges(ox1,ox2); gg.Pop(); setlocale(LC_NUMERIC, "");
}
if(x1>x2) { _x1=x1; x1=x2; x2=_x1; }
if(y1>y2) { _x1=y1; y1=y2; y2=_x1; }
x0 = xe; y0 = ye;
- refresh();
+ if(custDraw)
+ {
+ emit customDraw(x1,y1,x2,y2,false);
+ update();
+ }
+ else refresh();
}
}
if(ev->button()&Qt::RightButton && popup && !rotate) // popup menu
{
if(fname.isEmpty()) fname = mgl_get_plotid(gr);
if(fname.isEmpty()) QMessageBox::critical(this, appName, tr("No filename."),QMessageBox::Ok,0,0);
- else mgl_write_gif(gr,setExtension(fname,"png").toAscii().constData(), appName.toAscii().constData());
+ else mgl_write_gif(gr,setExtension(fname,"png").toStdString().c_str(), appName.toStdString().c_str());
}
//-----------------------------------------------------------------------------
void QMathGL::exportPNG(QString fname)
{
if(fname.isEmpty()) fname = mgl_get_plotid(gr);
if(fname.isEmpty()) QMessageBox::critical(this, appName, tr("No filename."),QMessageBox::Ok,0,0);
- else mgl_write_png(gr,setExtension(fname,"png").toAscii().constData(), appName.toAscii().constData());
+ else mgl_write_png(gr,setExtension(fname,"png").toStdString().c_str(), appName.toStdString().c_str());
}
//-----------------------------------------------------------------------------
void QMathGL::exportPNGs(QString fname)
{
if(fname.isEmpty()) fname = mgl_get_plotid(gr);
if(fname.isEmpty()) QMessageBox::critical(this, appName, tr("No filename."),QMessageBox::Ok,0,0);
- else mgl_write_png_solid(gr,setExtension(fname,"png").toAscii().constData(), appName.toAscii().constData());
+ else mgl_write_png_solid(gr,setExtension(fname,"png").toStdString().c_str(), appName.toStdString().c_str());
}
//-----------------------------------------------------------------------------
void QMathGL::exportJPG(QString fname)
{
if(fname.isEmpty()) fname = mgl_get_plotid(gr);
if(fname.isEmpty()) QMessageBox::critical(this, appName, tr("No filename."),QMessageBox::Ok,0,0);
- else mgl_write_jpg(gr,setExtension(fname,"jpg").toAscii().constData(), appName.toAscii().constData());
+ else mgl_write_jpg(gr,setExtension(fname,"jpg").toStdString().c_str(), appName.toStdString().c_str());
}
//-----------------------------------------------------------------------------
void QMathGL::exportBPS(QString fname)
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_bps(gr,setExtension(fname,"eps").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_bps(gr,setExtension(fname,"eps").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_eps(gr,setExtension(fname,"eps").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_eps(gr,setExtension(fname,"eps").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_svg(gr,setExtension(fname,"svg").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_svg(gr,setExtension(fname,"svg").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_xyz(gr,setExtension(fname,"xyz").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_xyz(gr,setExtension(fname,"xyz").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_tex(gr,setExtension(fname,"tex").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_tex(gr,setExtension(fname,"tex").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_off(gr,setExtension(fname,"off").toAscii().constData(), appName.toAscii().constData(),0);
+ mgl_write_off(gr,setExtension(fname,"off").toStdString().c_str(), appName.toStdString().c_str(),0);
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_obj(gr,setExtension(fname,"obj").toAscii().constData(), appName.toAscii().constData(),1);
+ mgl_write_obj(gr,setExtension(fname,"obj").toStdString().c_str(), appName.toStdString().c_str(),1);
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_stl(gr,setExtension(fname,"stl").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_stl(gr,setExtension(fname,"stl").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_x3d(gr,setExtension(fname,"x3d").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_x3d(gr,setExtension(fname,"x3d").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}*/
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_tga(gr,setExtension(fname,"tga").toAscii().constData(), appName.toAscii().constData());
+ mgl_write_tga(gr,setExtension(fname,"tga").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_write_prc(gr,setExtension(fname,"prc").toAscii().constData(), appName.toAscii().constData(),1);
+ mgl_write_prc(gr,setExtension(fname,"prc").toStdString().c_str(), appName.toStdString().c_str(),1);
setlocale(LC_NUMERIC, "");
}
}
else
{
setlocale(LC_NUMERIC, "C");
- mgl_export_mgld(gr,setExtension(fname,"mgld").toAscii().constData(), appName.toAscii().constData());
+ mgl_export_mgld(gr,setExtension(fname,"mgld").toStdString().c_str(), appName.toStdString().c_str());
setlocale(LC_NUMERIC, "");
}
}
//-----------------------------------------------------------------------------
void QMathGL::setMGLFont(QString path)
{ if(path.isEmpty()) mgl_restore_font(gr);
- else mgl_load_font(gr,path.toAscii().constData(),0); }
+ else mgl_load_font(gr,path.toStdString().c_str(),0); }
//-----------------------------------------------------------------------------
void QMathGL::setSize(int w, int h)
{
a = new QAction(QPixmap(alpha_xpm), TR("&Alpha"), Wnd);
a->setShortcut(Qt::ALT+Qt::Key_T); a->setCheckable(true);
Wnd->connect(a, SIGNAL(toggled(bool)), QMGL, SLOT(setAlpha(bool)));
- Wnd->connect(QMGL, SIGNAL(alphaChanged(bool)), a, SLOT(setOn(bool)));
+ Wnd->connect(QMGL, SIGNAL(alphaChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(TR("Switch on/off TRansparency for the graphics (Alt+T)."));
o->addAction(a); bb->addAction(a);
a = new QAction(QPixmap(light_xpm), TR("&Light"), Wnd);
a->setShortcut(Qt::ALT+Qt::Key_L); a->setCheckable(true);
Wnd->connect(a, SIGNAL(toggled(bool)), QMGL, SLOT(setLight(bool)));
- Wnd->connect(QMGL, SIGNAL(lightChanged(bool)), a, SLOT(setOn(bool)));
+ Wnd->connect(QMGL, SIGNAL(lightChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(TR("Switch on/off lightning for the graphics (Alt+L)."));
o->addAction(a); bb->addAction(a);
a = new QAction(QPixmap(rotate_xpm), TR("&Rotate by mouse"), Wnd);
a->setCheckable(true);
Wnd->connect(a, SIGNAL(toggled(bool)), QMGL, SLOT(setRotate(bool)));
- Wnd->connect(QMGL, SIGNAL(rotateChanged(bool)), a, SLOT(setOn(bool)));
+ Wnd->connect(QMGL, SIGNAL(rotateChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(TR("Switch on/off mouse handling of the graphics\n(rotation, shifting, zooming and perspective)."));
bb->addAction(a);
a = new QAction(QPixmap(zoom_in_xpm), TR("&Zoom by mouse"), Wnd);
a->setCheckable(true);
Wnd->connect(a, SIGNAL(toggled(bool)), QMGL, SLOT(setZoom(bool)));
- Wnd->connect(QMGL, SIGNAL(zoomChanged(bool)), a, SLOT(setOn(bool)));
+ Wnd->connect(QMGL, SIGNAL(zoomChanged(bool)), a, SLOT(setChecked(bool)));
a->setToolTip(TR("Switch on/off mouse zoom of selected region."));
bb->addAction(a);
o->addSeparator();
--- /dev/null
+include(GenerateExportHeader)
+add_compiler_export_flags()
+function(libmglqt mglqt)
+ add_library(mgl-${mglqt} SHARED ${MGL_QT_FILES})
+ add_library(mgl-${mglqt}-static STATIC ${MGL_QT_FILES})
+ set_target_properties(mgl-${mglqt} PROPERTIES SOVERSION ${MathGL_SOVERSION})
+ set_target_properties(mgl-${mglqt} PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-${mglqt} PROPERTIES DEFINE_SYMBOL "mgl_EXPORTS")
+ set_target_properties(mgl-${mglqt}-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-${mglqt}-static PROPERTIES COMPILE_FLAGS -DMGL_STATIC_DEFINE)
+ target_link_libraries(mgl-${mglqt} mgl)
+ target_link_libraries(mgl-${mglqt} ${QT_LIBRARIES})
+
+ if(enable-mgl2)
+ set_target_properties(mgl-${mglqt} PROPERTIES OUTPUT_NAME "mgl2-${mglqt}")
+ set_target_properties(mgl-${mglqt}-static PROPERTIES OUTPUT_NAME "mgl2-${mglqt}")
+ else(enable-mgl2)
+ set_target_properties(mgl-${mglqt}-static PROPERTIES OUTPUT_NAME "mgl-${mglqt}")
+ endif(enable-mgl2)
+
+ install(
+ TARGETS mgl-${mglqt} mgl-${mglqt}-static
+ RUNTIME DESTINATION bin
+ ARCHIVE DESTINATION ${MGL_LIB_INSTALL_DIR}
+ LIBRARY DESTINATION ${MGL_LIB_INSTALL_DIR}
+ )
+endfunction(libmglqt mglqt)
+
+if(enable-qt4)
+ include(../../cmake-qt4.txt)
+ qt4_wrap_cpp(MGL_MOC_FILES ../../include/mgl2/qmathgl.h)
+ set(MGL_QT_FILES ../qt.cpp ${MGL_MOC_FILES} ../../include/mgl2/qt.h ../../include/mgl2/qmathgl.h)
+ libmglqt(qt4)
+ if(NOT enable-qt5asqt)
+ libmglqt(qt)
+ endif(NOT enable-qt5asqt)
+
+ if(MGL_HAVE_FLTK AND NOT enable-qt5)
+ include_directories(${FLTK_INCLUDE_DIR})
+
+ set(MGL_WND_SRC ${MGL_QT_FILES} ../fltk.cpp ../../include/mgl2/fltk.h)
+
+ add_library(mgl-wnd SHARED ${MGL_WND_SRC})
+ add_library(mgl-wnd-static STATIC ${MGL_WND_SRC})
+
+ set_target_properties(mgl-wnd PROPERTIES SOVERSION ${MathGL_SOVERSION})
+ set_target_properties(mgl-wnd PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-wnd PROPERTIES DEFINE_SYMBOL "mgl_EXPORTS")
+ set_target_properties(mgl-wnd-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-wnd-static PROPERTIES COMPILE_FLAGS -DMGL_STATIC_DEFINE)
+
+ if(enable-mgl2)
+ set_target_properties(mgl-wnd PROPERTIES OUTPUT_NAME "mgl2-wnd")
+ set_target_properties(mgl-wnd-static PROPERTIES OUTPUT_NAME "mgl2-wnd")
+ else(enable-mgl2)
+ set_target_properties(mgl-wnd-static PROPERTIES OUTPUT_NAME "mgl-wnd")
+ endif(enable-mgl2)
+
+ target_link_libraries(mgl-wnd mgl)
+ target_link_libraries(mgl-wnd ${QT_LIBRARIES})
+ target_link_libraries(mgl-wnd ${FLTK_LIBRARIES})
+
+ install(
+ TARGETS mgl-wnd mgl-wnd-static
+ RUNTIME DESTINATION bin
+ ARCHIVE DESTINATION ${MGL_LIB_INSTALL_DIR}
+ LIBRARY DESTINATION ${MGL_LIB_INSTALL_DIR}
+ )
+ endif(MGL_HAVE_FLTK AND NOT enable-qt5)
+else(enable-qt4)
+ set(MGL_HAVE_QT4 0)
+endif(enable-qt4)
--- /dev/null
+include(GenerateExportHeader)
+add_compiler_export_flags()
+
+function(libmglqt mglqt)
+ add_library(mgl-${mglqt} SHARED ${MGL_QT_FILES})
+ add_library(mgl-${mglqt}-static STATIC ${MGL_QT_FILES})
+ set_target_properties(mgl-${mglqt} PROPERTIES SOVERSION ${MathGL_SOVERSION})
+ set_target_properties(mgl-${mglqt} PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-${mglqt} PROPERTIES DEFINE_SYMBOL "mgl_EXPORTS")
+ set_target_properties(mgl-${mglqt}-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-${mglqt}-static PROPERTIES COMPILE_FLAGS -DMGL_STATIC_DEFINE)
+ target_link_libraries(mgl-${mglqt} mgl)
+ qt5_use_modules(mgl-${mglqt} Core Widgets Gui Network WebKit PrintSupport)
+ qt5_use_modules(mgl-${mglqt}-static Core Widgets Gui Network WebKit PrintSupport)
+ if(enable-mgl2)
+ set_target_properties(mgl-${mglqt} PROPERTIES OUTPUT_NAME "mgl2-${mglqt}")
+ set_target_properties(mgl-${mglqt}-static PROPERTIES OUTPUT_NAME "mgl2-${mglqt}")
+ else(enable-mgl2)
+ set_target_properties(mgl-${mglqt}-static PROPERTIES OUTPUT_NAME "mgl-${mglqt}")
+ endif(enable-mgl2)
+ install(
+ TARGETS mgl-${mglqt} mgl-${mglqt}-static
+ RUNTIME DESTINATION bin
+ ARCHIVE DESTINATION ${MGL_LIB_INSTALL_DIR}
+ LIBRARY DESTINATION ${MGL_LIB_INSTALL_DIR}
+ )
+endfunction(libmglqt mglqt)
+
+if(enable-qt5)
+ include(../../cmake-qt5.txt)
+ qt5_wrap_cpp(MGL_MOC_FILES ../../include/mgl2/qmathgl.h)
+ set(MGL_QT_FILES ../qt.cpp ${MGL_MOC_FILES} ../../include/mgl2/qt.h ../../include/mgl2/qmathgl.h)
+ libmglqt(qt5)
+ if(enable-qt5asqt)
+ libmglqt(qt)
+ endif(enable-qt5asqt)
+
+ if(MGL_HAVE_FLTK)
+ include_directories(${FLTK_INCLUDE_DIR})
+
+ set(MGL_WND_SRC ${MGL_QT_FILES} ../fltk.cpp ../../include/mgl2/fltk.h)
+
+ add_library(mgl-wnd SHARED ${MGL_WND_SRC})
+ add_library(mgl-wnd-static STATIC ${MGL_WND_SRC})
+
+ set_target_properties(mgl-wnd PROPERTIES SOVERSION ${MathGL_SOVERSION})
+ set_target_properties(mgl-wnd PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-wnd PROPERTIES DEFINE_SYMBOL "mgl_EXPORTS")
+ set_target_properties(mgl-wnd-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(mgl-wnd-static PROPERTIES COMPILE_FLAGS -DMGL_STATIC_DEFINE)
+
+ if(enable-mgl2)
+ set_target_properties(mgl-wnd PROPERTIES OUTPUT_NAME "mgl2-wnd")
+ set_target_properties(mgl-wnd-static PROPERTIES OUTPUT_NAME "mgl2-wnd")
+ else(enable-mgl2)
+ set_target_properties(mgl-wnd-static PROPERTIES OUTPUT_NAME "mgl-wnd")
+ endif(enable-mgl2)
+
+ target_link_libraries(mgl-wnd mgl)
+ qt5_use_modules(mgl-wnd Core Widgets Gui Network WebKit PrintSupport)
+ qt5_use_modules(mgl-wnd-static Core Widgets Gui Network WebKit PrintSupport)
+ target_link_libraries(mgl-wnd ${FLTK_LIBRARIES})
+
+ install(
+ TARGETS mgl-wnd mgl-wnd-static
+ RUNTIME DESTINATION bin
+ ARCHIVE DESTINATION ${MGL_LIB_INSTALL_DIR}
+ LIBRARY DESTINATION ${MGL_LIB_INSTALL_DIR}
+ )
+ endif(MGL_HAVE_FLTK)
+else(enable-qt5)
+ set(MGL_HAVE_QT5 0)
+endif(enable-qt5)
/***************************************************************************\r
* wx.cpp is part of Math Graphic Library *\r
- * Copyright (C) 2007-2012 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
+ * Copyright (C) 2007-2014 Alexey Balakin <mathgl.abalakin@gmail.ru> *\r
* *\r
* This program is free software; you can redistribute it and/or modify *\r
* it under the terms of the GNU Library General Public License as *\r
projects / mathgl.git / commitdiff