source: branches/0.5-stable/configure.ac @ 2079

## Process this file with autoconf to produce a configure script.
##
## $Id: configure.ac 2079 2009-10-14 00:34:04Z 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
# Copyright (C) 2009 Jari Häkkinen, Peter Johansson
#
# 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([m4/version.m4])
AC_INIT([yat],[YAT_VERSION],[jari@thep.lu.se])
AC_PREREQ(2.61)
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([m4])
AC_PREFIX_DEFAULT([/usr/local])

AC_SUBST([YAT_LT_VERSION], [YAT_LT_VERSION_INFO])
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([1.10 std-options])

# Set default programming language
AC_LANG(C++)

# propagate selected configure variables to DISTCHECK_CONFIGURE_FLAGS
for var in CPPFLAGS CXX CXXFLAGS CXXCPP LDFLAGS LIBS; do
  eval isset=\${$var+set}
  if test "$isset" = 'set' ; then
    eval val=$`echo $var`
    DISTCHECK_CONFIGURE_FLAGS="${DISTCHECK_CONFIGURE_FLAGS}'${var}=${val}' "
  fi
done
AC_SUBST(DISTCHECK_CONFIGURE_FLAGS) 

# 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_PROG_LIBTOOL
# fall back to echo unless ECHO not already set (by libtool)
AS_IF([test "x$ECHO" = x], [ECHO=echo])
AC_SUBST(ECHO)

AC_CHECK_PROGS([MD5], [md5sum md5 md5deep], [no])

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

have_doxygen=no
dx_enable_latex=no
dx_enable_dvi=no
dx_enable_ps=no
dx_enable_pdf=no
AC_PATH_PROG([DOXYGEN], [doxygen], [no])
if test "$DOXYGEN" = "no"; then
   AC_MSG_WARN([unable to find doxygen application])
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_doxygen=yes])
   AC_MSG_RESULT([$doxygen_version])
   dx_enable_latex=yes
   # doxygen 1.5.8 has a bug for latex output and enums
   AS_IF([test $have_doxygen = yes],
         [AX_COMPARE_VERSION([$doxygen_version], [eq], [1.5.8],
                             [dx_enable_latex=no])])
fi

# we need latex output to generate dvi, ps, and pdf
AS_IF([test $dx_enable_latex = yes],
  [dx_enable_pdf=yes
   ACLTX_PROG_PDFLATEX([dx_enable_pdf=no])
   ACLTX_PROG_MAKEINDEX([dx_enable_pdf=no])
   dx_enable_dvi=yes
   ACLTX_PROG_LATEX([dx_enable_dvi=no])
   # ps needs dvi
   dx_enable_ps=$dx_enable_dvi
   ACLTX_PROG_DVIPS([dx_enable_ps=no])
  ]
)

AC_SUBST(have_doxygen)
AM_CONDITIONAL([DX_ENABLE_HTML], [test x$have_doxygen = xyes])
AM_CONDITIONAL([DX_ENABLE_LATEX], [test x$dx_enable_latex = xyes])
AM_CONDITIONAL([DX_ENABLE_DVI], [test x$dx_enable_dvi = xyes])
AM_CONDITIONAL([DX_ENABLE_PS], [test x$dx_enable_ps = xyes])
AM_CONDITIONAL([DX_ENABLE_PDF], [test x$dx_enable_pdf = xyes])
AC_CONFIG_FILES([test/documentation_test.sh], 
                [chmod +x test/documentation_test.sh])

# 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_COMPILE_IFELSE(
   [AC_LANG_PROGRAM([[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])] )

AC_MSG_CHECKING([if std::multiset::iterator is mutable])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <set> 
                                     @%:@include <vector>]],
                                   [[std::set<std::vector<double> > s;
                                     std::vector<double> v;
                                     s.insert(v);
                                     s.begin()->reserve(100);
                                   ]])],
                  [AC_DEFINE([MULTISET_ITERATOR_IS_MUTABLE], [1], 
                             [Define if std::multiset::iterator is mutable]) 
                   AC_MSG_RESULT([yes])
                  ],
                  [AC_MSG_RESULT([no])] )

