configure

  USE_MODEL_TRUE=
  USE_MODEL_FALSE='#'
else
  USE_MODEL_TRUE='#'
  USE_MODEL_FALSE=
fi


################# Actions to complete in case of multhreading ################

cat >>confdefs.h <<_ACEOF
#define THREADS_NMAX $n_pthreads
_ACEOF

if test "$use_pthreads" = "yes"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for multithreading" >&5
$as_echo_n "checking for multithreading... " >&6; }
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: maximum of $n_pthreads thread(s)" >&5
$as_echo "maximum of $n_pthreads thread(s)" >&6; }

$as_echo "#define USE_THREADS 1" >>confdefs.h

# CC, CFLAGS and LIBS are system and compiler-dependent


acx_pthread_ok=no

# First, check if the POSIX threads header, pthread.h, is available.
# If it isn't, don't bother looking for the threads libraries.
# AC_CHECK_HEADER(pthread.h, , acx_pthread_ok=noheader)
ac_fn_c_check_header_mongrel "$LINENO" "pthread.h" "ac_cv_header_pthread_h" "$ac_includes_default"
if test "x$ac_cv_header_pthread_h" = xyes; then :

else
  acx_pthread_ok=no
fi



# We must check for the threads library under a number of different
# names; the ordering is very important because some systems
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
# libraries is broken (non-POSIX).

# First of all, check if the user has set any of the PTHREAD_LIBS,
# etcetera environment variables, and if threads linking works using
# them:
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
        save_CFLAGS="$CFLAGS"
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        save_LIBS="$LIBS"
        LIBS="$PTHREAD_LIBS $LIBS"
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS" >&5
$as_echo_n "checking for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS... " >&6; }
        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char pthread_join ();
int
main ()
{
return pthread_join ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  acx_pthread_ok=yes
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_ok" >&5
$as_echo "$acx_pthread_ok" >&6; }
        if test x"$acx_pthread_ok" = xno; then
                PTHREAD_LIBS=""
                PTHREAD_CFLAGS=""
        fi
        LIBS="$save_LIBS"
        CFLAGS="$save_CFLAGS"
fi

# Create a list of thread flags to try.  Items starting with a "-" are
# C compiler flags, and other items are library names, except for "none"
# which indicates that we try without any flags at all.

acx_pthread_flags="pthreads none -Kthread -kthread lthread pthread -pthread -pthreads -mthreads --thread-safe -mt"

# The ordering *is* (sometimes) important.  Some notes on the
# individual items follow:

# pthreads: AIX (must check this before -lpthread)
# none: in case threads are in libc; should be tried before -Kthread and
#       other compiler flags to prevent continual compiler warnings
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
# -pthreads: Solaris/gcc
# -mthreads: Mingw32/gcc, Lynx/gcc
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
#      doesn't hurt to check since this sometimes defines pthreads too;
#      also defines -D_REENTRANT)
# pthread: Linux, etcetera
# --thread-safe: KAI C++

case "${host_cpu}-${host_os}" in
        *solaris*)

        # On Solaris (at least, for some versions), libc contains stubbed
        # (non-functional) versions of the pthreads routines, so link-based
        # tests will erroneously succeed.  (We need to link with -pthread or
        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
        # a function called by this macro, so we could check for that, but
        # who knows whether they'll stub that too in a future libc.)  So,
        # we'll just look for -pthreads and -lpthread first:

        acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags"
        ;;
esac

if test x"$acx_pthread_ok" = xno; then
for flag in $acx_pthread_flags; do

        case $flag in
                none)
                { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether pthreads work without any flags" >&5
$as_echo_n "checking whether pthreads work without any flags... " >&6; }
                ;;

                -*)
                { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with $flag" >&5
$as_echo_n "checking whether pthreads work with $flag... " >&6; }
                PTHREAD_CFLAGS="$flag"
                ;;

                *)
                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the pthreads library -l$flag" >&5
