source: trunk/configure.ac @ 1503

## Process this file with autoconf to produce a configure script.
##
## $Id: configure.ac 1503 2008-09-16 15:43:57Z peter $

# Copyright (C) 2003 Daniel Dalevi, Jari Häkkinen
# Copyright (C) 2004 Jari Häkkinen
# Copyright (C) 2005, 2006 Jari Häkkinen, Peter Johansson
# Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson, Markus Ringnér
#
# This file is part of the yat library, http://dev.thep.lu.se/yat
#
# The yat library is free software; you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 3 of the
# License, or (at your option) any later version.
#
# The yat library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with yat. If not, see <http://www.gnu.org/licenses/>.
#
# If you grabbed the source from the subversion repository you should,
# at top-level, execute:
#     ./bootstrap
# To push subsequent changes of this file into the build scripts you
# must issue:
#     autoreconf

m4_include([./build_support/version.m4])
AC_INIT([yat],[YAT_VERSION],[jari@thep.lu.se])
AC_PREREQ(2.60)
AC_CONFIG_SRCDIR([yat/utility/Matrix.h])
AC_CONFIG_AUX_DIR([autotools])
dnl arg below should be the same as in Makefile.am
AC_CONFIG_MACRO_DIR([build_support])
AC_PREFIX_DEFAULT([/usr/local])

AC_SUBST([YAT_LT_VERSION], [LT_VERSION])
AC_SUBST([YAT_MAJOR_VERSION], [MAJOR_VERSION])
AC_SUBST([YAT_MINOR_VERSION], [MINOR_VERSION])
AC_SUBST([YAT_PATCH_VERSION], [PATCH_VERSION])
AC_SUBST([YAT_DEV_BUILD], [DEV_BUILD])

AC_CONFIG_HEADER([config.h])
AM_INIT_AUTOMAKE()

# Set default programming language
AC_LANG(C++)

# Let user overide default CXXFLAGS
if test "${CXXFLAGS+set}" != set; then
  CXXFLAGS=""  # Setting CXXFLAGS here to prevent expansion in AC_PROG_CXX
fi
# Checks for programs.
AC_PROG_CXX
AC_PROG_INSTALL
AC_PROG_SED

AC_MSG_NOTICE(dnl
[checking whether tools for generating documentation are available])

have_dox_tools="yes"
AC_PATH_PROG([DOXYGEN], [doxygen], [no])
if test "$DOXYGEN" = "no"; then
   AC_MSG_WARN([unable to find doxygen application])
   have_dox_tools=no
else
   doxygen_min_version=1.5
   AC_MSG_CHECKING([if doxygen is at least $doxygen_min_version])
   doxygen_version=`$DOXYGEN --version`
   AX_COMPARE_VERSION([$doxygen_version], [ge], [$doxygen_min_version], ,
                      [have_dox_tools=no])
   AC_MSG_RESULT([$doxygen_version])
fi
AC_CHECK_PROG([have_epstopdf], [epstopdf], [yes], [no])
if test "$have_epstopdf" != "yes"; then
   AC_MSG_WARN([unable to find epstopdf application])
   have_dox_tools=no
fi
AC_CHECK_PROG([have_latex], [latex], [yes], [no])
if test "$have_latex" != "yes"; then
   AC_MSG_WARN([unable to find latex application])
fi
AC_CHECK_PROG([have_makeindex], [makeindex], [yes], [no])
if test "$have_makeindex" != "yes"; then
   AC_MSG_WARN([unable to find makeindex application])
   have_dox_tools=no
fi
AC_CHECK_PROG([have_pdflatex], [pdflatex], [yes], [no])
if test "$have_pdflatex" != "yes"; then
   AC_MSG_WARN([unable to find pdflatex application])
   have_dox_tools=no
fi

AM_CONDITIONAL(HAVE_DOXYGEN, test "$have_dox_tools" = "yes")
AC_CONFIG_FILES([test/documentation_test.sh], 
                [chmod +x test/documentation_test.sh])

# Save user-defined environment settings for later restoration
APR_SAVE_THE_ENVIRONMENT(CPPFLAGS)
APR_SAVE_THE_ENVIRONMENT(CXXFLAGS)
APR_SAVE_THE_ENVIRONMENT(LDFLAGS)

