/Users/mourrain/Devel/mmx/basix/include/basix/double.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : double.hpp
* DESCRIPTION: Extra routines for doubles
* COPYRIGHT  : (C) 2004  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX__DOUBLE_HPP__
#define __MMX__DOUBLE_HPP__
#include <fenv.h>
#include <basix/port.hpp>


namespace mmx {

/******************************************************************************
* Constants
******************************************************************************/

inline void set_nan (double& x) { x= NAN; }
inline void set_maximal (double& x) { x= HUGE_VAL; }
inline void set_minimal (double& x) { x= -HUGE_VAL; }
inline void set_infinity (double& x) { x= HUGE_VAL; }
inline void set_fuzz (double& x) { x= 0.0; }
inline void set_smallest (double& x) { x= nextafter (0.0, HUGE_VAL); }
inline void set_largest (double& x) { x= nextafter (HUGE_VAL, 0.0); }
inline void set_accuracy (double& x) { x= __DBL_EPSILON__; }
inline void set_log2 (double& x) { x= 0.6931471805599453094172321214581766L; }
inline void set_pi (double& x) { x= 3.1415926535897932384626433832795029L; }
inline void set_euler (double& x) { x= 0.5772156649015328606065120900824024L; }
inline double times_infinity (const double& x) { return x * HUGE_VAL; }

/******************************************************************************
* Elementary functions
******************************************************************************/

inline double sqrt (const double& x) { return std::sqrt (x); }
inline double exp (const double& x) { return std::exp (x); }
inline double exp2 (const double& x) { return ::exp2 (x); }
inline double log (const double& x) { return std::log (x); }
inline double log2 (const double& x) { return ::log2 (x); }
inline double cos (const double& x) { return std::cos (x); }
inline double sin (const double& x) { return std::sin (x); }
inline double tan (const double& x) { return std::tan (x); }
inline double cosh (const double& x) { return std::cosh (x); }
inline double sinh (const double& x) { return std::sinh (x); }
inline double tanh (const double& x) { return std::tanh (x); }
inline double acos (const double& x) { return std::acos (x); }
inline double asin (const double& x) { return std::asin (x); }
inline double atan (const double& x) { return std::atan (x); }
inline double hypot (const double& x, const double& y) {
  return ::hypot (x, y); }
inline double atan2 (const double& y, const double& x) {
  return std::atan2 (y, x); }
inline double pow (const double& x, const double& y) {
  return std::pow (x, y); }
inline double pow (const double& x, const int& y) {
  return std::pow (x, (double) y); }
inline double pow (const int& x, const double& y) {
  return std::pow ((double) x, y); }

INV_TRIGO_SUGAR(,double)
INV_HYPER_SUGAR(,double)
ARG_HYPER_SUGAR(,double)

/******************************************************************************
* Floating point related functions
******************************************************************************/

inline bool is_finite (const double& x) { return std::isfinite (x); }
inline bool is_infinite (const double& x) { return std::isinf (x); }
inline bool is_fuzz (const double& x) { (void) x; return false; }
inline bool is_nan (const double& x) { return std::isnan (x); }
inline bool is_reliable (const double& x) { (void) x; return false; }

  inline xnat precision (const double& x) { (void) x; return 51; }
inline double next_above (const double& x) { return nextafter (x, HUGE_VAL); }
inline double next_below (const double& x) { return nextafter (x, -HUGE_VAL); }
inline double rounding_error (const double& x) {
  return ldexp (abs (x), -50) + __DBL_MIN__; }
inline double additive_error (const double& x) {
  return ldexp (abs (x), -50); }

STMPL inline double magnitude (const double& x) { return log2 (x); }
inline xint exponent (const double& x) {
  return (xint) max (-10000.0, logb (x)); }

/******************************************************************************
* Shifting
******************************************************************************/

template<typename S> inline double
incexp2 (const double& x, const S& y) { return ldexp (x, y); }
inline double
incexp2 (const double& x) { return ldexp (x, 1); }
template<typename S> inline void
incexp2_assign (double& x, const S& y) { x= ldexp (x, y); }
template<typename S> inline void
incexp2 (double& x, const double& y, const S& z) { x= ldexp (y, z); }
template<typename S> inline double
decexp2 (const double& x, const S& y) { return ldexp (x, -y); }
inline double
decexp2 (const double& x) { return ldexp (x, -1); }
template<typename S> inline void
decexp2_assign (double& x, const S& y) { x= ldexp (x, -y); }
template<typename S> inline void
decexp2 (double& x, const double& y, const S& z) { x= ldexp (y, -z); }

/******************************************************************************
* Other functions
******************************************************************************/

inline int as_int (const double& x) { return (int) x; }
inline double as_double (const double& x) { return x; }

inline double square (const double& x) { return x * x; }
inline double invert (const double& x) { return 1.0 / x; }

inline double floor (const double& x) { return std::floor (x); }
inline double trunc (const double& x) { return ::trunc (x); }
inline double ceil  (const double& x) { return std::ceil (x); }
inline double round (const double& x) { return std::floor (x + 0.5); }

double uniform_deviate (const double& lo, const double& hi);

/******************************************************************************
* Utility macros for avoiding ambiguities
******************************************************************************/

#define mmx_sqrt  mmx::sqrt
#define mmx_hypot mmx::hypot
#define mmx_pow   mmx::pow
#define mmx_exp   mmx::exp
#define mmx_exp2  mmx::exp2
#define mmx_log   mmx::log
#define mmx_log2  mmx::log2
#define mmx_cos   mmx::cos
#define mmx_sin   mmx::sin
#define mmx_tan   mmx::tan
#define mmx_cosh  mmx::cosh
#define mmx_sinh  mmx::sinh
#define mmx_tanh  mmx::tanh
#define mmx_acos  mmx::acos
#define mmx_asin  mmx::asin
#define mmx_atan  mmx::atan
#define mmx_atan2 mmx::atan2
#define mmx_floor mmx::floor
#define mmx_trunc mmx::trunc
#define mmx_ceil  mmx::ceil
#define mmx_round mmx::round

}
#endif // __MMX__DOUBLE_HPP__