home | help 
std::numeri...ness_before(3)   C++ Standard Libary  std::numeri...ness_before(3)

NAME
     std::numeric_limits::tinyness_before - std::numeric_limits::tinyness_before

Synopsis
	static const bool tinyness_before;	(until C++11)
	static constexpr bool tinyness_before;	(since C++11)

	The  value  of	std::numeric_limits<T>::tinyness_before  is true for all
     floating-point
	types T that test results of floating-point  expressions  for  underflow
     before
	rounding.

Standard specializations
	T				  value of std::numeric_limits<T>::tiny-
     ness_before
	/* non-specialized */		 false
	bool				 false
	char				 false
	signed char			 false
	unsigned char			 false
	wchar_t 			 false
	char8_t (since C++20)		 false
	char16_t (since C++11)		 false
	char32_t (since C++11)		 false
	short				 false
	unsigned short			 false
	int				 false
	unsigned int			 false
	long				 false
	unsigned long			 false
	long long (since C++11) 	 false
	unsigned long long (since C++11) false
	float				 implementation-defined
	double				 implementation-defined
	long double			 implementation-defined

Notes
	Standard-compliant IEEE 754 floating-point implementations are	required
     to detect
	the  floating-point underflow, and have two alternative situations where
     this can be
	done

	 1. Underflow occurs (and FE_UNDERFLOW may be raised) if  a  computation
     produces a
	    result  whose  absolute  value, computed as though both the exponent
     range and the
	    precision  were  unbounded,  is   smaller	than   std::numeric_lim-
     its<T>::min(). Such
	    implementation  detects  tinyness  before rounding (e.g. UltraSparc,
     POWER).
	 2. Underflow occurs (and FE_UNDERFLOW	may  be  raised)  if  after  the
     rounding of the
	    result to the target floating-point type (that is, rounding to
	    std::numeric_limits<T>::digits bits), the result's absolute value is
     smaller
	    than  std::numeric_limits<T>::min(). Formally, the absolute value of
     a nonzero
	    result computed as though  the  exponent  range  were  unbounded  is
     smaller than
	    std::numeric_limits<T>::min().  Such implementation detects tinyness
     after
	    rounding (e.g. SuperSparc).

Example
	Multiplication of the largest subnormal number by the number one machine
     epsilon
	greater than 1.0 gives the tiny  value	0x0.fffffffffffff8p-1022  before
     rounding, but
	normal	value 1p-1022 after rounding. The implementation used to execute
     this test
	(IBM Power7) detects tinyness before rounding.

     // Run this code

      #include <iostream>
      #include <limits>
      #include <cmath>
      #include <cfenv>

      int main()
      {
	  std::cout << "Tinyness before: " << std::boolalpha
		    << std::numeric_limits<double>::tinyness_before << '\n';

	  double denorm_max = std::nextafter(std::numeric_limits<double>::min(),
     0);
	  double multiplier = 1 + std::numeric_limits<double>::epsilon();

	  std::feclearexcept(FE_ALL_EXCEPT);

	  double result = denorm_max * multiplier; // Underflow  only  if  tiny-
     ness_before

	  if (std::fetestexcept(FE_UNDERFLOW))
	      std::cout << "Underflow detected\n";

	  std::cout << std::hexfloat << denorm_max << " x " << multiplier  <<  "
     = "
		    << result << '\n';
      }

Possible output:
      Tinyness before: true
      Underflow detected
      0xf.ffffffffffffp-1030 x 0x1.0000000000001p+0 = 0x1p-1022

See also
	has_denorm_loss  identifies the floating-point types that detect loss of
     precision as
	[static]	denormalization loss rather than inexact result
			(public static member constant)
	has_denorm	identifies the denormalization style used by the  float-
     ing-point type
	[static]	(public static member constant)

http://cppreference.com 	   2024.06.10	    std::numeri...ness_before(3)
home | help