usage: ./configure [ variable=value ]...
This configure script generates the file 'makefile' and the file
'../include/NTL/config.h', based upon the values assigned to the
variables on the command line.
########### Here are the most important variables, and their default values.
CXX=g++ # The C++ compiler
CXXFLAGS=-g -O2 # C++ complilation flags
NATIVE=on # compiles code targeted to current hardware
TUNE=generic (or x86)# performance-tuning switch
DEF_PREFIX=/usr/local# Default software directory
PREFIX=$(DEF_PREFIX) # Directory in which to install NTL library components
SHARED=off # Generate a shared library (as well as static)
NTL_THREADS=on # compile in thread-safe mode
NTL_THREAD_BOOST=on # compile with thread boosting enabled
NTL_EXCEPTIONS=off # compile in exception-safe mode
NTL_GMP_LIP=on # Switch to enable the use of GMP as primary
# long integer package
GMP_PREFIX=$(DEF_PREFIX) # Directory in which GMP components are installed
NTL_GF2X_LIB=off # Switch to enable the use of the gf2x package
# for faster arithmetic over GF(2)[X]
GF2X_PREFIX=$(DEF_PREFIX) # Directory in which gf2x components are installed
NTL_STD_CXX11=on # Build assuming C++11 features
NTL_SAFE_VECTORS=on # build in "safe vector" mode
########## Here are more detailed description of these variables.
########## Basic compilation variables:
CXX=g++
# A C++ compiler, e.g., g++, CC, xlC
CXXFLAGS=-g -O2
# Flags for the C++ compiler.
# It is highly recommend to avoid things like -O3 and -Ofast.
# These may yield incorrect code.
NATIVE=on
# Flag to target code to current hardware. Setting this flag will pass
# -march=native through to the compiler via CXXAUTOFLAGS (if possible). This
# is the easiest way to exploit the hardware capabilities of your machine to
# their fullest potential. Note that if CXXFLAGS contains an '-march=XXX'
# option, then NATIVE will be turned off.
TUNE=generic (or x86)
# Switch to determine how various performance options get set
# auto make runs a performance-tuning wizard
# generic should be OK for most platforms
# x86 should be well suited for most x86 platforms
# More choices may be added in the future.
# The default is 'x86' if the configuration script detects that it
# is running on an x86 machine; otherwise the default is 'generic'.
########## Installation path:
DEF_PREFIX=/usr/local
# Default software directory
PREFIX=$(DEF_PREFIX)
# Set this to the directory in which you want NTL components to be
# installed. When 'make install' is executed, the header
# files are copied into $(PREFIX)/include/NTL, the library itself is
# copied to $(PREFIX)/lib/libntl.a, and the documentation files
# are copied into $(PREFIX)/share/doc/NTL.
# Unless you have root permissions when running 'make install',
# you will have to override the default PREFIX value with the
# name of your own local directory.
# If you want finer-grained control over where the different
# library components are installed, set the variables
# INCLUDEDIR, LIBDIR, and DOCDIR (see below).
########## Shared library switch:
SHARED=off
# Set this to 'on' if you want to generate a shared library, in addition to a
# static library. Shared libraries have many advantages, but unfortunately,
# their use is rather less portable than that of good, old-fashioned static
# libraries. If you set SHARED=on, then the makefile will use a libtool
# script. By default, the libtool script used is freshly built when you run
# configure. You can use a pre-built libtool command by setting the
# configuration variable LIBTOOL. Note that if SHARED=on, then in addition to
# using the libtool program, the makefile relies on features specific to GNU
# make.
########## thread safety
NTL_THREADS=on
# Set to 'on' if you want to compile NTL in thread-safe mode. This requires
# several C++11 features, including atomic types, mutexes, and thread_local
# storage. Your compiler may not yet support these features. Setting this
# flag will automatically set the NTL_STD_CXX11 flag (if neither NTL_STD_CXX11
# or NTL_STD_CXX14 is already set). It will also pass -pthread throught to the
# compiler via CXXAUTOFLAGS (if possible).
# Turning this flag off will also turn off the NTL_THREAD_BOOST flag.
########## thread boosting
NTL_THREAD_BOOST=on
# Set to 'on' if you want to compile NTL so that is does certain internal
# computations using multiple threads.
# This feature is a work in progress.
# As time goes on, more NTL algorithms are thread boosted.
# See BasicThreadPool documentation file for more details.
########## exceptions
NTL_EXCEPTIONS=off
# Set to 'on' if you want to compile NTL with exceptions enabled. This
# requires several C++11 features, including lambdas and the new rules for
# exception specifications. Your compiler may not yet support these feautures.
# Setting this flag will automatically set the NTL_STD_CXX11 flag (if neither
# NTL_STD_CXX11 or NTL_STD_CXX14 is already set).
# With exceptions disabled, any error conditions detected by NTL (including
# memory allocation errors) will result in an error message and a call to
# abort. Also, if compiling in C++11 mode (or later, see NTL_STD_CXX11), with
# exceptions disabled, certain move constructors and move assignment operators
# will be declared "noexcept". This can lead to greater efficiency (for
# example, std::vector's take advantage of this to avoid call to copy
# contructors).
# With exceptions enabled, most error conditions detected by NTL will result in
# an exception being thrown. NTL will also be compiled in a "thread safe" mode
# that prevents memory leaks (and other problems). In addition, some move
# constructors and move assignment operators may not be declared "noexcept".
########## GMP variables:
NTL_GMP_LIP=on
# Set to 'off' if you don't want to use GMP, the GNU Multi-Precision package,
# as the primary long integer package.
# This will lead to significantly slower code, and is not
# recommended.
GMP_PREFIX=$(DEF_PREFIX)
# If GMP was installed in a standard system directory, e.g., /usr/local,
# then do not set this variable.
# Otherwise, if you want to use GMP and GMP was installed in
# a directory <gmp_prefix>, then set GMP_PREFIX=<gmp_prefix>.
# This works if the directory <gmp_prefix>/include contains gmp.h
# and <gmp_prefix>/lib contains libgmp.a.
# For finer-grained control, set the variables GMP_INCDIR and GMP_LIBDIR
# instead (see below).
########## GF2X variables:
NTL_GF2X_LIB=off
# Set to 'on' if you want to use the gf2x library for faster
# arithmetic over GF(2)[X] (the NTL class GF2X).
# If you set this flag, please note the following.
# If you have installed gf2x in a standard "system" location, this is
# all you have to do. Otherwise, if gf2x is built, but not installed
# in a standard place, you have to set the variable GF2X_PREFIX.
GF2X_PREFIX=$(DEF_PREFIX)
# If gf2x was installed in a standard system directory, e.g., /usr/local,
# then do not set this variable.
# Otherwise, if you want to use gf2x and gf2x was installed in
# a directory <gf2x_prefix>, then set GF2X_PREFIX=<gf2x_prefix>.
# This works if the directory <gf2x_prefix>/include contains gf2x.h
# and <gf2x_prefix>/lib contains libgf2x.a.
# For finer-grained control, set the variables GF2X_INCDIR and GF2X_LIBDIR
# instead (see below).
########### Language stadards
NTL_STD_CXX11=on # Build assuming C++11 features
NTL_STD_CXX14=off # Build assuming C++14 features
# Setting one of these may also result in passing pass either -std=c++11 or
# -std=c++14 through to the compiler via CXXAUTOFLAGS (if it is necessary and
# possible).
############ Safe vector mode
NTL_SAFE_VECTORS=on # Build in "safe vector mode"
# Build NTL in "safe vector mode", which relaxes the "relocatability"
# requirement for NTL vector types. I expect that at some point in the next
# couple of years, this will be "on" by default. Setting this flag will
# automatically set the NTL_STD_CXX11 flag (if neither NTL_STD_CXX11 or
# NTL_STD_CXX14 is already set). See vector documentation file for more
# details.
########### Examples:
# If you are happy with all the default values:
./configure
# If your C++ compiler is called icpc:
./configure CXX=icpc
# If GMP was installed in a non-standard directory, say, $HOME/sw:
./configure GMP_PREFIX=$HOME/sw
# If you want to use the options -g and -O for compiling C++,
# just execute
./configure "CXXFLAGS=-g -O"
# Note the use of quotes to keep the argument in one piece.
# If you want to use the gf2x library:
./configure NTL_GF2X_LIB=on
###########
########### A little magic
###########
CXXAUTOFLAGS=
# This is a variable that is automagically set by the configuration script.
# These are C++ compiler flags that are selected depending on the choice of
# other configuration options, as well as information gleaned by the
# configuration script about the compiler. To do this, the configuration
# script attempts to figure out the type of compiler and the default language
# standard supported. The types of compiler currently recognized are gcc,
# clang, and icc. For these compilers, the automagic should definitely work.
# For others, your mileage may vary. The configuration script always prints
# out the value it chooses. Currently, the following flags may get passed
# through CXXAUTOFLAGS:
#
# -std=c++11
# -std=c++14 if requested explicitly via NTL_STD_CXX11=on or
# NTL_STD_CXX14=on, or implicitly via a request
# for a feature that requires C++11
#
# -pthread if thread-safety is requested via NTL_THREADS=on
# or NTL_THREAD_BOOST=on
#
# -fp-model precise only for the Intel icc compiler (to prevent
# non-value-preserving floating point optimizations)
#
# If you explicitly set the value of CXXAUTOFLAGS when invoking the
# configuration script, then it will not change that value.
NOCONTRACT=
# Like the CXXAUTOFLAGS variable, this is set automagically by the
# configuration script, unless you explicitly provide a value.
# It is only used in compiling the source file that implements
# the quad_float class. For that file only, NTL requires not only
# that the compiler does not perform any non-value-preserving
# floating point optimizations, but that is also does not perform
# any "contractions" (i.e., emit FMA (fused multiply add) instructions.
# Currently, it may be set as follows:
#
# -ffp-contract=off for gcc (and possibly clang) compilers
#
# -mno-fused-madd for old gcc compilers that don't support
# -ffp-contract=off
# -DFP_CONTRACT_OFF for the Intel icc compiler
#
# The configuation script will make every attempt to ensure that this really
# does disable contractions. If it doesn't work, a fallback strategy is used
# that should still work (but with a performance penalty).
MAKE_PROG=make
# To set CXXAUTOFLAGS and NOCONTRACT, the configure script actually needs to
# run make. If you wish to use a non-standard make program for this purpose,
# set this variable to point to that program.
########### Here is a complete list of the remaining variables,
########### with their default values. These variables are pretty
########### esoteric, and you will probably never change their
########### default values.
AR=ar
ARFLAGS=ruv
RANLIB=ranlib
LDFLAGS=
LDLIBS=-lm
CPPFLAGS=
LIBTOOL=undefined
LIBTOOL_LINK_FLAGS=
LIBDIR=$(PREFIX)/lib
INCLUDEDIR=$(PREFIX)/include
DOCDIR=$(PREFIX)/share/doc
NTL_TLS_HACK=on
NTL_DISABLE_MOVE_ASSIGN=on
NTL_DISABLE_MOVE=off
NTL_LEGACY_NO_NAMESPACE=off
NTL_LEGACY_INPUT_ERROR=off
NTL_LEGACY_SP_MULMOD=off
NTL_UNSIGNED_LONG_LONG_TYPE=undefined
NTL_CLEAN_INT=off
NTL_CLEAN_PTR=on
NTL_RANGE_CHECK=off
NTL_X86_FIX=off
NTL_NO_X86_FIX=off
NTL_NO_INIT_TRANS=on
NTL_DISABLE_LONGDOUBLE=off
NTL_DISABLE_LONGLONG=off
NTL_DISABLE_LL_ASM=off
NTL_MAXIMIZE_SP_NBITS=off
NTL_SPMM_ULL=off
NTL_FFT_BIGTAB=off
NTL_FFT_LAZYMUL=off
NTL_TBL_REM=off
NTL_AVOID_BRANCHING=off
NTL_GF2X_NOINLINE=off
NTL_GF2X_ALTCODE=off
NTL_GF2X_ALTCODE1=off
GMP_INCDIR=$(GMP_PREFIX)/include
GMP_LIBDIR=$(GMP_PREFIX)/lib
GF2X_INCDIR=$(GF2X_PREFIX)/include
GF2X_LIBDIR=$(GF2X_PREFIX)/lib
########### Here is a more detailed description of these variables.
########### Further compilation variables:
AR=ar
# command to make a library
ARFLAGS=ruv
# arguments for AR
RANLIB=ranlib
# set to echo if you want to disable it completely
LDFLAGS=
# arguments for linker for C++ programs
LDLIBS=-lm
# libraries for linking C++ programs
CPPFLAGS=
# arguments for the C preprocessor
LIBTOOL=undefined
# the libtool command -- only needed if SHARED=on
# if left undefined, a fresh libtool script will be built
LIBTOOL_LINK_FLAGS=
# flags to add to command line when building a shared library
# mainly used to pass the argument "-no-undefined" on cygwin
########### Details of the compilation process (when SHARED=off)
# When a C++ file foo.c is compiled:
$(CXX) -I../include $(CPPFLAGS) $(CXXFLAGS) -c foo.c
# When a C++ file foo.c is compiled and linked:
$(CXX) -I../include $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) \
-o foo foo.c $(LDLIBS)
# When the library ntl.a is built
$(AR) $(ARFLAGS) ntl.a [ object files ]...
$(RANLIB) ntl.a
# If the ranlib command does not exist, everything will still function OK.
########### Further installation variables:
LIBDIR=$(PREFIX)/lib
INCLUDEDIR=$(PREFIX)/include
DOCDIR=$(PREFIX)/share/doc
# Where to install NTL.
# Execution of 'make install' copies header files into $(INCLUDEDIR)/NTL,
# copies the library itself to $(LIBDIR)/libntl.a, and copies the
# documentation files into $(DOCDIR)/NTL.
########## TLS hack
NTL_TLS_HACK=on
# when building NTL with NTL_THREADS=on, if the compiler is gcc-compatible, a
# "TLS hack" may be used to workaround the fact that many compilers do not
# (correctly) implement C++11's thread_local feature. The workaround is to use
# gcc's more limited __thread feature, and to emulate thread_local semantics
# using pthread routines.
#
# The configuration script will first check if threads and TLS work with the
# hack, and if not, will try setting NTL_TLS_HACK=off. You can also turn off
# the hack by setting NTL_TLS_HACK=off.
########## Disabling move semantics
NTL_DISABLE_MOVE_ASSIGN=on
NTL_DISABLE_MOVE=off
# The first flag will disable the generation of move assignment operators for
# Vec<T>, Mat<T>, vec_GF2, and GF2X. By implication, move assignment operators
# will be disabled as well for many other types (like polynomials). The second
# flag will disable move constuctors and move assignment operators for all NTL
# types.
# These flags are only relevant in C++11 mode. They are meant to deal with
# backward compatibility issues for legacy NTL clients that may not deal well
# with automatically generated move operations. It turns out that move
# semantics can quietly break programs. See
# http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3153.htm
# However, the default now is just to disable move assignment operators for
# those classes where it seems likeliest to cause a problem. This default will
# likely be changed in the future, so that no move operations are disabled.
########## Legacy switches
NTL_LEGACY_NO_NAMESPACE=off
# put NTL components in the global namespace
NTL_LEGACY_INPUT_ERROR=off
# abort on input errors, instead of just setting the
# "fail bit" of the istream object
NTL_LEGACY_SP_MULMOD=off
# use pre-9.0 interfaces for single-precision MulMod routines.
# See discussion in ZZ.txt for details.
########### Basic Configuration Options:
NTL_UNSIGNED_LONG_LONG_TYPE=undefined
# Name of double-word unsigned integer type.
# This is a non-standard type, and is called 'long long' by many
# compilers. MS C++ calls it 'unsigned __int64'.
#
# Note that the new C99 standard defines the type 'unsigned long long'
# to be at least 64-bits wide. On 32-bit machines, this is just right.
# Although not officially part of the C++ standard (which predates C99),
# it is widely supported by C++ compilers, and is likely to be added
# to the C++ standard.
#
# Unfortunately, 64-bit machines usually define 'unsigned long long'
# to also be 64-bits wide, which is kind of useless.
# However, GCC provides a type __uint128_t which does the job.
#
# If left undefined, NTL will use some "ifdef magic" to find
# the type most suitable for your machine (based on compiler and
# word size).
NTL_CLEAN_INT=off
# Setting this to 'on' disables the use of some non-standard
# integer arithmetic which would yield slightly better performance.
NTL_CLEAN_PTR=on
# Setting this to 'on' disables the use of some non-standard
# pointer arithmetic which would yield slightly better performance.
# The 'off' setting really just invites undefined behavior without
# any measurable performance benefit.
NTL_RANGE_CHECK=off
# Setting this to 'on' will generate vector subscript range-check code.
# Useful for debugging, but it slows things down of course.
NTL_X86_FIX=off
# Set to 'on' to force the "x86 floating point fix",
# overriding the default behavior.
# By default, NTL will apply the "fix" if it looks like it is
# necessary, and if it knows how to fix it.
# The problem addressed here is that x86 processors sometimes
# run in a mode where FP registers have more precision than doubles.
# This will cause code in quad_float.c some trouble.
# NTL can normally automatically detect the problem, and fix it,
# so you shouldn't need to worry about this or the next flag.
NTL_NO_X86_FIX=off
# Set to 'on' to forces no "x86 floating point fix",
# overriding the default behavior.
NTL_NO_INIT_TRANS=on
# When 'off', NTL uses a special code sequence to avoid
# copying large objects in return statements. However, if your
# compiler optimizes away the return of a *named* local object,
# this is not necessary, and setting this flag to 'on' will result
# in *slightly* more compact and efficient code. The C++
# standard explicitly allows compilers to perform this optimization,
# and with time, more compilers actually do this.
# Traditionally, however, most will only avoid copying *temporary*
# objects in return statements, and NTL's default code sequence
# exploits this fact.
NTL_DISABLE_LONGDOUBLE=off
# Explicitly disables use of long double arithmetic
NTL_DISABLE_LONGLONG=off
# Explicitly disables use of long long arithmetic
NTL_DISABLE_LL_ASM=off
# Explicitly disables use of inline asm as replacement for
# long long arithmetic
NTL_MAXIMIZE_SP_NBITS=on
# Allows for 62-bit single-precision moduli on 64-bit platforms.
# By default, such moduli are restricted to 60 bits, which
# usually gives *slightly* better performance across a range of
# of parameters.
########## Performance Options:
NTL_SPMM_ULL=off
# Implement the MulModPrecon code using "unsigned long long"
# (or specify NTL_UNSIGNED_LONG_LONG_TYPE to override the default).
NTL_FFT_BIGTAB=off
# Precomputed tables are used to store all the roots of unity
# used in FFT computations.
NTL_FFT_LAZYMUL=off
# When set, a "lazy multiplication" strategy due to David Harvey:
# see his paper "FASTER ARITHMETIC FOR NUMBER-THEORETIC TRANSFORMS".
NTL_TBL_REM=off
# With this flag, some divisions are avoided in the
# ZZ_pX multiplication routines.
NTL_AVOID_BRANCHING=off
# With this option, branches are replaced at several
# key points with equivalent code using shifts and masks.
# Recommended for use with RISC architectures, especially
# ones with deep pipelines and high branch penalities.
# This flag is becoming less helpful as newer machines
# have much smaller branch penalties, but still may be worth a try.
NTL_GF2X_NOINLINE=off
# By default, the low-level GF2X multiplication routine in inlined.
# This can potentially lead to some trouble on some platforms,
# and you can override the default by setting this flag.
NTL_GF2X_ALTCODE=off
# With this option, the default strategy for implmenting low-level
# GF2X multiplication is replaced with an alternative strategy.
# This alternative strategy seems to work better on RISC machines
# with deep pipelines and high branch penalties (like a powerpc),
# but does no better (or even worse) on x86s.
NTL_GF2X_ALTCODE1=off
# Yet another alternative implementation for GF2X multiplication.
########## More GMP Options:
GMP_INCDIR=$(GMP_PREFIX)/include
# directory containing gmp.h
GMP_LIBDIR=$(GMP_PREFIX)/lib
# directory containing libgmp.a
####### More gf2x options:
GF2X_INCDIR=$(GF2X_PREFIX)/include
# directory containing gf2x.h
GF2X_LIBDIR=$(GF2X_PREFIX)/lib
# directory containing libgf2x.a