Commit 1e689e3c authored by Praetorius, Simon's avatar Praetorius, Simon

external libraries mtl4 and muparser added to lib directory

parent 92e102a5
project (mtl4) # GPU version
cmake_minimum_required(VERSION 2.8)
option(ENABLE_GCOV "enable gnu coverage flags for gnu compiler" OFF)
option(ENABLE_WARNINGS "Enable gnu specific warnings" ON)
option(ENABLE_DEVELOPMENT "enable program parts under development" OFF)
# adding the Path of our own Modules
SET(CMAKE_MODULE_PATH $ENV{CMAKE_MODULE_PATH})
SET(MTL4_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})
#SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${MTL4_ROOT_PATH}/Cmake_Module)
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${MTL4_ROOT_PATH})
#look for mtl4, use THIS directory as mtl dir
find_package(MTL REQUIRED HINTS ${CMAKE_CURRENT_SOURCE_DIR})
include_directories(${MTL_INCLUDE_DIRS})
add_definitions(${MTL_CXX_DEFINITIONS})
#REMAINING PART USES MTL4
include(CheckCXXCompilerFlag)
#let cmake look for the svn-version, only needed for packages?
if (NOT MSVC)
find_package(Subversion)
if(Subversion_FOUND)
Subversion_WC_INFO(${CMAKE_CURRENT_SOURCE_DIR} mtlSubinfo)
set(CurrentRevision ${mtlSubinfo_WC_REVISION})
# message("current revision: ${mtlSubinfo_WC_REVISION}")
else(Subversion_FOUND)
set(CurrentRevision "0")
endif(Subversion_FOUND)
endif (NOT MSVC)
# if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
# set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lstdc++")
# endif()
configure_file(boost/numeric/mtl/version.hpp.in boost/numeric/mtl/version.hpp @ONLY)
#look for compiler specific settings
if (MSVC)
# to quiet DevStudio 2005 secure code warnings
add_definitions(/D_SCL_SECURE_NO_WARNINGS)
add_definitions(/D_CRT_SECURE_NO_WARNINGS)
add_definitions(/DMTL_ASSERT_FOR_THROW /D_CRT_SECURE_NO_DEPRECATE /DNOMINMAX /D_CONSOLE /D"_HAS_ITERATOR_DEBUGGING=0" /D"_SECURE_SCL=0" )
# specialty flags such as the C++ language exception model etc. come from the init flags determined by CMAKE
# you may override them, but I have not found it necessary
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_INIT} /wd4018 /wd4099 /wd4522 /wd4996 /wd4355 /wd4244 /Z7")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE_INIT} /wd4018 /wd4099 /wd4522 /wd4996 /wd4355 /wd4244 /Z7")
endif (MSVC)
if( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND ENABLE_WARNINGS)
add_definitions("-Wall -Wextra -Wpointer-arith -Wcast-align -Wcast-qual -Wwrite-strings")
foreach(FLAG "-Wno-long-long") # "-Wno-unused-local-typedefs")
# message(STATUS "Check flag ${FLAG}")
mtl_check_cxx_compiler_flag(${FLAG} FLAG_OKAY)
if(FLAG_OKAY)
message(STATUS "Add ${FLAG}")
add_definitions("${FLAG}")
endif()
endforeach()
endif()
if (ENABLE_DEVELOPMENT)
add_definitions("-DMTL_WITH_DEVELOPMENT")
endif()
if (ENABLE_SHORT_ELE_PROD)
add_definitions("-DMTL_WITH_SHORT_ELE_PROD")
endif()
set(BUILDNAME "${TESTBUILDNAME}")
enable_testing()
include(CTest)
set(MTL_IS_CONFIGURED True) # impede double double configuration in libs
add_subdirectory(libs)
## This file should be placed in the root directory of your project.
## Then modify the CMakeLists.txt file in the root directory of your
## project to incorporate the testing dashboard.
## # The following are required to uses Dart and the Cdash dashboard
## ENABLE_TESTING()
## INCLUDE(CTest)
set(CTEST_PROJECT_NAME "mtl4")
set(CTEST_NIGHTLY_START_TIME "00:00:00 CEST")
set(CTEST_DROP_METHOD "http")
set(CTEST_DROP_SITE "simunova.zih.tu-dresden.de")
set(CTEST_DROP_LOCATION "/CDash/submit.php?project=mtl4")
set(CTEST_DROP_SITE_CDASH TRUE)
# set(CTEST_CURL_OPTIONS "CURLOPT_SSL_VERIFYPEER_OFF")
# build in parallel if not on Windows
# if (NOT MSVC)
# message("now with make -j4")
# set(CTEST_BUILD_FLAGS -j4)
# endif()
while (${CTEST_ELAPSED_TIME} LESS 36)
set (START_TIME ${CTEST_ELAPSED_TIME})
ctest_start (Continuous)
ctest_sleep( ${START_TIME} 3 ${CTEST_ELAPSED_TIME})
endwhile()
This diff is collapsed.
-*- text -*-
Software License for MTL
Copyright (c) 2007-2008 The Trustees of Indiana University.
2008 Dresden University of Technology and the Trustees of Indiana University.
2010 SimuNova UG, www.simunova.com.
All rights reserved.
Authors: Peter Gottschling and Andrew Lumsdaine
This file is part of the Matrix Template Library
See also tools/license/license.mtl.txt in the distribution.
---------------------------------------------------------------
The Matrix Template Library
Version 4
I. Installation
===============
see http://www.simunova.com/node/189
set(MTL_COMMON_CONFIG "${MTL_DIR}/tools/cmake/MTLCommon.cmake")
if( EXISTS ${MTL_COMMON_CONFIG})
include(${MTL_COMMON_CONFIG})
else()
message(ERROR "could not find the common mtl configuration. this is possibly a wrong installation of mtl.")
endif()
-*- text -*-
Software License for MTL
Copyright (c) 2007-2008 The Trustees of Indiana University. All rights reserved.
Authors: Peter Gottschling and Andrew Lumsdaine
This file is part of the Matrix Template Library
See also license.mtl.txt in the distribution.
---------------------------------------------------------------
The Matrix Template Library
Version 4
I. Introduction
===============
The Matrix Template Library is a C++ class library for basic linear
algebra. The MTL is designed for high-performance while at the same
time taking advantage of the generic programming paradigm (ala the
STL) to allow much greater flexibility and breadth of
functionality. Many new and advanced programming techniques were used
in the construction of this library.
The MTL is a low level library in the sense that the user must be
conscious of the matrix type being used, and that all computationally
expensive operations are explicit. The MTL is not a C++ Matlab or
Mathematica. Nevertheless, the interface is designed to be simple and easy
to use.
The matrix types provided include compressed sparse row/column,
traditional row- and column-major dense, Morton-order, and block-recursive
matrices. All matrix types share a common and easy to use interface.
The algorithms consist of the traditional basic linear algebra
routines (from the BLAS level-1 to 3) which includes matrix and vector
arithmetic.
II. Compilers
=============
The Matrix Template Library is written in compliance with the C++ standard
and should be compilable with every compiler compliant with the standard.
It has been tested (and passed) with the following compilers and architectures:
Linux & MacOS
-------------
clang++ 3.0 (32 bit)
g++ 4.1.3 (32 and 64 bit)
g++ 4.2.4 (64bit)
g++ 4.3.4 (32 and 64 bit)
g++ 4.4.3 (32 and 64 bit)
g++ 4.5.1 (64 bit)
g++ 4.6.0 (64 bit)
g++ 4.6.1 (64 bit)
icc 9.1 (32 and 64 bit)
icc 10.0 (32 and 64 bit)
icc 10.1 (32 and 64 bit)
icc 11.0 (32 and 64 bit)
icc 11.1 (32 and 64 bit)
Windows
-------
VC 8.0 from Visual Studio 2005 (32 bit)
VC 9.0 from Visual Studio 2008 (32 bit)
VC 10.0 from Visual Studio 2010 (32 bit)
Compilers that are not standard-compliant (e.g. VC 6.0 from VS 2003) are not subject to support.
III. Documentation
==================
The documentation can be generated with doxygen in the main directory and
is found in the /libs/numeric/mtl/doc. You
can also view the documentation at our web site:
http://www.simunova.com/node/184
At the moment, the documentation illustrates the basic operations and
partially provides a reference manual of some classes and functions.
A detailed description of more features, especially tuning opportunities,
is in the works.
There are also a large number of examples in the /libs/numeric/mtl/examples
directory.
IV. Installation Procedure
==========================
See the file INSTALL in this directory.
V. Contact Information
=======================
The Matrix Template Library is available at the main distribution site:
http://www.mtl4.org
This distribution includes:
- Source code for the MTL (all header files /boost/numeric/mtl)
- Some completing sources (header files /boost/numeric/meta_math)
- A test suite (/libs/numeric/mtl/test)
- Some example code (/libs/numeric/mtl/examples)
Bug reports should be sent to mtl4@osl.iu.edu.
Questions, comments, suggestions, and requests for additional
information should also be directed to mtl4@osl.iu.edu.
Subscribe at:
http://www.osl.iu.edu/mailman/listinfo.cgi/mtl4
This diff is collapsed.
// Software License for MTL
//
// Copyright (c) 2007 The Trustees of Indiana University.
// 2008 Dresden University of Technology and the Trustees of Indiana University.
// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.
// All rights reserved.
// Authors: Peter Gottschling and Andrew Lumsdaine
//
// This file is part of the Matrix Template Library
//
// See also license.mtl.txt in the distribution.
#ifndef ITL_BASIC_ITERATION_INCLUDE
#define ITL_BASIC_ITERATION_INCLUDE
#include <iostream>
#include <complex>
#include <string>
namespace itl {
template <class Real>
class basic_iteration
{
public:
typedef basic_iteration self;
typedef Real real;
template <class Vector>
basic_iteration(const Vector& r0, int max_iter_, Real t, Real a = Real(0))
: error(0), i(0), norm_r0(std::abs(two_norm(r0))),
max_iter(max_iter_), rtol_(t), atol_(a), is_finished(false), my_quite(false), my_suppress(false) { }
basic_iteration(Real nb, int max_iter_, Real t, Real a = Real(0))
: error(0), i(0), norm_r0(nb), max_iter(max_iter_), rtol_(t), atol_(a), is_finished(false),
my_quite(false), my_suppress(false) {}
virtual ~basic_iteration() {}
bool check_max()
{
if (i >= max_iter)
error= 1, is_finished= true, err_msg= "Too many iterations.";
return is_finished;
}
template <class Vector>
bool finished(const Vector& r)
{
if (converged(two_norm(r)))
return is_finished= true;
return check_max();
}
bool finished(const Real& r)
{
if (converged(r))
return is_finished= true;
return check_max();
}
template <typename T>
bool finished(const std::complex<T>& r)
{
if (converged(std::abs(r)))
return is_finished= true;
return check_max();
}
bool finished() const { return is_finished; }
template <class T>
int terminate(const T& r) { finished(r); return error; }
bool converged(const Real& r) { resid_= r; return converged(); }
bool converged() const
{
if (norm_r0 == 0)
return resid_ <= atol_; // ignore relative tolerance if |r0| is zero
return resid_ <= rtol_ * norm_r0 || resid_ <= atol_;
}
self& operator++() { ++i; return *this; }
self& operator+=(int n) { i+= n; return *this; }
bool first() const { return i <= 1; }
virtual operator int() const { return error; }
virtual int error_code() const { return error; }
bool is_converged() const { return is_finished && error == 0; }
int iterations() const { return i; }
int max_iterations() const { return max_iter; }