Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
FIX::double_conversion::Double Class Reference

Public Member Functions

 Double ()
 Double (double d)
 Double (uint64_t d64)
 Double (DiyFp diy_fp)
DiyFp AsDiyFp () const
DiyFp AsNormalizedDiyFp () const
uint64_t AsUint64 () const
double NextDouble () const
double PreviousDouble () const
int Exponent () const
uint64_t Significand () const
bool IsDenormal () const
bool IsSpecial () const
bool IsNan () const
bool IsInfinite () const
int Sign () const
DiyFp UpperBoundary () const
void NormalizedBoundaries (DiyFp *out_m_minus, DiyFp *out_m_plus) const
bool LowerBoundaryIsCloser () const
double value () const

Static Public Member Functions

static int SignificandSizeForOrderOfMagnitude (int order)
static double Infinity ()
static double NaN ()

Static Public Attributes

static const uint64_t kSignMask = UINT64_2PART_C(0x80000000, 00000000)
static const uint64_t kExponentMask = UINT64_2PART_C(0x7FF00000, 00000000)
static const uint64_t kSignificandMask = UINT64_2PART_C(0x000FFFFF, FFFFFFFF)
static const uint64_t kHiddenBit = UINT64_2PART_C(0x00100000, 00000000)
static const int kPhysicalSignificandSize = 52
static const int kSignificandSize = 53

Private Member Functions

 DISALLOW_COPY_AND_ASSIGN (Double)

Static Private Member Functions

static uint64_t DiyFpToUint64 (DiyFp diy_fp)

Private Attributes

const uint64_t d64_

Static Private Attributes

static const int kExponentBias = 0x3FF + kPhysicalSignificandSize
static const int kDenormalExponent = -kExponentBias + 1
static const int kMaxExponent = 0x7FF - kExponentBias
static const uint64_t kInfinity = UINT64_2PART_C(0x7FF00000, 00000000)
static const uint64_t kNaN = UINT64_2PART_C(0x7FF80000, 00000000)

Detailed Description

Definition at line 42 of file FieldConvertors.cpp.

Constructor & Destructor Documentation

◆ Double() [1/4]

FIX::double_conversion::Double::Double ( )
inline

Definition at line 51 of file FieldConvertors.cpp.

References FIX::DoubleConvertor::SIGNIFICANT_DIGITS.

◆ Double() [2/4]

FIX::double_conversion::Double::Double ( double d)
inlineexplicit

Definition at line 52 of file FieldConvertors.cpp.

References FIX::DoubleConvertor::SIGNIFICANT_DIGITS.

◆ Double() [3/4]

FIX::double_conversion::Double::Double ( uint64_t d64)
inlineexplicit

Definition at line 53 of file FieldConvertors.cpp.

References FIX::DoubleConvertor::SIGNIFICANT_DIGITS.

◆ Double() [4/4]

FIX::double_conversion::Double::Double ( DiyFp diy_fp)
inlineexplicit

Definition at line 54 of file FieldConvertors.cpp.

Member Function Documentation

◆ AsDiyFp()

DiyFp FIX::double_conversion::Double::AsDiyFp ( ) const
inline

Definition at line 59 of file FieldConvertors.cpp.

◆ AsNormalizedDiyFp()

DiyFp FIX::double_conversion::Double::AsNormalizedDiyFp ( ) const
inline

Definition at line 66 of file FieldConvertors.cpp.

69 {
70 double_conversion::StringBuilder builder( buffer, size );
71 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
72 {
73 builder.Reset();
74 return 0;
75 }
76
77 builder.TrimTrailingZeros();
78 return builder.position();
79 }
80
FIX::double_conversion::Double::value
double value() const
Definition FieldConvertors.cpp:200
FIX::g_dtoa_converter
static double_conversion::DoubleToStringConverter g_dtoa_converter(double_conversion::DoubleToStringConverter::NO_FLAGS, "INF", "NAN", 'e', -DoubleConvertor::SIGNIFICANT_DIGITS, DoubleConvertor::SIGNIFICANT_DIGITS, DoubleConvertor::SIGNIFICANT_DIGITS - 1, 0)
FIX::DoubleConvertor::SIGNIFICANT_DIGITS
static const int SIGNIFICANT_DIGITS
Definition FieldConvertors.h:252

◆ AsUint64()

uint64_t FIX::double_conversion::Double::AsUint64 ( ) const
inline

Definition at line 83 of file FieldConvertors.cpp.

