CMakeLists.txt

# Instructions:
# $ mkdir build
# $ cd build
# $ cmake ..
# $ make

project(shogun)
cmake_minimum_required(VERSION 2.8)

################# VARIABLES #####################
SET(DEFINES "SWIG_TYPE_TABLE=shogun;SHOGUN")
SET(INCLUDES "")

SET(EXT_SRC_HEADER "h")
SET(EXT_SRC_C "c")
SET(EXT_SRC_CPP "cpp")
SET(EXT_SRC_SWIG "_wrap.cxx")
SET(EXT_SRC_TEST "_unittest.cc")
SET(EXT_INP_SWIG "i")
SET(EXT_IF_SWIG "py")
SET(EXT_CPP_TMP "${EXT_SRC_CPP}.templ")
SET(EXT_CPP_SH "${EXT_SRC_CPP}.sh")
SET(EXT_CPP_PY "${EXT_SRC_CPP}.py")

SET(LIBSHOGUN_SRC_DIR ${CMAKE_SOURCE_DIR}/src/shogun)
SET(COMMON_MODULAR_SRC_DIR ${CMAKE_SOURCE_DIR}/src/interfaces/modular/)

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")
################ COMPILER #######################
# g++ version needs to be => 4.3
IF(CMAKE_COMPILER_IS_GNUCXX)
	# in order to support cmake 2.8.7 and older
	IF(NOT CMAKE_CXX_COMPILER_VERSION)
		include(CheckCompiler)
	ENDIF()
	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.3.0")
		MESSAGE(FATAL_ERROR "g++ version is too old")
	ENDIF()
ENDIF()

# check for supported c++11 features
INCLUDE(CheckCXX11Features)

#SET(CMAKE_CXX_FLAGS ${CXX11_COMPILER_FLAGS})

IF (HAVE_CXX11_ATOMIC)
	LIST(APPEND DEFINES HAVE_CXX11_ATOMIC)
ENDIF()

############### VERSION #####################
FILE(STRINGS "@CMAKE_SOURCE_DIR@/src/NEWS" NEWS LIMIT_COUNT 5)
STRING(REGEX REPLACE ".*SHOGUN Release version ([0-9.]*).*" "\\1" VERSION "${NEWS}")
STRING(REGEX REPLACE ".*SHOGUN Release version.*\\(libshogun ([0-9.]*).*" "\\1" LIBSHOGUNVER "${NEWS}")
STRING(REGEX REPLACE ".*SHOGUN Release version.*\\(libshogun ([0-9]*).*" "\\1" LIBSHOGUNSO "${NEWS}")
STRING(REGEX REPLACE ".*SHOGUN Release version.*data ([0-9.]*).*" "\\1" DATAVER "${NEWS}")
STRING(REGEX REPLACE "([0-9]*).[0-9]*.[0-9]*" "\\1" SHOGUN_VERSION_MAJOR "${VERSION}")
STRING(REGEX REPLACE "[0-9]*.([0-9]*).[0-9]*" "\\1" SHOGUN_VERSION_MINOR "${VERSION}")
STRING(REGEX REPLACE "[0-9]*.[0-9]*.([0-9]*)" "\\1" SHOGUN_VERSION_PATCH "${VERSION}")


# Detect OS
IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
	SET(DARWIN 1)
ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
	SET(LINUX 1)
ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
	SET(FREEBSD 1)
ENDIF()

# Get processor type, sets MACHINE macro
execute_process(COMMAND uname -m
    OUTPUT_VARIABLE MACHINE_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE)
SET(MACHINE ${MACHINE_OUTPUT})

#Build type
if( NOT CMAKE_BUILD_TYPE )
  set( CMAKE_BUILD_TYPE Debug CACHE STRING
       "Choose the type of build, options are: Debug Release."
       FORCE )
endif()

IF(CMAKE_BUILD_TYPE STREQUAL "Debug")
	#		COMP_OPTS="-g $COMP_OPTS";
	#	COMPFLAGS_SWIG_CPP="-g $COMPFLAGS_SWIG_CPP"
ENDIF()

################# EXAMPLES ##################
OPTION(BUILD_EXAMPLES "Build Examples" ON)

