text:
/* ==================================== JUCER_BINARY_RESOURCE ====================================

   This is an auto-generated file: Any edits you make may be overwritten!

*/

namespace BinaryData
{

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_0[] =
"FILE(GLOB Eigen_Cholesky_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Cholesky_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Cholesky COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt = (const char*) temp_binary_data_0;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_1[] =
"FILE(GLOB Eigen_CholmodSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_CholmodSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/CholmodSupport COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt2 = (const char*) temp_binary_data_1;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_2[] =
"FILE(GLOB Eigen_Core_arch_AltiVec_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Core_arch_AltiVec_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/AltiVec COMPONENT Devel\n"
")\n";

const char* CMakeLists_txt3 = (const char*) temp_binary_data_2;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_3[] =
"FILE(GLOB Eigen_Core_arch_Default_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Core_arch_Default_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/Default COMPONENT Devel\n"
")\n";

const char* CMakeLists_txt4 = (const char*) temp_binary_data_3;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_4[] =
"FILE(GLOB Eigen_Core_arch_NEON_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Core_arch_NEON_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/NEON COMPONENT Devel\n"
")\n";

const char* CMakeLists_txt5 = (const char*) temp_binary_data_4;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_5[] =
"FILE(GLOB Eigen_Core_arch_SSE_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Core_arch_SSE_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/SSE COMPONENT Devel\n"
")\n";

const char* CMakeLists_txt6 = (const char*) temp_binary_data_5;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_6[] =
"ADD_SUBDIRECTORY(SSE)\n"
"ADD_SUBDIRECTORY(AltiVec)\n"
"ADD_SUBDIRECTORY(NEON)\n"
"ADD_SUBDIRECTORY(Default)\n";

const char* CMakeLists_txt7 = (const char*) temp_binary_data_6;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_7[] =
"FILE(GLOB Eigen_Core_Product_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Core_Product_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/products COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt8 = (const char*) temp_binary_data_7;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_8[] =
"FILE(GLOB Eigen_Core_util_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_Core_util_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/util COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt9 = (const char*) temp_binary_data_8;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_9[] =
"FILE(GLOB Eigen_Core_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Core_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core COMPONENT Devel\n"
"  )\n"
"\n"
"ADD_SUBDIRECTORY(products)\n"
"ADD_SUBDIRECTORY(util)\n"
"ADD_SUBDIRECTORY(arch)\n";

const char* CMakeLists_txt10 = (const char*) temp_binary_data_9;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_10[] =
"FILE(GLOB Eigen_Eigen2Support_Geometry_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Eigen2Support_Geometry_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support/Geometry\n"
"  )\n";

const char* CMakeLists_txt11 = (const char*) temp_binary_data_10;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_11[] =
"FILE(GLOB Eigen_Eigen2Support_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Eigen2Support_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support COMPONENT Devel\n"
"  )\n"
"\n"
"ADD_SUBDIRECTORY(Geometry)";

const char* CMakeLists_txt12 = (const char*) temp_binary_data_11;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_12[] =
"FILE(GLOB Eigen_EIGENVALUES_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_EIGENVALUES_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigenvalues COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt13 = (const char*) temp_binary_data_12;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_13[] =
"FILE(GLOB Eigen_Geometry_arch_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Geometry_arch_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry/arch COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt14 = (const char*) temp_binary_data_13;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_14[] =
"FILE(GLOB Eigen_Geometry_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Geometry_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry COMPONENT Devel\n"
"  )\n"
"\n"
"ADD_SUBDIRECTORY(arch)\n";

const char* CMakeLists_txt15 = (const char*) temp_binary_data_14;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_15[] =
"FILE(GLOB Eigen_Householder_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Householder_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Householder COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt16 = (const char*) temp_binary_data_15;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_16[] =
"FILE(GLOB Eigen_IterativeLinearSolvers_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_IterativeLinearSolvers_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/IterativeLinearSolvers COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt17 = (const char*) temp_binary_data_16;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_17[] =
"FILE(GLOB Eigen_Jacobi_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_Jacobi_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Jacobi COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt18 = (const char*) temp_binary_data_17;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_18[] =
"FILE(GLOB Eigen_LU_arch_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_LU_arch_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU/arch COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt19 = (const char*) temp_binary_data_18;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_19[] =
"FILE(GLOB Eigen_LU_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_LU_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU COMPONENT Devel\n"
"  )\n"
"\n"
"ADD_SUBDIRECTORY(arch)\n";

const char* CMakeLists_txt20 = (const char*) temp_binary_data_19;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_20[] =
"FILE(GLOB Eigen_MetisSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_MetisSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/MetisSupport COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt21 = (const char*) temp_binary_data_20;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_21[] =
"FILE(GLOB Eigen_misc_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_misc_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/misc COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt22 = (const char*) temp_binary_data_21;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_22[] =
"FILE(GLOB Eigen_OrderingMethods_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_OrderingMethods_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/OrderingMethods COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt23 = (const char*) temp_binary_data_22;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_23[] =
"FILE(GLOB Eigen_PardisoSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_PardisoSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PardisoSupport COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt24 = (const char*) temp_binary_data_23;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_24[] =
"FILE(GLOB Eigen_PastixSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_PastixSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PaStiXSupport COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt25 = (const char*) temp_binary_data_24;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_25[] =
"FILE(GLOB Eigen_plugins_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_plugins_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/plugins COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt26 = (const char*) temp_binary_data_25;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_26[] =
"FILE(GLOB Eigen_QR_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_QR_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/QR COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt27 = (const char*) temp_binary_data_26;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_27[] =
"FILE(GLOB Eigen_SparseCholesky_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_SparseCholesky_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCholesky COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt28 = (const char*) temp_binary_data_27;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_28[] =
"FILE(GLOB Eigen_SparseCore_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_SparseCore_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCore COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt29 = (const char*) temp_binary_data_28;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_29[] =
"FILE(GLOB Eigen_SparseLU_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_SparseLU_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseLU COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt30 = (const char*) temp_binary_data_29;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_30[] =
"FILE(GLOB Eigen_SparseQR_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_SparseQR_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseQR/ COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt31 = (const char*) temp_binary_data_30;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_31[] =
"FILE(GLOB Eigen_SPQRSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_SPQRSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SPQRSupport/ COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt32 = (const char*) temp_binary_data_31;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_32[] =
"FILE(GLOB Eigen_StlSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_StlSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/StlSupport COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt33 = (const char*) temp_binary_data_32;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_33[] =
"FILE(GLOB Eigen_SuperLUSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_SuperLUSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SuperLUSupport COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt34 = (const char*) temp_binary_data_33;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_34[] =
"FILE(GLOB Eigen_SVD_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES\n"
"  ${Eigen_SVD_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SVD COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt35 = (const char*) temp_binary_data_34;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_35[] =
"FILE(GLOB Eigen_UmfPackSupport_SRCS \"*.h\")\n"
"\n"
"INSTALL(FILES \n"
"  ${Eigen_UmfPackSupport_SRCS}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/UmfPackSupport COMPONENT Devel\n"
"  )\n";

const char* CMakeLists_txt36 = (const char*) temp_binary_data_35;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_36[] =
"file(GLOB Eigen_src_subdirectories \"*\")\n"
"escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR \"${CMAKE_CURRENT_SOURCE_DIR}\")\n"
"foreach(f ${Eigen_src_subdirectories})\n"
"  if(NOT f MATCHES \"\\\\.txt\" AND NOT f MATCHES \"${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+\" )\n"
"    add_subdirectory(${f})\n"
"  endif()\n"
"endforeach()\n";

const char* CMakeLists_txt37 = (const char*) temp_binary_data_36;

//================== Array ==================
static const unsigned char temp_binary_data_37[] =
"#ifndef EIGEN_ARRAY_MODULE_H\n"
"#define EIGEN_ARRAY_MODULE_H\n"
"\n"
"// include Core first to handle Eigen2 support macros\n"
"#include \"Core\"\n"
"\n"
"#ifndef EIGEN2_SUPPORT\n"
"  #error The Eigen/Array header does no longer exist in Eigen3. All that functionality has moved to Eigen/Core.\n"
"#endif\n"
"\n"
"#endif // EIGEN_ARRAY_MODULE_H\n";

const char* Array = (const char*) temp_binary_data_37;

//================== Cholesky ==================
static const unsigned char temp_binary_data_38[] =
"#ifndef EIGEN_CHOLESKY_MODULE_H\n"
"#define EIGEN_CHOLESKY_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \\defgroup Cholesky_Module Cholesky module\n"
"  *\n"
"  *\n"
"  *\n"
"  * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.\n"
"  * Those decompositions are accessible via the following MatrixBase methods:\n"
"  *  - MatrixBase::llt(),\n"
"  *  - MatrixBase::ldlt()\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/Cholesky>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/Cholesky/LLT.h\"\n"
"#include \"src/Cholesky/LDLT.h\"\n"
"#ifdef EIGEN_USE_LAPACKE\n"
"#include \"src/Cholesky/LLT_MKL.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_CHOLESKY_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n";

const char* Cholesky = (const char*) temp_binary_data_38;

//================== CholmodSupport ==================
static const unsigned char temp_binary_data_39[] =
"#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H\n"
"#define EIGEN_CHOLMODSUPPORT_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"extern \"C\" {\n"
"  #include <cholmod.h>\n"
"}\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup CholmodSupport_Module CholmodSupport module\n"
"  *\n"
"  * This module provides an interface to the Cholmod library which is part of the suitesparse package.\n"
"  * It provides the two following main factorization classes:\n"
"  * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.\n"
"  * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).\n"
"  *\n"
"  * For the sake of completeness, this module also propose the two following classes:\n"
"  * - class CholmodSimplicialLLT\n"
"  * - class CholmodSimplicialLDLT\n"
"  * Note that these classes does not bring any particular advantage compared to the built-in\n"
"  * SimplicialLLT and SimplicialLDLT factorization classes.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/CholmodSupport>\n"
"  * \\endcode\n"
"  *\n"
"  * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.\n"
"  * The dependencies depend on how cholmod has been compiled.\n"
"  * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.\n"
"  *\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"\n"
"#include \"src/CholmodSupport/CholmodSupport.h\"\n"
"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_CHOLMODSUPPORT_MODULE_H\n"
"\n";

const char* CholmodSupport = (const char*) temp_binary_data_39;

//================== CMakeLists.txt ==================
static const unsigned char temp_binary_data_40[] =
"include(RegexUtils)\n"
"test_escape_string_as_regex()\n"
"\n"
"file(GLOB Eigen_directory_files \"*\")\n"
"\n"
"escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR \"${CMAKE_CURRENT_SOURCE_DIR}\")\n"
"\n"
"foreach(f ${Eigen_directory_files})\n"
"  if(NOT f MATCHES \"\\\\.txt\" AND NOT f MATCHES \"${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+\" AND NOT f MATCHES \"${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src\")\n"
"    list(APPEND Eigen_directory_files_to_install ${f})\n"
"  endif()\n"
"endforeach(f ${Eigen_directory_files})\n"
"\n"
"install(FILES\n"
"  ${Eigen_directory_files_to_install}\n"
"  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel\n"
"  )\n"
"\n"
"add_subdirectory(src)\n";

const char* CMakeLists_txt38 = (const char*) temp_binary_data_40;

//================== Core ==================
static const unsigned char temp_binary_data_41[] =
"// This file is part of Eigen, a lightweight C++ template library\n"
"// for linear algebra.\n"
"//\n"
"// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>\n"
"// Copyright (C) 2007-2011 Benoit Jacob <jacob.benoit.1@gmail.com>\n"
"//\n"
"// This Source Code Form is subject to the terms of the Mozilla\n"
"// Public License v. 2.0. If a copy of the MPL was not distributed\n"
"// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
"\n"
"#ifndef EIGEN_CORE_H\n"
"#define EIGEN_CORE_H\n"
"\n"
"// first thing Eigen does: stop the compiler from committing suicide\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"// then include this file where all our macros are defined. It's really important to do it first because\n"
"// it's where we do all the alignment settings (platform detection and honoring the user's will if he\n"
"// defined e.g. EIGEN_DONT_ALIGN) so it needs to be done before we do anything with vectorization.\n"
"#include \"src/Core/util/Macros.h\"\n"
"\n"
"// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3)\n"
"// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.\n"
"#if defined(__MINGW32__) && EIGEN_GNUC_AT_LEAST(4,6)\n"
"  #pragma GCC optimize (\"-fno-ipa-cp-clone\")\n"
"#endif\n"
"\n"
"#include <complex>\n"
"\n"
"// this include file manages BLAS and MKL related macros\n"
"// and inclusion of their respective header files\n"
"#include \"src/Core/util/MKL_support.h\"\n"
"\n"
"// if alignment is disabled, then disable vectorization. Note: EIGEN_ALIGN is the proper check, it takes into\n"
"// account both the user's will (EIGEN_DONT_ALIGN) and our own platform checks\n"
"#if !EIGEN_ALIGN\n"
"  #ifndef EIGEN_DONT_VECTORIZE\n"
"    #define EIGEN_DONT_VECTORIZE\n"
"  #endif\n"
"#endif\n"
"\n"
"#ifdef _MSC_VER\n"
"  #include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled\n"
"  #if (_MSC_VER >= 1500) // 2008 or later\n"
"    // Remember that usage of defined() in a #define is undefined by the standard.\n"
"    // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.\n"
"    #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || defined(_M_X64)\n"
"      #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER\n"
"    #endif\n"
"  #endif\n"
"#else\n"
"  // Remember that usage of defined() in a #define is undefined by the standard\n"
"  #if (defined __SSE2__) && ( (!defined __GNUC__) || (defined __INTEL_COMPILER) || EIGEN_GNUC_AT_LEAST(4,2) )\n"
"    #define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC\n"
"  #endif\n"
"#endif\n"
"\n"
"#ifndef EIGEN_DONT_VECTORIZE\n"
"\n"
"  #if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)\n"
"\n"
"    // Defines symbols for compile-time detection of which instructions are\n"
"    // used.\n"
"    // EIGEN_VECTORIZE_YY is defined if and only if the instruction set YY is used\n"
"    #define EIGEN_VECTORIZE\n"
"    #define EIGEN_VECTORIZE_SSE\n"
"    #define EIGEN_VECTORIZE_SSE2\n"
"\n"
"    // Detect sse3/ssse3/sse4:\n"
"    // gcc and icc defines __SSE3__, ...\n"
"    // there is no way to know about this on msvc. You can define EIGEN_VECTORIZE_SSE* if you\n"
"    // want to force the use of those instructions with msvc.\n"
"    #ifdef __SSE3__\n"
"      #define EIGEN_VECTORIZE_SSE3\n"
"    #endif\n"
"    #ifdef __SSSE3__\n"
"      #define EIGEN_VECTORIZE_SSSE3\n"
"    #endif\n"
"    #ifdef __SSE4_1__\n"
"      #define EIGEN_VECTORIZE_SSE4_1\n"
"    #endif\n"
"    #ifdef __SSE4_2__\n"
"      #define EIGEN_VECTORIZE_SSE4_2\n"
"    #endif\n"
"\n"
"    // include files\n"
"\n"
"    // This extern \"C\" works around a MINGW-w64 compilation issue\n"
"    // https://sourceforge.net/tracker/index.php?func=detail&aid=3018394&group_id=202880&atid=983354\n"
"    // In essence, intrin.h is included by windows.h and also declares intrinsics (just as emmintrin.h etc. below do).\n"
"    // However, intrin.h uses an extern \"C\" declaration, and g++ thus complains of duplicate declarations\n"
"    // with conflicting linkage.  The linkage for intrinsics doesn't matter, but at that stage the compiler doesn't know;\n"
"    // so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern \"C\" here too.\n"
"    // notice that since these are C headers, the extern \"C\" is theoretically needed anyways.\n"
"    extern \"C\" {\n"
"      // In theory we should only include immintrin.h and not the other *mmintrin.h header files directly.\n"
"      // Doing so triggers some issues with ICC. However old gcc versions seems to not have this file, thus:\n"
"      #if defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1110\n"
"        #include <immintrin.h>\n"
"      #else\n"
"        #include <emmintrin.h>\n"
"        #include <xmmintrin.h>\n"
"        #ifdef  EIGEN_VECTORIZE_SSE3\n"
"        #include <pmmintrin.h>\n"
"        #endif\n"
"        #ifdef EIGEN_VECTORIZE_SSSE3\n"
"        #include <tmmintrin.h>\n"
"        #endif\n"
"        #ifdef EIGEN_VECTORIZE_SSE4_1\n"
"        #include <smmintrin.h>\n"
"        #endif\n"
"        #ifdef EIGEN_VECTORIZE_SSE4_2\n"
"        #include <nmmintrin.h>\n"
"        #endif\n"
"      #endif\n"
"    } // end extern \"C\"\n"
"  #elif defined __ALTIVEC__\n"
"    #define EIGEN_VECTORIZE\n"
"    #define EIGEN_VECTORIZE_ALTIVEC\n"
"    #include <altivec.h>\n"
"    // We need to #undef all these ugly tokens defined in <altivec.h>\n"
"    // => use __vector instead of vector\n"
"    #undef bool\n"
"    #undef vector\n"
"    #undef pixel\n"
"  #elif defined  __ARM_NEON\n"
"    #define EIGEN_VECTORIZE\n"
"    #define EIGEN_VECTORIZE_NEON\n"
"    #include <arm_neon.h>\n"
"  #endif\n"
"#endif\n"
"\n"
"#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE)\n"
"  #define EIGEN_HAS_OPENMP\n"
"#endif\n"
"\n"
"#ifdef EIGEN_HAS_OPENMP\n"
"#include <omp.h>\n"
"#endif\n"
"\n"
"// MSVC for windows mobile does not have the errno.h file\n"
"#if !(defined(_MSC_VER) && defined(_WIN32_WCE)) && !defined(__ARMCC_VERSION)\n"
"#define EIGEN_HAS_ERRNO\n"
"#endif\n"
"\n"
"#ifdef EIGEN_HAS_ERRNO\n"
"#include <cerrno>\n"
"#endif\n"
"#include <cstddef>\n"
"#include <cstdlib>\n"
"#include <cmath>\n"
"#include <cassert>\n"
"#include <functional>\n"
"#include <iosfwd>\n"
"#include <cstring>\n"
"#include <string>\n"
"#include <limits>\n"
"#include <climits> // for CHAR_BIT\n"
"// for min/max:\n"
"#include <algorithm>\n"
"\n"
"// for outputting debug info\n"
"#ifdef EIGEN_DEBUG_ASSIGN\n"
"#include <iostream>\n"
"#endif\n"
"\n"
"// required for __cpuid, needs to be included after cmath\n"
"#if defined(_MSC_VER) && (defined(_M_IX86)||defined(_M_X64)) && (!defined(_WIN32_WCE))\n"
"  #include <intrin.h>\n"
"#endif\n"
"\n"
"#if defined(_CPPUNWIND) || defined(__EXCEPTIONS)\n"
"  #define EIGEN_EXCEPTIONS\n"
"#endif\n"
"\n"
"#ifdef EIGEN_EXCEPTIONS\n"
"  #include <new>\n"
"#endif\n"
"\n"
"/** \\brief Namespace containing all symbols from the %Eigen library. */\n"
"namespace Eigen {\n"
"\n"
"inline static const char *SimdInstructionSetsInUse(void) {\n"
"#if defined(EIGEN_VECTORIZE_SSE4_2)\n"
"  return \"SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2\";\n"
"#elif defined(EIGEN_VECTORIZE_SSE4_1)\n"
"  return \"SSE, SSE2, SSE3, SSSE3, SSE4.1\";\n"
"#elif defined(EIGEN_VECTORIZE_SSSE3)\n"
"  return \"SSE, SSE2, SSE3, SSSE3\";\n"
"#elif defined(EIGEN_VECTORIZE_SSE3)\n"
"  return \"SSE, SSE2, SSE3\";\n"
"#elif defined(EIGEN_VECTORIZE_SSE2)\n"
"  return \"SSE, SSE2\";\n"
"#elif defined(EIGEN_VECTORIZE_ALTIVEC)\n"
"  return \"AltiVec\";\n"
"#elif defined(EIGEN_VECTORIZE_NEON)\n"
"  return \"ARM NEON\";\n"
"#else\n"
"  return \"None\";\n"
"#endif\n"
"}\n"
"\n"
"} // end namespace Eigen\n"
"\n"
"#define STAGE10_FULL_EIGEN2_API             10\n"
"#define STAGE20_RESOLVE_API_CONFLICTS       20\n"
"#define STAGE30_FULL_EIGEN3_API             30\n"
"#define STAGE40_FULL_EIGEN3_STRICTNESS      40\n"
"#define STAGE99_NO_EIGEN2_SUPPORT           99\n"
"\n"
"#if   defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS\n"
"  #define EIGEN2_SUPPORT\n"
"  #define EIGEN2_SUPPORT_STAGE STAGE40_FULL_EIGEN3_STRICTNESS\n"
"#elif defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API\n"
"  #define EIGEN2_SUPPORT\n"
"  #define EIGEN2_SUPPORT_STAGE STAGE30_FULL_EIGEN3_API\n"
"#elif defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS\n"
"  #define EIGEN2_SUPPORT\n"
"  #define EIGEN2_SUPPORT_STAGE STAGE20_RESOLVE_API_CONFLICTS\n"
"#elif defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API\n"
"  #define EIGEN2_SUPPORT\n"
"  #define EIGEN2_SUPPORT_STAGE STAGE10_FULL_EIGEN2_API\n"
"#elif defined EIGEN2_SUPPORT\n"
"  // default to stage 3, that's what it's always meant\n"
"  #define EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API\n"
"  #define EIGEN2_SUPPORT_STAGE STAGE30_FULL_EIGEN3_API\n"
"#else\n"
"  #define EIGEN2_SUPPORT_STAGE STAGE99_NO_EIGEN2_SUPPORT\n"
"#endif\n"
"\n"
"#ifdef EIGEN2_SUPPORT\n"
"#undef minor\n"
"#endif\n"
"\n"
"// we use size_t frequently and we'll never remember to prepend it with std:: everytime just to\n"
"// ensure QNX/QCC support\n"
"using std::size_t;\n"
"// gcc 4.6.0 wants std:: for ptrdiff_t \n"
"using std::ptrdiff_t;\n"
"\n"
"/** \\defgroup Core_Module Core module\n"
"  * This is the main module of Eigen providing dense matrix and vector support\n"
"  * (both fixed and dynamic size) with all the features corresponding to a BLAS library\n"
"  * and much more...\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/Core>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/Core/util/Constants.h\"\n"
"#include \"src/Core/util/ForwardDeclarations.h\"\n"
"#include \"src/Core/util/Meta.h\"\n"
"#include \"src/Core/util/StaticAssert.h\"\n"
"#include \"src/Core/util/XprHelper.h\"\n"
"#include \"src/Core/util/Memory.h\"\n"
"\n"
"#include \"src/Core/NumTraits.h\"\n"
"#include \"src/Core/MathFunctions.h\"\n"
"#include \"src/Core/GenericPacketMath.h\"\n"
"\n"
"#if defined EIGEN_VECTORIZE_SSE\n"
"  #include \"src/Core/arch/SSE/PacketMath.h\"\n"
"  #include \"src/Core/arch/SSE/MathFunctions.h\"\n"
"  #include \"src/Core/arch/SSE/Complex.h\"\n"
"#elif defined EIGEN_VECTORIZE_ALTIVEC\n"
"  #include \"src/Core/arch/AltiVec/PacketMath.h\"\n"
"  #include \"src/Core/arch/AltiVec/Complex.h\"\n"
"#elif defined EIGEN_VECTORIZE_NEON\n"
"  #include \"src/Core/arch/NEON/PacketMath.h\"\n"
"  #include \"src/Core/arch/NEON/Complex.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/arch/Default/Settings.h\"\n"
"\n"
"#include \"src/Core/Functors.h\"\n"
"#include \"src/Core/DenseCoeffsBase.h\"\n"
"#include \"src/Core/DenseBase.h\"\n"
"#include \"src/Core/MatrixBase.h\"\n"
"#include \"src/Core/EigenBase.h\"\n"
"\n"
"#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874\n"
"                                // at least confirmed with Doxygen 1.5.5 and 1.5.6\n"
"  #include \"src/Core/Assign.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/BlasUtil.h\"\n"
"#include \"src/Core/DenseStorage.h\"\n"
"#include \"src/Core/NestByValue.h\"\n"
"#include \"src/Core/ForceAlignedAccess.h\"\n"
"#include \"src/Core/ReturnByValue.h\"\n"
"#include \"src/Core/NoAlias.h\"\n"
"#include \"src/Core/PlainObjectBase.h\"\n"
"#include \"src/Core/Matrix.h\"\n"
"#include \"src/Core/Array.h\"\n"
"#include \"src/Core/CwiseBinaryOp.h\"\n"
"#include \"src/Core/CwiseUnaryOp.h\"\n"
"#include \"src/Core/CwiseNullaryOp.h\"\n"
"#include \"src/Core/CwiseUnaryView.h\"\n"
"#include \"src/Core/SelfCwiseBinaryOp.h\"\n"
"#include \"src/Core/Dot.h\"\n"
"#include \"src/Core/StableNorm.h\"\n"
"#include \"src/Core/MapBase.h\"\n"
"#include \"src/Core/Stride.h\"\n"
"#include \"src/Core/Map.h\"\n"
"#include \"src/Core/Block.h\"\n"
"#include \"src/Core/VectorBlock.h\"\n"
"#include \"src/Core/Ref.h\"\n"
"#include \"src/Core/Transpose.h\"\n"
"#include \"src/Core/DiagonalMatrix.h\"\n"
"#include \"src/Core/Diagonal.h\"\n"
"#include \"src/Core/DiagonalProduct.h\"\n"
"#include \"src/Core/PermutationMatrix.h\"\n"
"#include \"src/Core/Transpositions.h\"\n"
"#include \"src/Core/Redux.h\"\n"
"#include \"src/Core/Visitor.h\"\n"
"#include \"src/Core/Fuzzy.h\"\n"
"#include \"src/Core/IO.h\"\n"
"#include \"src/Core/Swap.h\"\n"
"#include \"src/Core/CommaInitializer.h\"\n"
"#include \"src/Core/Flagged.h\"\n"
"#include \"src/Core/ProductBase.h\"\n"
"#include \"src/Core/GeneralProduct.h\"\n"
"#include \"src/Core/TriangularMatrix.h\"\n"
"#include \"src/Core/SelfAdjointView.h\"\n"
"#include \"src/Core/products/GeneralBlockPanelKernel.h\"\n"
"#include \"src/Core/products/Parallelizer.h\"\n"
"#include \"src/Core/products/CoeffBasedProduct.h\"\n"
"#include \"src/Core/products/GeneralMatrixVector.h\"\n"
"#include \"src/Core/products/GeneralMatrixMatrix.h\"\n"
"#include \"src/Core/SolveTriangular.h\"\n"
"#include \"src/Core/products/GeneralMatrixMatrixTriangular.h\"\n"
"#include \"src/Core/products/SelfadjointMatrixVector.h\"\n"
"#include \"src/Core/products/SelfadjointMatrixMatrix.h\"\n"
"#include \"src/Core/products/SelfadjointProduct.h\"\n"
"#include \"src/Core/products/SelfadjointRank2Update.h\"\n"
"#include \"src/Core/products/TriangularMatrixVector.h\"\n"
"#include \"src/Core/products/TriangularMatrixMatrix.h\"\n"
"#include \"src/Core/products/TriangularSolverMatrix.h\"\n"
"#include \"src/Core/products/TriangularSolverVector.h\"\n"
"#include \"src/Core/BandMatrix.h\"\n"
"#include \"src/Core/CoreIterators.h\"\n"
"\n"
"#include \"src/Core/BooleanRedux.h\"\n"
"#include \"src/Core/Select.h\"\n"
"#include \"src/Core/VectorwiseOp.h\"\n"
"#include \"src/Core/Random.h\"\n"
"#include \"src/Core/Replicate.h\"\n"
"#include \"src/Core/Reverse.h\"\n"
"#include \"src/Core/ArrayBase.h\"\n"
"#include \"src/Core/ArrayWrapper.h\"\n"
"\n"
"#ifdef EIGEN_USE_BLAS\n"
"#include \"src/Core/products/GeneralMatrixMatrix_MKL.h\"\n"
"#include \"src/Core/products/GeneralMatrixVector_MKL.h\"\n"
"#include \"src/Core/products/GeneralMatrixMatrixTriangular_MKL.h\"\n"
"#include \"src/Core/products/SelfadjointMatrixMatrix_MKL.h\"\n"
"#include \"src/Core/products/SelfadjointMatrixVector_MKL.h\"\n"
"#include \"src/Core/products/TriangularMatrixMatrix_MKL.h\"\n"
"#include \"src/Core/products/TriangularMatrixVector_MKL.h\"\n"
"#include \"src/Core/products/TriangularSolverMatrix_MKL.h\"\n"
"#endif // EIGEN_USE_BLAS\n"
"\n"
"#ifdef EIGEN_USE_MKL_VML\n"
"#include \"src/Core/Assign_MKL.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/GlobalFunctions.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#ifdef EIGEN2_SUPPORT\n"
"#include \"Eigen2Support\"\n"
"#endif\n"
"\n"
"#endif // EIGEN_CORE_H\n";

const char* Core = (const char*) temp_binary_data_41;

//================== Dense ==================
static const unsigned char temp_binary_data_42[] =
"#include \"Core\"\n"
"#include \"LU\"\n"
"#include \"Cholesky\"\n"
"#include \"QR\"\n"
"#include \"SVD\"\n"
"#include \"Geometry\"\n"
"#include \"Eigenvalues\"\n";

const char* Dense = (const char*) temp_binary_data_42;

//================== Eigen ==================
static const unsigned char temp_binary_data_43[] =
"#include \"Dense\"\n"
"//#include \"Sparse\"\n";

const char* Eigen = (const char*) temp_binary_data_43;

//================== Eigen2Support ==================
static const unsigned char temp_binary_data_44[] =
"// This file is part of Eigen, a lightweight C++ template library\n"
"// for linear algebra.\n"
"//\n"
"// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>\n"
"//\n"
"// This Source Code Form is subject to the terms of the Mozilla\n"
"// Public License v. 2.0. If a copy of the MPL was not distributed\n"
"// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
"\n"
"#ifndef EIGEN2SUPPORT_H\n"
"#define EIGEN2SUPPORT_H\n"
"\n"
"#if (!defined(EIGEN2_SUPPORT)) || (!defined(EIGEN_CORE_H))\n"
"#error Eigen2 support must be enabled by defining EIGEN2_SUPPORT before including any Eigen header\n"
"#endif\n"
"\n"
"#ifndef EIGEN_NO_EIGEN2_DEPRECATED_WARNING\n"
"\n"
"#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)\n"
"#warning \"Eigen2 support is deprecated in Eigen 3.2.x and it will be removed in Eigen 3.3. (Define EIGEN_NO_EIGEN2_DEPRECATED_WARNING to disable this warning)\"\n"
"#else\n"
"#pragma message (\"Eigen2 support is deprecated in Eigen 3.2.x and it will be removed in Eigen 3.3. (Define EIGEN_NO_EIGEN2_DEPRECATED_WARNING to disable this warning)\")\n"
"#endif\n"
"\n"
"#endif // EIGEN_NO_EIGEN2_DEPRECATED_WARNING\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup Eigen2Support_Module Eigen2 support module\n"
"  *\n"
"  * \\warning Eigen2 support is deprecated in Eigen 3.2.x and it will be removed in Eigen 3.3.\n"
"  *\n"
"  * This module provides a couple of deprecated functions improving the compatibility with Eigen2.\n"
"  * \n"
"  * To use it, define EIGEN2_SUPPORT before including any Eigen header\n"
"  * \\code\n"
"  * #define EIGEN2_SUPPORT\n"
"  * \\endcode\n"
"  *\n"
"  */\n"
"\n"
"#include \"src/Eigen2Support/Macros.h\"\n"
"#include \"src/Eigen2Support/Memory.h\"\n"
"#include \"src/Eigen2Support/Meta.h\"\n"
"#include \"src/Eigen2Support/Lazy.h\"\n"
"#include \"src/Eigen2Support/Cwise.h\"\n"
"#include \"src/Eigen2Support/CwiseOperators.h\"\n"
"#include \"src/Eigen2Support/TriangularSolver.h\"\n"
"#include \"src/Eigen2Support/Block.h\"\n"
"#include \"src/Eigen2Support/VectorBlock.h\"\n"
"#include \"src/Eigen2Support/Minor.h\"\n"
"#include \"src/Eigen2Support/MathFunctions.h\"\n"
"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"// Eigen2 used to include iostream\n"
"#include<iostream>\n"
"\n"
"#define EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \\\n"
"using Eigen::Matrix##SizeSuffix##TypeSuffix; \\\n"
"using Eigen::Vector##SizeSuffix##TypeSuffix; \\\n"
"using Eigen::RowVector##SizeSuffix##TypeSuffix;\n"
"\n"
"#define EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE(TypeSuffix) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \\\n"
"\n"
"#define EIGEN_USING_MATRIX_TYPEDEFS \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE(i) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE(f) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE(d) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE(cf) \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS_FOR_TYPE(cd)\n"
"\n"
"#define USING_PART_OF_NAMESPACE_EIGEN \\\n"
"EIGEN_USING_MATRIX_TYPEDEFS \\\n"
"using Eigen::Matrix; \\\n"
"using Eigen::MatrixBase; \\\n"
"using Eigen::ei_random; \\\n"
"using Eigen::ei_real; \\\n"
"using Eigen::ei_imag; \\\n"
"using Eigen::ei_conj; \\\n"
"using Eigen::ei_abs; \\\n"
"using Eigen::ei_abs2; \\\n"
"using Eigen::ei_sqrt; \\\n"
"using Eigen::ei_exp; \\\n"
"using Eigen::ei_log; \\\n"
"using Eigen::ei_sin; \\\n"
"using Eigen::ei_cos;\n"
"\n"
"#endif // EIGEN2SUPPORT_H\n";

const char* Eigen2Support = (const char*) temp_binary_data_44;

//================== Eigenvalues ==================
static const unsigned char temp_binary_data_45[] =
"#ifndef EIGEN_EIGENVALUES_MODULE_H\n"
"#define EIGEN_EIGENVALUES_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include \"Cholesky\"\n"
"#include \"Jacobi\"\n"
"#include \"Householder\"\n"
"#include \"LU\"\n"
"#include \"Geometry\"\n"
"\n"
"/** \\defgroup Eigenvalues_Module Eigenvalues module\n"
"  *\n"
"  *\n"
"  *\n"
"  * This module mainly provides various eigenvalue solvers.\n"
"  * This module also provides some MatrixBase methods, including:\n"
"  *  - MatrixBase::eigenvalues(),\n"
"  *  - MatrixBase::operatorNorm()\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/Eigenvalues>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/Eigenvalues/Tridiagonalization.h\"\n"
"#include \"src/Eigenvalues/RealSchur.h\"\n"
"#include \"src/Eigenvalues/EigenSolver.h\"\n"
"#include \"src/Eigenvalues/SelfAdjointEigenSolver.h\"\n"
"#include \"src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h\"\n"
"#include \"src/Eigenvalues/HessenbergDecomposition.h\"\n"
"#include \"src/Eigenvalues/ComplexSchur.h\"\n"
"#include \"src/Eigenvalues/ComplexEigenSolver.h\"\n"
"#include \"src/Eigenvalues/RealQZ.h\"\n"
"#include \"src/Eigenvalues/GeneralizedEigenSolver.h\"\n"
"#include \"src/Eigenvalues/MatrixBaseEigenvalues.h\"\n"
"#ifdef EIGEN_USE_LAPACKE\n"
"#include \"src/Eigenvalues/RealSchur_MKL.h\"\n"
"#include \"src/Eigenvalues/ComplexSchur_MKL.h\"\n"
"#include \"src/Eigenvalues/SelfAdjointEigenSolver_MKL.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_EIGENVALUES_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n";

const char* Eigenvalues = (const char*) temp_binary_data_45;

//================== Geometry ==================
static const unsigned char temp_binary_data_46[] =
"#ifndef EIGEN_GEOMETRY_MODULE_H\n"
"#define EIGEN_GEOMETRY_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include \"SVD\"\n"
"#include \"LU\"\n"
"#include <limits>\n"
"\n"
"#ifndef M_PI\n"
"#define M_PI 3.14159265358979323846\n"
"#endif\n"
"\n"
"/** \\defgroup Geometry_Module Geometry module\n"
"  *\n"
"  *\n"
"  *\n"
"  * This module provides support for:\n"
"  *  - fixed-size homogeneous transformations\n"
"  *  - translation, scaling, 2D and 3D rotations\n"
"  *  - quaternions\n"
"  *  - \\ref MatrixBase::cross() \"cross product\"\n"
"  *  - \\ref MatrixBase::unitOrthogonal() \"orthognal vector generation\"\n"
"  *  - some linear components: parametrized-lines and hyperplanes\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/Geometry>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/Geometry/OrthoMethods.h\"\n"
"#include \"src/Geometry/EulerAngles.h\"\n"
"\n"
"#if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS\n"
"  #include \"src/Geometry/Homogeneous.h\"\n"
"  #include \"src/Geometry/RotationBase.h\"\n"
"  #include \"src/Geometry/Rotation2D.h\"\n"
"  #include \"src/Geometry/Quaternion.h\"\n"
"  #include \"src/Geometry/AngleAxis.h\"\n"
"  #include \"src/Geometry/Transform.h\"\n"
"  #include \"src/Geometry/Translation.h\"\n"
"  #include \"src/Geometry/Scaling.h\"\n"
"  #include \"src/Geometry/Hyperplane.h\"\n"
"  #include \"src/Geometry/ParametrizedLine.h\"\n"
"  #include \"src/Geometry/AlignedBox.h\"\n"
"  #include \"src/Geometry/Umeyama.h\"\n"
"\n"
"  #if defined EIGEN_VECTORIZE_SSE\n"
"    #include \"src/Geometry/arch/Geometry_SSE.h\"\n"
"  #endif\n"
"#endif\n"
"\n"
"#ifdef EIGEN2_SUPPORT\n"
"#include \"src/Eigen2Support/Geometry/All.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_GEOMETRY_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n"
"\n";

const char* Geometry = (const char*) temp_binary_data_46;

//================== Householder ==================
static const unsigned char temp_binary_data_47[] =
"#ifndef EIGEN_HOUSEHOLDER_MODULE_H\n"
"#define EIGEN_HOUSEHOLDER_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \\defgroup Householder_Module Householder module\n"
"  * This module provides Householder transformations.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/Householder>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/Householder/Householder.h\"\n"
"#include \"src/Householder/HouseholderSequence.h\"\n"
"#include \"src/Householder/BlockHouseholder.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_HOUSEHOLDER_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n";

const char* Householder = (const char*) temp_binary_data_47;

//================== IterativeLinearSolvers ==================
static const unsigned char temp_binary_data_48[] =
"#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H\n"
"#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"#include \"OrderingMethods\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \n"
"  * \\defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module\n"
"  *\n"
"  * This module currently provides iterative methods to solve problems of the form \\c A \\c x = \\c b, where \\c A is a squared matrix, usually very large and sparse.\n"
"  * Those solvers are accessible via the following classes:\n"
"  *  - ConjugateGradient for selfadjoint (hermitian) matrices,\n"
"  *  - BiCGSTAB for general square matrices.\n"
"  *\n"
"  * These iterative solvers are associated with some preconditioners:\n"
"  *  - IdentityPreconditioner - not really useful\n"
"  *  - DiagonalPreconditioner - also called JAcobi preconditioner, work very well on diagonal dominant matrices.\n"
"  *  - IncompleteILUT - incomplete LU factorization with dual thresholding\n"
"  *\n"
"  * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/IterativeLinearSolvers>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"\n"
"#include \"src/IterativeLinearSolvers/IterativeSolverBase.h\"\n"
"#include \"src/IterativeLinearSolvers/BasicPreconditioners.h\"\n"
"#include \"src/IterativeLinearSolvers/ConjugateGradient.h\"\n"
"#include \"src/IterativeLinearSolvers/BiCGSTAB.h\"\n"
"#include \"src/IterativeLinearSolvers/IncompleteLUT.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H\n";

const char* IterativeLinearSolvers = (const char*) temp_binary_data_48;

//================== Jacobi ==================
static const unsigned char temp_binary_data_49[] =
"#ifndef EIGEN_JACOBI_MODULE_H\n"
"#define EIGEN_JACOBI_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \\defgroup Jacobi_Module Jacobi module\n"
"  * This module provides Jacobi and Givens rotations.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/Jacobi>\n"
"  * \\endcode\n"
"  *\n"
"  * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation:\n"
"  *  - MatrixBase::applyOnTheLeft()\n"
"  *  - MatrixBase::applyOnTheRight().\n"
"  */\n"
"\n"
"#include \"src/Jacobi/Jacobi.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_JACOBI_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n"
"\n";

const char* Jacobi = (const char*) temp_binary_data_49;

//================== LeastSquares ==================
static const unsigned char temp_binary_data_50[] =
"#ifndef EIGEN_REGRESSION_MODULE_H\n"
"#define EIGEN_REGRESSION_MODULE_H\n"
"\n"
"#ifndef EIGEN2_SUPPORT\n"
"#error LeastSquares is only available in Eigen2 support mode (define EIGEN2_SUPPORT)\n"
"#endif\n"
"\n"
"// exclude from normal eigen3-only documentation\n"
"#ifdef EIGEN2_SUPPORT\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include \"Eigenvalues\"\n"
"#include \"Geometry\"\n"
"\n"
"/** \\defgroup LeastSquares_Module LeastSquares module\n"
"  * This module provides linear regression and related features.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/LeastSquares>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/Eigen2Support/LeastSquares.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN2_SUPPORT\n"
"\n"
"#endif // EIGEN_REGRESSION_MODULE_H\n";

const char* LeastSquares = (const char*) temp_binary_data_50;

//================== LU ==================
static const unsigned char temp_binary_data_51[] =
"#ifndef EIGEN_LU_MODULE_H\n"
"#define EIGEN_LU_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \\defgroup LU_Module LU module\n"
"  * This module includes %LU decomposition and related notions such as matrix inversion and determinant.\n"
"  * This module defines the following MatrixBase methods:\n"
"  *  - MatrixBase::inverse()\n"
"  *  - MatrixBase::determinant()\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/LU>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/Kernel.h\"\n"
"#include \"src/misc/Image.h\"\n"
"#include \"src/LU/FullPivLU.h\"\n"
"#include \"src/LU/PartialPivLU.h\"\n"
"#ifdef EIGEN_USE_LAPACKE\n"
"#include \"src/LU/PartialPivLU_MKL.h\"\n"
"#endif\n"
"#include \"src/LU/Determinant.h\"\n"
"#include \"src/LU/Inverse.h\"\n"
"\n"
"#if defined EIGEN_VECTORIZE_SSE\n"
"  #include \"src/LU/arch/Inverse_SSE.h\"\n"
"#endif\n"
"\n"
"#ifdef EIGEN2_SUPPORT\n"
"  #include \"src/Eigen2Support/LU.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_LU_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n";

const char* LU = (const char*) temp_binary_data_51;

//================== MetisSupport ==================
static const unsigned char temp_binary_data_52[] =
"#ifndef EIGEN_METISSUPPORT_MODULE_H\n"
"#define EIGEN_METISSUPPORT_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"extern \"C\" {\n"
"#include <metis.h>\n"
"}\n"
"\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup MetisSupport_Module MetisSupport module\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/MetisSupport>\n"
"  * \\endcode\n"
"  * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). \n"
"  * It can be used just as any other built-in method as explained in \\link OrderingMethods_Module here. \\endlink\n"
"  */\n"
"\n"
"\n"
"#include \"src/MetisSupport/MetisSupport.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_METISSUPPORT_MODULE_H\n";

const char* MetisSupport = (const char*) temp_binary_data_52;

//================== OrderingMethods ==================
static const unsigned char temp_binary_data_53[] =
"#ifndef EIGEN_ORDERINGMETHODS_MODULE_H\n"
"#define EIGEN_ORDERINGMETHODS_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \n"
"  * \\defgroup OrderingMethods_Module OrderingMethods module\n"
"  *\n"
"  * This module is currently for internal use only\n"
"  * \n"
"  * It defines various built-in and external ordering methods for sparse matrices. \n"
"  * They are typically used to reduce the number of elements during \n"
"  * the sparse matrix decomposition (LLT, LU, QR).\n"
"  * Precisely, in a preprocessing step, a permutation matrix P is computed using \n"
"  * those ordering methods and applied to the columns of the matrix. \n"
"  * Using for instance the sparse Cholesky decomposition, it is expected that \n"
"  * the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A).\n"
"  * \n"
"  * \n"
"  * Usage : \n"
"  * \\code\n"
"  * #include <Eigen/OrderingMethods>\n"
"  * \\endcode\n"
"  * \n"
"  * A simple usage is as a template parameter in the sparse decomposition classes : \n"
"  * \n"
"  * \\code \n"
"  * SparseLU<MatrixType, COLAMDOrdering<int> > solver;\n"
"  * \\endcode \n"
"  * \n"
"  * \\code \n"
"  * SparseQR<MatrixType, COLAMDOrdering<int> > solver;\n"
"  * \\endcode\n"
"  * \n"
"  * It is possible as well to call directly a particular ordering method for your own purpose, \n"
"  * \\code \n"
"  * AMDOrdering<int> ordering;\n"
"  * PermutationMatrix<Dynamic, Dynamic, int> perm;\n"
"  * SparseMatrix<double> A; \n"
"  * //Fill the matrix ...\n"
"  * \n"
"  * ordering(A, perm); // Call AMD\n"
"  * \\endcode\n"
"  * \n"
"  * \\note Some of these methods (like AMD or METIS), need the sparsity pattern \n"
"  * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, \n"
"  * Eigen computes internally the pattern of \\f$A^T*A\\f$ before calling the method.\n"
"  * If your matrix is already symmetric (at leat in structure), you can avoid that\n"
"  * by calling the method with a SelfAdjointView type.\n"
"  * \n"
"  * \\code\n"
"  *  // Call the ordering on the pattern of the lower triangular matrix A\n"
"  * ordering(A.selfadjointView<Lower>(), perm);\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#ifndef EIGEN_MPL2_ONLY\n"
"#include \"src/OrderingMethods/Amd.h\"\n"
"#endif\n"
"\n"
"#include \"src/OrderingMethods/Ordering.h\"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_ORDERINGMETHODS_MODULE_H\n";

const char* OrderingMethods = (const char*) temp_binary_data_53;

//================== PardisoSupport ==================
static const unsigned char temp_binary_data_54[] =
"#ifndef EIGEN_PARDISOSUPPORT_MODULE_H\n"
"#define EIGEN_PARDISOSUPPORT_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include <mkl_pardiso.h>\n"
"\n"
"#include <unsupported/Eigen/SparseExtra>\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup PardisoSupport_Module PardisoSupport module\n"
"  *\n"
"  * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/PardisoSupport>\n"
"  * \\endcode\n"
"  *\n"
"  * In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies.\n"
"  * See this \\ref TopicUsingIntelMKL \"page\" for more information on MKL-Eigen integration.\n"
"  * \n"
"  */\n"
"\n"
"#include \"src/PardisoSupport/PardisoSupport.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_PARDISOSUPPORT_MODULE_H\n";

const char* PardisoSupport = (const char*) temp_binary_data_54;

//================== PaStiXSupport ==================
static const unsigned char temp_binary_data_55[] =
"#ifndef EIGEN_PASTIXSUPPORT_MODULE_H\n"
"#define EIGEN_PASTIXSUPPORT_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include <complex.h>\n"
"extern \"C\" {\n"
"#include <pastix_nompi.h>\n"
"#include <pastix.h>\n"
"}\n"
"\n"
"#ifdef complex\n"
"#undef complex\n"
"#endif\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup PaStiXSupport_Module PaStiXSupport module\n"
"  * \n"
"  * This module provides an interface to the PaSTiX library.\n"
"  * PaSTiX is a general \\b supernodal, \\b parallel and \\b opensource sparse solver.\n"
"  * It provides the two following main factorization classes:\n"
"  * - class PastixLLT : a supernodal, parallel LLt Cholesky factorization.\n"
"  * - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization.\n"
"  * - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern).\n"
"  * \n"
"  * \\code\n"
"  * #include <Eigen/PaStiXSupport>\n"
"  * \\endcode\n"
"  *\n"
"  * In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies.\n"
"  * The dependencies depend on how PaSTiX has been compiled.\n"
"  * For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task.\n"
"  *\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"\n"
"#include \"src/PaStiXSupport/PaStiXSupport.h\"\n"
"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_PASTIXSUPPORT_MODULE_H\n";

const char* PaStiXSupport = (const char*) temp_binary_data_55;

//================== QR ==================
static const unsigned char temp_binary_data_56[] =
"#ifndef EIGEN_QR_MODULE_H\n"
"#define EIGEN_QR_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include \"Cholesky\"\n"
"#include \"Jacobi\"\n"
"#include \"Householder\"\n"
"\n"
"/** \\defgroup QR_Module QR module\n"
"  *\n"
"  *\n"
"  *\n"
"  * This module provides various QR decompositions\n"
"  * This module also provides some MatrixBase methods, including:\n"
"  *  - MatrixBase::qr(),\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/QR>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/QR/HouseholderQR.h\"\n"
"#include \"src/QR/FullPivHouseholderQR.h\"\n"
"#include \"src/QR/ColPivHouseholderQR.h\"\n"
"#ifdef EIGEN_USE_LAPACKE\n"
"#include \"src/QR/HouseholderQR_MKL.h\"\n"
"#include \"src/QR/ColPivHouseholderQR_MKL.h\"\n"
"#endif\n"
"\n"
"#ifdef EIGEN2_SUPPORT\n"
"#include \"src/Eigen2Support/QR.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#ifdef EIGEN2_SUPPORT\n"
"#include \"Eigenvalues\"\n"
"#endif\n"
"\n"
"#endif // EIGEN_QR_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n";

const char* QR = (const char*) temp_binary_data_56;

//================== QtAlignedMalloc ==================
static const unsigned char temp_binary_data_57[] =
"\n"
"#ifndef EIGEN_QTMALLOC_MODULE_H\n"
"#define EIGEN_QTMALLOC_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#if (!EIGEN_MALLOC_ALREADY_ALIGNED)\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"void *qMalloc(size_t size)\n"
"{\n"
"  return Eigen::internal::aligned_malloc(size);\n"
"}\n"
"\n"
"void qFree(void *ptr)\n"
"{\n"
"  Eigen::internal::aligned_free(ptr);\n"
"}\n"
"\n"
"void *qRealloc(void *ptr, size_t size)\n"
"{\n"
"  void* newPtr = Eigen::internal::aligned_malloc(size);\n"
"  memcpy(newPtr, ptr, size);\n"
"  Eigen::internal::aligned_free(ptr);\n"
"  return newPtr;\n"
"}\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif\n"
"\n"
"#endif // EIGEN_QTMALLOC_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n";

const char* QtAlignedMalloc = (const char*) temp_binary_data_57;

//================== Sparse ==================
static const unsigned char temp_binary_data_58[] =
"#ifndef EIGEN_SPARSE_MODULE_H\n"
"#define EIGEN_SPARSE_MODULE_H\n"
"\n"
"/** \\defgroup Sparse_Module Sparse meta-module\n"
"  *\n"
"  * Meta-module including all related modules:\n"
"  * - \\ref SparseCore_Module\n"
"  * - \\ref OrderingMethods_Module\n"
"  * - \\ref SparseCholesky_Module\n"
"  * - \\ref SparseLU_Module\n"
"  * - \\ref SparseQR_Module\n"
"  * - \\ref IterativeLinearSolvers_Module\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/Sparse>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"SparseCore\"\n"
"#include \"OrderingMethods\"\n"
"#include \"SparseCholesky\"\n"
"#include \"SparseLU\"\n"
"#include \"SparseQR\"\n"
"#include \"IterativeLinearSolvers\"\n"
"\n"
"#endif // EIGEN_SPARSE_MODULE_H\n"
"\n";

const char* Sparse = (const char*) temp_binary_data_58;

//================== SparseCholesky ==================
static const unsigned char temp_binary_data_59[] =
"// This file is part of Eigen, a lightweight C++ template library\n"
"// for linear algebra.\n"
"//\n"
"// Copyright (C) 2008-2013 Gael Guennebaud <gael.guennebaud@inria.fr>\n"
"//\n"
"// This Source Code Form is subject to the terms of the Mozilla\n"
"// Public License v. 2.0. If a copy of the MPL was not distributed\n"
"// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
"\n"
"#ifndef EIGEN_SPARSECHOLESKY_MODULE_H\n"
"#define EIGEN_SPARSECHOLESKY_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"#include \"OrderingMethods\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \n"
"  * \\defgroup SparseCholesky_Module SparseCholesky module\n"
"  *\n"
"  * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices.\n"
"  * Those decompositions are accessible via the following classes:\n"
"  *  - SimplicialLLt,\n"
"  *  - SimplicialLDLt\n"
"  *\n"
"  * Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/SparseCholesky>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#ifdef EIGEN_MPL2_ONLY\n"
"#error The SparseCholesky module has nothing to offer in MPL2 only mode\n"
"#endif\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"#include \"src/SparseCholesky/SimplicialCholesky.h\"\n"
"\n"
"#ifndef EIGEN_MPL2_ONLY\n"
"#include \"src/SparseCholesky/SimplicialCholesky_impl.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_SPARSECHOLESKY_MODULE_H\n";

const char* SparseCholesky = (const char*) temp_binary_data_59;

//================== SparseCore ==================
static const unsigned char temp_binary_data_60[] =
"#ifndef EIGEN_SPARSECORE_MODULE_H\n"
"#define EIGEN_SPARSECORE_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include <vector>\n"
"#include <map>\n"
"#include <cstdlib>\n"
"#include <cstring>\n"
"#include <algorithm>\n"
"\n"
"/** \n"
"  * \\defgroup SparseCore_Module SparseCore module\n"
"  *\n"
"  * This module provides a sparse matrix representation, and basic associated matrix manipulations\n"
"  * and operations.\n"
"  *\n"
"  * See the \\ref TutorialSparse \"Sparse tutorial\"\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/SparseCore>\n"
"  * \\endcode\n"
"  *\n"
"  * This module depends on: Core.\n"
"  */\n"
"\n"
"namespace Eigen {\n"
"\n"
"/** The type used to identify a general sparse storage. */\n"
"struct Sparse {};\n"
"\n"
"}\n"
"\n"
"#include \"src/SparseCore/SparseUtil.h\"\n"
"#include \"src/SparseCore/SparseMatrixBase.h\"\n"
"#include \"src/SparseCore/CompressedStorage.h\"\n"
"#include \"src/SparseCore/AmbiVector.h\"\n"
"#include \"src/SparseCore/SparseMatrix.h\"\n"
"#include \"src/SparseCore/MappedSparseMatrix.h\"\n"
"#include \"src/SparseCore/SparseVector.h\"\n"
"#include \"src/SparseCore/SparseBlock.h\"\n"
"#include \"src/SparseCore/SparseTranspose.h\"\n"
"#include \"src/SparseCore/SparseCwiseUnaryOp.h\"\n"
"#include \"src/SparseCore/SparseCwiseBinaryOp.h\"\n"
"#include \"src/SparseCore/SparseDot.h\"\n"
"#include \"src/SparseCore/SparsePermutation.h\"\n"
"#include \"src/SparseCore/SparseRedux.h\"\n"
"#include \"src/SparseCore/SparseFuzzy.h\"\n"
"#include \"src/SparseCore/ConservativeSparseSparseProduct.h\"\n"
"#include \"src/SparseCore/SparseSparseProductWithPruning.h\"\n"
"#include \"src/SparseCore/SparseProduct.h\"\n"
"#include \"src/SparseCore/SparseDenseProduct.h\"\n"
"#include \"src/SparseCore/SparseDiagonalProduct.h\"\n"
"#include \"src/SparseCore/SparseTriangularView.h\"\n"
"#include \"src/SparseCore/SparseSelfAdjointView.h\"\n"
"#include \"src/SparseCore/TriangularSolver.h\"\n"
"#include \"src/SparseCore/SparseView.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_SPARSECORE_MODULE_H\n"
"\n";

const char* SparseCore = (const char*) temp_binary_data_60;

//================== SparseLU ==================
static const unsigned char temp_binary_data_61[] =
"// This file is part of Eigen, a lightweight C++ template library\n"
"// for linear algebra.\n"
"//\n"
"// Copyright (C) 2012 D\xc3\xa9sir\xc3\xa9 Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>\n"
"// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>\n"
"//\n"
"// This Source Code Form is subject to the terms of the Mozilla\n"
"// Public License v. 2.0. If a copy of the MPL was not distributed\n"
"// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
"\n"
"#ifndef EIGEN_SPARSELU_MODULE_H\n"
"#define EIGEN_SPARSELU_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"/** \n"
"  * \\defgroup SparseLU_Module SparseLU module\n"
"  * This module defines a supernodal factorization of general sparse matrices.\n"
"  * The code is fully optimized for supernode-panel updates with specialized kernels.\n"
"  * Please, see the documentation of the SparseLU class for more details.\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"\n"
"// Ordering interface\n"
"#include \"OrderingMethods\"\n"
"\n"
"#include \"src/SparseLU/SparseLU_gemm_kernel.h\"\n"
"\n"
"#include \"src/SparseLU/SparseLU_Structs.h\"\n"
"#include \"src/SparseLU/SparseLU_SupernodalMatrix.h\"\n"
"#include \"src/SparseLU/SparseLUImpl.h\"\n"
"#include \"src/SparseCore/SparseColEtree.h\"\n"
"#include \"src/SparseLU/SparseLU_Memory.h\"\n"
"#include \"src/SparseLU/SparseLU_heap_relax_snode.h\"\n"
"#include \"src/SparseLU/SparseLU_relax_snode.h\"\n"
"#include \"src/SparseLU/SparseLU_pivotL.h\"\n"
"#include \"src/SparseLU/SparseLU_panel_dfs.h\"\n"
"#include \"src/SparseLU/SparseLU_kernel_bmod.h\"\n"
"#include \"src/SparseLU/SparseLU_panel_bmod.h\"\n"
"#include \"src/SparseLU/SparseLU_column_dfs.h\"\n"
"#include \"src/SparseLU/SparseLU_column_bmod.h\"\n"
"#include \"src/SparseLU/SparseLU_copy_to_ucol.h\"\n"
"#include \"src/SparseLU/SparseLU_pruneL.h\"\n"
"#include \"src/SparseLU/SparseLU_Utils.h\"\n"
"#include \"src/SparseLU/SparseLU.h\"\n"
"\n"
"#endif // EIGEN_SPARSELU_MODULE_H\n";

const char* SparseLU = (const char*) temp_binary_data_61;

//================== SparseQR ==================
static const unsigned char temp_binary_data_62[] =
"#ifndef EIGEN_SPARSEQR_MODULE_H\n"
"#define EIGEN_SPARSEQR_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"#include \"OrderingMethods\"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \\defgroup SparseQR_Module SparseQR module\n"
"  * \\brief Provides QR decomposition for sparse matrices\n"
"  * \n"
"  * This module provides a simplicial version of the left-looking Sparse QR decomposition. \n"
"  * The columns of the input matrix should be reordered to limit the fill-in during the \n"
"  * decomposition. Built-in methods (COLAMD, AMD) or external  methods (METIS) can be used to this end.\n"
"  * See the \\link OrderingMethods_Module OrderingMethods\\endlink module for the list \n"
"  * of built-in and external ordering methods.\n"
"  * \n"
"  * \\code\n"
"  * #include <Eigen/SparseQR>\n"
"  * \\endcode\n"
"  * \n"
"  * \n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"\n"
"#include \"OrderingMethods\"\n"
"#include \"src/SparseCore/SparseColEtree.h\"\n"
"#include \"src/SparseQR/SparseQR.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif\n";

const char* SparseQR = (const char*) temp_binary_data_62;

//================== SPQRSupport ==================
static const unsigned char temp_binary_data_63[] =
"#ifndef EIGEN_SPQRSUPPORT_MODULE_H\n"
"#define EIGEN_SPQRSUPPORT_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#include \"SuiteSparseQR.hpp\"\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup SPQRSupport_Module SuiteSparseQR module\n"
"  * \n"
"  * This module provides an interface to the SPQR library, which is part of the suitesparse package.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/SPQRSupport>\n"
"  * \\endcode\n"
"  *\n"
"  * In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...).\n"
"  * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules\n"
"  *\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"#include \"src/CholmodSupport/CholmodSupport.h\"\n"
"#include \"src/SPQRSupport/SuiteSparseQRSupport.h\"\n"
"\n"
"#endif\n";

const char* SPQRSupport = (const char*) temp_binary_data_63;

//================== StdDeque ==================
static const unsigned char temp_binary_data_64[] =
"// This file is part of Eigen, a lightweight C++ template library\n"
"// for linear algebra.\n"
"//\n"
"// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>\n"
"// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>\n"
"//\n"
"// This Source Code Form is subject to the terms of the Mozilla\n"
"// Public License v. 2.0. If a copy of the MPL was not distributed\n"
"// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
"\n"
"#ifndef EIGEN_STDDEQUE_MODULE_H\n"
"#define EIGEN_STDDEQUE_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"#include <deque>\n"
"\n"
"#if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */\n"
"\n"
"#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...)\n"
"\n"
"#else\n"
"\n"
"#include \"src/StlSupport/StdDeque.h\"\n"
"\n"
"#endif\n"
"\n"
"#endif // EIGEN_STDDEQUE_MODULE_H\n";

const char* StdDeque = (const char*) temp_binary_data_64;

//================== StdList ==================
static const unsigned char temp_binary_data_65[] =
"// This file is part of Eigen, a lightweight C++ template library\n"
"// for linear algebra.\n"
"//\n"
"// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>\n"
"//\n"
"// This Source Code Form is subject to the terms of the Mozilla\n"
"// Public License v. 2.0. If a copy of the MPL was not distributed\n"
"// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
"\n"
"#ifndef EIGEN_STDLIST_MODULE_H\n"
"#define EIGEN_STDLIST_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"#include <list>\n"
"\n"
"#if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */    \n"
"\n"
"#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...)\n"
"\n"
"#else\n"
"\n"
"#include \"src/StlSupport/StdList.h\"\n"
"\n"
"#endif\n"
"\n"
"#endif // EIGEN_STDLIST_MODULE_H\n";

const char* StdList = (const char*) temp_binary_data_65;

//================== StdVector ==================
static const unsigned char temp_binary_data_66[] =
"// This file is part of Eigen, a lightweight C++ template library\n"
"// for linear algebra.\n"
"//\n"
"// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>\n"
"// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>\n"
"//\n"
"// This Source Code Form is subject to the terms of the Mozilla\n"
"// Public License v. 2.0. If a copy of the MPL was not distributed\n"
"// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
"\n"
"#ifndef EIGEN_STDVECTOR_MODULE_H\n"
"#define EIGEN_STDVECTOR_MODULE_H\n"
"\n"
"#include \"Core\"\n"
"#include <vector>\n"
"\n"
"#if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */\n"
"\n"
"#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...)\n"
"\n"
"#else\n"
"\n"
"#include \"src/StlSupport/StdVector.h\"\n"
"\n"
"#endif\n"
"\n"
"#endif // EIGEN_STDVECTOR_MODULE_H\n";

const char* StdVector = (const char*) temp_binary_data_66;

//================== SuperLUSupport ==================
static const unsigned char temp_binary_data_67[] =
"#ifndef EIGEN_SUPERLUSUPPORT_MODULE_H\n"
"#define EIGEN_SUPERLUSUPPORT_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"#ifdef EMPTY\n"
"#define EIGEN_EMPTY_WAS_ALREADY_DEFINED\n"
"#endif\n"
"\n"
"typedef int int_t;\n"
"#include <slu_Cnames.h>\n"
"#include <supermatrix.h>\n"
"#include <slu_util.h>\n"
"\n"
"// slu_util.h defines a preprocessor token named EMPTY which is really polluting,\n"
"// so we remove it in favor of a SUPERLU_EMPTY token.\n"
"// If EMPTY was already defined then we don't undef it.\n"
"\n"
"#if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED)\n"
"# undef EIGEN_EMPTY_WAS_ALREADY_DEFINED\n"
"#elif defined(EMPTY)\n"
"# undef EMPTY\n"
"#endif\n"
"\n"
"#define SUPERLU_EMPTY (-1)\n"
"\n"
"namespace Eigen { struct SluMatrix; }\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup SuperLUSupport_Module SuperLUSupport module\n"
"  *\n"
"  * This module provides an interface to the SuperLU library.\n"
"  * It provides the following factorization class:\n"
"  * - class SuperLU: a supernodal sequential LU factorization.\n"
"  * - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods).\n"
"  *\n"
"  * \\warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/SuperLUSupport>\n"
"  * \\endcode\n"
"  *\n"
"  * In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies.\n"
"  * The dependencies depend on how superlu has been compiled.\n"
"  * For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task.\n"
"  *\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"\n"
"#include \"src/SuperLUSupport/SuperLUSupport.h\"\n"
"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_SUPERLUSUPPORT_MODULE_H\n";

const char* SuperLUSupport = (const char*) temp_binary_data_67;

//================== SVD ==================
static const unsigned char temp_binary_data_68[] =
"#ifndef EIGEN_SVD_MODULE_H\n"
"#define EIGEN_SVD_MODULE_H\n"
"\n"
"#include \"QR\"\n"
"#include \"Householder\"\n"
"#include \"Jacobi\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"/** \\defgroup SVD_Module SVD module\n"
"  *\n"
"  *\n"
"  *\n"
"  * This module provides SVD decomposition for matrices (both real and complex).\n"
"  * This decomposition is accessible via the following MatrixBase method:\n"
"  *  - MatrixBase::jacobiSvd()\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/SVD>\n"
"  * \\endcode\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/SVD/JacobiSVD.h\"\n"
"#if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT)\n"
"#include \"src/SVD/JacobiSVD_MKL.h\"\n"
"#endif\n"
"#include \"src/SVD/UpperBidiagonalization.h\"\n"
"\n"
"#ifdef EIGEN2_SUPPORT\n"
"#include \"src/Eigen2Support/SVD.h\"\n"
"#endif\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_SVD_MODULE_H\n"
"/* vim: set filetype=cpp et sw=2 ts=2 ai: */\n";

const char* SVD = (const char*) temp_binary_data_68;

//================== UmfPackSupport ==================
static const unsigned char temp_binary_data_69[] =
"#ifndef EIGEN_UMFPACKSUPPORT_MODULE_H\n"
"#define EIGEN_UMFPACKSUPPORT_MODULE_H\n"
"\n"
"#include \"SparseCore\"\n"
"\n"
"#include \"src/Core/util/DisableStupidWarnings.h\"\n"
"\n"
"extern \"C\" {\n"
"#include <umfpack.h>\n"
"}\n"
"\n"
"/** \\ingroup Support_modules\n"
"  * \\defgroup UmfPackSupport_Module UmfPackSupport module\n"
"  *\n"
"  * This module provides an interface to the UmfPack library which is part of the suitesparse package.\n"
"  * It provides the following factorization class:\n"
"  * - class UmfPackLU: a multifrontal sequential LU factorization.\n"
"  *\n"
"  * \\code\n"
"  * #include <Eigen/UmfPackSupport>\n"
"  * \\endcode\n"
"  *\n"
"  * In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies.\n"
"  * The dependencies depend on how umfpack has been compiled.\n"
"  * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task.\n"
"  *\n"
"  */\n"
"\n"
"#include \"src/misc/Solve.h\"\n"
"#include \"src/misc/SparseSolve.h\"\n"
"\n"
"#include \"src/UmfPackSupport/UmfPackSupport.h\"\n"
"\n"
"#include \"src/Core/util/ReenableStupidWarnings.h\"\n"
"\n"
"#endif // EIGEN_UMFPACKSUPPORT_MODULE_H\n";

const char* UmfPackSupport = (const char*) temp_binary_data_69;

const char* getNamedResource (const char*, int&) throw();
const char* getNamedResource (const char* resourceNameUTF8, int& numBytes) throw()
{
    unsigned int hash = 0;
    if (resourceNameUTF8 != 0)
        while (*resourceNameUTF8 != 0)
            hash = 31 * hash + (unsigned int) *resourceNameUTF8++;

    switch (hash)
    {
        case 0x90e15cf5:  numBytes = 153; return CMakeLists_txt;
        case 0x8b4a41dd:  numBytes = 172; return CMakeLists_txt2;
        case 0x8b4a41de:  numBytes = 178; return CMakeLists_txt3;
        case 0x8b4a41df:  numBytes = 178; return CMakeLists_txt4;
        case 0x8b4a41e0:  numBytes = 169; return CMakeLists_txt5;
        case 0x8b4a41e1:  numBytes = 166; return CMakeLists_txt6;
        case 0x8b4a41e2:  numBytes = 97; return CMakeLists_txt7;
        case 0x8b4a41e3:  numBytes = 166; return CMakeLists_txt8;
        case 0x8b4a41e4:  numBytes = 157; return CMakeLists_txt9;
        case 0xddfdf9d4:  numBytes = 215; return CMakeLists_txt10;
        case 0xddfdf9d5:  numBytes = 179; return CMakeLists_txt11;
        case 0xddfdf9d6:  numBytes = 195; return CMakeLists_txt12;
        case 0xddfdf9d7:  numBytes = 162; return CMakeLists_txt13;
        case 0xddfdf9d8:  numBytes = 168; return CMakeLists_txt14;
        case 0xddfdf9d9:  numBytes = 177; return CMakeLists_txt15;
        case 0xddfdf9da:  numBytes = 162; return CMakeLists_txt16;
        case 0xddfdf9db:  numBytes = 195; return CMakeLists_txt17;
        case 0xddfdf9dc:  numBytes = 147; return CMakeLists_txt18;
        case 0xddfdf9dd:  numBytes = 150; return CMakeLists_txt19;
        case 0xddfdf9f3:  numBytes = 160; return CMakeLists_txt20;
        case 0xddfdf9f4:  numBytes = 166; return CMakeLists_txt21;
        case 0xddfdf9f5:  numBytes = 141; return CMakeLists_txt22;
        case 0xddfdf9f6:  numBytes = 174; return CMakeLists_txt23;
        case 0xddfdf9f7:  numBytes = 172; return CMakeLists_txt24;
        case 0xddfdf9f8:  numBytes = 169; return CMakeLists_txt25;
        case 0xddfdf9f9:  numBytes = 150; return CMakeLists_txt26;
        case 0xddfdf9fa:  numBytes = 135; return CMakeLists_txt27;
        case 0xddfdf9fb:  numBytes = 171; return CMakeLists_txt28;
        case 0xddfdf9fc:  numBytes = 160; return CMakeLists_txt29;
        case 0xddfdfa12:  numBytes = 153; return CMakeLists_txt30;
        case 0xddfdfa13:  numBytes = 154; return CMakeLists_txt31;
        case 0xddfdfa14:  numBytes = 163; return CMakeLists_txt32;
        case 0xddfdfa15:  numBytes = 159; return CMakeLists_txt33;
        case 0xddfdfa16:  numBytes = 172; return CMakeLists_txt34;
        case 0xddfdfa17:  numBytes = 138; return CMakeLists_txt35;
        case 0xddfdfa18:  numBytes = 172; return CMakeLists_txt36;
        case 0xddfdfa19:  numBytes = 308; return CMakeLists_txt37;
        case 0x03c98239:  numBytes = 304; return Array;
        case 0x71024ebe:  numBytes = 775; return Cholesky;
        case 0xfe5a710f:  numBytes = 1670; return CholmodSupport;
        case 0xddfdfa1a:  numBytes = 607; return CMakeLists_txt38;
        case 0x002023bf:  numBytes = 12826; return Core;
        case 0x03edd2ff:  numBytes = 122; return Dense;
        case 0x03fda00c:  numBytes = 37; return Eigen;
        case 0xae38af49:  numBytes = 3295; return Eigen2Support;
        case 0x80f6042e:  numBytes = 1394; return Eigenvalues;
        case 0x71e26c92:  numBytes = 1605; return Geometry;
        case 0xd03464ac:  numBytes = 580; return Householder;
        case 0xcb4ed54e:  numBytes = 1594; return IterativeLinearSolvers;
        case 0x83cc338a:  numBytes = 645; return Jacobi;
        case 0x31a9106d:  numBytes = 712; return LeastSquares;
        case 0x00000989:  numBytes = 983; return LU;
        case 0x2ed44d09:  numBytes = 697; return MetisSupport;
        case 0x20e2ff1e:  numBytes = 2189; return OrderingMethods;
        case 0x5790bfcd:  numBytes = 864; return PardisoSupport;
        case 0xe4d2f3ae:  numBytes = 1467; return PaStiXSupport;
        case 0x00000a21:  numBytes = 926; return QR;
        case 0xd49890e9:  numBytes = 637; return QtAlignedMalloc;
        case 0x93fa5640:  numBytes = 594; return Sparse;
        case 0x796264fe:  numBytes = 1433; return SparseCholesky;
        case 0xc68559ff:  numBytes = 1835; return SparseCore;
        case 0x7ebdcfc9:  numBytes = 1776; return SparseLU;
        case 0x7ebdd061:  numBytes = 991; return SparseQR;
        case 0xc18be4b1:  numBytes = 930; return SPQRSupport;
        case 0x54e6e25d:  numBytes = 749; return StdDeque;
        case 0xf23cb141:  numBytes = 682; return StdList;
        case 0x66a64526:  numBytes = 755; return StdVector;
        case 0x9831890b:  numBytes = 1904; return SuperLUSupport;
        case 0x00014241:  numBytes = 858; return SVD;
        case 0x6ac119e8:  numBytes = 1151; return UmfPackSupport;
        default: break;
    }

    numBytes = 0;
    return 0;
}

const char* namedResourceList[] =
{
    "CMakeLists_txt",
    "CMakeLists_txt2",
    "CMakeLists_txt3",
    "CMakeLists_txt4",
    "CMakeLists_txt5",
    "CMakeLists_txt6",
    "CMakeLists_txt7",
    "CMakeLists_txt8",
    "CMakeLists_txt9",
    "CMakeLists_txt10",
    "CMakeLists_txt11",
    "CMakeLists_txt12",
    "CMakeLists_txt13",
    "CMakeLists_txt14",
    "CMakeLists_txt15",
    "CMakeLists_txt16",
    "CMakeLists_txt17",
    "CMakeLists_txt18",
    "CMakeLists_txt19",
    "CMakeLists_txt20",
    "CMakeLists_txt21",
    "CMakeLists_txt22",
    "CMakeLists_txt23",
    "CMakeLists_txt24",
    "CMakeLists_txt25",
    "CMakeLists_txt26",
    "CMakeLists_txt27",
    "CMakeLists_txt28",
    "CMakeLists_txt29",
    "CMakeLists_txt30",
    "CMakeLists_txt31",
    "CMakeLists_txt32",
    "CMakeLists_txt33",
    "CMakeLists_txt34",
    "CMakeLists_txt35",
    "CMakeLists_txt36",
    "CMakeLists_txt37",
    "Array",
    "Cholesky",
    "CholmodSupport",
    "CMakeLists_txt38",
    "Core",
    "Dense",
    "Eigen",
    "Eigen2Support",
    "Eigenvalues",
    "Geometry",
    "Householder",
    "IterativeLinearSolvers",
    "Jacobi",
    "LeastSquares",
    "LU",
    "MetisSupport",
    "OrderingMethods",
    "PardisoSupport",
    "PaStiXSupport",
    "QR",
    "QtAlignedMalloc",
    "Sparse",
    "SparseCholesky",
    "SparseCore",
    "SparseLU",
    "SparseQR",
    "SPQRSupport",
    "StdDeque",
    "StdList",
    "StdVector",
    "SuperLUSupport",
    "SVD",
    "UmfPackSupport"
};

}