# 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_LIBM
AS_IF([test "x$LIBM" != x], [LIBS="$LIBM $LIBS"]) 
# 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_srot,cblas,atlas_found="yes",
                   atlas_found="partial",-m64),
      [gslcblas_found="yes"],-m64),)

# 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
   if test "x$gslcblas_found" = "xyes"; then
     LIBS="-lgslcblas $LIBS";
   fi
   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
   YAT_CPP_ADD_FLAG([CPPFLAGS], [`$GSL_CONFIG --cflags`])
else
   gslcblas="no";
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])

#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 -pedantic])
YAT_CPP_ADD_FLAG([AM_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 -O])
else
  YAT_CPP_ADD_FLAG([AM_CPPFLAGS], [-DGSL_RANGE_CHECK_OFF -DNDEBUG])
  YAT_CXX_ADD_FLAG([AM_CXXFLAGS], [-O3])
fi

# some versions of boost uses long long - turn off compiler warnings
# with -Wno-long-long
yat_save_CXXFLAGS=$CXXFLAGS
# use -pedantic and friends in CXXFLAGS temporarily 
CXXFLAGS="$AM_CXXFLAGS $CXXFLAGS"
# turn warnings into errors
YAT_CXX_ADD_FLAG([CXXFLAGS], [-Werror])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
  [
    @%:@include <boost/iterator/transform_iterator.hpp>
    @%:@include <cmath>
    @%:@include <functional>
    @%:@include <vector>
  ],[
      using namespace boost;
      typedef std::pointer_to_unary_function<double, double> F;
      std::vector<double> vec;
      transform_iterator<F, std::vector<double>::iterator> 
        i(vec.begin(), std::ptr_fun(fabs));
  ])],
[],
[YAT_CXX_ADD_FLAG([AM_CXXFLAGS], [-Wno-long-long])])
# restore CXXFLAGS
CXXFLAGS=$yat_save_CXXFLAGS

AC_ARG_ENABLE([svn-support],
              [AS_HELP_STRING([--enable-svn-support],
                              [enable svn support - used by yat maintainer])])

if test "x$enable_svn-support" = "xyes"; then
  svn_error_msg="svn support cannot be enabled:"
  AS_IF([test "x$MD5" = "xno"],
        [AC_MSG_ERROR([$svn_error_msg tool to create md5 file not found])])

  AC_CHECK_FILE([$srcdir/.svn], ,
                AC_MSG_ERROR([$svn_error_msg `$srcdir' is not an svn wc.]))
  AC_PATH_PROG([PERL], [perl], [no])
  if test "x$PERL" = "xno"; then
    AC_MSG_ERROR([$svn_error_msg perl executable not found.])
  fi
  AC_PROG_PERL_MODULES([strict Cwd File::Path Getopt::Long Pod::Usage], , 
         [AC_MSG_ERROR([$svn_error_msg missing some perl module.])])
fi
AM_CONDITIONAL([ENABLE_SVN_SUPPORT], [test "x$enable_svn_support" = "xyes"])


# 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([test/create_yathello.sh], [chmod +x test/create_yathello.sh])
AC_CONFIG_FILES([Makefile
     build_support/Makefile
     doc/Makefile
     doc/doxygen.config
     doc/first_page.doxygen
     m4/Makefile
     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_HEADER([yat/utility/config_public.h])

# 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])
AS_IF([test x$have_doxygen = xyes],
  [AC_MSG_NOTICE([ Documentation will be generated in the following formats:])
   AC_MSG_NOTICE([   html])
   AS_IF([test x$dx_enable_pdf = xyes], [AC_MSG_NOTICE([   pdf])])
   AS_IF([test x$dx_enable_ps = xyes],  [AC_MSG_NOTICE([   ps])])
   AS_IF([test x$dx_enable_dvi = xyes], [AC_MSG_NOTICE([   dvi])])
  ],
  [AC_MSG_NOTICE([Generation of documentation is disabled])
   AC_MSG_NOTICE([doxygen could not be found])
  ])
AC_MSG_NOTICE()
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'.])