################# DATATYPES #################
LIST(APPEND DEFINES USE_CHAR)
LIST(APPEND DEFINES USE_BOOL)
LIST(APPEND DEFINES USE_UINT8)
LIST(APPEND DEFINES USE_UINT16)
#LIST(APPEND DEFINES USE_UINT32)
LIST(APPEND DEFINES USE_UINT64)
#LIST(APPEND DEFINES USE_INT8)
#LIST(APPEND DEFINES USE_INT16)
LIST(APPEND DEFINES USE_INT32)
LIST(APPEND DEFINES USE_INT64)
LIST(APPEND DEFINES USE_FLOAT32)
LIST(APPEND DEFINES USE_FLOAT64)
#LIST(APPEND DEFINES USE_FLOATMAX)

# detect word size
IF(CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT DARWIN)
	SET(CMAKE_SWIG_FLAGS -DSWIGWORDSIZE64)
ENDIF()

#interfaces
OPTION(PythonModular "Python Modular" OFF)
OPTION(LuaModular "Lua Modular" OFF)
OPTION(RModular "R Modular" OFF)
OPTION(OctaveModular "Octave Modular" OFF)
OPTION(JavaModular "Java Modular" OFF)
OPTION(PerlModular "Perl Modular" OFF)
OPTION(RubyModular "Ruby Modular" OFF)
OPTION(CSharpModular "CSharp Modular" OFF)

OPTION(MatlabStatic "Matlab Static" OFF)

# SVMLight
OPTION(USE_SVMLIGHT "SVMLight" ON)
SET(SVMLightWarning "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
SET(SVMLightWarning "${SVMLightWarning}\nWARNING: SHOGUN is built using SVMlight which was written")
SET(SVMLightWarning "${SVMLightWarning}\nby Thorsten Joachims and uses a different non GPL compatible license.")
SET(SVMLightWarning "${SVMLightWarning}\nTo build a fully GPL'd SHOGUN use")
SET(SVMLightWarning "${SVMLightWarning}\nThe SVMlight license can be found in LICENSE.SVMlight.  In case")
SET(SVMLightWarning "${SVMLightWarning}\nyou do not know or cannot agree to the licensing terms expressed in")
SET(SVMLightWarning "${SVMLightWarning}\nLICENSE.SVMlight press ctrl+c to abort configure now.")
SET(SVMLightWarning "${SVMLightWarning}\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
IF(USE_SVMLIGHT)
	LIST(APPEND DEFINES USE_SVMLIGHT)
ENDIF()

#Trace memory allocs
OPTION(TRACE_MEMORY_ALLOCS "Memory allocation tracing" OFF)
IF(TRACE_MEMORY_ALLOCS)
	LIST(APPEND DEFINES TRACE_MEMORY_ALLOCS)
ENDIF()

# HMM
OPTION(USE_HMMDEBUG "HMM cache" OFF)
IF(USE_HMMDEBUG)
	LIST(APPEND DEFINES USE_HMMDEBUG)
ENDIF()

OPTION(USE_HMMCACHE "HMM cache" ON)
IF(USE_HMMCACHE)
	LIST(APPEND DEFINES USE_HMMCACHE)
ENDIF()

OPTION(USE_HMMPARALLEL "Parallel structures in hmm training" OFF)
IF(USE_HMMPARALLEL)
	SET(USE_HMMPARALLELSTRUCTURES 1)
	LIST(APPEND DEFINES USE_HMMPARALLELSTRUCTURES USE_HMMPARALLEL)
ENDIF()

# Viterbi path debug
OPTION(USE_PATHDEBUG "Viterbi path debugging" OFF)
IF(USE_PATHDEBUG)
	LIST(APPEND DEFINES USE_PATHDEBUG)
ENDIF()

# big states
OPTION(USE_BIGSTATES "Big (16bit) state" ON)
IF(USE_BIGSTATES)
	LIST(APPEND DEFINES USE_BIGSTATES)
ENDIF()

# Large file
OPTION(HAVE_LARGEFILE "Large file support" ON)
IF(HAVE_LARGEFILE)
	LIST(APPEND DEFINES HAVE_LARGEFILE)
ENDIF()

#kernelcache to use 4-byte-floating-point values instead of 8-byte-doubles
OPTION(USE_SHORTREAL_KERNELCACHE "Kernelcache to use 4-byte-floating-point values instead of 8-byte-doubles" ON)
IF(USE_SHORTREAL_KERNELCACHE)
	LIST(APPEND DEFINES USE_SHORTREAL_KERNELCACHE)
ENDIF()

# PRNG settings
SET(MEXP "19937" CACHE STRING "PRNG Mersenne exponent")
SET(SFMT_MEXP ${MEXP})
SET(DSFMT_MEXP ${MEXP})
LIST(APPEND DEFINES DSFMT_MEXP=${MEXP} SFMT_MEXP=${MEXP})

# Reference counting
OPTION(USE_REFERENCE_COUNTING "Reference Counting" ON)
IF(USE_REFERENCE_COUNTING)
	LIST(APPEND DEFINES USE_REFERENCE_COUNTING)
ENDIF()

######################### LIBRARIES #########################

# check for math functions
include(CheckFunctionExists)
FIND_LIBRARY(M_LIB m)
CHECK_FUNCTION_EXISTS(log2 HAVE_LOG2)
IF(HAVE_LOG2)
	LIST(APPEND DEFINES HAVE_LOG2)
ENDIF()

CHECK_FUNCTION_EXISTS(powl HAVE_POWL)
IF(HAVE_POWL)
	LIST(APPEND DEFINES HAVE_POWL)
ENDIF()

CHECK_FUNCTION_EXISTS(lgammal HAVE_LGAMMAL)
IF(HAVE_LGAMMAL)
	LIST(APPEND DEFINES HAVE_LGAMMAL)
ENDIF()

CHECK_FUNCTION_EXISTS(sqrtl HAVE_SQRTL)
IF(HAVE_SQRTL)
	LIST(APPEND DEFINES HAVE_SQRTL)
ENDIF()

# check SSE and SSE2 intrinsics header
include(CheckIncludeFile)
CHECK_INCLUDE_FILE(xmmintrin.h HAVE_BUILTIN_VECTOR)
CHECK_INCLUDE_FILE(emmintrin.h HAVE_SSE2)
IF(HAVE_SSE2)
	LIST(APPEND DEFINES HAVE_SSE2)
ENDIF()

FIND_PACKAGE(Threads)
IF (CMAKE_USE_PTHREADS_INIT)
	SET(HAVE_PTHREAD 1)
	LIST(APPEND DEFINES HAVE_PTHREAD)
ENDIF()

FIND_PACKAGE(OpenMP)
if (OPENMP_FOUND)
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
endif()

FIND_PACKAGE(PkgConfig)

FIND_PACKAGE(LAPACK)
IF (LAPACK_FOUND)
	SET(HAVE_LAPACK 1)
	LIST(APPEND DEFINES HAVE_LAPACK)
	SET(POSTLINKFLAGS ${LAPACK_LIBRARIES})
ENDIF()

FIND_PACKAGE(GLPK)
IF (GLPK_FOUND)
	SET(USE_GLPK 1)
	LIST(APPEND DEFINES USE_GLPK)
	LIST(APPEND INCLUDES ${GLPK_INCLUDE_DIRS})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${GLPK_LIBRARY})
ENDIF()

FIND_PACKAGE(CPLEX)
IF (CPLEX_FOUND)
	SET(USE_CPLEX 1)
	LIST(APPEND DEFINES USE_CPLEX)
	LIST(APPEND INCLUDES ${CPLEX_INCLUDE_DIR})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${CPLEX_LIBRARY})