# Checks for libraries.
AC_MSG_NOTICE([checking for libraries])
AC_CHECK_LIB(m,main)
# searching for cblas. Priority 1) find a cblas library, 2) find ATLAS
# generated cblas, and 3) fall back to GSL cblas implementation. If
# partial ATLAS is detected the configure script fails.
cblas_found="no"  # cblas_found may get values yes or no
# atlas_found may get values yes, no, or partial. In some cases
# partial atlas may be installed
atlas_found="no"
gslcblas_found="no" # gslcblas_found may get values yes or no
AC_SEARCH_LIBS(cblas_sdsdot,cblas,cblas_found="yes",
  AC_SEARCH_LIBS(ATL_sdsdot,atlas,
    AC_SEARCH_LIBS(cblas_sdsdot,cblas,atlas_found="yes",
                   atlas_found="partial",-m64),
      AC_SEARCH_LIBS(cblas_dswap,gslcblas,gslcblas_found="yes"),-m64),)
# CBLAS used in test of GSL
gsl_cblas_lib=-lgslcblas
if test ${cblas_found} = "yes"; then
  gsl_cblas_lib=-lcblas
fi
if test ${atlas_found} = "yes"; then
  YAT_CXX_ADD_FLAG([CXXFLAGS], [-m64]) 
  YAT_LD_ADD_FLAG([LDFLAGS], [-m64])
  gsl_cblas_lib=-latlas
fi
export GSL_CBLAS_LIB=${gsl_cblas_lib}

# GNU Scientific Library, GSL http://www.gnu.org/software/gsl/, checks
# Including AX_PATH_GSL macro from gsl.m4 distributed by GSL
gsl_found="no"
gsl_version="1.8"
AC_SUBST(gsl_version)
AX_PATH_GSL(${gsl_version},gsl_found="yes",gsl_version_check="no")
if test "$gsl_found" = "yes"; then
   LIBS="-lgsl $LIBS"
   # grep words starting with '-L' in other words LDFLAGS
   for i in $GSL_LIBS; do
     if test ${i:0:2} = "-L"; then
       YAT_LD_ADD_FLAG([LDFLAGS], [$i])
     fi
   done
fi

# Boost http://www.boost.org
boost_version=1.33
AC_SUBST(boost_version)
AX_BOOST_BASE("$boost_version")
boost_version_check=$succeeded;
YAT_CPP_ADD_FLAG([CPPFLAGS], [$BOOST_CPPFLAGS])

# Checks for library functions.
AC_PROG_LIBTOOL

#support for large files
AC_SYS_LARGEFILE
if test "$enable_largefile" = "no"; then
  AC_DEFINE([YAT_LFS_DISABLED], 1, 
            [defined to 1 if large file support is disabled])
fi

# we use AM_* for variables that are solely needed for building yat,
# i.e., they are not needed for a user of yat and are not propagated
# to yat-config or yat.m4.
YAT_CXX_ADD_FLAG([AM_CXXFLAGS], [-Wall])
YAT_CXX_ADD_FLAG([AM_CXXFLAGS], [-pedantic])
YAT_CPP_ADD_FLAG([CPPFLAGS], [-DHAVE_INLINE=1])
AC_ARG_ENABLE(debug,
  [AS_HELP_STRING([--enable-debug],[turn on debug options and code])])
if test "${enable_debug}" = "yes" ; then
  YAT_CPP_ADD_FLAG([AM_CPPFLAGS], [-DYAT_DEBUG=1])
  YAT_CXX_ADD_FLAG([AM_CXXFLAGS], [-g])
  YAT_CXX_ADD_FLAG([AM_CXXFLAGS], [-O])
else
  YAT_CPP_ADD_FLAG([CPPFLAGS], [-DGSL_RANGE_CHECK_OFF])
  YAT_CPP_ADD_FLAG([AM_CPPFLAGS], [-DNDEBUG])
  YAT_CXX_ADD_FLAG([AM_CXXFLAGS], [-O3])
fi

