Skip to content

Modernized CMakeLists.txt, removed deprecated CGAL macros, made LEDA-… #4

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
DhruvTotala wants to merge 1 commit into
base: develop
Choose a base branch
from
Open

Modernized CMakeLists.txt, removed deprecated CGAL macros, made LEDA-… #4

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
337 changes: 136 additions & 201 deletions respol/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,214 +1,149 @@
# Created by the script cgal_create_cmake_script
# This is the CMake script for compiling a CGAL application.
cmake_minimum_required(VERSION 3.14)

project(Resultant_enumeration_example LANGUAGES CXX)

# ================================
# C++ Standard
# ================================
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# ================================
# Find Dependencies
# ================================
find_package(CGAL REQUIRED)
find_package(Boost REQUIRED)

# ================================
# OPTIONS & CONFIGURATION
# ================================
include(CMakeDependentOption)

option(RESPOL_USE_FLAT_SET "use boost flat set to store normals" OFF)
option(RESPOL_USE_HASHED_DET "hash computed determinant minors" ON)

CMAKE_DEPENDENT_OPTION(RESPOL_HASH_STATS "print hashed determinants statistics" OFF "RESPOL_USE_HASHED_DET" OFF)
CMAKE_DEPENDENT_OPTION(RESPOL_HASH_SORTED_INDICES "used sorted indices in hash" ON "RESPOL_USE_HASHED_DET" OFF)
CMAKE_DEPENDENT_OPTION(RESPOL_HASH_CLEAR "clear the hash when memory consumption is high" ON "RESPOL_USE_HASHED_DET" OFF)
CMAKE_DEPENDENT_OPTION(RESPOL_HASH_ONLY_CAYLEY "use hash only for determinants in Cayley space" ON "RESPOL_USE_HASHED_DET" OFF)
CMAKE_DEPENDENT_OPTION(RESPOL_HASH_DET_TIME "output determinant computation time" OFF "RESPOL_USE_HASHED_DET" OFF)

option(RESPOL_VOL "compute volume of output polytope" ON)
option(RESPOL_EXTREME_SPECIALIZED_POINTS_ONLY "preprocess input" OFF)
option(RESPOL_BUILD_RANDOMIZED "build randomized version" OFF)
option(RESPOL_BUILD_CONVERTERS "build input converters" OFF)

# ================================
# PREPROCESSOR DEFINITIONS
# ================================
add_compile_definitions(USE_HACKED_KERNEL_ORIENTATION)
add_compile_definitions(USE_HACKED_GAUSSIAN_ELIMINATION)

if(RESPOL_USE_FLAT_SET)
add_compile_definitions(USE_BOOST_FLAT_SET)
endif()

if(RESPOL_USE_HASHED_DET)
add_compile_definitions(USE_HASHED_DETERMINANTS)
else()
add_compile_definitions(USE_CGAL_DET)
endif()

if(RESPOL_HASH_STATS)
add_compile_definitions(HASH_STATISTICS)
endif()

if(RESPOL_HASH_SORTED_INDICES)
add_compile_definitions(USE_SORTED_INDICES)
endif()

if(RESPOL_EXTREME_SPECIALIZED_POINTS_ONLY)
add_compile_definitions(USE_EXTREME_SPECIALIZED_POINTS_ONLY)
endif()

if(NOT DEFINED RESPOL_HASH_CLEAR_DETS)
set(RESPOL_HASH_CLEAR_DETS 1000000 CACHE STRING "Clear hash when it stores this amount of determinants")
endif()

if(RESPOL_HASH_CLEAR)
add_compile_definitions(USE_CLEAR_DET_HASH)
add_compile_definitions(CLEAR_DET_NUMBER=${RESPOL_HASH_CLEAR_DETS})
endif()

if(RESPOL_HASH_ONLY_CAYLEY)
add_compile_definitions(USE_ONLY_CAYLEY_DET_HASH)
endif()

project( Resultant_enumeration_example )
if(RESPOL_VOL)
add_compile_definitions(COMPUTE_VOL)
endif()