85 {

◆ DISALLOW_COPY_AND_ASSIGN()

FIX::double_conversion::Double::DISALLOW_COPY_AND_ASSIGN ( Double )
private

◆ DiyFpToUint64()

uint64_t FIX::double_conversion::Double::DiyFpToUint64 ( DiyFp diy_fp)
inlinestaticprivate

Definition at line 233 of file FieldConvertors.cpp.

263{
264
265// we include "double-conversion" project in FIX namespace
266// to avoid linking errors if quickfix is linked statically
267// and "double-conversion" is already used by target project
268
269#include "double-conversion/diy-fp.cc"
270#include "double-conversion/fixed-dtoa.cc"
271#include "double-conversion/bignum.cc"
272#include "double-conversion/bignum-dtoa.cc"
273#include "double-conversion/cached-powers.cc"
274#include "double-conversion/fast-dtoa.cc"
275#include "double-conversion/strtod.cc"
276#include "double-conversion/double-conversion.cc"
277
278 static double_conversion::DoubleToStringConverter g_dtoa_converter(
279 double_conversion::DoubleToStringConverter::NO_FLAGS,
280 "INF",
281 "NAN",
282 'e',
283 -DoubleConvertor::SIGNIFICANT_DIGITS,
284 DoubleConvertor::SIGNIFICANT_DIGITS,
285 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
286 0);
287
288 static double_conversion::StringToDoubleConverter g_atod_converter(
289 double_conversion::StringToDoubleConverter::NO_FLAGS,
290 std::numeric_limits<double>::quiet_NaN(),
291 std::numeric_limits<double>::quiet_NaN(),
292 "INF",
293 "NAN");
294
295 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
296 {
297 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
298 }
299
300 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
301 {
302 double_conversion::StringBuilder builder( buffer, size );
303 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
304 {
305 builder.Reset();
306 return 0;
307 }
308
309 builder.TrimTrailingZeros();
310 return builder.position();
311 }
312
313 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
314 {
315 double_conversion::StringBuilder builder( buffer, size );
316 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
317 {
318 builder.Reset();
319 return 0;
320 }
321
322 return builder.position();
323 }
324
325}
FIX::g_atod_converter
static double_conversion::StringToDoubleConverter g_atod_converter(double_conversion::StringToDoubleConverter::NO_FLAGS, std::numeric_limits< double >::quiet_NaN(), std::numeric_limits< double >::quiet_NaN(), "INF", "NAN")
FIX::DoubleConvertor::fast_fixed_dtoa
static int fast_fixed_dtoa(char *buffer, int size, double value)
Definition FieldConvertors.cpp:81
FIX::DoubleConvertor::fast_strtod
static double fast_strtod(const char *buffer, int size, int *processed_chars)
Definition FieldConvertors.cpp:63
FIX::DoubleConvertor::fast_dtoa
static int fast_dtoa(char *buffer, int size, double value)
Definition FieldConvertors.cpp:68

◆ Exponent()

int FIX::double_conversion::Double::Exponent ( ) const
inline

Definition at line 111 of file FieldConvertors.cpp.

141{
142
143// we include "double-conversion" project in FIX namespace
144// to avoid linking errors if quickfix is linked statically
145// and "double-conversion" is already used by target project
146
147#include "double-conversion/diy-fp.cc"
148#include "double-conversion/fixed-dtoa.cc"
149#include "double-conversion/bignum.cc"
150#include "double-conversion/bignum-dtoa.cc"
151#include "double-conversion/cached-powers.cc"
152#include "double-conversion/fast-dtoa.cc"
153#include "double-conversion/strtod.cc"
154#include "double-conversion/double-conversion.cc"
155
156 static double_conversion::DoubleToStringConverter g_dtoa_converter(
157 double_conversion::DoubleToStringConverter::NO_FLAGS,
158 "INF",
159 "NAN",
160 'e',
161 -DoubleConvertor::SIGNIFICANT_DIGITS,
162 DoubleConvertor::SIGNIFICANT_DIGITS,
163 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
164 0);
165
166 static double_conversion::StringToDoubleConverter g_atod_converter(
167 double_conversion::StringToDoubleConverter::NO_FLAGS,
168 std::numeric_limits<double>::quiet_NaN(),
169 std::numeric_limits<double>::quiet_NaN(),
170 "INF",
171 "NAN");
172
173 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
174 {
175 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
176 }
177
178 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
179 {
180 double_conversion::StringBuilder builder( buffer, size );
181 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
182 {
183 builder.Reset();
184 return 0;
185 }
186
187 builder.TrimTrailingZeros();
188 return builder.position();
189 }
190
191 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
192 {
193 double_conversion::StringBuilder builder( buffer, size );
194 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
195 {
196 builder.Reset();
197 return 0;
198 }
199
200 return builder.position();
201 }
202
203}

◆ Infinity()

double FIX::double_conversion::Double::Infinity ( )
inlinestatic

Definition at line 216 of file FieldConvertors.cpp.

246{
247
248// we include "double-conversion" project in FIX namespace
249// to avoid linking errors if quickfix is linked statically
250// and "double-conversion" is already used by target project
251
252#include "double-conversion/diy-fp.cc"
253#include "double-conversion/fixed-dtoa.cc"
254#include "double-conversion/bignum.cc"
255#include "double-conversion/bignum-dtoa.cc"
256#include "double-conversion/cached-powers.cc"
257#include "double-conversion/fast-dtoa.cc"
258#include "double-conversion/strtod.cc"
259#include "double-conversion/double-conversion.cc"
260
261 static double_conversion::DoubleToStringConverter g_dtoa_converter(
262 double_conversion::DoubleToStringConverter::NO_FLAGS,
263 "INF",
264 "NAN",
265 'e',
266 -DoubleConvertor::SIGNIFICANT_DIGITS,
267 DoubleConvertor::SIGNIFICANT_DIGITS,
268 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
269 0);
270
271 static double_conversion::StringToDoubleConverter g_atod_converter(
272 double_conversion::StringToDoubleConverter::NO_FLAGS,
273 std::numeric_limits<double>::quiet_NaN(),
274 std::numeric_limits<double>::quiet_NaN(),
275 "INF",
276 "NAN");
277
278 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
279 {
280 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
281 }
282
283 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
284 {
285 double_conversion::StringBuilder builder( buffer, size );
286 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
287 {
288 builder.Reset();
289 return 0;
290 }
291
292 builder.TrimTrailingZeros();
293 return builder.position();
294 }
295
296 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
297 {
298 double_conversion::StringBuilder builder( buffer, size );
299 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
300 {
301 builder.Reset();
302 return 0;
303 }
304
305 return builder.position();
306 }
307
308}

◆ IsDenormal()

bool FIX::double_conversion::Double::IsDenormal ( ) const
inline

Definition at line 131 of file FieldConvertors.cpp.

161{
162
163// we include "double-conversion" project in FIX namespace
164// to avoid linking errors if quickfix is linked statically
165// and "double-conversion" is already used by target project
166
167#include "double-conversion/diy-fp.cc"
168#include "double-conversion/fixed-dtoa.cc"
169#include "double-conversion/bignum.cc"
170#include "double-conversion/bignum-dtoa.cc"
171#include "double-conversion/cached-powers.cc"
172#include "double-conversion/fast-dtoa.cc"
173#include "double-conversion/strtod.cc"
174#include "double-conversion/double-conversion.cc"
175
176 static double_conversion::DoubleToStringConverter g_dtoa_converter(
177 double_conversion::DoubleToStringConverter::NO_FLAGS,
178 "INF",
179 "NAN",
180 'e',
181 -DoubleConvertor::SIGNIFICANT_DIGITS,
182 DoubleConvertor::SIGNIFICANT_DIGITS,
183 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
184 0);
185
186 static double_conversion::StringToDoubleConverter g_atod_converter(
187 double_conversion::StringToDoubleConverter::NO_FLAGS,
188 std::numeric_limits<double>::quiet_NaN(),
189 std::numeric_limits<double>::quiet_NaN(),
190 "INF",
191 "NAN");
192
193 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
194 {
195 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
196 }
197
198 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
199 {
200 double_conversion::StringBuilder builder( buffer, size );
201 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
202 {
203 builder.Reset();
204 return 0;
205 }
206
207 builder.TrimTrailingZeros();
208 return builder.position();
209 }
210
211 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
212 {
213 double_conversion::StringBuilder builder( buffer, size );
214 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
215 {
216 builder.Reset();
217 return 0;
218 }
219
220 return builder.position();
221 }
222
223}

◆ IsInfinite()

bool FIX::double_conversion::Double::IsInfinite ( ) const
inline

Definition at line 149 of file FieldConvertors.cpp.

179{
180
181// we include "double-conversion" project in FIX namespace
182// to avoid linking errors if quickfix is linked statically
183// and "double-conversion" is already used by target project
184
185#include "double-conversion/diy-fp.cc"
186#include "double-conversion/fixed-dtoa.cc"
187#include "double-conversion/bignum.cc"
188#include "double-conversion/bignum-dtoa.cc"
189#include "double-conversion/cached-powers.cc"
190#include "double-conversion/fast-dtoa.cc"
191#include "double-conversion/strtod.cc"
192#include "double-conversion/double-conversion.cc"
193
194 static double_conversion::DoubleToStringConverter g_dtoa_converter(
195 double_conversion::DoubleToStringConverter::NO_FLAGS,
196 "INF",
197 "NAN",
198 'e',
199 -DoubleConvertor::SIGNIFICANT_DIGITS,
200 DoubleConvertor::SIGNIFICANT_DIGITS,
201 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
202 0);
203
204 static double_conversion::StringToDoubleConverter g_atod_converter(
205 double_conversion::StringToDoubleConverter::NO_FLAGS,
206 std::numeric_limits<double>::quiet_NaN(),
207 std::numeric_limits<double>::quiet_NaN(),
208 "INF",
209 "NAN");
210
211 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
212 {
213 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
214 }
215
216 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
217 {
218 double_conversion::StringBuilder builder( buffer, size );
219 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
220 {
221 builder.Reset();
222 return 0;
223 }
224
225 builder.TrimTrailingZeros();
226 return builder.position();
227 }
228
229 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
230 {
231 double_conversion::StringBuilder builder( buffer, size );
232 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
233 {
234 builder.Reset();
235 return 0;
236 }
237
238 return builder.position();
239 }
240
241}

◆ IsNan()

bool FIX::double_conversion::Double::IsNan ( ) const
inline

Definition at line 143 of file FieldConvertors.cpp.

173{
174
175// we include "double-conversion" project in FIX namespace
176// to avoid linking errors if quickfix is linked statically
177// and "double-conversion" is already used by target project
178
179#include "double-conversion/diy-fp.cc"
180#include "double-conversion/fixed-dtoa.cc"
181#include "double-conversion/bignum.cc"
182#include "double-conversion/bignum-dtoa.cc"
183#include "double-conversion/cached-powers.cc"
184#include "double-conversion/fast-dtoa.cc"
185#include "double-conversion/strtod.cc"
186#include "double-conversion/double-conversion.cc"
187
188 static double_conversion::DoubleToStringConverter g_dtoa_converter(
189 double_conversion::DoubleToStringConverter::NO_FLAGS,
190 "INF",
191 "NAN",
192 'e',
193 -DoubleConvertor::SIGNIFICANT_DIGITS,
194 DoubleConvertor::SIGNIFICANT_DIGITS,
195 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
196 0);
197
198 static double_conversion::StringToDoubleConverter g_atod_converter(
199 double_conversion::StringToDoubleConverter::NO_FLAGS,
200 std::numeric_limits<double>::quiet_NaN(),
201 std::numeric_limits<double>::quiet_NaN(),
202 "INF",
203 "NAN");
204
205 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
206 {
207 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
208 }
209
210 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
211 {
212 double_conversion::StringBuilder builder( buffer, size );
213 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
214 {
215 builder.Reset();
216 return 0;
217 }
218
219 builder.TrimTrailingZeros();
220 return builder.position();
221 }
222
223 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
224 {
225 double_conversion::StringBuilder builder( buffer, size );
226 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
227 {
228 builder.Reset();
229 return 0;
230 }
231
232 return builder.position();
233 }
234
235}

◆ IsSpecial()

bool FIX::double_conversion::Double::IsSpecial ( ) const
inline

Definition at line 138 of file FieldConvertors.cpp.

168{
169
170// we include "double-conversion" project in FIX namespace
171// to avoid linking errors if quickfix is linked statically
172// and "double-conversion" is already used by target project
173
174#include "double-conversion/diy-fp.cc"
175#include "double-conversion/fixed-dtoa.cc"
176#include "double-conversion/bignum.cc"
177#include "double-conversion/bignum-dtoa.cc"
178#include "double-conversion/cached-powers.cc"
179#include "double-conversion/fast-dtoa.cc"
180#include "double-conversion/strtod.cc"
181#include "double-conversion/double-conversion.cc"
182
183 static double_conversion::DoubleToStringConverter g_dtoa_converter(
184 double_conversion::DoubleToStringConverter::NO_FLAGS,
185 "INF",
186 "NAN",
187 'e',
188 -DoubleConvertor::SIGNIFICANT_DIGITS,
189 DoubleConvertor::SIGNIFICANT_DIGITS,
190 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
191 0);
192
193 static double_conversion::StringToDoubleConverter g_atod_converter(
194 double_conversion::StringToDoubleConverter::NO_FLAGS,
195 std::numeric_limits<double>::quiet_NaN(),
196 std::numeric_limits<double>::quiet_NaN(),
197 "INF",
198 "NAN");
199
200 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
201 {
202 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
203 }
204
205 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
206 {
207 double_conversion::StringBuilder builder( buffer, size );
208 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
209 {
210 builder.Reset();
211 return 0;
212 }
213
214 builder.TrimTrailingZeros();
215 return builder.position();
216 }
217
218 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
219 {
220 double_conversion::StringBuilder builder( buffer, size );
221 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
222 {
223 builder.Reset();
224 return 0;
225 }
226
227 return builder.position();
228 }
229
230}

◆ LowerBoundaryIsCloser()

bool FIX::double_conversion::Double::LowerBoundaryIsCloser ( ) const
inline

Definition at line 187 of file FieldConvertors.cpp.

217{
218
219// we include "double-conversion" project in FIX namespace
220// to avoid linking errors if quickfix is linked statically
221// and "double-conversion" is already used by target project
222
223#include "double-conversion/diy-fp.cc"
224#include "double-conversion/fixed-dtoa.cc"
225#include "double-conversion/bignum.cc"
226#include "double-conversion/bignum-dtoa.cc"
227#include "double-conversion/cached-powers.cc"
228#include "double-conversion/fast-dtoa.cc"
229#include "double-conversion/strtod.cc"
230#include "double-conversion/double-conversion.cc"
231
232 static double_conversion::DoubleToStringConverter g_dtoa_converter(
233 double_conversion::DoubleToStringConverter::NO_FLAGS,
234 "INF",
235 "NAN",
236 'e',
237 -DoubleConvertor::SIGNIFICANT_DIGITS,
238 DoubleConvertor::SIGNIFICANT_DIGITS,
239 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
240 0);
241
242 static double_conversion::StringToDoubleConverter g_atod_converter(
243 double_conversion::StringToDoubleConverter::NO_FLAGS,
244 std::numeric_limits<double>::quiet_NaN(),
245 std::numeric_limits<double>::quiet_NaN(),
246 "INF",
247 "NAN");
248
249 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
250 {
251 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
252 }
253
254 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
255 {
256 double_conversion::StringBuilder builder( buffer, size );
257 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
258 {
259 builder.Reset();
260 return 0;
261 }
262
263 builder.TrimTrailingZeros();
264 return builder.position();
265 }
266
267 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
268 {
269 double_conversion::StringBuilder builder( buffer, size );
270 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
271 {
272 builder.Reset();
273 return 0;
274 }
275
276 return builder.position();
277 }
278
279}

◆ NaN()

double FIX::double_conversion::Double::NaN ( )
inlinestatic

Definition at line 220 of file FieldConvertors.cpp.

250{
251
252// we include "double-conversion" project in FIX namespace
253// to avoid linking errors if quickfix is linked statically
254// and "double-conversion" is already used by target project
255
256#include "double-conversion/diy-fp.cc"
257#include "double-conversion/fixed-dtoa.cc"
258#include "double-conversion/bignum.cc"
259#include "double-conversion/bignum-dtoa.cc"
260#include "double-conversion/cached-powers.cc"
261#include "double-conversion/fast-dtoa.cc"
262#include "double-conversion/strtod.cc"
263#include "double-conversion/double-conversion.cc"
264
265 static double_conversion::DoubleToStringConverter g_dtoa_converter(
266 double_conversion::DoubleToStringConverter::NO_FLAGS,
267 "INF",
268 "NAN",
269 'e',
270 -DoubleConvertor::SIGNIFICANT_DIGITS,
271 DoubleConvertor::SIGNIFICANT_DIGITS,
272 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
273 0);
274
275 static double_conversion::StringToDoubleConverter g_atod_converter(
276 double_conversion::StringToDoubleConverter::NO_FLAGS,
277 std::numeric_limits<double>::quiet_NaN(),
278 std::numeric_limits<double>::quiet_NaN(),
279 "INF",
280 "NAN");
281
282 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
283 {
284 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
285 }
286
287 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
288 {
289 double_conversion::StringBuilder builder( buffer, size );
290 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
291 {
292 builder.Reset();
293 return 0;
294 }
295
296 builder.TrimTrailingZeros();
297 return builder.position();
298 }
299
300 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
301 {
302 double_conversion::StringBuilder builder( buffer, size );
303 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
304 {
305 builder.Reset();
306 return 0;
307 }
308
309 return builder.position();
310 }
311
312}

◆ NextDouble()

double FIX::double_conversion::Double::NextDouble ( ) const
inline

Definition at line 88 of file FieldConvertors.cpp.

◆ NormalizedBoundaries()

void FIX::double_conversion::Double::NormalizedBoundaries ( DiyFp * out_m_minus,
DiyFp * out_m_plus ) const
inline

Definition at line 171 of file FieldConvertors.cpp.

201{
202
203// we include "double-conversion" project in FIX namespace
204// to avoid linking errors if quickfix is linked statically
205// and "double-conversion" is already used by target project
206
207#include "double-conversion/diy-fp.cc"
208#include "double-conversion/fixed-dtoa.cc"
209#include "double-conversion/bignum.cc"
210#include "double-conversion/bignum-dtoa.cc"
211#include "double-conversion/cached-powers.cc"
212#include "double-conversion/fast-dtoa.cc"
213#include "double-conversion/strtod.cc"
214#include "double-conversion/double-conversion.cc"
215
216 static double_conversion::DoubleToStringConverter g_dtoa_converter(
217 double_conversion::DoubleToStringConverter::NO_FLAGS,
218 "INF",
219 "NAN",
220 'e',
221 -DoubleConvertor::SIGNIFICANT_DIGITS,
222 DoubleConvertor::SIGNIFICANT_DIGITS,
223 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
224 0);
225
226 static double_conversion::StringToDoubleConverter g_atod_converter(
227 double_conversion::StringToDoubleConverter::NO_FLAGS,
228 std::numeric_limits<double>::quiet_NaN(),
229 std::numeric_limits<double>::quiet_NaN(),
230 "INF",
231 "NAN");
232
233 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
234 {
235 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
236 }
237
238 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
239 {
240 double_conversion::StringBuilder builder( buffer, size );
241 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
242 {
243 builder.Reset();
244 return 0;
245 }
246
247 builder.TrimTrailingZeros();
248 return builder.position();
249 }
250
251 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
252 {
253 double_conversion::StringBuilder builder( buffer, size );
254 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
255 {
256 builder.Reset();
257 return 0;
258 }
259
260 return builder.position();
261 }
262
263}

◆ PreviousDouble()

double FIX::double_conversion::Double::PreviousDouble ( ) const
inline

Definition at line 101 of file FieldConvertors.cpp.

131{
132
133// we include "double-conversion" project in FIX namespace
134// to avoid linking errors if quickfix is linked statically
135// and "double-conversion" is already used by target project
136
137#include "double-conversion/diy-fp.cc"
138#include "double-conversion/fixed-dtoa.cc"
139#include "double-conversion/bignum.cc"
140#include "double-conversion/bignum-dtoa.cc"
141#include "double-conversion/cached-powers.cc"
142#include "double-conversion/fast-dtoa.cc"
143#include "double-conversion/strtod.cc"
144#include "double-conversion/double-conversion.cc"
145
146 static double_conversion::DoubleToStringConverter g_dtoa_converter(
147 double_conversion::DoubleToStringConverter::NO_FLAGS,
148 "INF",
149 "NAN",
150 'e',
151 -DoubleConvertor::SIGNIFICANT_DIGITS,
152 DoubleConvertor::SIGNIFICANT_DIGITS,
153 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
154 0);
155
156 static double_conversion::StringToDoubleConverter g_atod_converter(
157 double_conversion::StringToDoubleConverter::NO_FLAGS,
158 std::numeric_limits<double>::quiet_NaN(),
159 std::numeric_limits<double>::quiet_NaN(),
160 "INF",
161 "NAN");
162
163 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
164 {
165 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
166 }
167
168 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
169 {
170 double_conversion::StringBuilder builder( buffer, size );
171 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
172 {
173 builder.Reset();
174 return 0;
175 }
176
177 builder.TrimTrailingZeros();
178 return builder.position();
179 }
180
181 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
182 {
183 double_conversion::StringBuilder builder( buffer, size );
184 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
185 {
186 builder.Reset();
187 return 0;
188 }
189
190 return builder.position();
191 }
192
193}

◆ Sign()

int FIX::double_conversion::Double::Sign ( ) const
inline

Definition at line 155 of file FieldConvertors.cpp.

185{
186
187// we include "double-conversion" project in FIX namespace
188// to avoid linking errors if quickfix is linked statically
189// and "double-conversion" is already used by target project
190
191#include "double-conversion/diy-fp.cc"
192#include "double-conversion/fixed-dtoa.cc"
193#include "double-conversion/bignum.cc"
194#include "double-conversion/bignum-dtoa.cc"
195#include "double-conversion/cached-powers.cc"
196#include "double-conversion/fast-dtoa.cc"
197#include "double-conversion/strtod.cc"
198#include "double-conversion/double-conversion.cc"
199
200 static double_conversion::DoubleToStringConverter g_dtoa_converter(
201 double_conversion::DoubleToStringConverter::NO_FLAGS,
202 "INF",
203 "NAN",
204 'e',
205 -DoubleConvertor::SIGNIFICANT_DIGITS,
206 DoubleConvertor::SIGNIFICANT_DIGITS,
207 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
208 0);
209
210 static double_conversion::StringToDoubleConverter g_atod_converter(
211 double_conversion::StringToDoubleConverter::NO_FLAGS,
212 std::numeric_limits<double>::quiet_NaN(),
213 std::numeric_limits<double>::quiet_NaN(),
214 "INF",
215 "NAN");
216
217 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
218 {
219 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
220 }
221
222 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
223 {
224 double_conversion::StringBuilder builder( buffer, size );
225 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
226 {
227 builder.Reset();
228 return 0;
229 }
230
231 builder.TrimTrailingZeros();
232 return builder.position();
233 }
234
235 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
236 {
237 double_conversion::StringBuilder builder( buffer, size );
238 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
239 {
240 builder.Reset();
241 return 0;
242 }
243
244 return builder.position();
245 }
246
247}

◆ Significand()

uint64_t FIX::double_conversion::Double::Significand ( ) const
inline

Definition at line 120 of file FieldConvertors.cpp.

150{
151
152// we include "double-conversion" project in FIX namespace
153// to avoid linking errors if quickfix is linked statically
154// and "double-conversion" is already used by target project
155
156#include "double-conversion/diy-fp.cc"
157#include "double-conversion/fixed-dtoa.cc"
158#include "double-conversion/bignum.cc"
159#include "double-conversion/bignum-dtoa.cc"
160#include "double-conversion/cached-powers.cc"
161#include "double-conversion/fast-dtoa.cc"
162#include "double-conversion/strtod.cc"
163#include "double-conversion/double-conversion.cc"
164
165 static double_conversion::DoubleToStringConverter g_dtoa_converter(
166 double_conversion::DoubleToStringConverter::NO_FLAGS,
167 "INF",
168 "NAN",
169 'e',
170 -DoubleConvertor::SIGNIFICANT_DIGITS,
171 DoubleConvertor::SIGNIFICANT_DIGITS,
172 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
173 0);
174
175 static double_conversion::StringToDoubleConverter g_atod_converter(
176 double_conversion::StringToDoubleConverter::NO_FLAGS,
177 std::numeric_limits<double>::quiet_NaN(),
178 std::numeric_limits<double>::quiet_NaN(),
179 "INF",
180 "NAN");
181
182 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
183 {
184 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
185 }
186
187 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
188 {
189 double_conversion::StringBuilder builder( buffer, size );
190 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
191 {
192 builder.Reset();
193 return 0;
194 }
195
196 builder.TrimTrailingZeros();
197 return builder.position();
198 }
199
200 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
201 {
202 double_conversion::StringBuilder builder( buffer, size );
203 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
204 {
205 builder.Reset();
206 return 0;
207 }
208
209 return builder.position();
210 }
211
212}

◆ SignificandSizeForOrderOfMagnitude()

int FIX::double_conversion::Double::SignificandSizeForOrderOfMagnitude ( int order)
inlinestatic

Definition at line 208 of file FieldConvertors.cpp.

238{
239
240// we include "double-conversion" project in FIX namespace
241// to avoid linking errors if quickfix is linked statically
242// and "double-conversion" is already used by target project
243
244#include "double-conversion/diy-fp.cc"
245#include "double-conversion/fixed-dtoa.cc"
246#include "double-conversion/bignum.cc"
247#include "double-conversion/bignum-dtoa.cc"
248#include "double-conversion/cached-powers.cc"
249#include "double-conversion/fast-dtoa.cc"
250#include "double-conversion/strtod.cc"
251#include "double-conversion/double-conversion.cc"
252
253 static double_conversion::DoubleToStringConverter g_dtoa_converter(
254 double_conversion::DoubleToStringConverter::NO_FLAGS,
255 "INF",
256 "NAN",
257 'e',
258 -DoubleConvertor::SIGNIFICANT_DIGITS,
259 DoubleConvertor::SIGNIFICANT_DIGITS,
260 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
261 0);
262
263 static double_conversion::StringToDoubleConverter g_atod_converter(
264 double_conversion::StringToDoubleConverter::NO_FLAGS,
265 std::numeric_limits<double>::quiet_NaN(),
266 std::numeric_limits<double>::quiet_NaN(),
267 "INF",
268 "NAN");
269
270 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
271 {
272 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
273 }
274
275 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
276 {
277 double_conversion::StringBuilder builder( buffer, size );
278 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
279 {
280 builder.Reset();
281 return 0;
282 }
283
284 builder.TrimTrailingZeros();
285 return builder.position();
286 }
287
288 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
289 {
290 double_conversion::StringBuilder builder( buffer, size );
291 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
292 {
293 builder.Reset();
294 return 0;
295 }
296
297 return builder.position();
298 }
299
300}

◆ UpperBoundary()

DiyFp FIX::double_conversion::Double::UpperBoundary ( ) const
inline

Definition at line 162 of file FieldConvertors.cpp.

192{
193
194// we include "double-conversion" project in FIX namespace
195// to avoid linking errors if quickfix is linked statically
196// and "double-conversion" is already used by target project
197
198#include "double-conversion/diy-fp.cc"
199#include "double-conversion/fixed-dtoa.cc"
200#include "double-conversion/bignum.cc"
201#include "double-conversion/bignum-dtoa.cc"
202#include "double-conversion/cached-powers.cc"
203#include "double-conversion/fast-dtoa.cc"
204#include "double-conversion/strtod.cc"
205#include "double-conversion/double-conversion.cc"
206
207 static double_conversion::DoubleToStringConverter g_dtoa_converter(
208 double_conversion::DoubleToStringConverter::NO_FLAGS,
209 "INF",
210 "NAN",
211 'e',
212 -DoubleConvertor::SIGNIFICANT_DIGITS,
213 DoubleConvertor::SIGNIFICANT_DIGITS,
214 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
215 0);
216
217 static double_conversion::StringToDoubleConverter g_atod_converter(
218 double_conversion::StringToDoubleConverter::NO_FLAGS,
219 std::numeric_limits<double>::quiet_NaN(),
220 std::numeric_limits<double>::quiet_NaN(),
221 "INF",
222 "NAN");
223
224 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
225 {
226 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
227 }
228
229 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
230 {
231 double_conversion::StringBuilder builder( buffer, size );
232 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
233 {
234 builder.Reset();
235 return 0;
236 }
237
238 builder.TrimTrailingZeros();
239 return builder.position();
240 }
241
242 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
243 {
244 double_conversion::StringBuilder builder( buffer, size );
245 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
246 {
247 builder.Reset();
248 return 0;
249 }
250
251 return builder.position();
252 }
253
254}

◆ value()

double FIX::double_conversion::Double::value ( ) const
inline

Definition at line 200 of file FieldConvertors.cpp.

230{
231
232// we include "double-conversion" project in FIX namespace
233// to avoid linking errors if quickfix is linked statically
234// and "double-conversion" is already used by target project
235
236#include "double-conversion/diy-fp.cc"
237#include "double-conversion/fixed-dtoa.cc"
238#include "double-conversion/bignum.cc"
239#include "double-conversion/bignum-dtoa.cc"
240#include "double-conversion/cached-powers.cc"
241#include "double-conversion/fast-dtoa.cc"
242#include "double-conversion/strtod.cc"
243#include "double-conversion/double-conversion.cc"
244
245 static double_conversion::DoubleToStringConverter g_dtoa_converter(
246 double_conversion::DoubleToStringConverter::NO_FLAGS,
247 "INF",
248 "NAN",
249 'e',
250 -DoubleConvertor::SIGNIFICANT_DIGITS,
251 DoubleConvertor::SIGNIFICANT_DIGITS,
252 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
253 0);
254
255 static double_conversion::StringToDoubleConverter g_atod_converter(
256 double_conversion::StringToDoubleConverter::NO_FLAGS,
257 std::numeric_limits<double>::quiet_NaN(),
258 std::numeric_limits<double>::quiet_NaN(),
259 "INF",
260 "NAN");
261
262 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
263 {
264 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
265 }
266
267 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
268 {
269 double_conversion::StringBuilder builder( buffer, size );
270 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
271 {
272 builder.Reset();
273 return 0;
274 }
275
276 builder.TrimTrailingZeros();
277 return builder.position();
278 }
279
280 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
281 {
282 double_conversion::StringBuilder builder( buffer, size );
283 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
284 {
285 builder.Reset();
286 return 0;
287 }
288
289 return builder.position();
290 }
291
292}

Member Data Documentation

◆ d64_

const uint64_t FIX::double_conversion::Double::d64_
private

Definition at line 231 of file FieldConvertors.cpp.

◆ kDenormalExponent

const int FIX::double_conversion::Double::kDenormalExponent = -kExponentBias + 1
staticprivate

Definition at line 226 of file FieldConvertors.cpp.

◆ kExponentBias

const int FIX::double_conversion::Double::kExponentBias = 0x3FF + kPhysicalSignificandSize
staticprivate

Definition at line 225 of file FieldConvertors.cpp.

◆ kExponentMask

const uint64_t FIX::double_conversion::Double::kExponentMask = UINT64_2PART_C(0x7FF00000, 00000000)
static

Definition at line 45 of file FieldConvertors.cpp.

◆ kHiddenBit

const uint64_t FIX::double_conversion::Double::kHiddenBit = UINT64_2PART_C(0x00100000, 00000000)
static

Definition at line 47 of file FieldConvertors.cpp.

◆ kInfinity

const uint64_t FIX::double_conversion::Double::kInfinity = UINT64_2PART_C(0x7FF00000, 00000000)
staticprivate

Definition at line 228 of file FieldConvertors.cpp.

◆ kMaxExponent

const int FIX::double_conversion::Double::kMaxExponent = 0x7FF - kExponentBias
staticprivate

Definition at line 227 of file FieldConvertors.cpp.

◆ kNaN

const uint64_t FIX::double_conversion::Double::kNaN = UINT64_2PART_C(0x7FF80000, 00000000)
staticprivate

Definition at line 229 of file FieldConvertors.cpp.

◆ kPhysicalSignificandSize

const int FIX::double_conversion::Double::kPhysicalSignificandSize = 52
static

Definition at line 48 of file FieldConvertors.cpp.

◆ kSignificandMask

const uint64_t FIX::double_conversion::Double::kSignificandMask = UINT64_2PART_C(0x000FFFFF, FFFFFFFF)
static

Definition at line 46 of file FieldConvertors.cpp.

◆ kSignificandSize

const int FIX::double_conversion::Double::kSignificandSize = 53
static

Definition at line 49 of file FieldConvertors.cpp.

◆ kSignMask

const uint64_t FIX::double_conversion::Double::kSignMask = UINT64_2PART_C(0x80000000, 00000000)
static

Definition at line 44 of file FieldConvertors.cpp.

The documentation for this class was generated from the following file:
Generated on for QuickFIX by doxygen 1.15.0 written by Dimitri van Heesch, © 1997-2001