$as_echo_n "checking for the pthreads library -l$flag... " >&6; }
                PTHREAD_LIBS="-l$flag"
                ;;
        esac

        save_LIBS="$LIBS"
        save_CFLAGS="$CFLAGS"
        LIBS="$PTHREAD_LIBS $LIBS"
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

        # Check for various functions.  We must include pthread.h,
        # since some functions may be macros.  (On the Sequent, we
        # need a special flag -Kthread to make this header compile.)
        # We check for pthread_join because it is in -lpthread on IRIX
        # while pthread_create is in libc.  We check for pthread_attr_init
        # due to DEC craziness with -lpthreads.  We check for
        # pthread_cleanup_push because it is one of the few pthread
        # functions on Solaris that doesn't have a non-functional libc stub.
        # We try pthread_create on general principles.
        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <pthread.h>
int
main ()
{
pthread_t th; pthread_join(th, 0);
                     pthread_attr_init(0); pthread_cleanup_push(0, 0);
                     pthread_create(0,0,0,0); pthread_cleanup_pop(0);
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  acx_pthread_ok=yes
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext

        LIBS="$save_LIBS"
        CFLAGS="$save_CFLAGS"

        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_ok" >&5
$as_echo "$acx_pthread_ok" >&6; }
        if test "x$acx_pthread_ok" = xyes; then
                break;
        fi

        PTHREAD_LIBS=""
        PTHREAD_CFLAGS=""
done
fi

# Various other checks:
if test "x$acx_pthread_ok" = xyes; then
        save_LIBS="$LIBS"
        LIBS="$PTHREAD_LIBS $LIBS"
        save_CFLAGS="$CFLAGS"
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

        # Detect AIX lossage: threads are created detached by default
        # and the JOINABLE attribute has a nonstandard name (UNDETACHED).
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for joinable pthread attribute" >&5
$as_echo_n "checking for joinable pthread attribute... " >&6; }
        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <pthread.h>
int
main ()
{
int attr=PTHREAD_CREATE_JOINABLE;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ok=PTHREAD_CREATE_JOINABLE
else
  ok=unknown
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
        if test x"$ok" = xunknown; then
                cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <pthread.h>
int
main ()
{
int attr=PTHREAD_CREATE_UNDETACHED;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ok=PTHREAD_CREATE_UNDETACHED
else
  ok=unknown
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
        fi
        if test x"$ok" != xPTHREAD_CREATE_JOINABLE; then

$as_echo "#define PTHREAD_CREATE_JOINABLE \$ok" >>confdefs.h

        fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${ok}" >&5
$as_echo "${ok}" >&6; }
        if test x"$ok" = xunknown; then
                { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: we do not know how to create joinable pthreads" >&5
$as_echo "$as_me: WARNING: we do not know how to create joinable pthreads" >&2;}
        fi

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking if more special flags are required for pthreads" >&5
$as_echo_n "checking if more special flags are required for pthreads... " >&6; }
        flag=no
        case "${host_cpu}-${host_os}" in
                *-aix* | *-freebsd*)     flag="-D_THREAD_SAFE";;
                *solaris* | alpha*-osf*) flag="-D_REENTRANT";;
        esac
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${flag}" >&5
$as_echo "${flag}" >&6; }
        if test "x$flag" != xno; then
                PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
        fi

        LIBS="$save_LIBS"
        CFLAGS="$save_CFLAGS"

        # More AIX lossage: must compile with cc_r
        # Extract the first word of "cc_r", so it can be a program name with args.
set dummy cc_r; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_PTHREAD_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$PTHREAD_CC"; then
  ac_cv_prog_PTHREAD_CC="$PTHREAD_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_PTHREAD_CC="cc_r"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_prog_PTHREAD_CC" && ac_cv_prog_PTHREAD_CC="${CC}"
fi
fi
PTHREAD_CC=$ac_cv_prog_PTHREAD_CC
if test -n "$PTHREAD_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PTHREAD_CC" >&5
$as_echo "$PTHREAD_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


else
        PTHREAD_CC="$CC"
fi





# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$acx_pthread_ok" = xyes; then

$as_echo "#define HAVE_PTHREAD 1" >>confdefs.h

        :