ENDIF()

FIND_PACKAGE(ARPACK)
IF (ARPACK_FOUND)
	SET(HAVE_ARPACK 1)
	LIST(APPEND DEFINES HAVE_ARPACK)
	LIST(APPEND INCLUDES ${ARPACK_INCLUDE_DIR})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${ARPACK_LIB})
ENDIF()

FIND_PACKAGE(Eigen3)
IF (EIGEN_FOUND)
	SET(HAVE_EIGEN3 1)
	LIST(APPEND DEFINES HAVE_EIGEN3)
	LIST(APPEND INCLUDES ${EIGEN_INCLUDE_DIR})
ENDIF()

FIND_PACKAGE(SuperLU)
IF (SUPERLU_FOUND)
	SET(HAVE_SUPERLU 1)
	LIST(APPEND DEFINES HAVE_SUPERLU)
	LIST(APPEND INCLUDES ${SUPERLU_INCLUDE_DIRS})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${SUPERLU_LIBRARIES})
ENDIF()

FIND_PACKAGE(NLopt)
IF (NLOPT_FOUND)
	SET(HAVE_NLOPT 1)
	LIST(APPEND DEFINES HAVE_NLOPT)
	LIST(APPEND INCLUDES ${NLOPT_INCLUDE_DIR})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${NLOPT_LIBRARIES})
ENDIF()