max_stars_repo_name: jwdinius/extended-object-tracking

max_issues_repo_name: chisyliu/extended-object-tracking

max_forks_repo_name: chisyliu/extended-object-tracking


text:
// Copyright (c) 2015, Galaxy Authors. All Rights Reserved
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Author: yuanyi03@baidu.com

#include <stdio.h>
#include <stdlib.h>
#include <boost/bind.hpp>
#include "agent/downloader_manager.h"

int FLAGS_agent_curl_recv_buffer_size = 1024 * 20;

void Callback(int ret) {
    fprintf(stdout, "downloader ret %d", ret);
    return ;
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        fprintf(stderr, "./downloader_manager_test uri path");
        return EXIT_FAILURE;
    }
    char* uri = argv[1];
    char* path = argv[2];
    galaxy::DownloaderManager* manager = galaxy::DownloaderManager::GetInstance();

    manager->DownloadInThread(uri, path, boost::bind(Callback, _1));
    while (1) {}
    return EXIT_SUCCESS;
}

/* vim: set ts=4 sw=4 sts=4 tw=100 */

ext: cc

max_stars_repo_name: fxsjy/galaxy

max_issues_repo_name: fxsjy/galaxy

max_forks_repo_name: fxsjy/galaxy


text:
/*!
@file
Defines `boost::hana::minimum`.

@copyright Louis Dionne 2013-2016
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 */