else
        acx_pthread_ok=no

fi


  CC="$PTHREAD_CC"
  AM_CFLAGS="$AM_CFLAGS $PTHREAD_CFLAGS -D_REENTRANT"
  LIBS="$PTHREAD_LIBS $LIBS"
fi
 if test $use_pthreads = "yes"; then
  USE_THREADS_TRUE=
  USE_THREADS_FALSE='#'
else
  USE_THREADS_TRUE='#'
  USE_THREADS_FALSE=
fi


if test "$enable_model_fitting" = "yes"; then
############ handle the INTEL MKL library (FFTW + LAPACK) ###########
  if test "$enable_mkl" = "yes"; then
    convlibs="${srcdir}/wcs/libwcs_c.a,${srcdir}/levmar/liblevmar.a"




if test x$with_mkl_dir = x; then
  mklroot=${MKLROOT}
else
  mklroot=$with_mkl_dir
fi


if test x$convlibs = x; then
  startgroup="-Wl,--start-group"
else
  startgroup="-Wl,--start-group,$convlibs"
fi


icc -V 2>&1 | grep -i "Intel" > /dev/null 2>&1 && flagicc=yes
icc -V 2>&1 | grep -i "Intel(R) 64" > /dev/null 2>&1 && flag64=yes
icc -dumpmachine 2>&1 | grep -i "darwin" > /dev/null 2>&1 && flagosx=yes

if test x$flagicc = x; then
  MKL_CFLAGS=""

  MKL_LDFLAGS=""

  MKL_LIBS=""

  MKL_WARN="INTEL compiler not detected"

  exit
fi

if test x$flagosx = xyes; then
  if test x$flag64 = xyes; then
    if test x = xyes; then
      MKL_CFLAGS="-openmp -DMKL_ILP64 -I$mklroot/include"

      if test x$enable_best_link = xyes; then
        MKL_LIBS="$mklroot/lib/libmkl_intel_ilp64.a \
		$mklroot/lib/libmkl_intel_thread.a \
		$mklroot/lib/libmkl_core.a -lpthread -lm"

      else
        MKL_LIBS="-L$mklroot/lib  -lmkl_intel_ilp64 \
	-lmkl_intel_thread -lmkl_core -lpthread -lm"

      fi
    else
      MKL_CFLAGS="-openmp -I$mklroot/include"

      if test x$enable_best_link = xyes; then
        MKL_LIBS="$mklroot/lib/libmkl_intel_lp64.a \
		$mklroot/lib/libmkl_intel_thread.a \
		$mklroot/lib/libmkl_core.a -lpthread -lm"

      else
        MKL_LIBS="-L$mklroot/lib -lmkl_intel_lp64 \
		-lmkl_intel_thread -lmkl_core -lpthread -lm"

      fi
    fi
  else
    MKL_CFLAGS="-openmp -I$mklroot/include"

    if test x$enable_best_link = xyes; then
    MKL_LIBS="$mklroot/lib/libmkl_intel.a \
	$mklroot/lib/libmkl_intel_thread.a \
	$mklroot/lib/libmkl_core.a -lpthread -lm"

    else
      MKL_LIBS="-L$mklroot/lib -lmkl_intel -lmkl_intel_thread \
	-lmkl_core -lpthread -lm"

    fi
  fi