CMAKE_MINIMUM_REQUIRED(VERSION 2.4.5)
if(RESPOL_HASH_DET_TIME)
add_compile_definitions(LOG_DET_TIME)
endif()

if ( COMMAND cmake_policy )
cmake_policy( SET CMP0005 NEW )
# ================================
# INCLUDE DIRECTORIES
# ================================
include_directories(
${CMAKE_SOURCE_DIR}/../external/triangulation/include
${CMAKE_SOURCE_DIR}/../external/spatial_sorting/include
${CMAKE_SOURCE_DIR}/../external/extreme_points_d/include
${CMAKE_SOURCE_DIR}/../external/kernel_d/include
${CMAKE_SOURCE_DIR}/../external
${CMAKE_SOURCE_DIR}/../include
${CMAKE_SOURCE_DIR}/../patches/include
${CMAKE_SOURCE_DIR}/../external/leda/incl
)

# ================================
# LEDA (OPTIONAL)
# ================================
find_library(LEDA_LIB NAMES libleda.a leda PATHS ${CMAKE_SOURCE_DIR}/../external/leda/)

if(LEDA_LIB)
message(STATUS "Found LEDA: ${LEDA_LIB}")
else()
message(WARNING "LEDA not found. Building without LEDA support.")
endif()

set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)

find_package(CGAL QUIET COMPONENTS Core )

if ( CGAL_FOUND )

# COMPILATION OPTIONS
######################################################################

include ( CMakeDependentOption )
option ( RESPOL_USE_FLAT_SET "use boost flat set to store normals" OFF )
option ( RESPOL_USE_HASHED_DET "hash computed determinant minors" ON )
CMAKE_DEPENDENT_OPTION ( RESPOL_HASH_STATS
"print hashed determinants statistics" OFF
"RESPOL_USE_HASHED_DET" OFF )
CMAKE_DEPENDENT_OPTION ( RESPOL_HASH_SORTED_INDICES
"used sorted indices in hash" ON
"RESPOL_USE_HASHED_DET" OFF )
CMAKE_DEPENDENT_OPTION ( RESPOL_HASH_CLEAR
"clear the hash when memory consumption is high" ON
"RESPOL_USE_HASHED_DET" OFF )
CMAKE_DEPENDENT_OPTION ( RESPOL_HASH_ONLY_CAYLEY
"use hash only for determinants in Cayley space" ON
"RESPOL_USE_HASHED_DET" OFF )
option ( RESPOL_VOL "compute the volume of the output polytope" ON )
CMAKE_DEPENDENT_OPTION ( RESPOL_HASH_DET_TIME
"output the determinant computation time" OFF
"RESPOL_USE_HASHED_DET" OFF )
#option ( RESPOL_USE_LINBOX "use LinBox to compute determinants" OFF )
#option ( RESPOL_USE_MAPLE "use Maple to check convex hulls" OFF )
#set ( RESPOL_USE_MAPLE_EXEC
# "/opt/maple13/bin/maple"
# CACHE
# FILEPATH
# "path to Maple executable" )
#option ( RESPOL_USE_LRS "use LRS to compute convex hulls" OFF )
#CMAKE_DEPENDENT_OPTION ( RESPOL_LRS_DEBUG
# "show info about LRS execution" OFF
# "RESPOL_USE_LRS" OFF )
#option ( RESPOL_USE_EIGEN "use Eigen to compute determinants" OFF )
option ( RESPOL_EXTREME_SPECIALIZED_POINTS_ONLY "preprocess the input" OFF )
option ( RESPOL_BUILD_RANDOMIZED "also build randomized init version" OFF )
option ( RESPOL_BUILD_CONVERTERS "build input file converters" OFF )

# INCLUDES
######################################################################

include( ${CGAL_USE_FILE} )
include( CGAL_CreateSingleSourceCGALProgram )
include_directories (BEFORE ../external/triangulation/include)
include_directories (BEFORE ../external/spatial_sorting/include)
include_directories (BEFORE ../external/extreme_points_d/include)
include_directories (BEFORE ../external/kernel_d/include)
include_directories (BEFORE ../external)
include_directories (BEFORE ../include)
include_directories (BEFORE ../external/leda/incl)
include_directories (BEFORE ../patches/include)

