config.txt

NTL is a high-performance, portable C++ library providing data structures and algorithms for manipul

# When a C file foo.c is compiled and linked:
   $(CC) -I../include $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o foo foo.c $(LDLIBS)

# 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_CXX) \ 
      -o foo foo.c $(LDLIBS_CXX)

# 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)/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.


########## Partial ISO modes

NTL_PSTD_NNS=off 

# NTL namespace --  wraps NTL in a namespace



NTL_PSTD_NHF=off
 
# new header files -- use <cstdlib>, etc., instead of <stdlib.h>, etc.  



NTL_PSTD_NTN=off 

# nothrow new -- use the nothrow version of new.  

# Any combination of these PSTD swtiches may be set -- setting them all
# is equvalent to setting NTL_STD_CXX.  Make sure you also unset NTL_STD_CXX;
# otherwise, they have no effect.


########### Basic Configuration Options:

NTL_LONG_LONG_TYPE=undefined

# Name of double-word signed integer type.
# This is a non-standard type, and is called 'long long' by many
# compilers.  MS C++ calls it '__int64'.
#
# Note that the new C99 standard defines the type '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 'long long'
# to also be 64-bits wide, which is kind of useless.
# However, GCC provides a type __int128_t which does the job.
#
# If left undefined, NTL will use somee "ifdef magic" to find
# the type most suitable for your machine (based on compiler and
# word size).

NTL_UNSIGNED_LONG_LONG_TYPE=undefined

# Name of double-word unsigned integer type.
#
# If left undefined, NTL will use somee "ifdef magic" to find
# the type most suitable for your machine (based on compiler and
# word size).





NTL_CXX_ONLY=off

# It is possible to compile everything using C++ only.
# If you want to do this, CC and CXX should both be C++ compilers.
# You may also want to set NTL_CXX_ONLY=on, which eliminates some
# "C" linkage that is no longer necessary.
# However, it should still work without it.
# 
# This flag can be set independently of NTL_STD_CXX.
# All functions that may have "C" linkage are never wrapped in
# namespace NTL;  instead, their names always start with "_ntl_",
# and as such, they should not conflict with other global names.



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=off

# Setting this to 'on' disables the use of some non-standard
# pointer arithmetic which would yield slightly better performance.


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=off

# 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.



########## Performance Options:

WIZARD=on

# Set to 'off' if you want to bypass the wizard; otherwise, set to 'on'.
# The wizard is a script that runs when NTL is built that sets the following
# flags to 'optimize' performance on the current platform.



NTL_LONG_LONG=off

# For platforms that support it, this flag can be set to cause
# the long-integer multiplication code to use the type "long long",
# which on some platforms yields a significant performance gain,
# but on others, it can yield no improvement and can even
# slow things down.
# The variable NTL_LONG_LONG_TYPE can be defined to use a type name
# other than "long long".
# If you set NTL_LONG_LONG, you might also want to set
# the flag NTL_TBL_REM.



NTL_AVOID_FLOAT=off

# On machines with slow floating point or---more comminly---slow int/float
# conversions, this flag can lead to faster long-integer multiplication code.
# If you set NTL_AVOID_FLOAT, you should probably also
# set NTL_TBL_REM.
# Note that at most one of NTL_LONG_LONG and NTL_AVOID_FLOAT may be set.


NTL_SPMM_UL=off

# On machines with slow floating point or---more comminly---slow int/float
# conversions, this flag can lead to faster single-precision multiplication
# with preconditioning (see MulModPrecon in the ZZ module).
# This sounds esoteric, but it is actually important.


NTL_SPMM_ULL=off

# Similar to NTL_SPMM_UL, but relies on double-word unsigned multiplication.
# This is (usually) done using the type 'unsigned long long',
# but you can set the variable NTL_UNSIGNED_LONG_LONG_TYPE to
# override the default.


NTL_SPMM_ASM=off

# Similar to NTL_SPMM_ULL, but relies on double-word unsigned multiplication
# using assembly code.  Only supported on select machines 
# and only under GCC.




NTL_TBL_REM=off

# With this flag, some divisions are avoided in the
# ZZ_pX multiplication routines.  If you use the NTL_AVOID_FLOAT
# or NTL_LONG_LONG flags, then you should probably use this one too.




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:


NTL_GMP_HACK=off

# Set to 'on' if you want to use GMP, the GNU Multi-Precision package,
# as a supplemental long integer package.
# This will typically yield significantly faster long integer arithmetic 
# compared  to the traditional long integer package, while still maintaining
# complete backward compataibility with code that uses the traditional
# long integer package.  However, this flag is mainly for
# enabling backward compatibility, and you are much better off
# using the NTL_GMP_LIP flag.  

# If you set this flag, you may have to set GMP_PREFIX as well. 




GMP_INCDIR=undefined

# Set to -I<directory containing gmp.h> if using GMP and GMP
# is not installed in a standard system directory.



GMP_LIBDIR=undefined
# Set to -L<directory containing libgmp.a> if using GMP and GMP
# is not installed in a standard system directory.

# You do not need to define GMP_INCDIR or GMP_LIBDIR, if either
#   - you are not compiling NTL with GMP,
#   - you are compiling NTL with GMP, and GMP has been installed in
#     a standard system ocataion (e.g., /usr/local), or
#   - you are compiling NTL with GMP, GMP has been installed in
#     <gmp_prefix>, and you set GMP_PREFIX=<gmp_prefix>.