#ifndef BOOST_HANA_MINIMUM_HPP
#define BOOST_HANA_MINIMUM_HPP

#include <boost/hana/fwd/minimum.hpp>

#include <boost/hana/concept/foldable.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/core/dispatch.hpp>
#include <boost/hana/detail/nested_by.hpp> // required by fwd decl
#include <boost/hana/fold_left.hpp>
#include <boost/hana/if.hpp>
#include <boost/hana/less.hpp>

BOOST_HANA_NAMESPACE_BEGIN
    //! @cond
    template <typename Xs>
    constexpr decltype(auto) minimum_t::operator()(Xs&& xs) const {
        using S = typename hana::tag_of<Xs>::type;
        using Minimum = BOOST_HANA_DISPATCH_IF(minimum_impl<S>,
            hana::Foldable<S>::value
        );

    #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
        static_assert(hana::Foldable<S>::value,
        "hana::minimum(xs) requires 'xs' to be Foldable");
    #endif

        return Minimum::apply(static_cast<Xs&&>(xs));
    }

    template <typename Xs, typename Predicate>
    constexpr decltype(auto) minimum_t::operator()(Xs&& xs, Predicate&& pred) const {
        using S = typename hana::tag_of<Xs>::type;
        using Minimum = BOOST_HANA_DISPATCH_IF(minimum_pred_impl<S>,
            hana::Foldable<S>::value
        );

    #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
        static_assert(hana::Foldable<S>::value,
        "hana::minimum(xs, predicate) requires 'xs' to be Foldable");
    #endif

        return Minimum::apply(static_cast<Xs&&>(xs),
                              static_cast<Predicate&&>(pred));
    }
    //! @endcond

    //////////////////////////////////////////////////////////////////////////
    // minimum (with a custom predicate)
    //////////////////////////////////////////////////////////////////////////
    namespace detail {
        template <typename Pred>
        struct min_by {
            Pred pred;

            template <typename X, typename Y>
            constexpr decltype(auto) operator()(X&& x, Y&& y) const {
                auto result = (*pred)(x, y);
                return hana::if_(result, static_cast<X&&>(x),
                                         static_cast<Y&&>(y));
            }
        };
    }

    template <typename T, bool condition>
    struct minimum_pred_impl<T, when<condition>> : default_ {
        template <typename Xs, typename Pred>
        static constexpr decltype(auto) apply(Xs&& xs, Pred const& pred) {
            // We use a pointer instead of a reference to avoid a Clang ICE.
            return hana::fold_left(static_cast<Xs&&>(xs),
                detail::min_by<decltype(&pred)>{&pred}
            );
        }
    };

    //////////////////////////////////////////////////////////////////////////
    // minimum (without a custom predicate)
    //////////////////////////////////////////////////////////////////////////
    template <typename T, bool condition>
    struct minimum_impl<T, when<condition>> : default_ {
        template <typename Xs>
        static constexpr decltype(auto) apply(Xs&& xs)
        { return hana::minimum(static_cast<Xs&&>(xs), hana::less); }
    };
