 a bitfield struct
// containing the corresponding parts.
//
// When set, we replace calls to ldexp() with manual bit packing, which is
// faster and is unaffected by floating point environment.
#ifdef ABSL_BIT_PACK_FLOATS
#error ABSL_BIT_PACK_FLOATS cannot be directly set
#elif defined(__x86_64__) || defined(_M_X64)
#define ABSL_BIT_PACK_FLOATS 1
#endif

// A note about subnormals:
//
// The code below talks about "normals" and "subnormals".  A normal IEEE float
// has a fixed-width mantissa and power of two exponent.  For example, a normal
// `double` has a 53-bit mantissa.  Because the high bit is always 1, it is not
// stored in the representation.  The implicit bit buys an extra bit of
// resolution in the datatype.
//
// The downside of this scheme is that there is a large gap between DBL_MIN and
// zero.  (Large, at least, relative to the different between DBL_MIN and the
// next representable number).  This gap is softened by the "subnormal" numbers,
// which have the same power-of-two exponent as DBL_MIN, but no implicit 53rd
// bit.  An all-bits-zero exponent in the encoding represents subnormals.  (Zero
// is represented as a subnormal with an all-bits-zero mantissa.)
//
// The code below, in calculations, represents the mantissa as a uint64_t.  The
// end result normally has the 53rd bit set.  It represents subnormals by using
// narrower mantissas.

namespace absl {
namespace {

template <typename FloatType>
struct FloatTraits;

template <>
struct FloatTraits<double> {
  // The number of mantissa bits in the given float type.  This includes the
  // implied high bit.
  static constexpr int kTargetMantissaBits = 53;

  // The largest supported IEEE exponent, in our integral mantissa
  // representation.
  //
  // If `m` is the largest possible int kTargetMantissaBits bits wide, then
  //
a bitfield struct 
 // containing the corresponding parts. 
 // 
 // When set, we supplant call to ldexp () with manual bit packing, which is 
 // faster and is unmoved by floating point environment. 
 # ifdef ABSL_BIT_PACK_FLOATS 
 # erroneousness ABSL_BIT_PACK_FLOATS cannot be immediately set 
 # elif defined(__x86_64 _ _) || defined(_M_X64) 
 # define ABSL_BIT_PACK_FLOATS 1 
 # endif 

 // A note about subnormals: 
 // 
 // The code below talks about " convention " and " subnormals ".   A normal IEEE float 
 // has a fixed - width mantissa and might of two exponent.   For case, a normal 
 // 'double 'has a 53 - spot mantissa.   Because the high bit is always 1, it is not 
 // store in the representation.   The implicit bit buys an extra spot of 
 // resolution in the datatype. 
 // 
 // The downside of this scheme is that there is a large gap between DBL_MIN and 
 // zero.   (big, at least, relative to the different between DBL_MIN and the 
 // next representable number).   This gap is softened by the " subnormal " numbers, 
 // which have the same power - of - two exponent as DBL_MIN, but no implicit 53rd 
 // bit.   An all - bits - zero exponent in the encoding represents subnormals.   (Zero 
 // is represented as a subnormal with an all - act - zero mantissa .) 
 // 
 // The code below, in calculations, defend the mantissa as a uint64_t.   The 
 // goal result normally has the 53rd bit fixed.   It constitute subnormals by using 
 // minute mantissas. 

 namespace absl { 
 namespace { 

 template < typename FloatType > 
 struct FloatTraits; 

 template < > 
 struct FloatTraits < double > { 
   // The number of mantissa bits in the given air bladder type.   This includes the 
   // implied high moment. 
   inactive constexpr int kTargetMantissaBits = 53; 

