ivl/details/core/math/constant.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl 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 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */

#ifndef IVL_CORE_DETAILS_MATH_BASIC_HPP
#define IVL_CORE_DETAILS_MATH_BASIC_HPP

namespace ivl {

/*
extern const double epsilon;

extern const double infty;

extern const double pi;

extern const std::complex<double> i;
extern const std::complex<double> j;
*/

static const double pi = 3.14159265358979323846264338327950288419716939937510;

static const double infty = std::numeric_limits<double>::infinity();

static const double epsilon = std::numeric_limits<double>::epsilon();

namespace math {

namespace math_details {

inline double get_infty() { return infty; } // suppress unused warning

}

static const std::complex<double> i(0, 1);

static const std::complex<double> j(0, 1);

};


inline double eps(double p = 1.0)
{
        return pow(epsilon, p);
}

template<class T>
inline T inf()
{
        return std::numeric_limits<typename types::to_real<T>::type>::infinity();
}

template<class T>
inline T nan()
{
        return std::numeric_limits<typename types::to_real<T>::type>::quiet_NaN();
}

template<class T>
inline T NaN()
{
        return std::numeric_limits<typename types::to_real<T>::type>::quiet_NaN();
}

} /* namespace ivl */

#endif // IVL_CORE_DETAILS_MATH_BASIC_HPP