# OTHER COMPILATION DEFINITIONS
######################################################################

#add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_ORIENTATION_DET")
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_HACKED_KERNEL_ORIENTATION")
#add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_HACKED_KERNEL_ORIENTATION_FOR_CONVEX_HULL")
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_HACKED_GAUSSIAN_ELIMINATION")
#add_definitions(${CMAKE_CXX_FLAGS} "-DRESTRICTED_RES")
#add_definitions(${CMAKE_CXX_FLAGS} "-DRANDOM_RES")

# CMAKE OPTIONS PROCESSING
######################################################################

if( RESPOL_USE_FLAT_SET )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_BOOST_FLAT_SET")
endif( RESPOL_USE_FLAT_SET )

if( RESPOL_USE_HASHED_DET )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_HASHED_DETERMINANTS")
else( RESPOL_USE_HASHED_DET )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_CGAL_DET")
endif( RESPOL_USE_HASHED_DET )

if( RESPOL_HASH_STATS )
add_definitions(${CMAKE_CXX_FLAGS} "-DHASH_STATISTICS")
endif( RESPOL_HASH_STATS )

if( RESPOL_HASH_SORTED_INDICES )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_SORTED_INDICES")
endif( RESPOL_HASH_SORTED_INDICES )

if( RESPOL_EXTREME_SPECIALIZED_POINTS_ONLY )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_EXTREME_SPECIALIZED_POINTS_ONLY")
endif( RESPOL_EXTREME_SPECIALIZED_POINTS_ONLY )

# Set the default value of RESPOL_HASH_CLEAR_DETS or use the cached value
# if it exists.
if( RESPOL_HASH_CLEAR_DETS )
set ( RESPOL_HASH_CLEAR_DETS ${RESPOL_HASH_CLEAR_DETS} CACHE INTERNAL
"cached setting of disabled option" )
else( RESPOL_HASH_CLEAR_DETS )
set ( RESPOL_HASH_CLEAR_DETS 1000000 CACHE INTERNAL "default setting" )
endif( RESPOL_HASH_CLEAR_DETS )

if( RESPOL_HASH_CLEAR )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_CLEAR_DET_HASH")
# This line makes this option visible in the GUI.
set ( RESPOL_HASH_CLEAR_DETS ${RESPOL_HASH_CLEAR_DETS} CACHE INTEGER
"clear the hash when it stores this amount of determinants" FORCE )
add_definitions(${CMAKE_CXX_FLAGS}
"-DCLEAR_DET_NUMBER=${RESPOL_HASH_CLEAR_DETS}")
endif( RESPOL_HASH_CLEAR )

if( RESPOL_HASH_ONLY_CAYLEY )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_ONLY_CAYLEY_DET_HASH")
endif( RESPOL_HASH_ONLY_CAYLEY )

if ( RESPOL_VOL )
add_definitions(${CMAKE_CXX_FLAGS} "-DCOMPUTE_VOL")
endif ( RESPOL_VOL )

if( RESPOL_HASH_DET_TIME )
add_definitions(${CMAKE_CXX_FLAGS} "-DLOG_DET_TIME")
endif( RESPOL_HASH_DET_TIME )

if( RESPOL_USE_LINBOX )
# TODO: let the user choose these directories
include_directories (BEFORE /home/vissarion/src/LinBox/include)
include_directories (BEFORE /home/vissarion/src/linbox-1.2.0)
include_directories (BEFORE /home/vissarion/src/fflas-ffpack-1.4.1)
add_definitions(${CMAKE_CXX_FLAGS} "-DLinBoxSrcOnly")
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_LINBOX_DET")
link_libraries("blas")
link_libraries("lapack")
link_libraries("givaro")
endif( RESPOL_USE_LINBOX )