FIND_PACKAGE(LpSolve)
IF (LPSOLVE_FOUND)
	SET(USE_LPSOLVE 1)
	LIST(APPEND DEFINES USE_LPSOLVE YY_NEVER_INTERACTIVE PARSER_LP INVERSE_ACTIVE=INVERSE_LUSOL RoleIsExternalInvEngine)
	LIST(APPEND INCLUDES ${LPSOLVE_INCLUDE_DIR})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${LPSOLVE_LIBRARIES})
ENDIF()

FIND_PACKAGE(Doxygen)
IF(DOXYGEN_FOUND)
	SET(HAVE_DOXYGEN 1)
	LIST(APPEND DEFINES HAVE_DOXYGEN)
ENDIF()

# detect PYTHON
FIND_PACKAGE(PythonInterp)
IF(NOT PYTHONINTERP_FOUND)
	MESSAGE(FATAL_ERROR "Currently we require python interpreter for build")
ENDIF()

# JSON
IF (PKG_CONFIG_FOUND)
	pkg_search_module(JSON libjson>=0.11 json>=0.11 json-c>=0.11)
	IF (JSON_FOUND)
		SET(HAVE_JSON 1)
		LIST(APPEND DEFINES HAVE_JSON)
		LIST(APPEND INCLUDES ${JSON_INCLUDE_DIRS})
		SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${JSON_LDFLAGS})
	ENDIF()
ENDIF()

FIND_PACKAGE(LibXml2)
IF (LIBXML2_FOUND)
	SET(HAVE_XML 1)
	LIST(APPEND DEFINES HAVE_XML)
	LIST(APPEND INCLUDES ${LIBXML2_INCLUDE_DIR})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${LIBXML2_LIBRARIES})
ENDIF()

FIND_PACKAGE(HDF5)
IF (HDF5_FOUND)
	SET(HAVE_HDF5 1)
	LIST(APPEND DEFINES HAVE_HDF5)
	LIST(APPEND INCLUDES ${HDF5_INCLUDE_DIRS})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${HDF5_LIBRARIES})
ENDIF()

FIND_PACKAGE(ZLIB)
IF (ZLIB_FOUND)
	SET(USE_GZIP 1)
	LIST(APPEND DEFINES USE_GZIP)
	LIST(APPEND INCLUDES ${ZLIB_INCLUDE_DIRS})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${ZLIB_LIBRARIES})
ENDIF()

FIND_PACKAGE(BZip2)
IF (BZIP2_FOUND)
	SET(USE_BZIP2 1)
	LIST(APPEND DEFINES USE_BZIP2)
	LIST(APPEND INCLUDES ${BZIP_INCLUDE_DIRS})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${BZIP2_LIBRARIES})
ENDIF()

FIND_PACKAGE(LibLZMA)
IF (LIBLZMA_FOUND)
	SET(USE_LZMA 1)
	LIST(APPEND DEFINES USE_LZMA)
	LIST(APPEND INCLUDES ${LIBLZMA_INCLUDE_DIRS})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${LIBLZMA_LIBRARIES})
ENDIF()

FIND_PACKAGE(SNAPPY)
IF (SNAPPY_FOUND)
	SET(USE_SNAPPY 1)
	LIST(APPEND DEFINES USE_SNAPPY)
	LIST(APPEND INCLUDES ${SNAPPY_INCLUDE_DIR})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${SNAPPY_LIBRARIES})
ENDIF()

FIND_PACKAGE(LZO)
IF (LZO_FOUND)
	SET(USE_LZO 1)
	LIST(APPEND DEFINES USE_LZO)
	LIST(APPEND INCLUDES ${LZO_INCLUDE_DIR})
	SET(POSTLINKFLAGS ${POSTLINKFLAGS} ${LZO_LIBS})
ENDIF()

FIND_PACKAGE(Spinlock)
IF (SPINLOCK_FOUND)
	SET(USE_SPINLOCKS 1)
	LIST(APPEND DEFINES USE_SPINLOCKS)
ENDIF()

# set DEFINES for defintions
#add_definitions(${DEFINES})

#SWIG Interfaces
SET(CMAKE_SWIG_FLAGS "${CMAKE_SWIG_FLAGS};-w473;-w454;-w312;-w325;-fvirtual")

OPTION(USE_SWIG_DIRECTORS "" OFF)

# check whether any of the modular interfaces are turned ON
IF (
	PythonModular OR LuaModular OR RModular OR
	OctaveModular OR JavaModular OR PerlModular OR
	RubyModular OR CSharpModular
   )
	FIND_PACKAGE(SWIG 2.0.4 REQUIRED)
