Permalink
Cannot retrieve contributors at this time
| define([libint_mmm_version],[2.7.0]) | |
| define([libint_buildid],[beta.6]) | |
| define([libint_so_version],[2:3:0]) | |
| dnl --------- Begin --------- | |
| dnl Process this file with autoconf to produce a configure script. | |
| define([AC_CACHE_LOAD], )dnl for debugging configure.in | |
| define([AC_CACHE_SAVE], )dnl for debugging configure.in | |
| AC_PREREQ([2.68]) | |
| AC_INIT([Libint2],[libint_mmm_version],[libint@valeyev.net],[libint2]) | |
| AC_CONFIG_SRCDIR(src/bin/libint/rr.h) | |
| AC_CONFIG_HEADERS(include/libint2/config.h) | |
| AC_CONFIG_AUX_DIR(bin) | |
| AC_CONFIG_MACRO_DIR([lib/autoconf]) | |
| dnl --- Compiling C++ only --- | |
| AC_LANG(C++) | |
| AC_CANONICAL_TARGET | |
| AC_DEFINE_UNQUOTED(LIBINT_HOST_ARCH, "$host") | |
| AC_DEFINE_UNQUOTED(LIBINT_TARGET_ARCH, "$target") | |
| define([default_prefix_dash],ifelse(libint_buildid, ,[],[-])) | |
| define([default_prefix],"/usr/local") | |
| LIBINT_MMM_VERSION=libint_mmm_version | |
| LIBINT_BUILDID=libint_buildid | |
| AC_SUBST(LIBINT_MMM_VERSION) | |
| AC_SUBST(LIBINT_BUILDID) | |
| changequote(<<, >>)dnl | |
| LIBINT_MAJOR_VERSION=`echo $LIBINT_MMM_VERSION|sed 's/\([0-9]*\)\.[0-9]*\.[0-9]*/\1/'` | |
| LIBINT_MINOR_VERSION=`echo $LIBINT_MMM_VERSION|sed 's/[0-9]*\.\([0-9]*\)\.[0-9]*/\1/'` | |
| LIBINT_MICRO_VERSION=`echo $LIBINT_MMM_VERSION|sed 's/[0-9]*\.[0-9]*\.\([0-9]*\)/\1/'` | |
| changequote([, ])dnl | |
| AC_DEFINE_UNQUOTED(LIBINT_MAJOR_VERSION,$LIBINT_MAJOR_VERSION) | |
| AC_DEFINE_UNQUOTED(LIBINT_MINOR_VERSION,$LIBINT_MINOR_VERSION) | |
| AC_DEFINE_UNQUOTED(LIBINT_MICRO_VERSION,$LIBINT_MICRO_VERSION) | |
| AC_SUBST(LIBINT_MAJOR_VERSION) | |
| AC_SUBST(LIBINT_MINOR_VERSION) | |
| AC_SUBST(LIBINT_MICRO_VERSION) | |
| LIBINT_SO_VERSION=libint_so_version | |
| AC_SUBST(LIBINT_SO_VERSION) | |
| dnl --------- Features --------- | |
| AC_ARG_WITH(api-prefix, | |
| AS_HELP_STRING([--with-api-prefix],[Prepend this string to every name in the library API (except for the types).]), | |
| [ | |
| AC_DEFINE_UNQUOTED(LIBINT_API_PREFIX,"$withval") | |
| echo Using API prefix: $withval | |
| ]) | |
| LIBINT_CGSHELL_ORDERING_STANDARD=1 | |
| LIBINT_CGSHELL_ORDERING_INTV3=2 | |
| LIBINT_CGSHELL_ORDERING_GAMESS=3 | |
| LIBINT_CGSHELL_ORDERING_ORCA=4 | |
| LIBINT_CGSHELL_ORDERING_BAGEL=5 | |
| libint_cgshell_ordering=standard | |
| AC_ARG_WITH(cartgauss-ordering, | |
| [ --with-cartgauss-ordering | |
| Use one of the following known orderings for shells of cartesian Gaussians: | |
| standard -- standard ordering (xxx, xxy, xxz, xyy, xyz, xzz, yyy, ...) | |
| intv3 -- intv3 ordering (yyy, yyz, yzz, zzz, xyy, xyz, xzz, xxy, xxz, xxx) | |
| gamess -- GAMESS ordering (xxx, yyy, zzz, xxy, xxz, yyx, yyz, zzx, zzy, xyz) | |
| orca -- ORCA ordering (hydrid between GAMESS and standard) | |
| bagel -- axis-permuted version of intv3 (xxx, xxy, xyy, yyy, xxz, xyz, yyz, xzz, yzz, zzz) | |
| The default is standard.], | |
| [ | |
| libint_cgshell_ordering=$withval | |
| ]) | |
| AC_MSG_RESULT([Using $libint_cgshell_ordering ordering of cartesian Gaussians]) | |
| case $libint_cgshell_ordering in | |
| standard) | |
| libint_cgshell_ordering=$LIBINT_CGSHELL_ORDERING_STANDARD | |
| ;; | |
| intv3) | |
| libint_cgshell_ordering=$LIBINT_CGSHELL_ORDERING_INTV3 | |
| ;; | |
| gamess) | |
| libint_cgshell_ordering=$LIBINT_CGSHELL_ORDERING_GAMESS | |
| ;; | |
| orca) | |
| libint_cgshell_ordering=$LIBINT_CGSHELL_ORDERING_ORCA | |
| ;; | |
| bagel) | |
| libint_cgshell_ordering=$LIBINT_CGSHELL_ORDERING_BAGEL | |
| ;; | |
| *) | |
| AC_MSG_ERROR([Invalid value for --with-cartgauss-ordering ($withval)]) | |
| ;; | |
| esac | |
| AC_DEFINE_UNQUOTED(LIBINT_CGSHELL_ORDERING,$libint_cgshell_ordering) | |
| AC_DEFINE_UNQUOTED(LIBINT_CGSHELL_ORDERING_STANDARD,$LIBINT_CGSHELL_ORDERING_STANDARD) | |
| AC_DEFINE_UNQUOTED(LIBINT_CGSHELL_ORDERING_INTV3,$LIBINT_CGSHELL_ORDERING_INTV3) | |
| AC_DEFINE_UNQUOTED(LIBINT_CGSHELL_ORDERING_GAMESS,$LIBINT_CGSHELL_ORDERING_GAMESS) | |
| AC_DEFINE_UNQUOTED(LIBINT_CGSHELL_ORDERING_ORCA,$LIBINT_CGSHELL_ORDERING_ORCA) | |
| AC_DEFINE_UNQUOTED(LIBINT_CGSHELL_ORDERING_BAGEL,$LIBINT_CGSHELL_ORDERING_BAGEL) | |
| LIBINT_SHGSHELL_ORDERING_STANDARD=1 | |
| LIBINT_SHGSHELL_ORDERING_GAUSSIAN=2 | |
| libint_shgshell_ordering=standard | |
| AC_ARG_WITH(shgauss-ordering, | |
| [ --with-shgauss-ordering | |
| Use one of the following known orderings for shells of solid harmonic Gaussians: | |
| standard -- standard ordering (-l, -l+1 ... l) | |
| gaussian -- the Gaussian ordering (0, 1, -1, 2, -2, ... l, -l) | |
| The default is standard.], | |
| [ | |
| libint_shgshell_ordering=$withval | |
| ]) | |
| AC_MSG_RESULT([Using $libint_shgshell_ordering ordering of solid harmonic Gaussians]) | |
| case $libint_shgshell_ordering in | |
| standard) | |
| libint_shgshell_ordering=$LIBINT_SHGSHELL_ORDERING_STANDARD | |
| ;; | |
| gaussian) | |
| libint_shgshell_ordering=$LIBINT_SHGSHELL_ORDERING_GAUSSIAN | |
| ;; | |
| *) | |
| AC_MSG_ERROR([Invalid value for --with-solidharmgauss-ordering ($withval)]) | |
| ;; | |
| esac | |
| AC_DEFINE_UNQUOTED(LIBINT_SHGSHELL_ORDERING,$libint_shgshell_ordering) | |
| AC_DEFINE_UNQUOTED(LIBINT_SHGSHELL_ORDERING_STANDARD,$LIBINT_SHGSHELL_ORDERING_STANDARD) | |
| AC_DEFINE_UNQUOTED(LIBINT_SHGSHELL_ORDERING_GAUSSIAN,$LIBINT_SHGSHELL_ORDERING_GAUSSIAN) | |
| LIBINT_SHELL_SET_STANDARD=1 AC_SUBST(LIBINT_SHELL_SET_STANDARD) | |
| LIBINT_SHELL_SET_ORCA=2 AC_SUBST(LIBINT_SHELL_SET_ORCA) | |
| libint_shell_set=standard | |
| AC_ARG_WITH(shell-set, | |
| [ --with-shell-set The library will support computation of shell sets sets subject to these restrictions: | |
| standard -- standard ordering: | |
| for (ab|cd): | |
| l(a) >= l(b), | |
| l(c) >= l(d), | |
| l(a)+l(b) <= l(c)+l(d) | |
| for (b|cd): | |
| l(c) >= l(d) | |
| orca -- ORCA ordering: | |
| for (ab|cd): | |
| l(a) <= l(b), | |
| l(c) <= l(d), | |
| l(a) < l(c) || (l(a) == l(c) && l(b) < l(d)) | |
| for (b|cd): | |
| l(c) <= l(d) | |
| The default is standard.], | |
| [ | |
| libint_shell_set=$withval | |
| ]) | |
| AC_MSG_RESULT([Will generate $libint_shell_set shell quartet sets]) | |
| case $libint_shell_set in | |
| standard) | |
| libint_shell_set=$LIBINT_SHELL_SET_STANDARD | |
| ;; | |
| orca) | |
| libint_shell_set=$LIBINT_SHELL_SET_ORCA | |
| ;; | |
| *) | |
| AC_MSG_ERROR([Invalid value for --with-shell-set ($withval)]) | |
| ;; | |
| esac | |
| LIBINT_SHELL_SET=$libint_shell_set AC_SUBST(LIBINT_SHELL_SET) | |
| AC_DEFINE_UNQUOTED(LIBINT_SHELL_SET,$libint_shell_set) | |
| AC_DEFINE_UNQUOTED(LIBINT_SHELL_SET_STANDARD,$LIBINT_SHELL_SET_STANDARD) | |
| AC_DEFINE_UNQUOTED(LIBINT_SHELL_SET_ORCA,$LIBINT_SHELL_SET_ORCA) | |
| AC_ARG_ENABLE(debug, | |
| AS_HELP_STRING([--enable-debug],[Compile with debugging options]), | |
| [ | |
| case $enableval in | |
| yes) | |
| DEBUG=yes | |
| ;; | |
| no) | |
| DEBUG=no | |
| ;; | |
| opt) | |
| DEBUG=opt | |
| ;; | |
| *) | |
| AC_MSG_ERROR([Invalid value for --enable-debug ($enableval)]) | |
| ;; | |
| esac | |
| ],[ | |
| DEBUG=no | |
| ] | |
| ) | |
| # can be used in the future to exclude source directories | |
| EXCLUDED_DIRS= | |
| AC_ARG_ENABLE(1body, | |
| AS_HELP_STRING([--enable-1body=N],[Compile with support for up to N-th derivatives of 1-body integrals]), | |
| [ | |
| case $enableval in | |
| yes) | |
| INCLUDE_ONEBODY=0 | |
| ;; | |
| no) | |
| INCLUDE_ONEBODY=no | |
| ;; | |
| *) | |
| if test $enableval -lt 0; then | |
| AC_MSG_ERROR([Invalid value for --enable-1body ($enableval)]) | |
| fi | |
| INCLUDE_ONEBODY=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| INCLUDE_ONEBODY=0 | |
| ] | |
| ) | |
| DISABLE_ONEBODY_PROPERTY_DERIVS=1 | |
| AC_ARG_ENABLE(1body-property-derivs, | |
| AS_HELP_STRING([--enable-1body-property-derivs],[Enable geometric derivatives of 1-body property integrals (all but overlap, kinetic, elecpot). These derivatives are disabled by default to save compile time.]), | |
| [ | |
| case $enableval in | |
| yes) | |
| DISABLE_ONEBODY_PROPERTY_DERIVS=0 | |
| ;; | |
| esac | |
| ]) | |
| if test X$DISABLE_ONEBODY_PROPERTY_DERIVS != 0; then | |
| AC_DEFINE(DISABLE_ONEBODY_PROPERTY_DERIVS) | |
| fi | |
| AC_ARG_ENABLE(eri, | |
| AS_HELP_STRING([--enable-eri=N],[Compile with support for up to N-th derivatives of electron repulsion integrals]), | |
| [ | |
| case $enableval in | |
| yes) | |
| INCLUDE_ERI=0 | |
| ;; | |
| no) | |
| INCLUDE_ERI=no | |
| ;; | |
| *) | |
| if test $enableval -lt 0; then | |
| AC_MSG_ERROR([Invalid value for --enable-eri ($enableval)]) | |
| fi | |
| INCLUDE_ERI=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| INCLUDE_ERI=0 | |
| ] | |
| ) | |
| AC_ARG_ENABLE(eri3, | |
| AS_HELP_STRING([--enable-eri3=N],[Compile with support for up to N-th derivatives of 3-center electron repulsion integrals]), | |
| [ | |
| case $enableval in | |
| yes) | |
| INCLUDE_ERI3=0 | |
| ;; | |
| no) | |
| INCLUDE_ERI3=no | |
| ;; | |
| *) | |
| if test $enableval -lt 0; then | |
| AC_MSG_ERROR([Invalid value for --enable-eri3 ($enableval)]) | |
| fi | |
| INCLUDE_ERI3=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| INCLUDE_ERI3=no | |
| ] | |
| ) | |
| AC_ARG_ENABLE(eri2, | |
| AS_HELP_STRING([--enable-eri2=N],[Compile with support for up to N-th derivatives of 2-center electron repulsion integrals]), | |
| [ | |
| case $enableval in | |
| yes) | |
| INCLUDE_ERI2=0 | |
| ;; | |
| no) | |
| INCLUDE_ERI2=no | |
| ;; | |
| *) | |
| if test $enableval -lt 0; then | |
| AC_MSG_ERROR([Invalid value for --enable-eri2 ($enableval)]) | |
| fi | |
| INCLUDE_ERI2=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| INCLUDE_ERI2=no | |
| ] | |
| ) | |
| AC_ARG_ENABLE(g12, | |
| AS_HELP_STRING([--enable-g12=N],[Compile with support for N-th derivatives of MP2-F12 energies with Gaussian factors]), | |
| [ | |
| case $enableval in | |
| yes) | |
| INCLUDE_G12=0 | |
| ;; | |
| no) | |
| INCLUDE_G12=no | |
| ;; | |
| *) | |
| if test $enableval -lt 0; then | |
| AC_MSG_ERROR([Invalid value for --enable-g12 ($enableval)]) | |
| fi | |
| INCLUDE_G12=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| INCLUDE_G12=no | |
| ] | |
| ) | |
| AC_ARG_ENABLE(g12dkh, | |
| AS_HELP_STRING([--enable-g12dkh=N],[Compile with support for N-th derivatives of DKH-MP2-F12 energies with Gaussian factors]), | |
| [ | |
| case $enableval in | |
| yes) | |
| INCLUDE_G12DKH=0 | |
| ;; | |
| no) | |
| INCLUDE_G12DKH=no | |
| ;; | |
| *) | |
| if test $enableval -lt 0; then | |
| AC_MSG_ERROR([Invalid value for --enable-g12dkh ($enableval)]) | |
| fi | |
| INCLUDE_G12DKH=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| INCLUDE_G12DKH=no | |
| ] | |
| ) | |
| LIBINT_MAX_AM=4 | |
| AC_ARG_WITH(max-am, | |
| AS_HELP_STRING([--with-max-am=N],[Support Gaussians of angular momentum up to N. Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| LIBINT_MAX_AM_LIST="$withval" | |
| AC_SUBST(LIBINT_MAX_AM_LIST) | |
| AC_DEFINE_UNQUOTED(LIBINT_MAX_AM_LIST, "$LIBINT_MAX_AM_LIST") | |
| LIBINT_MAX_AM=`echo $LIBINT_MAX_AM_LIST | tr , "\n" | sort -n | tail -n1` | |
| ;; | |
| *) | |
| if test $withval -le 0; then | |
| AC_MSG_ERROR([Invalid value for --with-max-am ($withval)]) | |
| else | |
| LIBINT_MAX_AM=$withval | |
| fi | |
| if test $LIBINT_MAX_AM -ge 8; then | |
| AC_MSG_ERROR([Value for --with-max-am too high ($withval). Are you sure you know what you are doing?]) | |
| fi | |
| ;; | |
| esac | |
| ] | |
| ) | |
| AC_DEFINE_UNQUOTED(LIBINT_MAX_AM,$LIBINT_MAX_AM) | |
| LIBINT_OPT_AM=$((($LIBINT_MAX_AM/2)+1)) | |
| AC_ARG_WITH(opt-am, | |
| AS_HELP_STRING([--with-opt-am=N],[Optimize maximally for up to angular momentum N (N <= max-am).]), | |
| [ | |
| case $withval in | |
| *,*) | |
| LIBINT_OPT_AM_LIST="$withval" | |
| AC_SUBST(LIBINT_OPT_AM_LIST) | |
| AC_DEFINE_UNQUOTED(LIBINT_OPT_AM_LIST, "$LIBINT_OPT_AM_LIST") | |
| LIBINT_OPT_AM=`echo $LIBINT_OPT_AM_LIST | tr , "\n" | sort -n | tail -n1` | |
| ;; | |
| *) | |
| if test $withval -le $LIBINT_MAX_AM; then | |
| LIBINT_OPT_AM=$withval | |
| fi | |
| ;; | |
| esac | |
| ] | |
| ) | |
| AC_DEFINE_UNQUOTED(LIBINT_OPT_AM,$LIBINT_OPT_AM) | |
| ERI_MAX_AM=$LIBINT_MAX_AM | |
| AC_ARG_WITH(eri-max-am, | |
| AS_HELP_STRING([--with-eri-max-am=N],[Support ERIs for Gaussians of angular momentum up to N. Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ERI_MAX_AM_LIST="$withval" | |
| AC_SUBST(ERI_MAX_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ERI_MAX_AM_LIST, "$ERI_MAX_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le 0; then | |
| AC_MSG_ERROR([Invalid value for --with-eri-max-am ($withval)]) | |
| else | |
| ERI_MAX_AM=$withval | |
| fi | |
| if test $ERI_MAX_AM -ge 8; then | |
| AC_MSG_ERROR([Value for --with-eri-max-am too high ($withval). Are you sure you know what you are doing?]) | |
| fi | |
| AC_SUBST(ERI_MAX_AM) | |
| AC_DEFINE_UNQUOTED(ERI_MAX_AM,$ERI_MAX_AM) | |
| ;; | |
| esac | |
| ] | |
| ) | |
| ERI_OPT_AM=$LIBINT_OPT_AM | |
| AC_ARG_WITH(eri-opt-am, | |
| AS_HELP_STRING([--with-eri-opt-am=N],[Optimize ERIs maximally for up to angular momentum N (N <= max-am). Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ERI_OPT_AM_LIST="$withval" | |
| AC_SUBST(ERI_OPT_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ERI_OPT_AM_LIST, "$ERI_OPT_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le $ERI_MAX_AM; then | |
| ERI_OPT_AM=$withval | |
| AC_SUBST(ERI_OPT_AM) | |
| AC_DEFINE_UNQUOTED(ERI_OPT_AM,$ERI_OPT_AM) | |
| fi | |
| ;; | |
| esac | |
| ] | |
| ) | |
| if test X$INCLUDE_ERI != Xno; then | |
| AC_DEFINE_UNQUOTED(INCLUDE_ERI,$INCLUDE_ERI) | |
| LIBINT_SUPPORTS_ERI=yes | |
| AC_SUBST(LIBINT_SUPPORTS_ERI) | |
| LIBINT_ERI_DERIV=$INCLUDE_ERI | |
| AC_SUBST(LIBINT_ERI_DERIV) | |
| fi | |
| ONEBODY_MAX_AM=$LIBINT_MAX_AM | |
| AC_ARG_WITH(1body-max-am, | |
| AS_HELP_STRING([--with-1body-max-am=N],[Support 1-e ints for Gaussians of angular momentum up to N. Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ONEBODY_MAX_AM_LIST="$withval" | |
| AC_SUBST(ONEBODY_MAX_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ONEBODY_MAX_AM_LIST, "$ONEBODY_MAX_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le 0; then | |
| AC_MSG_ERROR([Invalid value for --with-1body-max-am ($withval)]) | |
| else | |
| ONEBODY_MAX_AM=$withval | |
| fi | |
| if test $ONEBODY_MAX_AM -ge 8; then | |
| AC_MSG_ERROR([Value for --with-1body-max-am too high ($withval). Are you sure you know what you are doing?]) | |
| fi | |
| AC_SUBST(ONEBODY_MAX_AM) | |
| AC_DEFINE_UNQUOTED(ONEBODY_MAX_AM,$ONEBODY_MAX_AM) | |
| ;; | |
| esac | |
| ] | |
| ) | |
| ONEBODY_OPT_AM=$LIBINT_OPT_AM | |
| AC_ARG_WITH(1body-opt-am, | |
| AS_HELP_STRING([--with-1body-opt-am=N],[Optimize 1-e ints maximally for up to angular momentum N (N <= max-am). Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ONEBODY_OPT_AM_LIST="$withval" | |
| AC_SUBST(ONEBODY_OPT_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ONEBODY_OPT_AM_LIST, "$ONEBODY_OPT_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le $ONEBODY_MAX_AM; then | |
| ONEBODY_OPT_AM=$withval | |
| AC_SUBST(ONEBODY_OPT_AM) | |
| AC_DEFINE_UNQUOTED(ONEBODY_OPT_AM,$ONEBODY_OPT_AM) | |
| fi | |
| ;; | |
| esac | |
| ] | |
| ) | |
| MULTIPOLE_MAX_ORDER=4 | |
| AC_ARG_WITH(multipole-max-order, | |
| AS_HELP_STRING([--with-multipole-max-order=N],[Maximum order of spherical multipole integrals. The default is 4. There is no maximum]), | |
| [ | |
| case $withval in | |
| *) | |
| MULTIPOLE_MAX_ORDER=$withval | |
| ;; | |
| esac | |
| ] | |
| ) | |
| AC_DEFINE_UNQUOTED(MULTIPOLE_MAX_ORDER,$MULTIPOLE_MAX_ORDER) | |
| if test X$INCLUDE_ONEBODY != Xno; then | |
| AC_DEFINE_UNQUOTED(INCLUDE_ONEBODY,$INCLUDE_ONEBODY) | |
| LIBINT_SUPPORTS_ONEBODY=yes | |
| AC_SUBST(LIBINT_SUPPORTS_ONEBODY) | |
| LIBINT_ONEBODY_DERIV=$INCLUDE_ONEBODY | |
| AC_SUBST(LIBINT_ONEBODY_DERIV) | |
| fi | |
| # check max am for 3-center ERIs, if needed | |
| ERI3_MAX_AM=$LIBINT_MAX_AM | |
| AC_ARG_WITH(eri3-max-am, | |
| AS_HELP_STRING([--with-eri3-max-am=N],[Support 3-center ERIs for Gaussians of angular momentum up to N. Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ERI3_MAX_AM_LIST="$withval" | |
| AC_SUBST(ERI3_MAX_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ERI3_MAX_AM_LIST, "$ERI3_MAX_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le 0; then | |
| AC_MSG_ERROR([Invalid value for --with-eri3-max-am ($withval)]) | |
| else | |
| ERI3_MAX_AM=$withval | |
| fi | |
| if test $ERI3_MAX_AM -ge 8; then | |
| AC_MSG_ERROR([Value for --with-eri3-max-am too high ($withval). Are you sure you know what you are doing?]) | |
| fi | |
| AC_SUBST(ERI3_MAX_AM) | |
| AC_DEFINE_UNQUOTED(ERI3_MAX_AM,$ERI3_MAX_AM) | |
| ;; | |
| esac | |
| ] | |
| ) | |
| ERI3_OPT_AM=$LIBINT_OPT_AM | |
| AC_ARG_WITH(eri3-opt-am, | |
| AS_HELP_STRING([--with-eri3-opt-am=N],[Optimize 3-center ERIs maximally for up to angular momentum N (N <= max-am). Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ERI3_OPT_AM_LIST="$withval" | |
| AC_SUBST(ERI3_OPT_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ERI3_OPT_AM_LIST, "$ERI3_OPT_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le $ERI3_MAX_AM; then | |
| ERI3_OPT_AM=$withval | |
| AC_SUBST(ERI3_OPT_AM) | |
| AC_DEFINE_UNQUOTED(ERI3_OPT_AM,$ERI3_OPT_AM) | |
| fi | |
| ;; | |
| esac | |
| ] | |
| ) | |
| AC_ARG_ENABLE(eri3-pure-sh, | |
| AS_HELP_STRING([--enable-eri3-pure-sh],[Assume the "unpaired" center of 3-center electron repulsion integrals will be transformed to pure solid harmonics]), | |
| [ | |
| case $enableval in | |
| yes) | |
| ERI3_PURE_SH=yes | |
| ;; | |
| no) | |
| ERI3_PURE_SH=no | |
| ;; | |
| esac | |
| ],[ | |
| ERI3_PURE_SH=no | |
| ] | |
| ) | |
| if test X$INCLUDE_ERI3 != Xno; then | |
| AC_DEFINE_UNQUOTED(INCLUDE_ERI3,$INCLUDE_ERI3) | |
| if test X$ERI3_PURE_SH != Xno; then | |
| AC_DEFINE(ERI3_PURE_SH) | |
| fi | |
| fi | |
| # check max am for 2-center ERIs, if needed | |
| ERI2_MAX_AM=$LIBINT_MAX_AM | |
| AC_ARG_WITH(eri2-max-am, | |
| AS_HELP_STRING([--with-eri2-max-am=N],[Support 2-center ERIs for Gaussians of angular momentum up to N. Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ERI2_MAX_AM_LIST="$withval" | |
| AC_SUBST(ERI2_MAX_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ERI2_MAX_AM_LIST, "$ERI2_MAX_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le 0; then | |
| AC_MSG_ERROR([Invalid value for --with-eri2-max-am ($withval)]) | |
| else | |
| ERI2_MAX_AM=$withval | |
| fi | |
| if test $ERI2_MAX_AM -ge 8; then | |
| AC_MSG_ERROR([Value for --with-eri2-max-am too high ($withval). Are you sure you know what you are doing?]) | |
| fi | |
| AC_SUBST(ERI2_MAX_AM) | |
| AC_DEFINE_UNQUOTED(ERI2_MAX_AM,$ERI2_MAX_AM) | |
| ;; | |
| esac | |
| ] | |
| ) | |
| ERI2_OPT_AM=$LIBINT_OPT_AM | |
| AC_ARG_WITH(eri2-opt-am, | |
| AS_HELP_STRING([--with-eri2-opt-am=N],[Optimize 2-center ERIs maximally for up to angular momentum N (N <= max-am). Can specify values for each derivative levels as a list N0,N1,N2...]), | |
| [ | |
| case $withval in | |
| *,*) | |
| ERI2_OPT_AM_LIST="$withval" | |
| AC_SUBST(ERI2_OPT_AM_LIST) | |
| AC_DEFINE_UNQUOTED(ERI2_OPT_AM_LIST, "$ERI2_OPT_AM_LIST") | |
| ;; | |
| *) | |
| if test $withval -le $ERI2_MAX_AM; then | |
| ERI2_OPT_AM=$withval | |
| AC_SUBST(ERI2_OPT_AM) | |
| AC_DEFINE_UNQUOTED(ERI2_OPT_AM,$ERI2_OPT_AM) | |
| fi | |
| ;; | |
| esac | |
| ] | |
| ) | |
| AC_ARG_ENABLE(eri2-pure-sh, | |
| AS_HELP_STRING([--enable-eri2-pure-sh],[Assume the 2-center electron repulsion integrals will be transformed to pure solid harmonics]), | |
| [ | |
| case $enableval in | |
| yes) | |
| ERI2_PURE_SH=yes | |
| ;; | |
| no) | |
| ERI2_PURE_SH=no | |
| ;; | |
| esac | |
| ],[ | |
| ERI2_PURE_SH=no | |
| ] | |
| ) | |
| if test X$INCLUDE_ERI2 != Xno; then | |
| AC_DEFINE_UNQUOTED(INCLUDE_ERI2,$INCLUDE_ERI2) | |
| if test X$ERI2_PURE_SH != Xno; then | |
| AC_DEFINE(ERI2_PURE_SH) | |
| fi | |
| fi | |
| # check max am for G12 integrals, if needed | |
| G12_MAX_AM=$LIBINT_MAX_AM | |
| AC_ARG_WITH(g12-max-am, | |
| AS_HELP_STRING([--with-g12-max-am=N],[Support integrals for G12 methods of angular momentum up to N.]), | |
| if test $withval -le 0; then | |
| AC_MSG_ERROR([Invalid value for --with-g12-max-am ($withval)]) | |
| else | |
| G12_MAX_AM=$withval | |
| fi | |
| ) | |
| G12_OPT_AM=$LIBINT_OPT_AM | |
| AC_ARG_WITH(g12-opt-am, | |
| AS_HELP_STRING([--with-g12-opt-am=N],[Optimize G12 integrals for up to angular momentum N (N <= max-am).]), | |
| if test $withval -le $G12_MAX_AM; then | |
| G12_OPT_AM=$withval | |
| fi | |
| ) | |
| AC_ARG_ENABLE(t1g12-support, | |
| AS_HELP_STRING([--disable-t1g12-support],[Libint will not support [Ti,G12] integrals]), | |
| [ | |
| case $enableval in | |
| yes) | |
| SUPPORT_T1G12=1 | |
| ;; | |
| no) | |
| SUPPORT_T1G12=0 | |
| ;; | |
| *) | |
| SUPPORT_T1G12=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| SUPPORT_T1G12=1 | |
| ] | |
| ) | |
| AC_ARG_ENABLE(composite-evaluators, | |
| AS_HELP_STRING([--disable-composite-evaluators],[Libint will not use composite evaluators (i.e. every evaluator wil compute one integral type only)]), | |
| [ | |
| case $enableval in | |
| yes) | |
| LIBINT_USE_COMPOSITE_EVALUATORS=1 | |
| AC_MSG_RESULT([Will generate composite evaluators for multiple integral types]) | |
| ;; | |
| no) | |
| LIBINT_USE_COMPOSITE_EVALUATORS=0 | |
| AC_MSG_RESULT([Will generate separate evaluators for each integral type]) | |
| ;; | |
| *) | |
| LIBINT_USE_COMPOSITE_EVALUATORS=$enableval | |
| ;; | |
| esac | |
| ],[ | |
| LIBINT_USE_COMPOSITE_EVALUATORS=1 | |
| AC_MSG_RESULT([Will generate composite evaluators for multiple integral types]) | |
| ] | |
| ) | |
| AC_DEFINE_UNQUOTED(LIBINT_USE_COMPOSITE_EVALUATORS,$LIBINT_USE_COMPOSITE_EVALUATORS) | |
| if test "X$INCLUDE_G12" != "Xno"; then | |
| AC_DEFINE_UNQUOTED(INCLUDE_G12,$INCLUDE_G12) | |
| AC_SUBST(G12_MAX_AM) | |
| AC_SUBST(G12_OPT_AM) | |
| AC_SUBST(SUPPORT_T1G12) | |
| AC_DEFINE_UNQUOTED(G12_MAX_AM,$G12_MAX_AM) | |
| AC_DEFINE_UNQUOTED(G12_OPT_AM,$G12_OPT_AM) | |
| AC_DEFINE_UNQUOTED(SUPPORT_T1G12,$SUPPORT_T1G12) | |
| fi | |
| # check max am for G12DKH integrals, if needed | |
| G12DKH_MAX_AM=$LIBINT_MAX_AM | |
| AC_ARG_WITH(g12dkh-max-am, | |
| AS_HELP_STRING([--with-g12dkh-max-am=N],[Support integrals for relativistic G12 methods of angular momentum up to N.]), | |
| if test $withval -le 0; then | |
| AC_MSG_ERROR([Invalid value for --with-g12dkh-max-am ($withval)]) | |
| else | |
| G12DKH_MAX_AM=$withval | |
| fi | |
| ) | |
| G12DKH_OPT_AM=$LIBINT_OPT_AM | |
| AC_ARG_WITH(g12dkh-opt-am, | |
| AS_HELP_STRING([--with-g12dkh-opt-am=N],[Optimize G12DKH integrals for up to angular momentum N (N <= max-am).]), | |
| if test $withval -le $G12DKH_MAX_AM; then | |
| G12DKH_OPT_AM=$withval | |
| fi | |
| ) | |
| if test "X$INCLUDE_G12DKH" != "Xno"; then | |
| AC_DEFINE_UNQUOTED(INCLUDE_G12DKH,$INCLUDE_G12DKH) | |
| AC_SUBST(G12DKH_MAX_AM) | |
| AC_SUBST(G12DKH_OPT_AM) | |
| AC_DEFINE_UNQUOTED(G12DKH_MAX_AM,$G12DKH_MAX_AM) | |
| AC_DEFINE_UNQUOTED(G12DKH_OPT_AM,$G12DKH_OPT_AM) | |
| fi | |
| LIBINT_UNROLLING_THRESHOLD=100 | |
| AC_ARG_ENABLE(unrolling, | |
| AS_HELP_STRING([--enable-unrolling],[Unroll shell sets into integrals (--enable-unrolling=S will unroll shell sets larger than S).]), | |
| [ | |
| case $enableval in | |
| yes) | |
| LIBINT_UNROLLING_THRESHOLD=1000000000 | |
| ;; | |
| no) | |
| LIBINT_UNROLLING_THRESHOLD= | |
| AC_MSG_RESULT([Shell sets will not be unrolled]) | |
| ;; | |
| *) | |
| LIBINT_UNROLLING_THRESHOLD=$enableval | |
| ;; | |
| esac | |
| ]) | |
| if test X$LIBINT_UNROLLING_THRESHOLD != X; then | |
| if test X$LIBINT_UNROLLING_THRESHOLD = X1000000000; then | |
| AC_MSG_RESULT([All shell sets will be unrolled]) | |
| else | |
| AC_MSG_RESULT([Shell sets will be unrolled up to size $LIBINT_UNROLLING_THRESHOLD]) | |
| fi | |
| AC_DEFINE_UNQUOTED(LIBINT_ENABLE_UNROLLING, $LIBINT_UNROLLING_THRESHOLD) | |
| fi | |
| AC_ARG_ENABLE(generic-code, | |
| AS_HELP_STRING([--enable-generic-code],[Use manually-written generic code.]), | |
| [ | |
| case $enableval in | |
| yes) | |
| AC_DEFINE(LIBINT_ENABLE_GENERIC_CODE) | |
| AC_MSG_RESULT([Generic RR code will be used]) | |
| ;; | |
| no) | |
| AC_MSG_RESULT([Generic RR code will not be used]) | |
| ;; | |
| esac | |
| ]) | |
| LIBINT_VECTOR_LENGTH=1 | |
| AC_ARG_WITH(vector-length, | |
| AS_HELP_STRING([--with-vector-length=N],[Compute integrals in vectors of length N.]), | |
| [ | |
| if test $withval -gt 0; then | |
| LIBINT_VECTOR_LENGTH=$withval | |
| AC_DEFINE_UNQUOTED(LIBINT_VECTOR_LENGTH,$withval) | |
| AC_MSG_RESULT([Using vector length: $withval]) | |
| fi | |
| ]) | |
| if test $LIBINT_VECTOR_LENGTH -gt 1; then | |
| LIBINT_VECTOR_METHOD=block | |
| AC_ARG_WITH(vector-method, | |
| AS_HELP_STRING([--with-vector-method],[Specifies how to vectorize integrals. Allowed values are 'block' (default), and 'line'.]), | |
| [ | |
| LIBINT_VECTOR_METHOD=$withval | |
| ]) | |
| case $LIBINT_VECTOR_METHOD in | |
| block) | |
| ;; | |
| line) | |
| ;; | |
| *) | |
| AC_MSG_ERROR([Unrecognized vector method: $LIBINT_VECTOR_METHOD]) | |
| ;; | |
| esac | |
| AC_DEFINE_UNQUOTED(LIBINT_VECTOR_METHOD,"$LIBINT_VECTOR_METHOD") | |
| AC_MSG_RESULT([Using vector method: $LIBINT_VECTOR_METHOD]) | |
| fi | |
| AC_ARG_ENABLE(single-evaltype, | |
| AS_HELP_STRING([--enable-single-evaltype],[Generate single evaluator type (i.e. all tasks use the same evaluator)]), | |
| [ | |
| if test X$enableval = Xyes; then | |
| enable_single_evaltype=1 | |
| else | |
| enable_single_evaltype=0 | |
| fi | |
| ], | |
| [ | |
| enable_single_evaltype=1 | |
| ] | |
| ) | |
| if test X$enable_single_evaltype = X1; then | |
| AC_DEFINE(LIBINT_SINGLE_EVALTYPE) | |
| AC_MSG_RESULT([Will generate single evaluator type]) | |
| else | |
| AC_MSG_RESULT([Will generate specialized evaluator types for each task]) | |
| AC_MSG_ERROR([Cannot generate specialized evaluator types yet]) | |
| fi | |
| libint_generate_gma=0 | |
| AC_ARG_ENABLE(fma, | |
| AS_HELP_STRING([--enable-fma],[Generate FMA (fused multiply-add) instructions (CXXGEN must support C++11; to benefit must have FMA-capable hardware and compiler)]), | |
| [ | |
| case $enableval in | |
| yes) | |
| libint_generate_gma=1 | |
| AC_DEFINE(LIBINT_GENERATE_FMA) | |
| AC_MSG_RESULT([Will generate FMA instructions]) | |
| ;; | |
| no) | |
| AC_MSG_RESULT([Will not generate FMA instructions]) | |
| ;; | |
| esac | |
| ], | |
| [ | |
| AC_MSG_RESULT([Will not generate FMA instructions]) | |
| ]) | |
| AC_ARG_ENABLE(accum-ints, | |
| AS_HELP_STRING([--enable-accum-ints],[Accumulate integrals to the buffer, rather than copy.]), | |
| [ | |
| case $enableval in | |
| yes) | |
| AC_DEFINE(LIBINT_ACCUM_INTS) | |
| AC_MSG_RESULT([Will accumulate integrals to the buffer]) | |
| ;; | |
| no) | |
| AC_MSG_RESULT([Will copy integrals to the buffer]) | |
| ;; | |
| esac | |
| ], | |
| [ | |
| AC_MSG_RESULT([Will copy integrals to the buffer]) | |
| ]) | |
| AC_ARG_ENABLE(flop-counter, | |
| AS_HELP_STRING([--enable-flop-counter],[Support (approximate) FLOP counting by the library. CXXGEN must support C++11!]), | |
| [ | |
| case $enableval in | |
| yes) | |
| AC_DEFINE(LIBINT_FLOP_COUNT) | |
| AC_MSG_RESULT([FLOP counter will be supported]) | |
| ;; | |
| no) | |
| AC_MSG_RESULT([FLOP counter will not be supported]) | |
| ;; | |
| esac | |
| ], | |
| [ | |
| AC_MSG_RESULT([FLOP counter will not be supported]) | |
| ]) | |
| AC_ARG_ENABLE(profile, | |
| AS_HELP_STRING([--enable-profile],[Turn on profiling instrumentation of the library. CXXGEN must support C++11!]), | |
| [ | |
| case $enableval in | |
| yes) | |
| AC_DEFINE(LIBINT_PROFILE) | |
| AC_MSG_RESULT([Profiling instrumentation enabled (generated code will require C++11)]) | |
| ;; | |
| no) | |
| AC_MSG_RESULT([Profiling instrumentation disabled]) | |
| ;; | |
| esac | |
| ], | |
| [ | |
| AC_MSG_RESULT([Profiling instrumentation disabled]) | |
| ]) | |
| acx_contracted_ints=yes | |
| AC_ARG_ENABLE(contracted-ints, | |
| AS_HELP_STRING([--enable-contracted-ints],[Turn on support for contracted integrals.]), | |
| [ | |
| case $enableval in | |
| no) | |
| acx_contracted_ints=no | |
| ;; | |
| esac | |
| ]) | |
| if test "X$acx_contracted_ints" = Xyes; then | |
| AC_DEFINE(LIBINT_CONTRACTED_INTS) | |
| AC_MSG_RESULT([Will support contracted integrals]) | |
| else | |
| AC_MSG_RESULT([Will not support contracted integrals]) | |
| fi | |
| AC_SUBST(LIBINT_CONTRACTED_INTS, $acx_contracted_ints) | |
| dnl | |
| dnl Preferred strategies for evaluation | |
| dnl | |
| AC_ARG_WITH(eri-strategy, | |
| AS_HELP_STRING([--with-eri-strategy],[Compute ERIs using the following strategy. This option is for experts ONLY.]), | |
| [ | |
| case $withval in | |
| OS) | |
| AC_DEFINE_UNQUOTED(LIBINT_ERI_STRATEGY,0) | |
| ;; | |
| HGP) | |
| AC_DEFINE_UNQUOTED(LIBINT_ERI_STRATEGY,1) | |
| ;; | |
| HL) | |
| AC_DEFINE_UNQUOTED(LIBINT_ERI_STRATEGY,2) | |
| ;; | |
| esac | |
| AC_MSG_RESULT([Using ERI strategy: $withval]) | |
| ], | |
| [AC_DEFINE(LIBINT_ERI_STRATEGY,1)] | |
| ) | |
| BUILDID="libint_buildid" | |
| AC_ARG_WITH(build-id, | |
| AS_HELP_STRING([--with-build-id],[Gives an identifier for the build.]), | |
| BUILDID=$withval | |
| ) | |
| AC_SUBST(BUILDID) | |
| AC_DEFINE_UNQUOTED(LIBINT_BUILDID,"$BUILDID") | |
| if test "$BUILDID"; then | |
| LIBINT_VERSION="$LIBINT_MMM_VERSION-$BUILDID" | |
| else | |
| LIBINT_VERSION="$LIBINT_MMM_VERSION" | |
| fi | |
| AC_DEFINE_UNQUOTED(LIBINT_VERSION, "$LIBINT_VERSION") | |
| AC_SUBST(LIBINT_VERSION) | |
| ac_default_prefix="/usr/local/libint/$LIBINT_VERSION" | |
| AC_ARG_WITH(cxx, | |
| AS_HELP_STRING([--with-cxx],[Gives the name of the C++ compiler to use.]), | |
| CXX=$withval | |
| ) | |
| CXXFLAGS_OPT= | |
| AC_ARG_WITH(cxx-optflags, | |
| AS_HELP_STRING([--with-cxx-optflags],[Gives optimization flags for the C++ compiler.]), | |
| if test "X$withval" != "Xyes" -a "X$withval" != "Xno"; then | |
| CXXFLAGS_OPT=$withval | |
| fi | |
| ) | |
| AC_ARG_WITH(cxxgen, | |
| AS_HELP_STRING([--with-cxxgen],[Gives the name of the C++ compiler to compile generated code.]), | |
| CXXGEN=$withval | |
| ) | |
| CXXGENFLAGS_OPT= | |
| AC_ARG_WITH(cxxgen-optflags, | |
| AS_HELP_STRING([--with-cxxgen-optflags],[Gives optimization flags for the C++ compiler for generated source.]), | |
| if test "X$withval" != "Xyes" -a "X$withval" != "Xno"; then | |
| CXXGENFLAGS_OPT=$withval | |
| fi | |
| ) | |
| AC_ARG_WITH(cxxdepend, | |
| AS_HELP_STRING([--with-cxxdepend],[Gives the name of the C++ compiler with which to extract dependency information.]), | |
| CXXDEPEND=$withval | |
| ) | |
| AC_ARG_WITH(ranlib, | |
| AS_HELP_STRING([--with-ranlib],[Gives the name of the ranlib program.]), | |
| RANLIB=$withval | |
| ) | |
| AC_ARG_WITH(ar, | |
| AS_HELP_STRING([--with-ar],[Names the archive creator.]), | |
| AR=$withval | |
| ) | |
| ARFLAGS=r | |
| AC_ARG_WITH(ar-flags, | |
| AS_HELP_STRING([--with-ar-flags],[Flags for the the archive creator.]), | |
| ARFLAGS=$withval | |
| ) | |
| AC_SUBST(ARFLAGS) | |
| AC_ARG_WITH(ld, | |
| AS_HELP_STRING([--with-ld],[Names the object linker.]), | |
| LD=$withval | |
| ) | |
| libintincludedir=$includedir | |
| AC_ARG_WITH(libint-includedir, | |
| AS_HELP_STRING([--with-libint-includedir],[Specifies include file install subdir.]), | |
| libintincludedir=$withval | |
| ) | |
| AC_SUBST(libintincludedir) | |
| EXPORTDIR=libint-$LIBINT_VERSION | |
| AC_ARG_WITH(libint-exportdir, | |
| AS_HELP_STRING([--with-libint-exportdir],[Specifies export directory name. Default is libint-<version>.]), | |
| EXPORTDIR=$withval | |
| ) | |
| AC_SUBST(EXPORTDIR) | |
| AC_ARG_WITH(incdirs, | |
| AS_HELP_STRING([--with-incdirs],[Specifies include directories (-Idir1 -Idir2).]), | |
| EXTRAINCDIRS=$withval | |
| CPPFLAGS=$withval | |
| echo Using extra include directories: $withval | |
| ) | |
| AC_ARG_WITH(libs, | |
| AS_HELP_STRING([--with-libs],[Specifies libraries (-llib1 -llib2).]), | |
| LIBS=$withval | |
| echo Using extra libraries: $withval | |
| ) | |
| AC_ARG_WITH(libdirs, | |
| AS_HELP_STRING([--with-libdirs],[Specifies library directories (-Ldir1 -Ldir2).]), | |
| LIBDIRS=$withval | |
| LDFLAGS=$withval | |
| echo Using extra library directories: $withval | |
| ) | |
| SCRATCHDIR=tmp | |
| AC_ARG_WITH(scratchdir, | |
| AS_HELP_STRING([--with-scratchdir],[Specifies the location for the machine-generated library source and object files.]), | |
| SCRATCHDIR=$withval | |
| ) | |
| AC_SUBST(SCRATCHDIR) | |
| PKGCONFIGDIR='$(libdir)/pkgconfig' | |
| AC_ARG_WITH(pkgconfigdir, | |
| AS_HELP_STRING([--with-pkgconfigdir],[Specifies the location to put pkg-config's data file. Default is $(libdir)/pkgconfig.]), | |
| PKGCONFIGDIR=$withval | |
| ) | |
| AC_SUBST(PKGCONFIGDIR) | |
| CMAKEDIR='$(libdir)/cmake/libint2' | |
| AC_ARG_WITH(cmakedir, | |
| AS_HELP_STRING([--with-cmakedir],[Specifies the location to put FindLibint2.cmake file. Default is $(libdir)/cmake/libint2.]), | |
| CMAKEDIR=$withval | |
| ) | |
| AC_SUBST(CMAKEDIR) | |
| dnl --------- Want absolute path for srcdir, not relative. --------- | |
| if test X$ac_srcdir_defaulted = Xyes; then | |
| case $srcdir in | |
| ..*) | |
| srcdir=`(cd $srcdir; pwd)` | |
| #srcdir=`(cd $srcdir; echo $PWD)` | |
| ;; | |
| esac | |
| fi | |
| dnl --------- Checks for programs. --------- | |
| AC_PROG_MAKE_SET | |
| AC_PROG_LN_S | |
| AC_PROG_INSTALL | |
| # if not given a C++ compiler | |
| if test "X$CXX" = "X"; then | |
| AC_CHECK_PROGS(CXX, clang++ icpc xlC_r g++ c++ CC, c++) | |
| fi | |
| # if not given a C++ compiler for generated source, use CXX | |
| if test "X$CXXGEN" = X; then | |
| CXXGEN=$CXX | |
| fi | |
| AC_SUBST(CXXGEN) | |
| # discard CXXFLAGS provided by the C++ detection macros | |
| initial_CXXFLAGS="$CXXFLAGS" | |
| AC_PROG_CXX | |
| AC_PROG_CXXCPP | |
| CXXFLAGS="$initial_CXXFLAGS" | |
| AC_CHECK_PROG(AR,ar,ar) | |
| AC_CHECK_PROG(PERL,perl,perl) | |
| AC_CHECK_PROGS(TAR,gnutar tar,tar) | |
| AC_CHECK_PROGS(PYTHON,python python3 python2 python2.7,python) | |
| AC_PATH_PROG(DOXYGEN,doxygen,,$PATH:/usr/local/bin:/opt/local/bin) | |
| AC_PATH_PROG(PDFLATEX,pdflatex,,$PATH:/usr/local/bin:/opt/local/bin) | |
| AC_PATH_PROG(PSLATEX,pslatex,,$PATH:/usr/local/bin:/opt/local/bin) | |
| AC_PATH_PROG(DVIPS,dvips,,$PATH:/usr/local/bin:/opt/local/bin) | |
| AC_PATH_PROG(LATEX,latex,,$PATH:/usr/local/bin:/opt/local/bin) | |
| AC_PATH_PROG(LATEX2HTML,latex2html,,$PATH:/usr/local/bin:/opt/local/bin) | |
| AC_PATH_PROG(BIBTEX,bibtex,,$PATH:/usr/local/bin:/opt/local/bin) | |
| dnl The lack of certain tools is a show stopper | |
| changequote(<<, >>)dnl | |
| if [ X$PERL = X ]; then | |
| echo "Could not find program: perl" | |
| exit 1 | |
| fi | |
| if [ X$PYTHON = X ]; then | |
| echo "Could not find program: python" | |
| exit 1 | |
| fi | |
| changequote([, ])dnl | |
| dnl -------- Checks for compiler/linker options. ---------- | |
| # set the optimization default if neither CXXFLAGS or --with-*-optflags were given | |
| if test "X$CXXFLAGS_OPT" = X -a "X$CXXFLAGS" = X; then | |
| CXXFLAGS_OPT=-O2 | |
| fi | |
| if test "X$CXXGENFLAGS_OPT" = X -a "X$CXXGENFLAGS" = X; then | |
| AC_MSG_WARN([C++ optimization options are not given! For optimum performance give CXXGENFLAGS or use --with-cxxgen-optflags configure option]) | |
| CXXGENFLAGS_OPT="-O2 -DNDEBUG" | |
| fi | |
| # options needed only for debugging | |
| CXXFLAGS_DBG=-g | |
| # options that are always needed | |
| CXXFLAGS_MISC= | |
| # now form CXXGENFLAGS ... | |
| if test "X$CXXGENFLAGS" = X; then | |
| CXXGENFLAGS=$CXXFLAGS | |
| fi | |
| if test $DEBUG = yes; then | |
| CXXGENFLAGS="$CXXGENFLAGS $CXXFLAGS_DBG $CXXFLAGS_MISC" | |
| LDFLAGS="$LDFLAGS -g" | |
| elif test $DEBUG = opt; then | |
| CXXGENFLAGS="$CXXGENFLAGS $CXXFLAGS_DBG $CXXGENFLAGS_OPT $CXXFLAGS_MISC" | |
| LDFLAGS="$LDFLAGS -g" | |
| else | |
| CXXGENFLAGS="$CXXGENFLAGS $CXXGENFLAGS_OPT $CXXFLAGS_MISC" | |
| fi | |
| # ... and CXXFLAGS | |
| if test $DEBUG = yes; then | |
| CXXFLAGS="$CXXFLAGS $CXXFLAGS_DBG $CXXFLAGS_MISC" | |
| LDFLAGS="$LDFLAGS -g" | |
| elif test $DEBUG = opt; then | |
| CXXFLAGS="$CXXFLAGS $CXXFLAGS_DBG $CXXFLAGS_OPT $CXXFLAGS_MISC" | |
| LDFLAGS="$LDFLAGS -g" | |
| else | |
| CXXFLAGS="$CXXFLAGS $CXXFLAGS_OPT $CXXFLAGS_MISC" | |
| fi | |
| OBJSUF=o | |
| LIBSUF=a | |
| dnl -- check how dependency information is built -- | |
| # The GNU compilers work with: | |
| CXXDEPENDSUF=none | |
| CXXDEPENDFLAGS=-M | |
| /bin/rm -f depcheck.u depcheck.c depcheck.o | |
| # Check for an IBM visual age C++ compiler | |
| echo "#include <iostream>" > depcheck.cc | |
| $CXX $CPPFLAGS $CXXFLAGS -M -E depcheck.cc > /dev/null 2>&1 | |
| if test -f depcheck.u; then | |
| CXXDEPENDSUF=u | |
| CXXDEPENDFLAGS="-M -E" | |
| fi | |
| /bin/rm -f depcheck.u depcheck.c depcheck.o | |
| if test "X$CXXDEPEND" = X; then | |
| CXXDEPEND=$CXX | |
| fi | |
| AC_SUBST(CXXDEPEND) | |
| AC_SUBST(CXXDEPENDSUF) | |
| AC_SUBST(CXXDEPENDFLAGS) | |
| dnl -- special architecture options -- | |
| # nothing so far | |
| AC_SUBST(EXTRAINCLUDE) | |
| AC_SUBST(EXTRADEFINES) | |
| AC_SUBST(CXXFLAGS) | |
| AC_SUBST(CXXGENFLAGS) | |
| AC_SUBST(LIBDIRS) | |
| AC_SUBST(LD) | |
| AC_SUBST(LDFLAGS) | |
| AC_SUBST(OBJSUF) | |
| AC_SUBST(LIBSUF) | |
| dnl ---------- Checks for "standard" header files. ----------- | |
| AC_HEADER_STDC | |
| AC_CHECK_HEADERS(limits.h stdint.h) | |
| dnl ---------- Check for posix_memalign ---------------------- | |
| AC_CHECK_FUNC(posix_memalign,[have_posix_memalign=1 AC_DEFINE(HAVE_POSIX_MEMALIGN)],[have_posix_memalign=0]) | |
| if test "X$have_posix_memalign" != "X0"; then | |
| # control memory alignment if posix_memalign is found | |
| # if vectorization is off (default) then let the default alignment be determined by the system | |
| # if vectorization is on then the default alignment is veclen * sizeof(LIBINT2_REALTYPE) | |
| # see default_params.cc to see this logic in action | |
| LIBINT_ALIGN_SIZE=default # this will be interpreted as "use the default alignment" | |
| AC_ARG_WITH(align-size, | |
| AS_HELP_STRING([--with-align-size],[(EXPERT) if posix_memalign is available, this will specify alignment of Libint data, in units of sizeof(LIBINT2_REALTYPE). Default is to use built-in heuristics.]), | |
| [ | |
| if test "X$withval" != "Xdefault"; then | |
| LIBINT_ALIGN_SIZE=$withval | |
| if test $LIBINT_ALIGN_SIZE -lt 1; then | |
| AC_MSG_ERROR([Invalid alignment: $LIBINT_ALIGN_SIZE]) | |
| fi | |
| fi | |
| ] | |
| ) | |
| if test "X$LIBINT_ALIGN_SIZE" != "Xdefault"; then | |
| AC_MSG_RESULT([will use custom memory alignment: $LIBINT_ALIGN_SIZE * sizeof(LIBINT2_REALTYPE)]) | |
| else | |
| LIBINT_ALIGN_SIZE=0 | |
| fi | |
| AC_DEFINE_UNQUOTED(LIBINT_ALIGN_SIZE, $LIBINT_ALIGN_SIZE) | |
| else # no posix_memalign = death | |
| echo "did not find posix_memalign ... this SHOULD NOT happen. Cannot proceed." | |
| exit 1 | |
| fi | |
| dnl ------------------ Check for support for C++11 standard features -------------- | |
| enable_cpptr1=no # TR1's array seems to be broken on OS X | |
| acx_with_boost=yes | |
| ACX_CHECK_CPP11 | |
| if test "X$acx_have_cxx11" = "Xno"; then | |
| AC_MSG_ERROR([C++11 support is required to compile the Libint compiler. Obtain a recent C++ compiler that supports C++11, or consider using a pregenerated library]) | |
| fi | |
| # to support FMA CXXGEN must be able to compile C++11 | |
| # NB -std=c++11 is not added to CXXGENFLAGS automatically! | |
| ACX_CHECK_CPP11_CXXGEN | |
| if test "X$libint_generate_gma" = "X1" -a "X$CXXGEN_SUPPORTS_CPP11" = "Xno"; then | |
| AC_MSG_ERROR([CXXGEN must support C++11 to provide FMA support. Add -std=c++11 to CXXGENFLAGS.]) | |
| fi | |
| dnl ------------------ Check for gmp C++ interface ----------------------- | |
| ACX_CHECK_GMPXX | |
| if test "X$acx_have_gmpxx" = "Xno"; then | |
| AC_MSG_ERROR([cannot link against GMP C++ library. Please get the latest GMP with support for C++. It can be obtained at gmplib.org .]) | |
| fi | |
| dnl ---------- Check for optional MPFR library (needed for high-precision testing) -------- | |
| AC_ARG_ENABLE(mpfr, | |
| AS_HELP_STRING([--enable-mpfr],[Use MPFR library to test Libint integrals in high precision.]), | |
| [ | |
| case $enableval in | |
| yes) | |
| AC_CHECK_HEADER(mpfr.h,[ | |
| AC_MSG_CHECKING([if MPFR library is usable]) | |
| LIBS="-lmpfr $LIBS" | |
| AC_LINK_IFELSE( | |
| [AC_LANG_PROGRAM( | |
| [[#include <mpfr.h> | |
| ]], | |
| [[ | |
| mpfr_t x; mpfr_init(x); | |
| ]] | |
| ) | |
| ], | |
| [AC_MSG_RESULT([yes]) | |
| AC_DEFINE(LIBINT_HAS_MPFR) | |
| ], | |
| [ | |
| AC_MSG_RESULT([no]) | |
| ] | |
| ) | |
| ] | |
| ) | |
| ;; | |
| esac | |
| ] | |
| ) | |
| dnl ------------------ Check for Boost library ----------------------- | |
| dnl Boost.Preprocessor requires 1.30 (which introduced MPL; Preprocessor was introduced in 1.29) | |
| AX_BOOST_BASE([1.30],, [AC_MSG_ERROR([libint compiler needs Boost 1.30 or later (needs Boost 1.57 if don't want to use bundled Boost.Preprocessor and be able to use clang), download from https://www.boost.org/users/download/ , unpack (no need to install), and add -I/path/to/boost to CPPFLAGS])]) | |
| CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS" | |
| # no need to update LDFLAGS: we are not using precompoiled boost | |
| AC_MSG_CHECKING([for variadic macro support in Boost.Preprocessor]) | |
| AC_COMPILE_IFELSE( | |
| [AC_LANG_PROGRAM( | |
| [[#include <boost/preprocessor.hpp> | |
| #if not BOOST_PP_VARIADICS // no variadic macros? your compiler is out of date! (should not be possible since variadic macros are part of C++11) | |
| # error "your compiler does not provide variadic macros (but does support C++11), something is seriously broken, please create an issue at https://github.com/evaleev/libint/issues" | |
| #endif | |
| ]], | |
| [[ | |
| ]] | |
| ) | |
| ], | |
| [AC_MSG_RESULT([yes]) | |
| AC_DEFINE(LIBINT_HAS_SYSTEM_BOOST_PREPROCESSOR_VARIADICS) | |
| HAVE_SYSTEM_BOOST_PREPROCESSOR_VARIADICS=1 | |
| ], | |
| [ | |
| AC_MSG_RESULT([no]) | |
| HAVE_SYSTEM_BOOST_PREPROCESSOR_VARIADICS=0 | |
| AC_MSG_WARN([Boost.Preprocessor with variadic macro support not detected. Will use the bundled Boost.Preprocessor. Download latest boost from https://www.boost.org/users/download/ , unpack (no need to install), and add -I/path/to/boost to CPPFLAGS]) | |
| ] | |
| ) | |
| AC_SUBST(HAVE_SYSTEM_BOOST_PREPROCESSOR_VARIADICS) | |
| AC_MSG_CHECKING([for Boost::mpl::for_each]) | |
| AC_COMPILE_IFELSE( | |
| [AC_LANG_PROGRAM( | |
| [[#include <boost/mpl/list.hpp> | |
| #include <boost/mpl/for_each.hpp> | |
| #include <iostream> | |
| struct P { | |
| template <class T> void operator()(T x) const { std::cout << x << std::endl; } | |
| }; | |
| ]], | |
| [[ | |
| typedef boost::mpl::list<int,double,char> tlist; | |
| boost::mpl::for_each<tlist>(P()); | |
| ]] | |
| ) | |
| ], | |
| [AC_MSG_RESULT([yes]) | |
| ], | |
| [ | |
| AC_MSG_RESULT([no]) | |
| AC_MSG_ERROR([Boost::mpl is required. Download latest boost from https://www.boost.org/users/download/ , unpack (no need to install), and add -I/path/to/boost to CPPFLAGS]) | |
| ] | |
| ) | |
| dnl ------------------ Check for shared_ptr ----------------------- | |
| HAVE_SHARED_PTR=no | |
| AC_MSG_CHECKING([for std::shared_ptr]) | |
| AC_COMPILE_IFELSE( | |
| [AC_LANG_PROGRAM( | |
| [[#include <memory> | |
| ]], | |
| [[ | |
| std::shared_ptr<int> a(new int); | |
| std::shared_ptr<int> b = a; | |
| ]] | |
| ) | |
| ], | |
| [AC_MSG_RESULT([yes]) | |
| HAVE_SHARED_PTR=std | |
| ], | |
| [ | |
| AC_MSG_RESULT([no]) | |
| ] | |
| ) | |
| if test "X$HAVE_SHARED_PTR" = "Xno"; then | |
| AC_MSG_CHECKING([for Boost::shared_ptr]) | |
| AC_COMPILE_IFELSE( | |
| [AC_LANG_PROGRAM( | |
| [[#include <boost/shared_ptr.hpp> | |
| ]], | |
| [[ | |
| boost::shared_ptr<int> a(new int); | |
| boost::shared_ptr<int> b = a; | |
| ]] | |
| ) | |
| ], | |
| [AC_MSG_RESULT([yes]) | |
| HAVE_SHARED_PTR=boost | |
| AC_DEFINE(HAVE_SHARED_PTR_IN_BOOST) | |
| ], | |
| [ | |
| AC_MSG_RESULT([no]) | |
| AC_MSG_ERROR([shared_ptr is required. Please download Boost from boost.org or use C++ compiler that supports std::shared_ptr.]) | |
| ] | |
| ) | |
| fi | |
| dnl ------------------ Check for Eigen library ----------------------- | |
| ACX_CHECK_EIGEN | |
| if test "X$acx_have_eigen" = "Xyes"; then | |
| AC_SUBST(LIBINT_HAS_EIGEN,$acx_have_eigen) | |
| fi | |
| dnl -- Checks for typedefs, structures, and compiler characteristics. -- | |
| AC_TYPE_SIZE_T | |
| `` | |
| CPPFLAGS="$CPPFLAGS" CXX="$CXX" CXXFLAGS="$CXXFLAGS" \ | |
| LD="$LD" LDFLAGS="$LDFLAGS" LIBS="-lm $LIBS $FLIBS" \ | |
| LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" | |
| dnl --------- expand some variables ----------- | |
| DATADIR_ABSOLUTE=`eval echo $datarootdir`/libint/$LIBINT_VERSION | |
| AC_SUBST(DATADIR_ABSOLUTE) | |
| dnl Check if sources compiled with CXX and CXXGEN can be linked together | |
| CXX_COMPATIBLE_WITH_CXXGEN=yes | |
| if test "X$CXX" != "X$CXXGEN"; then | |
| AC_MSG_CHECKING([[for compatible cxx and cxxgen compilers]]) | |
| echo "extern void func1(); int main(int argc, char**argv) { func1(); } " > linkcheck1.cc | |
| echo "void func1() {}" > linkcheck2.cc | |
| $CXX $CPPFLAGS $CXXFLAGS -c linkcheck1.cc > /dev/null 2>&1 | |
| $CXXGEN $CPPFLAGS $CXXGENFLAGS -c linkcheck2.cc > /dev/null 2>&1 | |
| $LD $LDFLAGS -o linkcheck1 linkcheck1.o linkcheck2.o > /dev/null 2>&1 | |
| $CXX $LDFLAGS -o linkcheck2 linkcheck1.o linkcheck2.o > /dev/null 2>&1 | |
| $CXXGEN $LDFLAGS -o linkcheck3 linkcheck1.o linkcheck2.o > /dev/null 2>&1 | |
| if test -f linkcheck1 -a -f linkcheck2 -a -f linkcheck3; then | |
| AC_MSG_RESULT([[yes]]) | |
| else | |
| AC_MSG_RESULT([[no]]) | |
| AC_MSG_WARN([[Compilers cxx and cxxgen produce incompatible code! You will not be able to test generated code.]]) | |
| CXX_COMPATIBLE_WITH_CXXGEN=no | |
| fi | |
| /bin/rm -f linkcheck1 linkcheck2 linkcheck3 linkcheck1.cc linkcheck2.cc linkcheck1.o linkcheck2.o | |
| fi | |
| AC_SUBST(CXX_COMPATIBLE_WITH_CXXGEN) | |
| dnl ------------------ Check if real type is given and is usable with CXXGEN ----------------------- | |
| AC_ARG_WITH(real-type, | |
| AS_HELP_STRING([--with-real-type],[Compute all integrals using the given real type (default: double).]), | |
| [ | |
| AC_DEFINE_UNQUOTED(LIBINT_USER_DEFINED_REAL,"$withval") | |
| libint_user_defined_real=$withval | |
| AC_MSG_RESULT([Using real type: $withval]) | |
| ]) | |
| # extra includes may be needed in that case! | |
| if test "X$libint_user_defined_real" != "X"; then | |
| copy_CXX=$CXX | |
| copy_CXXFLAGS=$CXXFLAGS | |
| CXX=$CXXGEN | |
| CXXFLAGS=$CXXGENFLAGS | |
| AC_ARG_WITH(real-type-includes, | |
| AS_HELP_STRING([--with-real-type-includes],[Additional includes necessary to use the real type (default: none).]), | |
| [ | |
| AC_DEFINE_UNQUOTED(LIBINT_USER_DEFINED_REAL_INCLUDES,"$withval") | |
| libint_user_defined_real_includes=$withval | |
| ] | |
| ) | |
| AC_MSG_CHECKING([if $libint_user_defined_real is usable]) | |
| # by default should look for SIMD vector types in src/lib/libint | |
| copy2_CXXFLAGS=$CXXFLAGS | |
| CXXFLAGS="$CXXFLAGS -I$srcdir/include -Iinclude -I$srcdir/src/lib/libint" | |
| AC_COMPILE_IFELSE( | |
| [AC_LANG_PROGRAM( | |
| [[#include <libint2/util/vector.h> | |
| $libint_user_defined_real_includes | |
| ]], | |
| [[ | |
| $libint_user_defined_real x1; | |
| $libint_user_defined_real x2 = 2.0; | |
| $libint_user_defined_real x3 = x2; | |
| $libint_user_defined_real x4 = x2 + x3; | |
| $libint_user_defined_real x5 = x2 - x3; | |
| $libint_user_defined_real x6 = x2 * x3; | |
| $libint_user_defined_real x7 = 2 * x2; | |
| $libint_user_defined_real x8 = x2 * 3; | |
| x6 += x2 * x3; | |
| x7 -= 3 * x3; | |
| ]] | |
| ) | |
| ], | |
| [AC_MSG_RESULT([yes]) | |
| CXXFLAGS=$copy2_CXXFLAGS | |
| ], | |
| [AC_MSG_RESULT([no]) | |
| AC_MSG_ERROR([[real type $libint_user_defined_real is not usable, perhaps extra -I directories or extra #include's are needed?]]) | |
| ] | |
| ) | |
| # CXXFLAGS may have changed | |
| CXXGENFLAGS=$CXXFLAGS | |
| CXX=$copy_CXX | |
| CXXFLAGS=$copy_CXXFLAGS | |
| fi | |
| dnl --------- Shared library configuration. --------- | |
| dnl by default make only static libraries | |
| LT_INIT([disable-shared]) | |
| LT_LANG([C++]) | |
| OBJSUF=lo | |
| LIBSUF=la | |
| ENABLESHARED=yes | |
| AC_SUBST(ENABLESHARED) | |
| dnl -- configure tester -- | |
| TESTER_ARGS="(\"1 0 1 0 0\", \"1 0 1 0 10000\", \"1 1 1 1 0\", \"1 1 1 1 10000\", \"2 0 2 0 0\", \"2 1 2 0 10000\", \"1 1 1 1 10000 16 0\", \"1 1 1 1 10000 16 1\", \"1 1 1 1 10000 1 1\", \"1 1 1 1 0 16 0\", \"1 1 1 1 0 16 1\", \"1 1 1 1 10000 16 0 1\")" | |
| TESTER_ARGS_LONG="(\"3 0 3 0 10000\", \"4 0 4 0 10000\", \"2 2 2 2 0\", \"2 2 2 2 10000\")" | |
| AC_SUBST(TESTER_ARGS) | |
| AC_SUBST(TESTER_ARGS_LONG) | |
| dnl -- make Makefiles in object tree -- | |
| $PERL $srcdir/bin/objectdir.pl $EXCLUDED_DIRS $srcdir | |
| AC_CONFIG_FILES([src/bin/test_eri/test_eri.pl],[chmod +x src/bin/test_eri/test_eri.pl]) | |
| AC_CONFIG_FILES([src/bin/test_eri/time_eri.pl],[chmod +x src/bin/test_eri/time_eri.pl]) | |
| AC_CONFIG_FILES([src/bin/test_eri/run_time_eri.pl],[chmod +x src/bin/test_eri/run_time_eri.pl]) | |
| AC_CONFIG_FILES([src/bin/test_eri/stdtests.pl],[chmod +x src/bin/test_eri/stdtests.pl]) | |
| AC_CONFIG_FILES([src/bin/test_eri/run_timing_suite.pl],[chmod +x src/bin/test_eri/run_timing_suite.pl]) | |
| AC_CONFIG_FILES(src/bin/MakeVars src/lib/MakeVars src/lib/MakeRules src/lib/libint/MakeVars.features | |
| tests/MakeVars | |
| doc/MakeVars doc/MakeRules doc/progman/macros.tex doc/classdoc/doxygen.cfg | |
| include/libint2/basis.h libint2.pc) | |
| dnl --------- Done! --------- | |
| AC_OUTPUT | |