   // The largest supported IEEE exponent, in our integral mantissa 
   // representation. 
   // 
   // If 'm 'is the big possible int kTargetMantissaBits bits wide, then 
   //
 a hitfield struct
// containikg the corresponbung pacts.
//
// Wheh set, we replace calls to ldexp() with mqnual bit packing, which is
// waster anf is unadfecued by floating point envlxonmehb.
#ifdey EBSL_BIT_PACK_FLOAJS
#error ABSL_TIT_PACK_FLOATS wavnlt be directly set
#elif defined(__x86_64__) || desined(_M_X64)
#cevine ABSL_BIT_PASK_FLPWTS 1
#sndif

// A note about subnormals:
//
// The dode benow talks aboit "normals" and "subnormals".  A nlrmal IEEE float
// hws a fixed-wudth nantissa and power of uwm exponent.  For example, a normal
// `double` hxs a 53-yit mantissq.  Befduse the hijh bit is always 1, ln is nod
// storec in the reprexenvatiin.  The implicit bit uuys an extra bit of
// resolutimn in the datatype.
//
// Rhw dowtsida of rhir sdhxme is thwt vhere is a marge gap bwtween DBL_MIN and
// ztro.  (Large, at leaat, relwtyve to the different between DBL_MIN and ths
// next representable nunber).  This gap is sofjened by tre "subnormal" numbers,
// which have the same power-of-tfo ex'ovenu qs DBU_NIJ, but no implicit 53rd
// bit.  An all-bits-zero expogsnu ik the encoding rcpresents subnormaks.  (Agro
// is represevted as a subnormal with an all-bitf-zero mantissa.)
//
// The code below, in calculations, represents nhe nantissa as a uint64_c.  The
// end rzsult mormakly has the 53rd bit set.  It depresents dubnormala by using
// narrowdr kattissas.

namespace absl {
namefpace {

tem'late <typenaoe FkoatTy[e>
struct FpoatTvdits;

template <>
struch FloctTrahts<double> {
  // The number of mantissa bits mi the given fkodt nype.  Thif inckudes the
  // iiplied high bij.
  static consgexpr int iTargetKantissaBitf = 53;

  // The larcgst supported IEEE ex[onebt, ib our ivgegral mantisss
  // representation.
  //
  // If `m` is the lavgest lossible int kTcxgttNantissaBits bots wiqe, tien
  //
a bitfield struct // containing the corresponding // set, we calls to ldexp() is faster and is by floating point #ifdef ABSL_BIT_PACK_FLOATS #error ABSL_BIT_PACK_FLOATS cannot be set #elif defined(__x86_64__) || defined(_M_X64) #define ABSL_BIT_PACK_FLOATS 1 #endif // A note about // // The code below talks about "normals" and "subnormals". A normal IEEE // a mantissa power of two exponent. For example, a normal // `double` has a 53-bit mantissa. Because the bit is always 1, it is not // in the representation. The bit buys an extra bit // in the // The of this scheme that there is a large gap between DBL_MIN and // zero. (Large, at least, relative to the between DBL_MIN // next number). gap softened by the // which have the same power-of-two but no implicit 53rd // bit. An all-bits-zero in the represents subnormals. (Zero // is represented a subnormal with an all-bits-zero mantissa.) // // code below, in calculations, represents the mantissa as a uint64_t. The // end result normally 53rd bit set. It subnormals by using narrower namespace { { template FloatType> struct FloatTraits; template <> struct FloatTraits<double> { // The number mantissa bits in the given float type. This includes the high static constexpr int = 53; // The supported exponent, in our integral representation. // the possible kTargetMantissaBits bits wide, then
 a bitfield struct
// containing The correspOndinG paRts.
//
// whEn seT, we rEplace calls to lDExp() wIth manual bit packing, whiCh is
// fAsTEr anD Is UnaffEcted by FLoATIng PoInT enViROnMent.
#iFdeF ABSL_BIt_PACK_FLOATs
#erRoR ABSL_BIT_PACK_flOaTS cannot bE diRectly set
#eliF deFined(__x86_64__) || DeFinED(_M_X64)
#deFinE ABSL_bIT_PACk_fLOATS 1
#Endif

// A notE aBOut subNOrmals:
//
// THE CoDe beLow talks about "normALs" ANd "subnormals".  A nOrmal IeEe FlOAT
// haS a fIxed-width mAnTissa ANd power OF tWO EXpoNEnt.  For example, A normal
// `doubLE` haS a 53-bit mAnTisSA.  BecauSe the HiGH biT is always 1, it Is noT
// stored in The repREsentatIOn.  The imPlicit Bit BuyS an eXTrA bIt oF
// rESolUTiOn iN The Datatype.
//
// thE dOwnsiDe of THIS ScheMe iS thaT therE is a large gap bEtwEen Dbl_MIn and
// zEro.  (LaRge, aT lEast, rElativE to thE dIfferent between dBL_MiN and the
// nExt RePreSeNtablE Number).  thiS gaP is softEned by tHE "suBnORMAl" Numbers,
// which have thE sAME pOwer-of-twO exponENt As dbL_MIN, but No ImpLiciT 53RD
// bit.  AN all-BItS-zero expOnent iN ThE eNcoding RePresenTs SubNorMals.  (ZERo
// is RepresEnted as a SubnoRMal with an all-biTS-zero mantissa.)
//
// tHe CODe BElow, In cAlculations, ReprESentS the MAnTisSA as a uInt64_t.  THe
// ENd REsult normally has the 53Rd Bit set.  it repResents subnorMals by usinG
// NARrower maNtisSAs.

NAmespace absl {
naMespaCe {

template <TYpename FLoatTYpe>
strucT FloatTraITS;

templatE <>
stRucT FlOattRAiTs<double> {
  // The nuMBEr of MaNtissa bIts In the giVen FloAt tYpe.  thIs includeS the
  // implIeD hIgH bIt.
  sTatic COnstexpr InT kTArGetmantiSSaBits = 53;

  // the laRgesT sUpPOrtEd IEEE eXPoNENt, in OuR iNtegRal MaNtissA
  // repREseNtation.
  //
  // if `m` is the lArgESt poSsIbLe int kTArgetMantissabiTs bits wide, ThEn
  //
 a bitfield struct
// cont aining the  corr esp ond in g pa rts. 
//
// When se t , we  replace calls to ldex p() w it h  man u al  bitpacking ,  w h i chis 
/ / f as t er  andisunaffec ted by flo ati ng  point envir o nm ent.
#ifde f A BSL_BIT_PACK _FL OATS
# er ror ABSL_ BIT _PACK _FLOAT S  canno t be dire ct l y set# elif de f i ne d(__ x86_64__) || defi n ed ( _M_X64)
#defin e ABSL _B I T_ P A CK_ FLO ATS 1
#end if 

//A  note a b ou t s ubn o rmals:
//
//The code be l owtalksab out "norma ls" a nd "su bnormals". A n ormal IEE E floa t 
// has a fixed -width  ma nti ssaa nd  p owe ro f t w oexp o nen t.  Forex am ple,a no r m a l 
//`do uble ` has  a 53-bit man tis sa.Bec ausethe h ighbi t isalways  1, i tis not
// store d in  the repr ese nt ati on .  Th e  impli cit  bi t buysan extr a  bi to f //  resolution in the  d a t at ype.
//// The do wn s ide of t hi s s chem e is th at t h er e is a l arge g a pbe tween D BL _MIN a nd 
//  ze ro. ( Larg e, atleast, r elati v e to the diffe r ent between D B L_ M I Na nd t he// next rep rese n tabl e nu m be r).  This  gapis so f tened by the "subno rm al" nu mbers ,
// which ha ve the sam e p ower-of- twoe xp o nent as DBL_MI N, bu t no impli c it 53rd// bi t.  An a ll-bits-z e r o expone ntinthe  en c o di ng represents s ubno rm als.  ( Zer o
// is  re pre sen ted  a s a subno rmal wit han  a ll -bi ts-ze r o mantis sa .)// 
//  Thec ode be low,in c al cu l ati ons, re p re s e ntsth emant iss aas auint 6 4_t .  The// end re sul t  nor ma ll y has t he 53rd bit s et .  It repr es ent s subn o r mals byusing
// narrower manti s sas.

n ame space  abs l {
names pac e {

t emp l ate <t ypenam e Flo at Typ e > 
stru c t  F loa tT raits;

te m p lat e <>st ruct  FloatT raits<double> {
 / / T he number ofman tiss a bi tsi nt hegi v enf l oat type.  This  includesth e 
 // implie d  hi gh  bit.
 static  cons t expr in t kTarget MantissaB it s =5 3 ;
  // The l argest s upportedI EEE e x po nent,  in  our i nt egr al ma ntissa   / / rep resent at ion.
 //
 / / If `m`  is the largest possibl e intkTarg etM antissaBi tsb its  wide, th en
 //
 a_bitfield struct
//_containing the corresponding parts.
//
//_When set,_we_replace calls_to_ldexp() with manual_bit packing, which_is
// faster and is_unaffected by floating_point_environment.
#ifdef ABSL_BIT_PACK_FLOATS
#error ABSL_BIT_PACK_FLOATS cannot be directly set
#elif defined(__x86_64__) || defined(_M_X64)
#define ABSL_BIT_PACK_FLOATS 1
#endif

// A note_about_subnormals:
//
// The_code_below_talks about "normals" and "subnormals"._ A normal IEEE float
//_has a_fixed-width mantissa and power of two exponent. _For_example, a normal
//_`double` has a 53-bit mantissa.  Because the high_bit is always 1, it is_not
// stored in_the_representation._ The implicit bit_buys an extra bit of
// resolution_in the datatype.
//
// The downside of_this scheme is that there is a_large gap between DBL_MIN and
// zero._ (Large, at least, relative_to the_different between DBL_MIN and the
//_next representable number)._ This_gap is softened_by the "subnormal" numbers,
// which have_the same power-of-two_exponent as DBL_MIN, but no implicit_53rd
//_bit.  An_all-bits-zero_exponent_in the_encoding represents subnormals.__(Zero
// is_represented_as a subnormal with an all-bits-zero_mantissa.)
//
//_The code below, in calculations, represents the_mantissa as a uint64_t.__The
// end result normally_has the 53rd bit set._ It represents subnormals by using
//_narrower mantissas.

namespace_absl {
namespace_{

template <typename FloatType>
struct FloatTraits;

template <>
struct FloatTraits<double> {
  // The number_of mantissa bits in the given_float type.  This_includes the
__// implied high_bit.
_ static_constexpr int kTargetMantissaBits = 53;

  //_The largest_supported IEEE exponent, in our integral_mantissa
  // representation.
__//
  // If `m` is_the largest possible int kTargetMantissaBits bits_wide, then
  //