if( RESPOL_USE_MAPLE )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_MAPLE_CONVEX_HULL")
add_definitions(${CMAKE_CXX_FLAGS}
"-DMAPLE_EXECUTABLE=${RESPOL_USE_MAPLE_EXEC}")
endif( RESPOL_USE_MAPLE )

#if( RESPOL_USE_LRS )
# add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_LRSLIB")
# add_definitions(${CMAKE_CXX_FLAGS} "-DSIGNALS")
# add_definitions(${CMAKE_CXX_FLAGS} "-DGMP")
# if ( ${CMAKE_SYSTEM_PROCESSOR} MATCHES ".*64.*" )
# add_definitions(${CMAKE_CXX_FLAGS} "-DB64")
# endif ( ${CMAKE_SYSTEM_PROCESSOR} MATCHES ".*64.*" )
# include_directories (BEFORE ../external/lrslib-042c/include)
# set ( RESPOL_AUX_PROGS "../external/lrslib-042c/include/lrslib.c"
# "../external/lrslib-042c/include/lrsgmp.c")
# create_single_source_cgal_program("test_lrs.cpp" ${RESPOL_AUX_PROGS})
#endif( RESPOL_USE_LRS )

if ( RESPOL_USE_EIGEN )
add_definitions(${CMAKE_CXX_FLAGS} "-DUSE_EIGEN_DET")
endif ( RESPOL_USE_EIGEN )

#if( RESPOL_LRS_DEBUG )
# add_definitions(${CMAKE_CXX_FLAGS} "-DTIMES")
# add_definitions(${CMAKE_CXX_FLAGS} "-DLRS_DEBUG")
#endif( RESPOL_LRS_DEBUG )

if( RESPOL_BUILD_CONVERTERS )
create_single_source_cgal_program("parse_input.cpp")
endif( RESPOL_BUILD_CONVERTERS )

if( RESPOL_BUILD_RANDOMIZED )
create_single_source_cgal_program("res_enum_d_rand.cpp" ${RESPOL_AUX_PROGS})
endif( RESPOL_BUILD_RANDOMIZED )

find_library(LEDA NAMES libleda.a PATHS ../external/leda/)

if (NOT LEDA)

message(FATAL_ERROR "This program requires the leda library, and will not be compiled.")

else ()

message(STATUS "Library leda found: ${LEDA}")
link_libraries(${LEDA})

# COMPILATION
######################################################################

create_single_source_cgal_program("res_enum_d.cpp" ${RESPOL_AUX_PROGS})
create_single_source_cgal_program("test_suite.cpp")
#create_single_source_cgal_program("tropli_disc.cpp")
#create_single_source_cgal_program("compute_ch.cpp")

enable_testing()
add_test(NAME test_suite COMMAND "test_suite")
set_tests_properties(test_suite PROPERTIES FAIL_REGULAR_EXPRESSION "FAIL")
endif()
# ================================
# Helper Macro
# ================================
macro(add_respol_executable target_name source_file)

add_executable(${target_name} ${source_file})

target_link_libraries(${target_name} PRIVATE CGAL::CGAL Boost::boost)

if(LEDA_LIB)
target_link_libraries(${target_name} PRIVATE ${LEDA_LIB})
endif()

endmacro()

# ================================
# EXECUTABLES
# ================================
if(LEDA_LIB)
add_respol_executable(res_enum_d res_enum_d.cpp)
else()
message(WARNING "Skipping res_enum_d because LEDA is missing")
endif()

message(STATUS "This program requires the CGAL library, and will not be compiled.")
add_respol_executable(test_suite test_suite.cpp)

if(RESPOL_BUILD_RANDOMIZED)
add_respol_executable(res_enum_d_rand res_enum_d_rand.cpp)
endif()

if(RESPOL_BUILD_CONVERTERS)
add_respol_executable(parse_input parse_input.cpp)
endif()

# ================================
# TESTING
# ================================
enable_testing()
add_test(NAME test_suite COMMAND test_suite)
set_tests_properties(test_suite PROPERTIES FAIL_REGULAR_EXPRESSION "FAIL")