BOOST_HANA_NAMESPACE_END

#endif // !BOOST_HANA_MINIMUM_HPP

ext: hpp

max_stars_repo_name: rudylee/expo

max_issues_repo_name: rudylee/expo

max_forks_repo_name: rudylee/expo


text:
/**
 * @file burgersequation_main.cc
 * @brief NPDE homework BurgersEquation code
 * @author Oliver Rietmann
 * @date 15.04.2019
 * @copyright Developed at ETH Zurich
 */

#include <Eigen/Core>
#include <cstdlib>
#include <fstream>
#include <iostream>

#include "burgersequation.h"

int main() {
  /* SAM_LISTING_BEGIN_1 */
  const unsigned int N = 100;
  Eigen::VectorXd x = Eigen::VectorXd::LinSpaced(N + 1, -1.0, 4.0);
  Eigen::VectorXd mu03 = BurgersEquation::solveBurgersGodunov(0.3, N);
  Eigen::VectorXd mu30 = BurgersEquation::solveBurgersGodunov(3.0, N);

  // Write the solutions to a file that can be used for plotting.
  //====================
  // Your code goes here

  //====================
  /* SAM_LISTING_END_1 */

  /* SAM_LISTING_BEGIN_2 */
  Eigen::Matrix<double, 3, 4> result = BurgersEquation::numexpBurgersGodunov();

  // Write the result to a file that can be used for plotting.
  //====================
  // Your code goes here
  //====================
  /* SAM_LISTING_END_2 */

  return 0;
}