/*************************************************************************** * blitz/numinquire.h Numeric inquiry functions * * $Id: numinquire.h,v 1.1.1.1 1999-04-09 17:59:02 ansari Exp $ * * Copyright (C) 1997,1998 Todd Veldhuizen * * This program 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 2 * of the License, or (at your option) any later version. * * This program 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. * * Suggestions: blitz-suggest@cybervision.com * Bugs: blitz-bugs@cybervision.com * * For more information, please see the Blitz++ Home Page: * http://seurat.uwaterloo.ca/blitz/ * *************************************************************************** * $Log: not supported by cvs2svn $ * Revision 1.2 1998/03/14 00:04:47 tveldhui * 0.2-alpha-05 * * Revision 1.1 1997/07/16 14:51:20 tveldhui * Update: Alpha release 0.2 (Arrays) * */ /* * These numeric inquiry functions are provided as an alternative * to the somewhat klunky numeric_limits::yadda_yadda syntax. * Where a similar Fortran 90 function exists, the same name has * been used. * * The argument in all cases is a dummy of the appropriate type * (double, int, etc.) * * These functions assume that numeric_limits has been specialized * for the appropriate case. If not, the results are not useful. */ #ifndef BZ_NUMINQUIRE_H #define BZ_NUMINQUIRE_H #ifndef BZ_HAVE_NUMERIC_LIMITS #error requires from the ISO/ANSI C++ standard (you may need to rerun the compiler/bzconfig script) #endif #include #ifndef BZ_RANGE_H #include #endif BZ_NAMESPACE(blitz) /* * This traits class provides zero and one values for numeric * types. This was previously a template function with specializations, * but the specializations were causing multiply-defined symbols * at link time. TV 980226 */ template struct _bz_OneZeroTraits { static inline T_numtype zero() { return 0; } static inline T_numtype one() { return 1; } }; #ifdef BZ_HAVE_COMPLEX template<> struct _bz_OneZeroTraits > { static inline complex zero() { return complex(0.0f,0.0f); } static inline complex one() { return complex(1.0f,0.0f); } }; template<> struct _bz_OneZeroTraits > { static inline complex zero() { return complex(0.0,0.0); } static inline complex one() { return complex(1.0,0.0); } }; template<> struct _bz_OneZeroTraits > { static inline complex zero() { return complex(0.0,0.0); } static inline complex one() { return complex(1.0,0.0); } }; #endif // BZ_HAVE_COMPLEX template inline T zero(T) { return _bz_OneZeroTraits::zero(); } template inline T one(T) { return _bz_OneZeroTraits::one(); } template inline int digits(T) { return numeric_limits::digits; } template inline int digits10(T) { return numeric_limits::digits10; } template inline T epsilon(T) BZ_THROW { return numeric_limits::epsilon(); } template inline T huge(T) BZ_THROW { return numeric_limits::max(); } template inline T tiny(T) BZ_THROW { return numeric_limits::min(); } template inline int max_exponent(T) { return numeric_limits::max_exponent; } template inline int min_exponent(T) { return numeric_limits::min_exponent; } template inline int min_exponent10(T) { return numeric_limits::min_exponent10; } template inline int max_exponent10(T) { return numeric_limits::max_exponent10; } template inline int precision(T) { return numeric_limits::digits10; } template inline int radix(T) { return numeric_limits::radix; } template inline Range range(T) { return Range(numeric_limits::min_exponent10, numeric_limits::max_exponent10); } template inline bool is_signed(T) { return numeric_limits::is_signed; } template inline bool is_integer(T) { return numeric_limits::is_integer; } template inline bool is_exact(T) { return numeric_limits::is_exact; } template inline T round_error(T) BZ_THROW { return numeric_limits::round_error(); } template inline bool has_infinity(T) { return numeric_limits::has_infinity; } template inline bool has_quiet_NaN(T) { return numeric_limits::has_quiet_NaN; } template inline bool has_signaling_NaN(T) { return numeric_limits::has_signaling_NaN; } // Provided for non-US english users template inline bool has_signalling_NaN(T) { return numeric_limits::has_signaling_NaN; } template inline bool has_denorm(T) { return numeric_limits::has_denorm; } template inline bool has_denorm_loss(T) { return numeric_limits::has_denorm_loss; } template inline T infinity(T) BZ_THROW { return numeric_limits::infinity(); } template inline T quiet_NaN(T) BZ_THROW { return numeric_limits::quiet_NaN(); } template inline T signaling_NaN(T) BZ_THROW { return numeric_limits::signaling_NaN(); } template inline T signalling_NaN(T) BZ_THROW { return numeric_limits::signaling_NaN(); } template inline T denorm_min(T) BZ_THROW { return numeric_limits::denorm_min(); } template inline bool is_iec559(T) { return numeric_limits::is_iec559; } template inline bool is_bounded(T) { return numeric_limits::is_bounded; } template inline bool is_modulo(T) { return numeric_limits::is_modulo; } template inline bool traps(T) { return numeric_limits::traps; } template inline bool tinyness_before(T) { return numeric_limits::tinyness_before; } template inline std::float_round_style round_style(T) { return numeric_limits::round_style; } BZ_NAMESPACE_END #endif // BZ_NUMINQUIRE_H