# check for quiet_NaN support in OS
# Check at run-time, but if we are cross-compiling fall back on a
# compilation test
AC_MSG_CHECKING([if std::numeric_limits<>::has_quiet_NaN is true])
AC_RUN_IFELSE(
  [AC_LANG_PROGRAM(
    [@%:@include <limits>],
    [return !std::numeric_limits<double>::has_quiet_NaN])],
  [quiet_nan=yes 
   AC_MSG_RESULT($quiet_nan)],
  [quiet_nan=no 
   AC_MSG_RESULT($quiet_nan)],
  # if we are cross-compiling fall back on compilation test
  [AC_MSG_RESULT(cross-compiling)
   AC_MSG_CHECKING([for std::numeric_limits<>::quiet_NaN()])
    AC_COMPILE_IFELSE(
     [AC_LANG_PROGRAM(
        [@%:@include <limits>
         extern void f(double);],
        [f(std::numeric_limits<double>::quiet_NaN())])],
     [quiet_nan=yes],
     [quiet_nan=no])
   AC_MSG_RESULT($quiet_nan)])
# Check for infinity support for doubles in OS
# Check at run-time, but if we are cross-compiling fall back on a
# compilation test
AC_MSG_CHECKING([if std::numeric_limits<>::has_infinity is true])
AC_RUN_IFELSE(
  [AC_LANG_PROGRAM(
    [@%:@include <limits>],
    [return !std::numeric_limits<double>::has_infinity])],
  [has_infinity=yes
   AC_MSG_RESULT($has_infinity)],
  [has_infinity=no 
   AC_MSG_RESULT($has_infinity)],
  # if we are cross-compiling fall back on compilation test
  [AC_MSG_RESULT(cross-compiling)
   AC_MSG_CHECKING([for std::numeric_limits<>::infinity()])
    AC_COMPILE_IFELSE(
     [AC_LANG_PROGRAM(
        [@%:@include <limits>
         extern void f(double);],
        [f(std::numeric_limits<double>::infinity())])],
     [has_infinity=yes],
     [has_infinity=no])
   AC_MSG_RESULT($has_infinity)])

AC_MSG_CHECKING([g++ deprecation attribute])
AC_TRY_COMPILE([void f() __attribute__ ((deprecated));], [], 
               AC_DEFINE([YAT_HAVE_GCC_DEPRECATED], [1], 
          [Define if compiler supports deprecated attribute, as in g++ 4.0]) 
               AC_MSG_RESULT([yes]),
               AC_MSG_RESULT([no]) )


# yat specific settings
YAT_LIBNAME="yat"
YAT_LIB_LOCATION="yat"
AC_SUBST(YAT_LIBNAME)
AC_SUBST(YAT_LIB)
AC_SUBST(YAT_LIB_LOCATION)

#doxygen stuff
DX_HTML_OUTPUT=html
DX_LATEX_OUTPUT=latex
AC_SUBST(DX_HTML_OUTPUT)
AC_SUBST(DX_LATEX_OUTPUT)


AC_CONFIG_FILES([Makefile
     build_support/yat.pc
     doc/Makefile
     doc/doxygen.config
     doc/first_page.doxygen
     test/Makefile
     test/environment.h
     test/data/Makefile
     yat/Makefile
     yat/classifier/Makefile
     yat/normalizer/Makefile
     yat/random/Makefile
     yat/regression/Makefile
     yat/statistics/Makefile
     yat/utility/version.h
     yat/utility/Makefile])

AC_CONFIG_FILES([build_support/yat-config],
                [chmod +x build_support/yat-config])

AC_CONFIG_HEADER([yat/utility/config_public.h])

# warning about missing doxygen
if (test "$have_dox_tools" != "yes") ; then
  AC_MSG_WARN([
  Some pre-requisites for generating documentation were not
  fulfilled. The build will not create any documentation.
  Please consult the 'README' file for more information about
  what is needed to generate documentation and refer to above
  warning messages.
  ])
fi

# Print failure status information about selected items, and exit if
# fatal errors were encountered. No output will be created if
# configure is halted prematurely.

# used to trigger exit before creation of output
all_reqs_ok="true"

# No support for quiet NAN is fatal -- sub-sequent compilation, or execution
# of created binary, will fail.
if test "${quiet_nan}" = "no" ; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  Support for quiet NAN required.
  Yat will not work on this system!])