ENDIF()

# python modular
IF (PythonModular)
	FIND_PACKAGE(PythonLibs REQUIRED)
	FIND_PACKAGE(NumPy REQUIRED)

	LIST(APPEND DEFINES HAVE_PYTHON)
	
	#custom swig flags for python modular interface
	SET(TARGET_SWIGFLAGS "-builtin\;-modern\;-modernargs")
	add_subdirectory(src/interfaces/python_modular)
ENDIF()

# lua modular
IF (LuaModular)
	#FIND_PACKAGE(Lua51 REQUIRED)
	pkg_search_module(LUA REQUIRED lua lua5.1 lua5.2)
	UNSET(TARGET_SWIGFLAGS)
	add_subdirectory(src/interfaces/lua_modular)
ENDIF()

# java modular
IF (JavaModular)
	FIND_PACKAGE(Java REQUIRED)
	FIND_PACKAGE(JNI REQUIRED)

	#find jblas
	INCLUDE(UseJava)
	FIND_JAR(JBLAS NAMES jblas jblas-1.2.0
			PATHS /opt/local/share/java
				  ENV JBLAS_PATH)
	IF(JBLAS)
		LIST(APPEND DEFINES HAVE_JBLAS)
		SET(HAVE_JBLAS 1)
	ELSE()
		MESSAGE(FATAL_ERROR "JBlas could not be found!\n"
			"It is required for java modular interface!!!")
	ENDIF()

	SET(TARGET_SWIGFLAGS "-package\;org.shogun")
	add_subdirectory(src/interfaces/java_modular)
ENDIF()

# ruby modular
IF (RubyModular)
	FIND_PACKAGE(Ruby REQUIRED)
	FIND_PACKAGE(RubyNArray REQUIRED)
	SET(NARRAY_LIB ${RUBY_NARRAY_LIBRARY})
	UNSET(TARGET_SWIGFLAGS)
	add_subdirectory(src/interfaces/ruby_modular)
ENDIF()

# octave modular
IF (OctaveModular)		
	FIND_PACKAGE(Octave REQUIRED)
	UNSET(TARGET_SWIGFLAGS)
	add_subdirectory(src/interfaces/octave_modular)
ENDIF()

# csharp modular
IF (CSharpModular)
	FIND_PACKAGE(CSharp REQUIRED)
	UNSET(TARGET_SWIGFLAGS)
	add_subdirectory(src/interfaces/csharp_modular)
ENDIF()

# r modular
IF (RModular)
	FIND_PACKAGE(R REQUIRED)
	UNSET(TARGET_SWIGFLAGS)
	#add_subdirectory(src/interfaces/r_modular)
ENDIF()

# perl modular
IF (PerlModular)
	FIND_PACKAGE(FindPerlLibs REQUIRED)
	UNSET(TARGET_SWIGFLAGS)
	#add_subdirectory(src/interfaces/perl_modular)
ENDIF()

IF (MatlabStatic)
	#add_subdirectory(src/interfaces/matlab_static)
ENDIF()

IF (SVMLight)
	MESSAGE(STATUS ${SVMLightWarning})
ENDIF()

# Find GTEST and GMOCK frameworks
SET(GOOGLE_MOCK_SOURCE_DIR "" CACHE PATH "Path to the GMock source")
IF ("${GOOGLE_MOCK_SOURCE_DIR}" STREQUAL "" OR NOT EXISTS "${GOOGLE_MOCK_SOURCE_DIR}/CMakeLists.txt")
	MESSAGE("Unit testing is disabled")
ELSE()
	enable_testing()
	add_subdirectory(tests/unit)
ENDIF()

# save configuration options
SET(CONFIGURE_OPTIONS "TODO")
SET(COMPFLAGS_CPP "TODO")
SET(LINKFLAGS "${POSTLINKFLAGS}")

add_subdirectory(src/shogun)

IF(BUILD_EXAMPLES)
	add_subdirectory(examples)
ENDIF()

# general cpack settings
set(CPACK_PACKAGE_NAME "Shogun")
set(CPACK_PACKAGE_VENDOR "Shogun")
#SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/README")
#SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/src/COPYRIGHT")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Shogun Machine Learning Toolbox")
set(CPACK_PACKAGE_VERSION ${VERSION})
set(CPACK_PACKAGE_VERSION_MAJOR ${SHOGUN_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${SHOGUN_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${SHOGUN_VERSION_PATCH})

INCLUDE(CPack)