else
  if test x$flag64 = xyes; then
    if test x = xyes; then
      MKL_CFLAGS="-openmp -DMKL_ILP64 -I$mklroot/include"

      if test x$enable_best_link = xyes; then
      MKL_LIBS="$startgroup,$mklroot/lib/intel64/libmkl_intel_ilp64.a,\
$mklroot/lib/intel64/libmkl_intel_thread.a,\
$mklroot/lib/intel64/libmkl_core.a,-end-group -lpthread -lm"

      else
        MKL_LIBS="-L$mklroot/lib/intel64  -lmkl_intel_ilp64 \
		-lmkl_intel_thread -lmkl_core -lpthread -lm"

      fi
    else
      MKL_CFLAGS="-openmp -I$mklroot/include"

      if test x$enable_best_link = xyes; then
        MKL_LIBS="$startgroup,$mklroot/lib/intel64/libmkl_intel_lp64.a,\
$mklroot/lib/intel64/libmkl_intel_thread.a,\
$mklroot/lib/intel64/libmkl_core.a,--end-group -lpthread -lm"

      else
        MKL_LIBS="-L$mklroot/lib/intel64 -lmkl_intel_lp64 \
	-lmkl_intel_thread -lmkl_core -lpthread -lm"

      fi
    fi
  else
    MKL_CFLAGS="-openmp -I$mklroot/include"

    if test x$enable_best_link = xyes; then
      MKL_LIBS="$startgroup,$mklroot/lib/ia32/libmkl_intel.a,\
$mklroot/lib/ia32/libmkl_intel_thread.a,\
$mklroot/lib/ia32/libmkl_core.a,--end-group -lpthread -lm"

    else
      MKL_LIBS="-L$mklroot/lib/ia32 -lmkl_intel -lmkl_intel_thread \
	-lmkl_core -lpthread -lm"

    fi
  fi
fi

MKL_LDFLAGS=""




$as_echo "#define HAVE_MKL 1" >>confdefs.h


$as_echo "#define HAVE_FFTW 1" >>confdefs.h


$as_echo "#define HAVE_LAPACK 1" >>confdefs.h


$as_echo "#define HAVE_LAPACKE 1" >>confdefs.h




cat >>confdefs.h <<_ACEOF
#define MKL_H "mkl.h"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define FFTW_H "fftw/fftw3_mkl.h"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define LAPACK_H "mkl_lapack.h"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define LAPACKE_H "mkl_lapacke.h"
_ACEOF



    if test "$MKL_WARN" != ""; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $MKL_WARN" >&5
$as_echo "$as_me: WARNING: $MKL_WARN" >&2;}
    fi
    AM_CFLAGS="$AM_CFLAGS $MKL_CFLAGS "
    AM_LDFLAGS="$AM_LDFLAGS $MKL_LDFLAGS"
    LIBS="$LIBS $MKL_LIBS"
  else
################ handle the FFTW library (Fourier transforms) ################




acx_fftw_ok=no
if test x$with_fftw_incdir = x; then
  if test x$with_fftw_libdir = x; then
    ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
if test "x$ac_cv_header_fftw3_h" = xyes; then :
  acx_fftw_ok=yes
fi


    if test x$acx_fftw_ok = xyes; then

$as_echo "#define FFTW_H \"fftw3.h\"" >>confdefs.h

    else
      ac_fn_c_check_header_mongrel "$LINENO" "fftw/fftw3.h" "ac_cv_header_fftw_fftw3_h" "$ac_includes_default"
if test "x$ac_cv_header_fftw_fftw3_h" = xyes; then :
  acx_fftw_ok=yes
fi


      if test x$acx_fftw_ok = xyes; then

$as_echo "#define FFTW_H \"fftw/fftw3.h\"" >>confdefs.h

      else
        FFTW_ERROR="FFTW include files not found in default location!"
      fi
    fi
  else
    as_ac_Header=`$as_echo "ac_cv_header_$with_fftw_libdir/include/fftw3.h" | $as_tr_sh`
ac_fn_c_check_header_mongrel "$LINENO" "$with_fftw_libdir/include/fftw3.h" "$as_ac_Header" "$ac_includes_default"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
  acx_fftw_ok=yes
fi


    if test x$acx_fftw_ok = xyes; then

$as_echo "#define FFTW_H \$with_fftw_libdir\"/include/fftw3.h" >>confdefs.h

    else
      ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
if test "x$ac_cv_header_fftw3_h" = xyes; then :
  acx_fftw_ok=yes
fi


      if test x$acx_fftw_ok = xyes; then

$as_echo "#define FFTW_H \"fftw3.h\"" >>confdefs.h

      else
        FFTW_ERROR="FFTW include files not found in $with_fftw_libdir/include!"
      fi
    fi
  fi
else
  as_ac_Header=`$as_echo "ac_cv_header_$with_fftw_incdir/fftw3.h" | $as_tr_sh`