fi

# No support for infinity is fatal -- sub-sequent compilation, or execution
# of created binary, will fail.
if test "${has_infinity}" = "no" ; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  Support for infinity required.
  Yat will not work on this system!])
fi


# Non-existing BLAS is fatal -- sub-sequent compilation will fail.
if test "${cblas_found}" = "no" -a "${atlas_found}" = "no" -a "${gslcblas_found}" = "no"; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  cBLAS not found. The C implementation of Basic Linear Algebra
  Subprograms (cBLAS) library cannot be found. Please make sure
  cBLAS is installed.])
fi
if test "${atlas_found}" = "partial"; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  Partial ATLAS BLAS library found. Please repair your installation.])
fi

# Non-existing GSL is fatal -- sub-sequent compilation will fail.
if test "${gsl_found}" = "no" ; then
  all_reqs_ok="false"
  if test "${gsl_version_check}" = "no" ; then
  AC_MSG_WARN([
  GSL found but not the required version. Please install
  GSL version ${gsl_version} or later])
  else
  AC_MSG_WARN([
  GSL not found. The GNU Scientific Library (GSL) library cannot be
  found. Please make sure GSL is installed.])
  fi
fi

# Too old Boost is fatal -- sub-sequent compilation will fail.
if test "${boost_version_check}" != "yes" ; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  Boost found but not the required version. Please install
  Boost version ${boost_version} or later])
fi

if (test "$all_reqs_ok" = "false") ; then
  AC_MSG_FAILURE([
  Some pre-requisites were not fulfilled, aborting configure.
  Please consult the 'README' file for more information about what
  is needed to compile yat and refer to above warning messages.
  Needed files were NOT created.])
fi

# Reset flags 
APR_RESTORE_THE_ENVIRONMENT(CPPFLAGS, EXTRA_)
APR_RESTORE_THE_ENVIRONMENT(CXXFLAGS, EXTRA_)
APR_RESTORE_THE_ENVIRONMENT(LDFLAGS, EXTRA_)

AM_CPPFLAGS="-I\$(top_srcdir) $AM_CPPFLAGS $EXTRA_CPPFLAGS"
AM_CXXFLAGS="$AM_CXXFLAGS $EXTRA_CXXFLAGS"
AM_LDFLAGS="$AM_LDFLAGS $EXTRA_LDFLAGS"

AC_SUBST(AM_CPPFLAGS)
AC_SUBST(AM_CXXFLAGS)
AC_SUBST(AM_LDFLAGS)

# Create output.
AC_OUTPUT

# Some more messages.
AC_MSG_NOTICE([])
AC_MSG_NOTICE([ Ready to compile the yat library])
AC_MSG_NOTICE([ The following flags and libraries will be used:])
AC_MSG_NOTICE([ +++++++++++++++++++++++++++++++++++++++++++++++])
AC_MSG_NOTICE([  CPPFLAGS=\"$CPPFLAGS\"])
AC_MSG_NOTICE([  AM_CPPFLAGS=\"$AM_CPPFLAGS\"])
AC_MSG_NOTICE([  CXXFLAGS=\"$CXXFLAGS\"])
AC_MSG_NOTICE([  AM_CXXFLAGS=\"$AM_CXXFLAGS\"])
AC_MSG_NOTICE([  LDFLAGS=\"$LDFLAGS\"])
AC_MSG_NOTICE([  AM_LDFLAGS=\"$AM_LDFLAGS\"])
AC_MSG_NOTICE([  LIBS=\"$LIBS\"])
AC_MSG_NOTICE([ +++++++++++++++++++++++++++++++++++++++++++++++])
AC_MSG_NOTICE([])
if test "${gslcblas_found}" = "yes"; then
AC_MSG_NOTICE([ GSL BLAS found. This is a reference implementation only.])
AC_MSG_NOTICE([ Consider using hardware optimized BLAS.])
AC_MSG_NOTICE([ ATLAS (http://math-atlas.sourceforge.net/) provides an])
AC_MSG_NOTICE([ optimized BLAS library. It is supported by yat!])
AC_MSG_NOTICE([])
fi
AC_MSG_NOTICE([ Now type 'make ; make check'.])