--- /dev/null
+cmake_minimum_required(VERSION 2.8.9)
+if(POLICY CMP0043)
+ cmake_policy(SET CMP0043 OLD)
+endif()
+
+project( MathGL )
+
+if(NOT CMAKE_BUILD_TYPE)
+ set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are:
+ None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel." FORCE)
+endif(NOT CMAKE_BUILD_TYPE)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(MathGL_VERSION_MAJOR 2)
+set(MathGL_VERSION_MINOR 3.3)
+set(MathGL_SOVERSION 7.4.0)
+
+function(mgl_add_lib mgl_tmp_lib)
+ if(${mgl_tmp_lib} MATCHES mgl)
+ set(mgllib mgl)
+ set(mgllib2 mgl2)
+ else(${mgl_tmp_lib} MATCHES mgl)
+ set(mgllib mgl-${mgl_tmp_lib})
+ set(mgllib2 mgl2-${mgl_tmp_lib})
+ endif(${mgl_tmp_lib} MATCHES mgl)
+ set(mgl_src_lst ${ARGV})
+ list(REMOVE_AT mgl_src_lst 0)
+ add_library(${mgllib} SHARED ${mgl_src_lst})
+ add_library(${mgllib}-static STATIC ${mgl_src_lst})
+ set_target_properties(${mgllib} PROPERTIES SOVERSION ${MathGL_SOVERSION})
+ set_target_properties(${mgllib} PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ set_target_properties(${mgllib} PROPERTIES DEFINE_SYMBOL "mgl_EXPORTS")
+ set_target_properties(${mgllib}-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+ target_compile_definitions(${mgllib}-static PUBLIC MGL_STATIC_DEFINE)
+
+ if(enable-mgl2)
+ set_target_properties(${mgllib} PROPERTIES OUTPUT_NAME "${mgllib2}")
+ set_target_properties(${mgllib}-static PROPERTIES OUTPUT_NAME "${mgllib2}")
+ else(enable-mgl2)
+ set_target_properties(${mgllib}-static PROPERTIES OUTPUT_NAME "${mgllib}")
+ endif(enable-mgl2)
+
+ install(
+ TARGETS ${mgllib} ${mgllib}-static
+ RUNTIME DESTINATION bin
+ ARCHIVE DESTINATION ${MGL_LIB_INSTALL_DIR}
+ LIBRARY DESTINATION ${MGL_LIB_INSTALL_DIR}
+ )
+endfunction(mgl_add_lib mgl_tmp_lib)
+
+MACRO(MGL_DEPENDENT_OPTION option doc default depends1 force1 depends2 force2)
+ IF(${option}_ISSET MATCHES "^${option}_ISSET$")
+ SET(${option}_AVAILABLE 1)
+ IF(${force1})
+ FOREACH(d ${depends1})
+ STRING(REGEX REPLACE " +" ";" CMAKE_DEPENDENT_OPTION_DEP "${d}")
+ IF(${CMAKE_DEPENDENT_OPTION_DEP})
+ ELSE(${CMAKE_DEPENDENT_OPTION_DEP})
+ SET(${option}_AVAILABLE 0)
+ SET(depends1_AVAILABLE 1)
+ ENDIF(${CMAKE_DEPENDENT_OPTION_DEP})
+ ENDFOREACH(d)
+ ENDIF(${force1})
+ IF(${force2})
+ FOREACH(d ${depends2})
+ STRING(REGEX REPLACE " +" ";" CMAKE_DEPENDENT_OPTION_DEP "${d}")
+ IF(${CMAKE_DEPENDENT_OPTION_DEP})
+ ELSE(${CMAKE_DEPENDENT_OPTION_DEP})
+ SET(${option}_AVAILABLE 0)
+ SET(depends2_AVAILABLE 1)
+ ENDIF(${CMAKE_DEPENDENT_OPTION_DEP})
+ ENDFOREACH(d)
+ ENDIF(${force2})
+ IF(${option}_AVAILABLE)
+ OPTION(${option} "${doc}" "${default}")
+ SET(${option} "${${option}}" CACHE BOOL "${doc}" FORCE)
+ ELSE(${option}_AVAILABLE)
+ IF(${option} MATCHES "^${option}$")
+ ELSE(${option} MATCHES "^${option}$")
+ SET(${option} "${${option}}" CACHE INTERNAL "${doc}")
+ ENDIF(${option} MATCHES "^${option}$")
+ IF(depends1_AVAILABLE)
+ SET(${option} OFF)
+ ELSEIF(depends2_AVAILABLE)
+ SET(${option} ON)
+ ENDIF(depends1_AVAILABLE)
+ ENDIF(${option}_AVAILABLE)
+ ELSE(${option}_ISSET MATCHES "^${option}_ISSET$")
+ SET(${option} "${${option}_ISSET}")
+ ENDIF(${option}_ISSET MATCHES "^${option}_ISSET$")
+ENDMACRO(MGL_DEPENDENT_OPTION)
+include(CMakeDependentOption)
+
+set(MGL_LIB_INSTALL_DIR "lib" CACHE STRING "Set library install directory")
+string(TIMESTAMP MGL_NIGHT "%d.%m.%y")
+
+option(enable-double "Enable double precision in MathGL library" ON)
+option(enable-mpi "Enable mpi")
+option(enable-opengl "Enable OpenGL support" ON)
+option(enable-all-docs "Enable all documentation building")
+#option(enable-doc "Enable documentation building")
+option(enable-all "Enable all core features")
+option(enable-all-widgets "Enable all Widgets")
+option(enable-all-swig "Enable all SWIG based interfaces")
+option(enable-rvalue "Enable move constructor support (need C++11)" OFF)
+option(enable-pthread "Enable POSIX threads support" OFF)
+option(enable-pthr_fltk "Enable POSIX threads for widgets" ON)
+option(enable-openmp "Enable OpenMP support" ON)
+
+if(enable-pthread AND enable-openmp)
+ message(SEND_ERROR "You can't enable POSIX threads and OpenMP at the same time!")
+endif(enable-pthread AND enable-openmp)
+
+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")
+CMAKE_DEPENDENT_OPTION(enable-doc-site "Enable HTML documentation for website" OFF "NOT enable-all-docs" ON)
+CMAKE_DEPENDENT_OPTION(enable-doc-html "Enable HTML documentation" OFF "NOT enable-all-docs" ON)
+CMAKE_DEPENDENT_OPTION(enable-doc-info "Enable INFO documentation" OFF "NOT enable-all-docs" ON)
+CMAKE_DEPENDENT_OPTION(enable-doc-pdf-ru "Enable Russian PDF documentation" OFF "NOT enable-all-docs" ON)
+CMAKE_DEPENDENT_OPTION(enable-doc-pdf-en "Enable English PDF documentation" OFF "NOT enable-all-docs" ON)
+CMAKE_DEPENDENT_OPTION(enable-doc-prc "Enable PDF samples for HTML docs" OFF "NOT enable-all-docs" ON)
+CMAKE_DEPENDENT_OPTION(enable-doc-json "Enable JSON samples for HTML docs" OFF "NOT enable-all-docs" ON)
+option(enable-texi2html "Use texi2html (obsolete package) instead of texi2any" OFF)
+CMAKE_DEPENDENT_OPTION(enable-mgltex "Enable installation of mgltex package (MGL scripts in LATEX document)" OFF "NOT enable-lgpl" OFF)
+
+CMAKE_DEPENDENT_OPTION(enable-zlib "Enable zlib support" ON "NOT enable-all" ON)
+CMAKE_DEPENDENT_OPTION(enable-png "Enable png support" ON "NOT enable-all" ON)
+CMAKE_DEPENDENT_OPTION(enable-jpeg "Enable jpeg support" OFF "NOT enable-all" ON)
+MGL_DEPENDENT_OPTION(enable-gsl "Enable gsl support" OFF "NOT enable-lgpl" ON "NOT enable-all" ON)
+MGL_DEPENDENT_OPTION(enable-hdf4 "Enable hdf4 support" OFF "NOT enable-lgpl" ON "NOT enable-all" ON)
+MGL_DEPENDENT_OPTION(enable-hdf5 "Enable hdf5 support" OFF "NOT enable-lgpl" ON "NOT enable-all" ON)
+CMAKE_DEPENDENT_OPTION(enable-pdf "Enable pdf support" OFF "NOT enable-all" ON)
+CMAKE_DEPENDENT_OPTION(enable-gif "Enable gif support" OFF "NOT enable-all" ON)
+CMAKE_DEPENDENT_OPTION(enable-glut "Enable glut support" OFF "NOT enable-all-widgets" ON)
+CMAKE_DEPENDENT_OPTION(enable-fltk "Enable fltk widget" OFF "NOT enable-all-widgets" ON)
+CMAKE_DEPENDENT_OPTION(enable-wx "Enable wxWidget widget" OFF "NOT enable-all-widgets" ON)
+CMAKE_DEPENDENT_OPTION(enable-qt4 "Enable Qt4 widget" OFF "NOT enable-all-widgets" ON)
+CMAKE_DEPENDENT_OPTION(enable-qt5 "Enable Qt5 widget" OFF "NOT enable-all-widgets" ON)
+CMAKE_DEPENDENT_OPTION(enable-qt5asqt "Set Qt5 as default libmgl-qt" ON "enable-qt5" OFF)
+
+if(UNIX AND enable-rvalue)
+ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")
+endif(UNIX AND enable-rvalue)
+
+# MSVC does not require any special flags
+
+if(enable-qt4 OR enable-qt5)
+set(enable-qt ON)
+endif(enable-qt4 OR enable-qt5)
+
+CMAKE_DEPENDENT_OPTION(enable-json-sample "Enable JSON sample" ON "enable-qt" 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)
+MGL_DEPENDENT_OPTION(enable-octave-install "Octave interface will install for all users" ON "NOT enable-lgpl" ON "NOT enable-all-swig" ON)
+
+include_directories( ${MathGL_SOURCE_DIR}/include ${MathGL_BINARY_DIR}/include)
+set(MGL_INCLUDE_PATH "${CMAKE_INSTALL_PREFIX}/include/mgl2")
+set(MGL_CGI_PATH "${CMAKE_INSTALL_PREFIX}/share/mathgl" CACHE STRING "Set CGI install directory")
+set(MGL_DEF_FONT "STIX" CACHE STRING "Set default font name")
+
+if(NOT WIN32)
+# set(MGL_CGI_PATH "${CMAKE_INSTALL_PREFIX}/share/mathgl")
+ set(MGL_DATA_PATH "${CMAKE_INSTALL_PREFIX}/share/mathgl")
+ set(MGL_DOC_PATH "${CMAKE_INSTALL_PREFIX}/share/doc/mathgl")
+ set(MGL_MAN_PATH "${CMAKE_INSTALL_PREFIX}/share/man")
+ set(MGL_INFO_PATH "${CMAKE_INSTALL_PREFIX}/share/info")
+ set(MGL_FONT_PATH "${MGL_DATA_PATH}/fonts")
+else(NOT WIN32)
+ set(MGL_FONT_PATH "${CMAKE_INSTALL_PREFIX}/fonts")
+endif(NOT WIN32)
+
+include(CheckFunctionExists)
+include(CMakePushCheckState)
+include(TestBigEndian)
+
+TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
+if(WORDS_BIGENDIAN)
+ ADD_DEFINITIONS(-DWORDS_BIGENDIAN)
+endif(WORDS_BIGENDIAN)
+
+CHECK_FUNCTION_EXISTS(sin MGL_SIN)
+CHECK_FUNCTION_EXISTS(memrchr HAVE_MEMRCHR)
+if(NOT MGL_SIN)
+ cmake_push_check_state()
+ set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} m)
+ CHECK_FUNCTION_EXISTS(sin MGL_SIN_M)
+ cmake_pop_check_state()
+ if(MGL_SIN_M)
+ set(M_LIB m)
+ elseif(MGL_SIN_M)
+ message(SEND_ERROR "Math library not found")
+ endif(MGL_SIN_M)
+endif(NOT MGL_SIN)
+if(HAVE_MEMRCHR)
+ ADD_DEFINITIONS(-DHAVE_MEMRCHR)
+endif(HAVE_MEMRCHR)
+
+include(CheckTypeSize)
+check_type_size("long" SIZEOF_LONG)
+
+include(CheckCXXSourceCompiles)
+unset(MGL_HAVE_C99_COMPLEX)
+CHECK_CXX_SOURCE_COMPILES(
+"#include <complex>
+#include <complex.h>
+int main(int argc, char *args[])
+{std::complex<double> c(2.0, 1.0);
+double _Complex i=1.0i;
+double _Complex *a = reinterpret_cast<double _Complex *>(&c);
+std::complex<double> b(*a);return 0;}" MGL_HAVE_C99_COMPLEX)
+if(NOT MGL_HAVE_C99_COMPLEX)
+ set(MGL_HAVE_C99_COMPLEX 0)
+endif(NOT MGL_HAVE_C99_COMPLEX)
+
+unset(MGL_HAVE_NAN_INF)
+CHECK_CXX_SOURCE_COMPILES(
+"#include <math.h>
+int main(){double a=NAN, b=INFINITY;return 0;}" MGL_HAVE_NAN_INF)
+if(NOT MGL_HAVE_NAN_INF)
+ set(MGL_HAVE_NAN_INF 0)
+endif(NOT MGL_HAVE_NAN_INF)
+
+unset(MGL_HAVE_ATTRIBUTE)
+CHECK_CXX_SOURCE_COMPILES(
+"int __attribute__((pure)) test1() {return 0;}
+int __attribute__((const)) test2(int x) {return x*x;}
+int main(int argc, char* argv[]) {return 0;}" MGL_HAVE_ATTRIBUTE)
+if(NOT MGL_HAVE_ATTRIBUTE)
+ set(MGL_HAVE_ATTRIBUTE 0)
+endif(NOT MGL_HAVE_ATTRIBUTE)
+
+unset(MGL_HAVE_TYPEOF)
+CHECK_CXX_SOURCE_COMPILES(
+"#define mgl_isnum(a) ({typeof (a) _a = (a); _a==_a;})
+int main(){bool a=mgl_isnum(1);return 0;}" MGL_HAVE_TYPEOF)
+if(NOT MGL_HAVE_TYPEOF)
+ set(MGL_HAVE_TYPEOF 0)
+endif(NOT MGL_HAVE_TYPEOF)
+
+unset(MGL_HAVE_RVAL)
+CHECK_CXX_SOURCE_COMPILES(
+"struct test { test() {} test(test&& a){} };
+int main() { test t; return 0; }" MGL_HAVE_RVAL)
+if(NOT MGL_HAVE_RVAL)
+ set(MGL_HAVE_RVAL 0)
+endif(NOT MGL_HAVE_RVAL)
+
+if(enable-double)
+ set(MGL_USE_DOUBLE 1)
+else(enable-double)
+ set(MGL_USE_DOUBLE 0)
+endif(enable-double)
+
+if(enable-qt4 OR enable-qt5)
+ set(MGL_HAVE_QT 1)
+endif(enable-qt4 OR enable-qt5)
+
+if(enable-openmp)
+ find_package(OpenMP)
+ if(OPENMP_FOUND)
+ set(MGL_HAVE_OMP 1)
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+ else(OPENMP_FOUND)
+ message(SEND_ERROR "Couldn't find OpenMP. You can enable POSIX threads instead.")
+ set(MGL_HAVE_OMP 0)
+ endif(OPENMP_FOUND)
+else(enable-openmp)
+ set(MGL_HAVE_OMP 0)
+endif(enable-openmp)
+
+if(enable-mpi)
+ set(MGL_HAVE_MPI 1)
+ find_package(MPI REQUIRED)
+ set(CMAKE_CXX_COMPILE_FLAGS ${CMAKE_CXX_COMPILE_FLAGS} ${MPI_COMPILE_FLAGS})
+ set(CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS} ${MPI_LINK_FLAGS})
+ include_directories(${MPI_INCLUDE_PATH})
+else(enable-mpi)
+ set(MGL_HAVE_MPI 0)
+endif(enable-mpi)
+
+if(enable-pthread)
+ set(MGL_HAVE_PTHREAD 1)
+ include(FindThreads)
+ if(NOT CMAKE_USE_PTHREADS_INIT)
+ message(SEND_ERROR "Couldn't find POSIX threads library.")
+ endif(NOT CMAKE_USE_PTHREADS_INIT)
+else(enable-pthread)
+ set(MGL_HAVE_PTHREAD 0)
+endif(enable-pthread)
+
+if(enable-gsl)
+ set(MGL_HAVE_GSL 1)
+ FIND_PACKAGE(PkgConfig)
+ pkg_check_modules(GSL2 REQUIRED gsl)
+ if(GSL2_FOUND)
+ if ( NOT ${GSL2_VERSION} LESS 2.0)
+ SET(MGL_HAVE_GSL2 1)
+ endif ( NOT ${GSL2_VERSION} LESS 2.0)
+ endif ( GSL2_FOUND )
+ find_library(GSL_LIB gsl)
+ find_library(GSL_CBLAS_LIB gslcblas)
+ find_path(GSL_INCLUDE_DIR gsl/gsl_fft_complex.h)
+ if(NOT GSL_LIB OR NOT GSL_CBLAS_LIB OR NOT GSL_INCLUDE_DIR)
+ message(SEND_ERROR "${GSL_LIB}")
+ message(SEND_ERROR "${GSL_CBLAS_LIB}")
+ message(SEND_ERROR "${GSL_INCLUDE_DIR}")
+ message(SEND_ERROR "Couldn't find GSL libraries.")
+ endif(NOT GSL_LIB OR NOT GSL_CBLAS_LIB OR NOT GSL_INCLUDE_DIR)
+else(enable-gsl)
+ set(MGL_HAVE_GSL 0)
+endif(enable-gsl)
+
+if(enable-all OR enable-ltdl)
+ set(MGL_HAVE_LTDL 1)
+ find_library(LTDL_LIB ltdl)
+ find_path(LTDL_INCLUDE_DIR ltdl.h)
+ if(NOT LTDL_LIB OR NOT LTDL_INCLUDE_DIR)
+ message(SEND_ERROR "${LTDL_LIB}")
+ message(SEND_ERROR "${LTDL_INCLUDE_DIR}")
+ message(SEND_ERROR "Couldn't find LTDL library.")
+ endif(NOT LTDL_LIB OR NOT LTDL_INCLUDE_DIR)
+else(enable-all OR enable-ltdl)
+ set(MGL_HAVE_LTDL 0)
+endif(enable-all OR enable-ltdl)
+
+if(enable-hdf4)
+ set(MGL_HAVE_HDF4 1)
+ find_library(HDF4_LIB df)
+ find_library(HDF4MF_LIB mfhdf)
+ find_path(HDF4_INCLUDE_DIR hdf/mfhdf.h)
+ if(NOT HDF4_LIB OR NOT HDF4MF_LIB OR NOT HDF4_INCLUDE_DIR)
+ message(SEND_ERROR "${HDF4_LIB}")
+ message(SEND_ERROR "${HDF4MF_LIB}")
+ message(SEND_ERROR "${HDF4_INCLUDE_DIR}")
+ message(SEND_ERROR "Couldn't find HDF4 libraries.")
+ endif(NOT HDF4_LIB OR NOT HDF4MF_LIB OR NOT HDF4_INCLUDE_DIR)
+else(enable-hdf4)
+ set(MGL_HAVE_HDF4 0)
+endif(enable-hdf4)
+
+if(enable-hdf5)
+ set(MGL_HAVE_HDF5 1)
+ include(FindHDF5)
+ if(NOT HDF5_FOUND)
+ message(SEND_ERROR "Couldn't find HDF5 library.")
+ endif(NOT HDF5_FOUND)
+else(enable-hdf5)
+ set(MGL_HAVE_HDF5 0)
+endif(enable-hdf5)
+
+if(enable-jpeg)
+ set(MGL_HAVE_JPEG 1)
+ include(FindJPEG)
+ if(NOT JPEG_FOUND)
+ message(SEND_ERROR "Couldn't find JPEG library.")
+ endif(NOT JPEG_FOUND)
+else(enable-jpeg)
+ set(MGL_HAVE_JPEG 0)
+endif(enable-jpeg)
+
+
+if(enable-zlib)
+ set(MGL_HAVE_ZLIB 1)
+ include(FindZLIB)
+ if(NOT ZLIB_FOUND)
+ message(SEND_ERROR "Couldn't find ZLib library.")
+ endif(NOT ZLIB_FOUND)
+else(enable-zlib)
+ set(MGL_HAVE_ZLIB 0)
+endif(enable-zlib)
+
+if(enable-png)
+ set(MGL_HAVE_PNG 1)
+ if(NOT MGL_HAVE_ZLIB)
+ message(SEND_ERROR "You have to enable ZLib if you plan to use PNG export.")
+ endif(NOT MGL_HAVE_ZLIB)
+ include(FindPNG)
+ if(NOT PNG_FOUND)
+ message(SEND_ERROR "Couldn't find PNG library.")
+ endif(NOT PNG_FOUND)
+else(enable-png)
+ set(MGL_HAVE_PNG 0)
+endif(enable-png)
+
+
+if(enable-pdf)
+ set(MGL_HAVE_PDF 1)
+ if(NOT MGL_HAVE_PNG)
+ message(SEND_ERROR "You have to enable PNG if you plan to use PDF export.")
+ endif(NOT MGL_HAVE_PNG)
+ find_library(HPDF_LIB hpdf)
+ if(NOT HPDF_LIB)
+ message(SEND_ERROR "Couldn't find libHaru or libhpdf.")
+ endif(NOT HPDF_LIB)
+ find_path(HPDF_INCLUDE_DIR hpdf_u3d.h)
+ if(NOT HPDF_INCLUDE_DIR)
+ message(SEND_ERROR "Couldn't find headers of 3d-enabled version of libhpdf.")
+ endif(NOT HPDF_INCLUDE_DIR)
+else(enable-pdf)
+ set(MGL_HAVE_PDF 0)
+endif(enable-pdf)
+
+if(enable-gif)
+ set(MGL_HAVE_GIF 1)
+ include(FindGIF)
+ if(NOT GIF_FOUND)
+ message(SEND_ERROR "Couldn't find GIF library.")
+ endif(NOT GIF_FOUND)
+else(enable-gif)
+ set(MGL_HAVE_GIF 0)
+endif(enable-gif)
+
+if(enable-opengl)
+ set(MGL_HAVE_OPENGL 1)
+ include(FindOpenGL)
+ if(NOT OPENGL_FOUND)
+ message(SEND_ERROR "Couldn't find OpenGL libraries.")
+ endif(NOT OPENGL_FOUND)
+else(enable-opengl)
+ set(MGL_HAVE_OPENGL 0)
+endif(enable-opengl)
+
+if(enable-glut)
+ set(MGL_HAVE_GLUT 1)
+ if(NOT MGL_HAVE_OPENGL)
+ message(SEND_ERROR "You have to enable OpenGL if you plan to use GLUT.")
+ endif(NOT MGL_HAVE_OPENGL)
+ include(FindGLUT)
+ if(NOT GLUT_FOUND)
+ message(SEND_ERROR "Couldn't find GLUT library.")
+ endif(NOT GLUT_FOUND)
+else(enable-glut)
+ set(MGL_HAVE_GLUT 0)
+endif(enable-glut)
+
+if(enable-fltk)
+ set(MGL_HAVE_FLTK 1)
+ include(FindFLTK)
+ if(NOT FLTK_FOUND)
+ message(SEND_ERROR "Couldn't find FLTK library.")
+ endif(NOT FLTK_FOUND)
+else(enable-fltk)
+ set(MGL_HAVE_FLTK 0)
+endif(enable-fltk)
+
+if(enable-wx)
+ set(MGL_HAVE_WX 1)
+ FIND_PACKAGE(wxWidgets COMPONENTS base core gl)
+ if(NOT wxWidgets_FOUND)
+ message(SEND_ERROR "Couldn't find wxWidgets library.")
+ endif(NOT wxWidgets_FOUND)
+else(enable-wx)
+ set(MGL_HAVE_WX 0)
+endif(enable-wx)
+
+if(enable-doc-info)
+ set(MGL_HAVE_DOC_INFO 1)
+ find_program(findmi makeinfo)
+ if(NOT findmi)
+ message(SEND_ERROR "Couldn't find makeinfo needed for documentation building.")
+ endif(NOT findmi)
+else(enable-doc-info)
+ set(MGL_HAVE_DOC_INFO 0)
+endif(enable-doc-info)
+
+if(enable-doc-html OR enable-doc-site)
+ if(enable-texi2html)
+ find_program(findth texi2html)
+ if(NOT findth)
+ message(SEND_ERROR "Couldn't find texi2html needed for documentation building.")
+ endif(NOT findth)
+ else(enable-texi2html)
+ find_program(findth texi2any)
+ if(NOT findth)
+ message(SEND_ERROR "Couldn't find texi2any needed for documentation building.")
+ endif(NOT findth)
+ endif(enable-texi2html)
+endif(enable-doc-html OR enable-doc-site)
+
+if(enable-texi2html)
+ set(site_en ${CMAKE_BINARY_DIR}/texinfo/doc_en/doc_en.html)
+ set(site_ru ${CMAKE_BINARY_DIR}/texinfo/doc_ru/doc_ru.html)
+ set(th_opt )
+else(enable-texi2html)
+ set(th_opt --html)
+ set(site_en ${CMAKE_BINARY_DIR}/texinfo/doc_en/index.html)
+ set(site_ru ${CMAKE_BINARY_DIR}/texinfo/doc_ru/index.html)
+endif(enable-texi2html)
+
+if(enable-doc-html)
+ set(MGL_HAVE_DOC_HTML 1)
+else(enable-doc-html)
+ set(MGL_HAVE_DOC_HTML 0)
+endif(enable-doc-html)
+
+if(enable-doc-site)
+ set(MGL_HAVE_DOC_SITE 1)
+else(enable-doc-site)
+ set(MGL_HAVE_DOC_SITE 0)
+endif(enable-doc-site)
+
+if(enable-doc-pdf-ru)
+ set(MGL_HAVE_DOC_PDF_RU 1)
+ find_program(findtp texi2pdf)
+ if(NOT findtp)
+ message(SEND_ERROR "Couldn't find texi2pdf needed for documentation building.")
+ endif(NOT findtp)
+else(enable-doc-pdf-ru)
+ set(MGL_HAVE_DOC_PDF_RU 0)
+endif(enable-doc-pdf-ru)
+
+if(enable-doc-pdf-en)
+ set(MGL_HAVE_DOC_PDF_EN 1)
+ find_program(findtp texi2pdf)
+ if(NOT findtp)
+ message(SEND_ERROR "Couldn't find texi2pdf needed for documentation building.")
+ endif(NOT findtp)
+else(enable-doc-pdf-en)
+ set(MGL_HAVE_DOC_PDF_EN 0)
+endif(enable-doc-pdf-en)
+
+if(enable-doc-json)
+ set(MGL_HAVE_DOC_JSON 1)
+else(enable-doc-json)
+ set(MGL_HAVE_DOC_JSON 0)
+endif(enable-doc-json)
+
+if(enable-doc-prc)
+ set(MGL_HAVE_DOC_PRC 1)
+ if(NOT enable-pdf)
+ message(SEND_ERROR "You need to enable pdf support for MathGL.")
+ endif(NOT enable-pdf)
+else(enable-doc-prc)
+ set(MGL_HAVE_DOC_PRC 0)
+endif(enable-doc-prc)
+
+if(UNIX)
+ add_definitions(-DNO_COLOR_ARRAY)
+endif(UNIX)
+
+if(WIN32)
+ add_definitions(-DWIN32)
+endif(WIN32)
+
+add_subdirectory( src )
+add_subdirectory( widgets )
+add_subdirectory( include )
+if(NOT enable-lgpl)
+ add_subdirectory( udav )
+ add_subdirectory( json )
+ if(enable-python OR enable-lua OR enable-octave)
+ add_subdirectory( lang )
+ endif(enable-python OR enable-lua OR enable-octave)
+ if(NOT MSVC AND NOT BORLAND)
+ add_subdirectory( utils )
+ add_subdirectory( fonts )
+ endif(NOT MSVC AND NOT BORLAND)
+# add_subdirectory( mgllab )
+endif(NOT enable-lgpl)
+
+if(NOT MSVC AND NOT BORLAND)
+ add_subdirectory( examples )
+
+ if(MGL_HAVE_DOC_HTML OR MGL_HAVE_DOC_SITE OR MGL_HAVE_DOC_INFO OR MGL_HAVE_DOC_PDF_RU OR MGL_HAVE_DOC_PDF_EN )
+ add_subdirectory( texinfo )
+ endif(MGL_HAVE_DOC_HTML OR MGL_HAVE_DOC_SITE OR MGL_HAVE_DOC_INFO OR MGL_HAVE_DOC_PDF_RU OR MGL_HAVE_DOC_PDF_EN )
+
+endif(NOT MSVC AND NOT BORLAND)
+
+if(enable-mgltex)
+ add_subdirectory( mgltex )
+endif(enable-mgltex)
+
+if(WIN32)
+ install(FILES ${CMAKE_SOURCE_DIR}/FindMathGL2.cmake DESTINATION ${CMAKE_INSTALL_PREFIX} RENAME mathgl2-config.cmake)
+else(WIN32)
+ install(FILES ${CMAKE_SOURCE_DIR}/FindMathGL2.cmake DESTINATION ${MGL_LIB_INSTALL_DIR}/cmake/mathgl2/ RENAME mathgl2-config.cmake)
+endif(WIN32)
--- /dev/null
+/***************************************************************************\r
+ * fit.cpp is part of Math Graphic Library\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
+ * published by the Free Software Foundation; either version 3 of the *\r
+ * License, or (at your option) any later version. *\r
+ * *\r
+ * This program is distributed in the hope that it will be useful, *\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\r
+ * GNU General Public License for more details. *\r
+ * *\r
+ * You should have received a copy of the GNU Library General Public *\r
+ * License along with this program; if not, write to the *\r
+ * Free Software Foundation, Inc., *\r
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
+ ***************************************************************************/\r
+#include <ctype.h>\r
+#include "mgl2/fit.h"\r
+#include "mgl2/prim.h"\r
+#include "mgl2/eval.h"\r
+#include "mgl2/data.h"\r
+#include "mgl2/base.h"\r
+\r
+#if MGL_HAVE_GSL\r
+#include <gsl/gsl_multifit_nlin.h>\r
+#include <gsl/gsl_blas.h>\r
+#endif\r
+HMDT MGL_NO_EXPORT mglFormulaCalc(const char *str, const std::vector<mglDataA*> &head);\r
+//-----------------------------------------------------------------------------\r
+int mglFitPnts=100; ///< Number of output points in fitting\r
+char mglFitRes[1024]; ///< Last fitted formula\r
+mreal mglFitChi=NAN; ///< Chi value for last fitted formula\r
+mglData mglFitCovar; ///< Covar matrix for lat fitted formula\r
+//-----------------------------------------------------------------------------\r
+mreal MGL_EXPORT mgl_get_fit_chi() { return mglFitChi; }\r
+mreal MGL_EXPORT mgl_get_fit_chi_() { return mglFitChi; }\r
+//-----------------------------------------------------------------------------\r
+HCDT MGL_EXPORT mgl_get_fit_covar() { return &mglFitCovar; }\r
+uintptr_t MGL_EXPORT mgl_get_fit_covar_() { return (uintptr_t)&mglFitCovar; }\r
+//-----------------------------------------------------------------------------\r
+void MGL_EXPORT mgl_puts_fit(HMGL gr, double x, double y, double z, const char *pre, const char *font, double size)\r
+{\r
+ long n = strlen(mglFitRes)+(pre?strlen(pre):0)+1;\r
+ char *buf = new char[n];\r
+ if(pre) snprintf(buf,n,"%s%s",pre,mglFitRes);\r
+ else strncpy(buf,mglFitRes,n);\r
+ buf[n-1]=0; mgl_puts(gr,x,y,z,buf,font,size);\r
+ delete []buf;\r
+}\r
+void MGL_EXPORT mgl_puts_fit_(uintptr_t* gr, mreal *x, mreal *y, mreal *z, const char *prefix, const char *font, mreal *size, int l, int n)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,prefix,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,font,n); d[n]=0;\r
+ mgl_puts_fit(_GR_, *x,*y,*z, s, d, *size);\r
+ delete []s; delete []d;\r
+}\r
+//-----------------------------------------------------------------------------\r
+/// Structure for keeping data and precompiled fitted formula\r
+struct mglFitData\r
+{\r
+ long n; ///< number of points\r
+ mglDataA *x,*y,*z; ///< x, y, z values\r
+ mreal *a; ///< function values\r
+ mreal *s; ///< value dispersions (sigma)\r
+ const char *eq; ///< approximation formula\r
+ int m; ///< number of variables\r
+ const char *var; ///< variables for fitting\r
+};\r
+//-----------------------------------------------------------------------------\r
+#if MGL_HAVE_GSL\r
+int mgl_fit__f (const gsl_vector *x, void *data, gsl_vector *f)\r
+{\r
+ mglFitData *fd = (mglFitData *)data;\r
+ mglDataV *var = new mglDataV[fd->m];\r
+ std::vector<mglDataA*> list;\r
+ for(long i=0;i<fd->m;i++)\r
+ { var[i].s=fd->var[i]; var[i].Fill(gsl_vector_get(x,i)); list.push_back(var+i); }\r
+ if(fd->x) list.push_back(fd->x);\r
+ if(fd->y) list.push_back(fd->y);\r
+ if(fd->z) list.push_back(fd->z);\r
+ HMDT res = mglFormulaCalc(fd->eq, list);\r
+#pragma omp parallel for\r
+ for(long i=0;i<fd->n;i++)\r
+ {\r
+ mreal aa = fd->a[i], ss = fd->s[i];\r
+ if(mgl_isnum(aa) && ss==ss && ss!=0)\r
+ gsl_vector_set (f, i, (res->a[i] - aa)/ss);\r
+ else gsl_vector_set (f, i, 0);\r
+ }\r
+ delete []var; mgl_delete_data(res);\r
+ return GSL_SUCCESS;\r
+}\r
+//-----------------------------------------------------------------------------\r
+int MGL_NO_EXPORT mgl_fit__df (const gsl_vector * x, void *data, gsl_matrix * J)\r
+{\r
+ mglFitData *fd = (mglFitData *)data;\r
+ mglDataV *var = new mglDataV[fd->m];\r
+ std::vector<mglDataA*> list;\r
+ for(long i=0;i<fd->m;i++)\r
+ { var[i].s=fd->var[i]; var[i].Fill(gsl_vector_get(x,i)); list.push_back(var+i); }\r
+ if(fd->x) list.push_back(fd->x);\r
+ if(fd->y) list.push_back(fd->y);\r
+ if(fd->z) list.push_back(fd->z);\r
+ HMDT res = mglFormulaCalc(fd->eq, list);\r
+ const mreal eps = 1e-5;\r
+ for(long j=0;j<fd->m;j++)\r
+ {\r
+ var[j].Fill(gsl_vector_get(x,j)+eps);\r
+ HMDT dif = mglFormulaCalc(fd->eq, list);\r
+ var[j].Fill(gsl_vector_get(x,j));\r
+#pragma omp parallel for\r
+ for(long i=0;i<fd->n;i++)\r
+ {\r
+ mreal aa = fd->a[i], ss = fd->s[i];\r
+ if(mgl_isnum(aa) && ss==ss && ss!=0)\r
+ gsl_matrix_set (J, i, j, (dif->a[i]-res->a[i])/(eps*ss));\r
+ else gsl_matrix_set (J, i, j, 0);\r
+ }\r
+ mgl_delete_data(dif);\r
+ }\r
+ delete []var; mgl_delete_data(res);\r
+ return GSL_SUCCESS;\r
+}\r
+//-----------------------------------------------------------------------------\r
+int MGL_NO_EXPORT mgl_fit__fdf (const gsl_vector * x, void *data, gsl_vector * f, gsl_matrix * J)\r
+{\r
+ mglFitData *fd = (mglFitData *)data;\r
+ mglDataV *var = new mglDataV[fd->m];\r
+ std::vector<mglDataA*> list;\r
+ for(long i=0;i<fd->m;i++)\r
+ { var[i].s=fd->var[i]; var[i].Fill(gsl_vector_get(x,i)); list.push_back(var+i); }\r
+ if(fd->x) list.push_back(fd->x);\r
+ if(fd->y) list.push_back(fd->y);\r
+ if(fd->z) list.push_back(fd->z);\r
+ HMDT res = mglFormulaCalc(fd->eq, list);\r
+#pragma omp parallel for\r
+ for(long i=0;i<fd->n;i++)\r
+ {\r
+ mreal aa = fd->a[i], ss = fd->s[i];\r
+ if(mgl_isnum(aa) && ss==ss && ss!=0)\r
+ gsl_vector_set (f, i, (res->a[i] - aa)/ss);\r
+ else gsl_vector_set (f, i, 0);\r
+ }\r
+ const mreal eps = 1e-5;\r
+ for(long j=0;j<fd->m;j++)\r
+ {\r
+ var[j].Fill(gsl_vector_get(x,j)+eps);\r
+ HMDT dif = mglFormulaCalc(fd->eq, list);\r
+ var[j].Fill(gsl_vector_get(x,j));\r
+#pragma omp parallel for\r
+ for(long i=0;i<fd->n;i++)\r
+ {\r
+ mreal aa = fd->a[i], ss = fd->s[i];\r
+ if(mgl_isnum(aa) && ss==ss && ss!=0)\r
+ gsl_matrix_set (J, i, j, (dif->a[i]-res->a[i])/(eps*ss));\r
+ else gsl_matrix_set (J, i, j, 0);\r
+ }\r
+ mgl_delete_data(dif);\r
+ }\r
+ delete []var; mgl_delete_data(res);\r
+ return GSL_SUCCESS;\r
+}\r
+#endif\r
+//-----------------------------------------------------------------------------\r
+/// GSL based fitting procedure for formula/arguments specified by string\r
+mreal MGL_NO_EXPORT mgl_fit_base(mglFitData &fd, mreal *ini)\r
+{\r
+#if MGL_HAVE_GSL\r
+ register long i,m=fd.m,n=fd.n,iter=0;\r
+ if(n<1 || ini==0) return -1;\r
+ // setup data\r
+ double *x_init = new double[fd.m];\r
+ for(i=0;i<m;i++) x_init[i] = ini[i];\r
+ // setup fitting\r
+ gsl_vector_view vx = gsl_vector_view_array(x_init, m);\r
+ const gsl_multifit_fdfsolver_type *T = gsl_multifit_fdfsolver_lmsder;\r
+ gsl_multifit_fdfsolver *s = gsl_multifit_fdfsolver_alloc(T, n, m);\r
+ gsl_multifit_function_fdf f;\r
+ f.f = mgl_fit__f; f.df = mgl_fit__df;\r
+ f.fdf = mgl_fit__fdf; f.n = n; f.p = m;\r
+ f.params = &fd;\r
+ gsl_multifit_fdfsolver_set(s, &f, &vx.vector);\r
+ int status; // start fitting\r
+ do\r
+ {\r
+ iter++;\r
+ status = gsl_multifit_fdfsolver_iterate(s);\r
+ if ( status ) break;\r
+ status = gsl_multifit_test_delta (s->dx, s->x, 1e-4, 1e-4 );\r
+ }\r
+ while ( status == GSL_CONTINUE && iter < 500 );\r
+\r
+ gsl_matrix *covar = gsl_matrix_alloc(m, m);\r
+#ifdef HAVE_GSL_2\r
+ gsl_matrix *J = gsl_matrix_alloc(s->fdf->n, s->fdf->p);\r
+ gsl_multifit_fdfsolver_jac(s, J);\r
+ gsl_multifit_covar (J, 0.0, covar);\r
+ gsl_matrix_free (J);\r
+#else\r
+ gsl_multifit_covar(s->J, 0.0, covar);\r
+#endif\r
+ mglFitCovar.Set(covar);\r
+ gsl_matrix_free(covar);\r
+\r
+ mreal res = gsl_blas_dnrm2(s->f);\r
+ for(i=0;i<m;i++) ini[i] = gsl_vector_get(s->x, i);\r
+ // free memory\r
+ gsl_multifit_fdfsolver_free(s);\r
+ delete []x_init;\r
+ return res;\r
+#else\r
+ return 0.0;\r
+#endif\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mglPrepareFitEq(mglBase *gr,mreal chi, const char *eq, const char *var, mreal *par)\r
+{\r
+ char buf[32]="";\r
+ mglFitChi = chi;\r
+ snprintf(mglFitRes,1024,"chi=%g",chi); mglFitRes[1023]=0;\r
+ size_t i,k,len=strlen(var);\r
+ for(i=0;i<len;i++)\r
+ {\r
+ snprintf(buf,32,", %c=%g",var[i],par[i]);\r
+ buf[31]=0; strcat(mglFitRes,buf);\r
+ }\r
+ gr->SetWarn(-1,mglFitRes);\r
+\r
+ memset(mglFitRes, 0, 1024); //mglFitRes[0] = 0;\r
+ len=strlen(eq);\r
+ for(i=k=0;i<len;i++)\r
+ {\r
+ const char *c = strchr(var,eq[i]);\r
+ if(c && (i==0 || !isalnum(eq[i-1])) && (i==len-1 || !isalnum(eq[i+1])))\r
+ {\r
+ snprintf(buf,32,"%g",par[c-var]);\r
+ buf[31]=0; strcat(mglFitRes+k, buf); k+=strlen(buf);\r
+ }\r
+ else { mglFitRes[k] = eq[i]; k++; }\r
+ }\r
+ mglFitRes[k]=0;\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_fit_1(HMGL gr, HCDT y, const char *eq, const char *var, HMDT ini, const char *opt)\r
+{\r
+ gr->SaveState(opt);\r
+ mglData x(y->GetNx()); x.Fill(gr->Min.x, gr->Max.x);\r
+ mglData s(y); s.Fill(1,1);\r
+ return mgl_fit_xys(gr,&x,y,&s,eq,var,ini,0);\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_fit_2(HMGL gr, HCDT z, const char *eq, const char *var, HMDT ini, const char *opt)\r
+{\r
+ gr->SaveState(opt);\r
+ mglData x(z->GetNx()); x.Fill(gr->Min.x, gr->Max.x);\r
+ mglData y(z->GetNy()); y.Fill(gr->Min.y, gr->Max.y);\r
+ mglData s(z); s.Fill(1,1);\r
+ return mgl_fit_xyzs(gr,&x,&y,z,&s,eq,var,ini,0);\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_fit_3(HMGL gr, HCDT a, const char *eq, const char *var, HMDT ini, const char *opt)\r
+{\r
+ gr->SaveState(opt);\r
+ mglData x(a->GetNx()); x.Fill(gr->Min.x, gr->Max.x);\r
+ mglData y(a->GetNy()); y.Fill(gr->Min.y, gr->Max.y);\r
+ mglData z(a->GetNz()); z.Fill(gr->Min.z, gr->Max.z);\r
+ mglData s(a); s.Fill(1,1);\r
+ return mgl_fit_xyzas(gr,&x,&y,&z,a,&s,eq,var,ini,0);\r
+}\r
+//-----------------------------------------------------------------------------\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
+{\r
+ mglData s(y); s.Fill(1,1);\r
+ return mgl_fit_xys(gr,x,y,&s,eq,var,ini,opt);\r
+}\r
+//-----------------------------------------------------------------------------\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
+{\r
+ mglData s(z); s.Fill(1,1);\r
+ return mgl_fit_xyzs(gr,x,y,z,&s,eq,var,ini,opt);\r
+}\r
+//-----------------------------------------------------------------------------\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
+{\r
+ mglData s(a); s.Fill(1,1);\r
+ return mgl_fit_xyzas(gr,x,y,z,a,&s,eq,var,ini,opt);\r
+}\r
+//-----------------------------------------------------------------------------\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
+{\r
+ gr->SaveState(opt);\r
+ mglData x(y->GetNx()); x.Fill(gr->Min.x, gr->Max.x);\r
+ return mgl_fit_xys(gr,&x,y,s,eq,var,ini,0);\r
+}\r
+//-----------------------------------------------------------------------------\r
+void MGL_NO_EXPORT mgl_fill_fit(HMGL gr, mglData &fit, mglData &in, mglFitData &fd, const char *var, long nx, long ny, long nz, long k)\r
+{\r
+ mglDataV *vv = new mglDataV[fd.m];\r
+ std::vector<mglDataA*> list;\r
+ for(long i=0;i<fd.m;i++)\r
+ { vv[i].s=var[i]; vv[i].Fill(in.a[i]); list.push_back(vv+i); }\r
+ mglDataV x(nx,ny,nz, gr->Min.x,gr->Max.x,'x'); x.s = L"x"; list.push_back(&x);\r
+ mglDataV y(nx,ny,nz, gr->Min.y,gr->Max.y,'y'); y.s = L"y"; list.push_back(&y);\r
+ mglDataV z(nx,ny,nz, gr->Min.z,gr->Max.z,'z'); z.s = L"z"; list.push_back(&z);\r
+ HMDT res = mglFormulaCalc(fd.eq, list);\r
+ long nn = nx*ny*nz;\r
+ memcpy(fit.a+k*nn,res->a,nn*sizeof(mreal));\r
+ delete []vv; mgl_delete_data(res);\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_fit_xys(HMGL gr, HCDT xx, HCDT yy, HCDT ss, const char *eq, const char *var, HMDT ini, const char *opt)\r
+{\r
+ long m = yy->GetNx();\r
+ mreal rr = gr->SaveState(opt);\r
+ long nn = (mgl_isnan(rr) || rr<=0) ? mglFitPnts:long(rr+0.5);\r
+ if(xx->GetNx()!=m)\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return 0; }\r
+ if(m<2)\r
+ { gr->SetWarn(mglWarnLow,"Fit[S]"); return 0; }\r
+ if(ss->GetNN() != yy->GetNN())\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return 0; }\r
+ if(!var || *var==0)\r
+ { gr->SetWarn(mglWarnNull,"Fit[S]"); return 0; }\r
+\r
+ mglData x(xx), y(yy), s(ss); x.s=L"x";\r
+ long mm = yy->GetNy()*yy->GetNz();\r
+#pragma omp parallel for\r
+ for(long i=0;i<m;i++) if(mgl_isnan(x.a[i]))\r
+ for(long j=0;j<mm;j++) y.a[i+m*j] = NAN;\r
+ mglFitData fd;\r
+ fd.n = m; fd.x = &x; fd.y = 0;\r
+ fd.z = 0; fd.a = y.a; fd.s = s.a;\r
+ fd.eq = eq; fd.var = var; fd.m = strlen(var);\r
+ mglData in(fd.m), *fit=new mglData(nn, yy->GetNy(), yy->GetNz());\r
+ mreal res=-1;\r
+ for(long i=0;i<yy->GetNy()*yy->GetNz();i++)\r
+ {\r
+ if(ini && ini->nx>=fd.m) in.Set(ini->a,fd.m);\r
+ else in.Fill(0.,0);\r
+ mglDataR xc(x); xc.SetInd(i%x.ny, L"x");\r
+ fd.a = y.a+i*m; fd.x = &xc; //x.a+(i%x.ny)*m;\r
+ fd.s = s.a+i*m;\r
+ res = mgl_fit_base(fd,in.a);\r
+ mgl_fill_fit(gr,*fit,in,fd,var,nn,1,1,i);\r
+ if(ini && ini->nx>=fd.m) memcpy(ini->a,in.a,fd.m*sizeof(mreal));\r
+ }\r
+ mglPrepareFitEq(gr,res,eq,var,in.a);\r
+ gr->LoadState(); return fit;\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_fit_xyzs(HMGL gr, HCDT xx, HCDT yy, HCDT zz, HCDT ss, const char *eq, const char *var, HMDT ini, const char *opt)\r
+{\r
+ long m=zz->GetNx(),n=zz->GetNy();\r
+ mreal rr = gr->SaveState(opt);\r
+ long nn = (mgl_isnan(rr) || rr<=0) ? mglFitPnts:long(rr+0.5);\r
+ if(xx->GetNx()!=m)\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return 0; }\r
+ if(ss->GetNN() != zz->GetNN())\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return 0; }\r
+ if(yy->GetNx()!=n && (xx->GetNy()!=n || yy->GetNx()!=m || yy->GetNy()!=n))\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return 0; }\r
+ if(m<2|| n<2)\r
+ { gr->SetWarn(mglWarnLow,"Fit[S]"); return 0; }\r
+ if(!var || *var==0)\r
+ { gr->SetWarn(mglWarnNull,"Fit[S]"); return 0; }\r
+\r
+ mglData x(m, n), y(m, n), z(zz), s(ss); x.s=L"x"; y.s=L"y";\r
+ long nz = zz->GetNz(), mm = n*m;\r
+#pragma omp parallel for collapse(2)\r
+ for(long i=0;i<m;i++) for(long j=0;j<n;j++)\r
+ {\r
+ register long i0 = i+m*j;\r
+ x.a[i0] = GetX(xx,i,j,0).x;\r
+ y.a[i0] = GetY(yy,i,j,0).x;\r
+ if(mgl_isnan(x.a[i0]) || mgl_isnan(y.a[i0]))\r
+ for(long k=0;k<nz;k++) z.a[i0+mm*k] = NAN;\r
+ }\r
+ mglFitData fd;\r
+ fd.n = m*n; fd.x = &x; fd.y = &y;\r
+ fd.z = 0; fd.a = z.a; fd.s = s.a;\r
+ fd.eq = eq; fd.var=var; fd.m = strlen(var);\r
+\r
+ mglData in(fd.m), *fit=new mglData(nn, nn, zz->GetNz());\r
+ mreal res = -1;\r
+ for(long i=0;i<nz;i++)\r
+ {\r
+ if(ini && ini->nx>=fd.m) in.Set(ini->a,fd.m);\r
+ else in.Fill(0.,0);\r
+ fd.a = z.a+i*m*n; fd.s = s.a+i*m*n;\r
+ res = mgl_fit_base(fd,in.a);\r
+ mgl_fill_fit(gr,*fit,in,fd,var,nn,nn,1,i);\r
+ if(ini && ini->nx>=fd.m) memcpy(ini->a,in.a,fd.m*sizeof(mreal));\r
+ }\r
+ mglPrepareFitEq(gr,res, eq,var,in.a);\r
+ gr->LoadState(); return fit;\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_fit_xyzas(HMGL gr, HCDT xx, HCDT yy, HCDT zz, HCDT aa, HCDT ss, const char *eq, const char *var, HMDT ini, const char *opt)\r
+{\r
+ long m=aa->GetNx(), n=aa->GetNy(), l=aa->GetNz(), i = n*m*l;\r
+ mreal rr = gr->SaveState(opt);\r
+ long nn = (mgl_isnan(rr) || rr<=0) ? mglFitPnts:long(rr+0.5);\r
+ if(m<2 || n<2 || l<2)\r
+ { gr->SetWarn(mglWarnLow,"Fit[S]"); return 0; }\r
+ if(ss->GetNN() != i)\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return 0; }\r
+ bool both = xx->GetNN()==i && yy->GetNN()==i && zz->GetNN()==i;\r
+ if(!(both || (xx->GetNx()==m && yy->GetNx()==n && zz->GetNx()==l)))\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return 0; }\r
+ if(!var || *var==0)\r
+ { gr->SetWarn(mglWarnNull,"Fit[S]"); return 0; }\r
+\r
+ mglData x(m,n,l), y(m,n,l), z(m,n,l), a(aa), s(ss);\r
+ x.s=L"x"; y.s=L"y"; z.s=L"z";\r
+#pragma omp parallel for collapse(3)\r
+ for(long i=0;i<m;i++) for(long j=0;j<n;j++) for(long k=0;k<l;k++)\r
+ {\r
+ register long i0 = i+m*(j+n*k);\r
+ x.a[i0] = GetX(xx,i,j,k).x;\r
+ y.a[i0] = GetY(yy,i,j,k).x;\r
+ z.a[i0] = GetZ(zz,i,j,k).x;\r
+ if(mgl_isnan(x.a[i0]) || mgl_isnan(y.a[i0]) || mgl_isnan(z.a[i0])) a.a[i0] = NAN;\r
+ }\r
+ mglFitData fd;\r
+ fd.n = m*n*l; fd.x = &x; fd.y = &y;\r
+ fd.z = &z; fd.a = a.a; fd.s = s.a;\r
+ fd.eq = eq; fd.var=var; fd.m = strlen(var);\r
+ mglData in(fd.m), *fit=new mglData(nn, nn, nn);\r
+ mreal res = -1;\r
+\r
+ if(ini && ini->nx>=fd.m) in.Set(ini->a,fd.m);\r
+ else in.Fill(0.,0);\r
+ res = mgl_fit_base(fd,in.a);\r
+ mgl_fill_fit(gr,*fit,in,fd,var,nn,nn,nn,0);\r
+ if(ini && ini->nx>=fd.m) memcpy(ini->a,in.a,fd.m*sizeof(mreal));\r
+\r
+ mglPrepareFitEq(gr,res, eq,var,in.a);\r
+ gr->LoadState(); return fit;\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_hist_x(HMGL gr, HCDT x, HCDT a, const char *opt)\r
+{\r
+ long nn=a->GetNN();\r
+ if(nn!=x->GetNN())\r
+ { gr->SetWarn(mglWarnDim,"Hist"); return 0; }\r
+ mreal rr = gr->SaveState(opt);\r
+ long n = (mgl_isnan(rr) || rr<=0) ? mglFitPnts:long(rr+0.5);\r
+ mglData *res = new mglData(n);\r
+\r
+ mreal vx = n/(gr->Max.x-gr->Min.x);\r
+ for(long i=0;i<nn;i++)\r
+ {\r
+ register long j1 = long((x->vthr(i)-gr->Min.x)*vx);\r
+ if(j1>=0 && j1<n) res->a[j1] += a->vthr(i);\r
+ }\r
+ gr->LoadState(); return res;\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_hist_xy(HMGL gr, HCDT x, HCDT y, HCDT a, const char *opt)\r
+{\r
+ long nn=a->GetNN();\r
+ if(nn!=x->GetNN() || nn!=y->GetNN())\r
+ { gr->SetWarn(mglWarnDim,"Hist"); return 0; }\r
+ mreal rr = gr->SaveState(opt);\r
+ long n = (mgl_isnan(rr) || rr<=0) ? mglFitPnts:long(rr+0.5);\r
+ mglData *res = new mglData(n, n);\r
+ mreal vx = n/(gr->Max.x-gr->Min.x);\r
+ mreal vy = n/(gr->Max.y-gr->Min.y);\r
+ for(long i=0;i<nn;i++)\r
+ {\r
+ register long j1 = long((x->vthr(i)-gr->Min.x)*vx);\r
+ register long j2 = long((y->vthr(i)-gr->Min.y)*vy);\r
+ if(j1>=0 && j1<n && j2>=0 && j2<n) res->a[j1+n*j2] += a->vthr(i);\r
+ }\r
+ gr->LoadState(); return res;\r
+}\r
+//-----------------------------------------------------------------------------\r
+HMDT MGL_EXPORT mgl_hist_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *opt)\r
+{\r
+ long nn=a->GetNN();\r
+ if(nn!=x->GetNN() || nn!=y->GetNN() || nn!=z->GetNN())\r
+ { gr->SetWarn(mglWarnDim,"Hist"); return 0; }\r
+ mreal rr = gr->SaveState(opt);\r
+ long n = (mgl_isnan(rr) || rr<=0) ? mglFitPnts:long(rr+0.5);\r
+ mglData *res = new mglData(n, n, n);\r
+ mreal vx = n/(gr->Max.x-gr->Min.x), vy = n/(gr->Max.y-gr->Min.y), vz = n/(gr->Max.z-gr->Min.z);\r
+ for(long i=0;i<nn;i++)\r
+ {\r
+ register long j1 = long((x->vthr(i)-gr->Min.x)*vx);\r
+ register long j2 = long((y->vthr(i)-gr->Min.y)*vy);\r
+ register long j3 = long((z->vthr(i)-gr->Min.z)*vz);\r
+ if(j1>=0 && j1<n && j2>=0 && j2<n && j3>=0 && j3<n)\r
+ res->a[j1+n*(j2+n*j3)] += a->vthr(i);\r
+ }\r
+ gr->LoadState(); return res;\r
+}\r
+//-----------------------------------------------------------------------------\r
+uintptr_t MGL_EXPORT mgl_hist_x_(uintptr_t* gr, uintptr_t* x, uintptr_t* a, const char *opt, int lo)\r
+{ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_hist_x(_GR_, _DA_(x), _DA_(a), o);\r
+ delete []o; return r; }\r
+uintptr_t MGL_EXPORT mgl_hist_xy_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* a, const char *opt, int lo)\r
+{ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_hist_xy(_GR_, _DA_(x), _DA_(y), _DA_(a), o);\r
+ delete []o; return r; }\r
+uintptr_t MGL_EXPORT mgl_hist_xyz_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, const char *opt, int lo)\r
+{ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_hist_xyz(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(a), o);\r
+ delete []o; return r; }\r
+//-----------------------------------------------------------------------------\r
+MGL_EXPORT const char *mgl_get_fit(HMGL ) { return mglFitRes; }\r
+int MGL_EXPORT mgl_get_fit_(uintptr_t *gr, char *out, int len)\r
+{\r
+ const char *res = mgl_get_fit(_GR_);\r
+ if(out) strncpy(out,res,len);\r
+ return strlen(res);\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_1(_GR_, _DA_(y), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_2(_GR_, _DA_(z), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_3(_GR_, _DA_(a), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_xy(_GR_, _DA_(x), _DA_(y), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_xyz(_GR_, _DA_(x), _DA_(y), _DA_(z), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_xyza(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_ys(_GR_, _DA_(y), _DA_(ss), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_xys(_GR_, _DA_(x), _DA_(y), _DA_(ss), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_xyzs(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(ss), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\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 l, int n, int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,var,n); d[n]=0;\r
+ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ uintptr_t r = (uintptr_t)mgl_fit_xyzas(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(a), _DA_(ss), s, d, _DM_(ini), o);\r
+ delete []o; delete []s; delete []d; return r;\r
+}\r
+//-----------------------------------------------------------------------------\r
projects / mathgl.git / commitdiff