ac_fn_c_check_header_mongrel "$LINENO" "$with_fftw_incdir/fftw3.h" "$as_ac_Header" "$ac_includes_default"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
  acx_fftw_ok=yes
fi


  if test x$acx_fftw_ok = xyes; then

cat >>confdefs.h <<_ACEOF
#define FFTW_H "$with_fftw_incdir/fftw3.h"
_ACEOF

  else
    FFTW_ERROR="FFTW include files not found in $with_fftw_incdir!"
  fi
fi


FFTW_LIBS=""
OLIBS="$LIBS"
LIBS=""

if test x$acx_fftw_ok = xyes; then
  if test x$with_fftw_libdir = x; then
    if test xyes = xyes; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwf_execute in -lfftw3f" >&5
$as_echo_n "checking for fftwf_execute in -lfftw3f... " >&6; }
if ${ac_cv_lib_fftw3f_fftwf_execute+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3f -lm $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftwf_execute ();
int
main ()
{
return fftwf_execute ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3f_fftwf_execute=yes
else
  ac_cv_lib_fftw3f_fftwf_execute=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3f_fftwf_execute" >&5
$as_echo "$ac_cv_lib_fftw3f_fftwf_execute" >&6; }
if test "x$ac_cv_lib_fftw3f_fftwf_execute" = xyes; then :
  acx_fftw_ok=yes
else
  acx_fftw_ok=no
fi

      if test x$acx_fftw_ok = xyes; then

$as_echo "#define HAVE_FFTWF 1" >>confdefs.h

        FFTW_LIBS="-lfftw3f"
      else
        FFTW_ERROR="FFTW single precision library files not found at usual locations!"
      fi
    else
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
$as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
if ${ac_cv_lib_fftw3_fftw_execute+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3 -lm $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftw_execute ();
int
main ()
{
return fftw_execute ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3_fftw_execute=yes
else
  ac_cv_lib_fftw3_fftw_execute=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_execute" >&5
$as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
if test "x$ac_cv_lib_fftw3_fftw_execute" = xyes; then :
  acx_fftw_ok=yes
else
  acx_fftw_ok=no
fi

      if test x$acx_fftw_ok = xyes; then

$as_echo "#define HAVE_FFTW 1" >>confdefs.h

        FFTW_LIBS="-lfftw3"
      else
        FFTW_ERROR="FFTW double precision library files not found at usual locations!"
      fi
    fi
    if test x$acx_fftw_ok = xyes && test x$use_pthreads = xyes; then
      if test xyes = xyes; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwf_init_threads in -lfftw3f" >&5
$as_echo_n "checking for fftwf_init_threads in -lfftw3f... " >&6; }
if ${ac_cv_lib_fftw3f_fftwf_init_threads+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3f -lm -lpthread $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftwf_init_threads ();
int
main ()
{
return fftwf_init_threads ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3f_fftwf_init_threads=yes
else
  ac_cv_lib_fftw3f_fftwf_init_threads=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3f_fftwf_init_threads" >&5
$as_echo "$ac_cv_lib_fftw3f_fftwf_init_threads" >&6; }
if test "x$ac_cv_lib_fftw3f_fftwf_init_threads" = xyes; then :
  acx_fftwt_ok=yes
else
  acx_fftwt_ok=no
fi

        if test x$acx_fftwt_ok = xyes; then

$as_echo "#define HAVE_FFTWF_MP 1" >>confdefs.h

          FFTW_LIBS="-lfftw3f"
        else
          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwf_init_threads in -lfftw3f_threads" >&5
$as_echo_n "checking for fftwf_init_threads in -lfftw3f_threads... " >&6; }
if ${ac_cv_lib_fftw3f_threads_fftwf_init_threads+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3f_threads -lfftw3f -lm -lpthread $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftwf_init_threads ();
int
main ()
{
return fftwf_init_threads ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3f_threads_fftwf_init_threads=yes
else
  ac_cv_lib_fftw3f_threads_fftwf_init_threads=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3f_threads_fftwf_init_threads" >&5
$as_echo "$ac_cv_lib_fftw3f_threads_fftwf_init_threads" >&6; }
if test "x$ac_cv_lib_fftw3f_threads_fftwf_init_threads" = xyes; then :
  acx_fftwt_ok=yes
else
  acx_fftwt_ok=no
fi

          if test x$acx_fftwt_ok = xyes; then

$as_echo "#define HAVE_FFTWF_MP 1" >>confdefs.h

            FFTW_LIBS="-lfftw3f_threads -lfftw3f"
          else
            FFTW_WARN="FFTW single precision library was compiled without multithreading support!"

          fi
        fi
      else
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_init_threads in -lfftw3" >&5
$as_echo_n "checking for fftw_init_threads in -lfftw3... " >&6; }
if ${ac_cv_lib_fftw3_fftw_init_threads+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3 -lm -lpthread $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftw_init_threads ();
int
main ()
{
return fftw_init_threads ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3_fftw_init_threads=yes
else
  ac_cv_lib_fftw3_fftw_init_threads=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_init_threads" >&5
$as_echo "$ac_cv_lib_fftw3_fftw_init_threads" >&6; }
if test "x$ac_cv_lib_fftw3_fftw_init_threads" = xyes; then :
  acx_fftwt_ok=yes
else
  acx_fftwt_ok=no
fi

        if test x$acx_fftwt_ok = xyes; then

$as_echo "#define HAVE_FFTW_MP 1" >>confdefs.h

          FFTW_LIBS="-lfftw3"
        else
          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_init_threads in -lfftw3_threads" >&5
$as_echo_n "checking for fftw_init_threads in -lfftw3_threads... " >&6; }
if ${ac_cv_lib_fftw3_threads_fftw_init_threads+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3_threads -lfftw3 -lm -lpthread $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftw_init_threads ();
int
main ()
{
return fftw_init_threads ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3_threads_fftw_init_threads=yes
else
  ac_cv_lib_fftw3_threads_fftw_init_threads=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_threads_fftw_init_threads" >&5
$as_echo "$ac_cv_lib_fftw3_threads_fftw_init_threads" >&6; }
if test "x$ac_cv_lib_fftw3_threads_fftw_init_threads" = xyes; then :
  acx_fftwt_ok=yes
else
  acx_fftwt_ok=no
fi

          if test x$acx_fftwt_ok = xyes; then

$as_echo "#define HAVE_FFTW_MP 1" >>confdefs.h

            FFTW_LIBS="-lfftw3_threads -lfftw3"
          else
            FFTW_WARN="FFTW double precision library was compiled without multithreading support!"

          fi
        fi
      fi
    fi
  else
    if test xyes = xyes; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwf_execute in -lfftw3f" >&5
$as_echo_n "checking for fftwf_execute in -lfftw3f... " >&6; }
if ${ac_cv_lib_fftw3f_fftwf_execute+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3f -L$with_fftw_libdir -lm $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftwf_execute ();
int
main ()
{
return fftwf_execute ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3f_fftwf_execute=yes
else
  ac_cv_lib_fftw3f_fftwf_execute=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3f_fftwf_execute" >&5
$as_echo "$ac_cv_lib_fftw3f_fftwf_execute" >&6; }
if test "x$ac_cv_lib_fftw3f_fftwf_execute" = xyes; then :
  acx_fftw_ok=yes
else
  acx_fftw_ok=no
fi

      if test x$acx_fftw_ok = xyes; then

$as_echo "#define HAVE_FFTWF 1" >>confdefs.h

        FFTW_LIBS="-L$with_fftw_libdir -lfftw3f"
      else
        FFTW_ERROR="FFTW single precision library files not found in $with_fftw_libdir!"
      fi
    else
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
$as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
if ${ac_cv_lib_fftw3_fftw_execute+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfftw3 -L$with_fftw_libdir -lm $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char fftw_execute ();
int
main ()
{
return fftw_execute ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_fftw3_fftw_execute=yes
else
  ac_cv_lib_fftw3_fftw_execute=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi