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

Public Member Functions

 Bignum ()
void AssignUInt16 (uint16_t value)
void AssignUInt64 (uint64_t value)
void AssignBignum (const Bignum &other)
void AssignDecimalString (Vector< const char > value)
void AssignHexString (Vector< const char > value)
void AssignPowerUInt16 (uint16_t base, int exponent)
void AddUInt64 (uint64_t operand)
void AddBignum (const Bignum &other)
void SubtractBignum (const Bignum &other)
void Square ()
void ShiftLeft (int shift_amount)
void MultiplyByUInt32 (uint32_t factor)
void MultiplyByUInt64 (uint64_t factor)
void MultiplyByPowerOfTen (int exponent)
void Times10 ()
uint16_t DivideModuloIntBignum (const Bignum &other)
bool ToHexString (char *buffer, int buffer_size) const

Static Public Member Functions

static int Compare (const Bignum &a, const Bignum &b)
static bool Equal (const Bignum &a, const Bignum &b)
static bool LessEqual (const Bignum &a, const Bignum &b)
static bool Less (const Bignum &a, const Bignum &b)
static int PlusCompare (const Bignum &a, const Bignum &b, const Bignum &c)
static bool PlusEqual (const Bignum &a, const Bignum &b, const Bignum &c)
static bool PlusLessEqual (const Bignum &a, const Bignum &b, const Bignum &c)
static bool PlusLess (const Bignum &a, const Bignum &b, const Bignum &c)

Static Public Attributes

static const int kMaxSignificantBits = 3584

Private Types

typedef uint32_t Chunk
typedef uint64_t DoubleChunk

Private Member Functions

void EnsureCapacity (int size)
void Align (const Bignum &other)
void Clamp ()
bool IsClamped () const
void Zero ()
void BigitsShiftLeft (int shift_amount)
int BigitLength () const
Chunk BigitAt (int index) const
void SubtractTimes (const Bignum &other, int factor)
 DISALLOW_COPY_AND_ASSIGN (Bignum)

Private Attributes

Chunk bigits_buffer_ [kBigitCapacity]
Vector< Chunk > bigits_
int used_digits_
int exponent_

Static Private Attributes

static const int kChunkSize = sizeof(Chunk) * 8
static const int kDoubleChunkSize = sizeof(DoubleChunk) * 8
static const int kBigitSize = 28
static const Chunk kBigitMask = (1 << kBigitSize) - 1
static const int kBigitCapacity = kMaxSignificantBits / kBigitSize

Detailed Description

Definition at line 36 of file FieldConvertors.cpp.

Member Typedef Documentation

◆ Chunk

typedef uint32_t FIX::double_conversion::Bignum::Chunk
private

Definition at line 101 of file FieldConvertors.cpp.

◆ DoubleChunk

typedef uint64_t FIX::double_conversion::Bignum::DoubleChunk
private

Definition at line 102 of file FieldConvertors.cpp.

Constructor & Destructor Documentation

◆ Bignum()

FIX::double_conversion::Bignum::Bignum ( )

Definition at line 34 of file FieldConvertors.cpp.

Member Function Documentation

◆ AddBignum()

void FIX::double_conversion::Bignum::AddBignum ( const Bignum & other)

Definition at line 170 of file FieldConvertors.cpp.

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

◆ AddUInt64()

void FIX::double_conversion::Bignum::AddUInt64 ( uint64_t operand)

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}

◆ Align()

void FIX::double_conversion::Bignum::Align ( const Bignum & other)
private

Definition at line 699 of file FieldConvertors.cpp.

729{
730
731// we include "double-conversion" project in FIX namespace
732// to avoid linking errors if quickfix is linked statically
733// and "double-conversion" is already used by target project
734
735#include "double-conversion/diy-fp.cc"
736#include "double-conversion/fixed-dtoa.cc"
737#include "double-conversion/bignum.cc"
738#include "double-conversion/bignum-dtoa.cc"
739#include "double-conversion/cached-powers.cc"
740#include "double-conversion/fast-dtoa.cc"
741#include "double-conversion/strtod.cc"
742#include "double-conversion/double-conversion.cc"
743
744 static double_conversion::DoubleToStringConverter g_dtoa_converter(
745 double_conversion::DoubleToStringConverter::NO_FLAGS,
746 "INF",
747 "NAN",
748 'e',
749 -DoubleConvertor::SIGNIFICANT_DIGITS,
750 DoubleConvertor::SIGNIFICANT_DIGITS,
751 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
752 0);
753
754 static double_conversion::StringToDoubleConverter g_atod_converter(
755 double_conversion::StringToDoubleConverter::NO_FLAGS,
756 std::numeric_limits<double>::quiet_NaN(),
757 std::numeric_limits<double>::quiet_NaN(),
758 "INF",
759 "NAN");
760
761 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
762 {
763 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
764 }
765
766 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
767 {
768 double_conversion::StringBuilder builder( buffer, size );
769 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
770 {
771 builder.Reset();
772 return 0;
773 }
774
775 builder.TrimTrailingZeros();
776 return builder.position();
777 }
778
779 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
780 {
781 double_conversion::StringBuilder builder( buffer, size );
782 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
783 {
784 builder.Reset();
785 return 0;
786 }
787
788 return builder.position();
789 }
790
791}

◆ AssignBignum()

void FIX::double_conversion::Bignum::AssignBignum ( const Bignum & other)

Definition at line 77 of file FieldConvertors.cpp.

82 {
83 double_conversion::StringBuilder builder( buffer, size );
84 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
85 {
86 builder.Reset();
87 return 0;

◆ AssignDecimalString()

void FIX::double_conversion::Bignum::AssignDecimalString ( Vector< const char > value)

Definition at line 103 of file FieldConvertors.cpp.

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

◆ AssignHexString()

void FIX::double_conversion::Bignum::AssignHexString ( Vector< const char > value)

Definition at line 132 of file FieldConvertors.cpp.

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

◆ AssignPowerUInt16()

void FIX::double_conversion::Bignum::AssignPowerUInt16 ( uint16_t base,
int exponent )

Definition at line 413 of file FieldConvertors.cpp.

443{
444
445// we include "double-conversion" project in FIX namespace
446// to avoid linking errors if quickfix is linked statically
447// and "double-conversion" is already used by target project
448
449#include "double-conversion/diy-fp.cc"
450#include "double-conversion/fixed-dtoa.cc"
451#include "double-conversion/bignum.cc"
452#include "double-conversion/bignum-dtoa.cc"
453#include "double-conversion/cached-powers.cc"
454#include "double-conversion/fast-dtoa.cc"
455#include "double-conversion/strtod.cc"
456#include "double-conversion/double-conversion.cc"
457
458 static double_conversion::DoubleToStringConverter g_dtoa_converter(
459 double_conversion::DoubleToStringConverter::NO_FLAGS,
460 "INF",
461 "NAN",
462 'e',
463 -DoubleConvertor::SIGNIFICANT_DIGITS,
464 DoubleConvertor::SIGNIFICANT_DIGITS,
465 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
466 0);
467
468 static double_conversion::StringToDoubleConverter g_atod_converter(
469 double_conversion::StringToDoubleConverter::NO_FLAGS,
470 std::numeric_limits<double>::quiet_NaN(),
471 std::numeric_limits<double>::quiet_NaN(),
472 "INF",
473 "NAN");
474
475 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
476 {
477 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
478 }
479
480 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
481 {
482 double_conversion::StringBuilder builder( buffer, size );
483 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
484 {
485 builder.Reset();
486 return 0;
487 }
488
489 builder.TrimTrailingZeros();
490 return builder.position();
491 }
492
493 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
494 {
495 double_conversion::StringBuilder builder( buffer, size );
496 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
497 {
498 builder.Reset();
499 return 0;
500 }
501
502 return builder.position();
503 }
504
505}

◆ AssignUInt16()

void FIX::double_conversion::Bignum::AssignUInt16 ( uint16_t value)

Definition at line 49 of file FieldConvertors.cpp.

◆ AssignUInt64()

void FIX::double_conversion::Bignum::AssignUInt64 ( uint64_t value)

Definition at line 60 of file FieldConvertors.cpp.

64 {
65 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
66 }
67
68 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
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;

◆ BigitAt()

Bignum::Chunk FIX::double_conversion::Bignum::BigitAt ( int index) const
private

Definition at line 612 of file FieldConvertors.cpp.

642{
643
644// we include "double-conversion" project in FIX namespace
645// to avoid linking errors if quickfix is linked statically
646// and "double-conversion" is already used by target project
647
648#include "double-conversion/diy-fp.cc"
649#include "double-conversion/fixed-dtoa.cc"
650#include "double-conversion/bignum.cc"
651#include "double-conversion/bignum-dtoa.cc"
652#include "double-conversion/cached-powers.cc"
653#include "double-conversion/fast-dtoa.cc"
654#include "double-conversion/strtod.cc"
655#include "double-conversion/double-conversion.cc"
656
657 static double_conversion::DoubleToStringConverter g_dtoa_converter(
658 double_conversion::DoubleToStringConverter::NO_FLAGS,
659 "INF",
660 "NAN",
661 'e',
662 -DoubleConvertor::SIGNIFICANT_DIGITS,
663 DoubleConvertor::SIGNIFICANT_DIGITS,
664 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
665 0);
666
667 static double_conversion::StringToDoubleConverter g_atod_converter(
668 double_conversion::StringToDoubleConverter::NO_FLAGS,
669 std::numeric_limits<double>::quiet_NaN(),
670 std::numeric_limits<double>::quiet_NaN(),
671 "INF",
672 "NAN");
673
674 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
675 {
676 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
677 }
678
679 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
680 {
681 double_conversion::StringBuilder builder( buffer, size );
682 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
683 {
684 builder.Reset();
685 return 0;
686 }
687
688 builder.TrimTrailingZeros();
689 return builder.position();
690 }
691
692 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
693 {
694 double_conversion::StringBuilder builder( buffer, size );
695 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
696 {
697 builder.Reset();
698 return 0;
699 }
700
701 return builder.position();
702 }
703
704}

◆ BigitLength()

int FIX::double_conversion::Bignum::BigitLength ( ) const
inlineprivate

Definition at line 128 of file FieldConvertors.cpp.

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

◆ BigitsShiftLeft()

void FIX::double_conversion::Bignum::BigitsShiftLeft ( int shift_amount)
private

Definition at line 723 of file FieldConvertors.cpp.

753{
754
755// we include "double-conversion" project in FIX namespace
756// to avoid linking errors if quickfix is linked statically
757// and "double-conversion" is already used by target project
758
759#include "double-conversion/diy-fp.cc"
760#include "double-conversion/fixed-dtoa.cc"
761#include "double-conversion/bignum.cc"
762#include "double-conversion/bignum-dtoa.cc"
763#include "double-conversion/cached-powers.cc"
764#include "double-conversion/fast-dtoa.cc"
765#include "double-conversion/strtod.cc"
766#include "double-conversion/double-conversion.cc"
767
768 static double_conversion::DoubleToStringConverter g_dtoa_converter(
769 double_conversion::DoubleToStringConverter::NO_FLAGS,
770 "INF",
771 "NAN",
772 'e',
773 -DoubleConvertor::SIGNIFICANT_DIGITS,
774 DoubleConvertor::SIGNIFICANT_DIGITS,
775 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
776 0);
777
778 static double_conversion::StringToDoubleConverter g_atod_converter(
779 double_conversion::StringToDoubleConverter::NO_FLAGS,
780 std::numeric_limits<double>::quiet_NaN(),
781 std::numeric_limits<double>::quiet_NaN(),
782 "INF",
783 "NAN");
784
785 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
786 {
787 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
788 }
789
790 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
791 {
792 double_conversion::StringBuilder builder( buffer, size );
793 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
794 {
795 builder.Reset();
796 return 0;
797 }
798
799 builder.TrimTrailingZeros();
800 return builder.position();
801 }
802
803 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
804 {
805 double_conversion::StringBuilder builder( buffer, size );
806 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
807 {
808 builder.Reset();
809 return 0;
810 }
811
812 return builder.position();
813 }
814
815}

◆ Clamp()

void FIX::double_conversion::Bignum::Clamp ( )
private

Definition at line 674 of file FieldConvertors.cpp.

704{
705
706// we include "double-conversion" project in FIX namespace
707// to avoid linking errors if quickfix is linked statically
708// and "double-conversion" is already used by target project
709
710#include "double-conversion/diy-fp.cc"
711#include "double-conversion/fixed-dtoa.cc"
712#include "double-conversion/bignum.cc"
713#include "double-conversion/bignum-dtoa.cc"
714#include "double-conversion/cached-powers.cc"
715#include "double-conversion/fast-dtoa.cc"
716#include "double-conversion/strtod.cc"
717#include "double-conversion/double-conversion.cc"
718
719 static double_conversion::DoubleToStringConverter g_dtoa_converter(
720 double_conversion::DoubleToStringConverter::NO_FLAGS,
721 "INF",
722 "NAN",
723 'e',
724 -DoubleConvertor::SIGNIFICANT_DIGITS,
725 DoubleConvertor::SIGNIFICANT_DIGITS,
726 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
727 0);
728
729 static double_conversion::StringToDoubleConverter g_atod_converter(
730 double_conversion::StringToDoubleConverter::NO_FLAGS,
731 std::numeric_limits<double>::quiet_NaN(),
732 std::numeric_limits<double>::quiet_NaN(),
733 "INF",
734 "NAN");
735
736 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
737 {
738 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
739 }
740
741 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
742 {
743 double_conversion::StringBuilder builder( buffer, size );
744 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
745 {
746 builder.Reset();
747 return 0;
748 }
749
750 builder.TrimTrailingZeros();
751 return builder.position();
752 }
753
754 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
755 {
756 double_conversion::StringBuilder builder( buffer, size );
757 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
758 {
759 builder.Reset();
760 return 0;
761 }
762
763 return builder.position();
764 }
765
766}

◆ Compare()

int FIX::double_conversion::Bignum::Compare ( const Bignum & a,
const Bignum & b )
static

Definition at line 619 of file FieldConvertors.cpp.

649{
650
651// we include "double-conversion" project in FIX namespace
652// to avoid linking errors if quickfix is linked statically
653// and "double-conversion" is already used by target project
654
655#include "double-conversion/diy-fp.cc"
656#include "double-conversion/fixed-dtoa.cc"
657#include "double-conversion/bignum.cc"
658#include "double-conversion/bignum-dtoa.cc"
659#include "double-conversion/cached-powers.cc"
660#include "double-conversion/fast-dtoa.cc"
661#include "double-conversion/strtod.cc"
662#include "double-conversion/double-conversion.cc"
663
664 static double_conversion::DoubleToStringConverter g_dtoa_converter(
665 double_conversion::DoubleToStringConverter::NO_FLAGS,
666 "INF",
667 "NAN",
668 'e',
669 -DoubleConvertor::SIGNIFICANT_DIGITS,
670 DoubleConvertor::SIGNIFICANT_DIGITS,
671 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
672 0);
673
674 static double_conversion::StringToDoubleConverter g_atod_converter(
675 double_conversion::StringToDoubleConverter::NO_FLAGS,
676 std::numeric_limits<double>::quiet_NaN(),
677 std::numeric_limits<double>::quiet_NaN(),
678 "INF",
679 "NAN");
680
681 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
682 {
683 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
684 }
685
686 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
687 {
688 double_conversion::StringBuilder builder( buffer, size );
689 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
690 {
691 builder.Reset();
692 return 0;
693 }
694
695 builder.TrimTrailingZeros();
696 return builder.position();
697 }
698
699 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
700 {
701 double_conversion::StringBuilder builder( buffer, size );
702 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
703 {
704 builder.Reset();
705 return 0;
706 }
707
708 return builder.position();
709 }
710
711}

◆ DISALLOW_COPY_AND_ASSIGN()

FIX::double_conversion::Bignum::DISALLOW_COPY_AND_ASSIGN ( Bignum )
private

◆ DivideModuloIntBignum()

uint16_t FIX::double_conversion::Bignum::DivideModuloIntBignum ( const Bignum & other)

Definition at line 487 of file FieldConvertors.cpp.

517{
518
519// we include "double-conversion" project in FIX namespace
520// to avoid linking errors if quickfix is linked statically
521// and "double-conversion" is already used by target project
522
523#include "double-conversion/diy-fp.cc"
524#include "double-conversion/fixed-dtoa.cc"
525#include "double-conversion/bignum.cc"
526#include "double-conversion/bignum-dtoa.cc"
527#include "double-conversion/cached-powers.cc"
528#include "double-conversion/fast-dtoa.cc"
529#include "double-conversion/strtod.cc"
530#include "double-conversion/double-conversion.cc"
531
532 static double_conversion::DoubleToStringConverter g_dtoa_converter(
533 double_conversion::DoubleToStringConverter::NO_FLAGS,
534 "INF",
535 "NAN",
536 'e',
537 -DoubleConvertor::SIGNIFICANT_DIGITS,
538 DoubleConvertor::SIGNIFICANT_DIGITS,
539 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
540 0);
541
542 static double_conversion::StringToDoubleConverter g_atod_converter(
543 double_conversion::StringToDoubleConverter::NO_FLAGS,
544 std::numeric_limits<double>::quiet_NaN(),
545 std::numeric_limits<double>::quiet_NaN(),
546 "INF",
547 "NAN");
548
549 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
550 {
551 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
552 }
553
554 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
555 {
556 double_conversion::StringBuilder builder( buffer, size );
557 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
558 {
559 builder.Reset();
560 return 0;
561 }
562
563 builder.TrimTrailingZeros();
564 return builder.position();
565 }
566
567 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
568 {
569 double_conversion::StringBuilder builder( buffer, size );
570 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
571 {
572 builder.Reset();
573 return 0;
574 }
575
576 return builder.position();
577 }
578
579}

◆ EnsureCapacity()

void FIX::double_conversion::Bignum::EnsureCapacity ( int size)
inlineprivate

Definition at line 114 of file FieldConvertors.cpp.

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

◆ Equal()

bool FIX::double_conversion::Bignum::Equal ( const Bignum & a,
const Bignum & b )
inlinestatic

Definition at line 77 of file FieldConvertors.cpp.

◆ IsClamped()

bool FIX::double_conversion::Bignum::IsClamped ( ) const
private

Definition at line 685 of file FieldConvertors.cpp.

715{
716
717// we include "double-conversion" project in FIX namespace
718// to avoid linking errors if quickfix is linked statically
719// and "double-conversion" is already used by target project
720
721#include "double-conversion/diy-fp.cc"
722#include "double-conversion/fixed-dtoa.cc"
723#include "double-conversion/bignum.cc"
724#include "double-conversion/bignum-dtoa.cc"
725#include "double-conversion/cached-powers.cc"
726#include "double-conversion/fast-dtoa.cc"
727#include "double-conversion/strtod.cc"
728#include "double-conversion/double-conversion.cc"
729
730 static double_conversion::DoubleToStringConverter g_dtoa_converter(
731 double_conversion::DoubleToStringConverter::NO_FLAGS,
732 "INF",
733 "NAN",
734 'e',
735 -DoubleConvertor::SIGNIFICANT_DIGITS,
736 DoubleConvertor::SIGNIFICANT_DIGITS,
737 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
738 0);
739
740 static double_conversion::StringToDoubleConverter g_atod_converter(
741 double_conversion::StringToDoubleConverter::NO_FLAGS,
742 std::numeric_limits<double>::quiet_NaN(),
743 std::numeric_limits<double>::quiet_NaN(),
744 "INF",
745 "NAN");
746
747 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
748 {
749 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
750 }
751
752 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
753 {
754 double_conversion::StringBuilder builder( buffer, size );
755 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
756 {
757 builder.Reset();
758 return 0;
759 }
760
761 builder.TrimTrailingZeros();
762 return builder.position();
763 }
764
765 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
766 {
767 double_conversion::StringBuilder builder( buffer, size );
768 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
769 {
770 builder.Reset();
771 return 0;
772 }
773
774 return builder.position();
775 }
776
777}

◆ Less()

bool FIX::double_conversion::Bignum::Less ( const Bignum & a,
const Bignum & b )
inlinestatic

Definition at line 83 of file FieldConvertors.cpp.

85 {

◆ LessEqual()

bool FIX::double_conversion::Bignum::LessEqual ( const Bignum & a,
const Bignum & b )
inlinestatic

Definition at line 80 of file FieldConvertors.cpp.

82 {

◆ MultiplyByPowerOfTen()

void FIX::double_conversion::Bignum::MultiplyByPowerOfTen ( int exponent)

Definition at line 301 of file FieldConvertors.cpp.

331{
332
333// we include "double-conversion" project in FIX namespace
334// to avoid linking errors if quickfix is linked statically
335// and "double-conversion" is already used by target project
336
337#include "double-conversion/diy-fp.cc"
338#include "double-conversion/fixed-dtoa.cc"
339#include "double-conversion/bignum.cc"
340#include "double-conversion/bignum-dtoa.cc"
341#include "double-conversion/cached-powers.cc"
342#include "double-conversion/fast-dtoa.cc"
343#include "double-conversion/strtod.cc"
344#include "double-conversion/double-conversion.cc"
345
346 static double_conversion::DoubleToStringConverter g_dtoa_converter(
347 double_conversion::DoubleToStringConverter::NO_FLAGS,
348 "INF",
349 "NAN",
350 'e',
351 -DoubleConvertor::SIGNIFICANT_DIGITS,
352 DoubleConvertor::SIGNIFICANT_DIGITS,
353 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
354 0);
355
356 static double_conversion::StringToDoubleConverter g_atod_converter(
357 double_conversion::StringToDoubleConverter::NO_FLAGS,
358 std::numeric_limits<double>::quiet_NaN(),
359 std::numeric_limits<double>::quiet_NaN(),
360 "INF",
361 "NAN");
362
363 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
364 {
365 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
366 }
367
368 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
369 {
370 double_conversion::StringBuilder builder( buffer, size );
371 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
372 {
373 builder.Reset();
374 return 0;
375 }
376
377 builder.TrimTrailingZeros();
378 return builder.position();
379 }
380
381 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
382 {
383 double_conversion::StringBuilder builder( buffer, size );
384 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
385 {
386 builder.Reset();
387 return 0;
388 }
389
390 return builder.position();
391 }
392
393}

◆ MultiplyByUInt32()

void FIX::double_conversion::Bignum::MultiplyByUInt32 ( uint32_t factor)

Definition at line 248 of file FieldConvertors.cpp.

278{
279
280// we include "double-conversion" project in FIX namespace
281// to avoid linking errors if quickfix is linked statically
282// and "double-conversion" is already used by target project
283
284#include "double-conversion/diy-fp.cc"
285#include "double-conversion/fixed-dtoa.cc"
286#include "double-conversion/bignum.cc"
287#include "double-conversion/bignum-dtoa.cc"
288#include "double-conversion/cached-powers.cc"
289#include "double-conversion/fast-dtoa.cc"
290#include "double-conversion/strtod.cc"
291#include "double-conversion/double-conversion.cc"
292
293 static double_conversion::DoubleToStringConverter g_dtoa_converter(
294 double_conversion::DoubleToStringConverter::NO_FLAGS,
295 "INF",
296 "NAN",
297 'e',
298 -DoubleConvertor::SIGNIFICANT_DIGITS,
299 DoubleConvertor::SIGNIFICANT_DIGITS,
300 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
301 0);
302
303 static double_conversion::StringToDoubleConverter g_atod_converter(
304 double_conversion::StringToDoubleConverter::NO_FLAGS,
305 std::numeric_limits<double>::quiet_NaN(),
306 std::numeric_limits<double>::quiet_NaN(),
307 "INF",
308 "NAN");
309
310 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
311 {
312 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
313 }
314
315 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
316 {
317 double_conversion::StringBuilder builder( buffer, size );
318 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
319 {
320 builder.Reset();
321 return 0;
322 }
323
324 builder.TrimTrailingZeros();
325 return builder.position();
326 }
327
328 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
329 {
330 double_conversion::StringBuilder builder( buffer, size );
331 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
332 {
333 builder.Reset();
334 return 0;
335 }
336
337 return builder.position();
338 }
339
340}

◆ MultiplyByUInt64()

void FIX::double_conversion::Bignum::MultiplyByUInt64 ( uint64_t factor)

Definition at line 274 of file FieldConvertors.cpp.

304{
305
306// we include "double-conversion" project in FIX namespace
307// to avoid linking errors if quickfix is linked statically
308// and "double-conversion" is already used by target project
309
310#include "double-conversion/diy-fp.cc"
311#include "double-conversion/fixed-dtoa.cc"
312#include "double-conversion/bignum.cc"
313#include "double-conversion/bignum-dtoa.cc"
314#include "double-conversion/cached-powers.cc"
315#include "double-conversion/fast-dtoa.cc"
316#include "double-conversion/strtod.cc"
317#include "double-conversion/double-conversion.cc"
318
319 static double_conversion::DoubleToStringConverter g_dtoa_converter(
320 double_conversion::DoubleToStringConverter::NO_FLAGS,
321 "INF",
322 "NAN",
323 'e',
324 -DoubleConvertor::SIGNIFICANT_DIGITS,
325 DoubleConvertor::SIGNIFICANT_DIGITS,
326 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
327 0);
328
329 static double_conversion::StringToDoubleConverter g_atod_converter(
330 double_conversion::StringToDoubleConverter::NO_FLAGS,
331 std::numeric_limits<double>::quiet_NaN(),
332 std::numeric_limits<double>::quiet_NaN(),
333 "INF",
334 "NAN");
335
336 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
337 {
338 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
339 }
340
341 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
342 {
343 double_conversion::StringBuilder builder( buffer, size );
344 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
345 {
346 builder.Reset();
347 return 0;
348 }
349
350 builder.TrimTrailingZeros();
351 return builder.position();
352 }
353
354 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
355 {
356 double_conversion::StringBuilder builder( buffer, size );
357 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
358 {
359 builder.Reset();
360 return 0;
361 }
362
363 return builder.position();
364 }
365
366}

◆ PlusCompare()

int FIX::double_conversion::Bignum::PlusCompare ( const Bignum & a,
const Bignum & b,
const Bignum & c )
static

Definition at line 637 of file FieldConvertors.cpp.

667{
668
669// we include "double-conversion" project in FIX namespace
670// to avoid linking errors if quickfix is linked statically
671// and "double-conversion" is already used by target project
672
673#include "double-conversion/diy-fp.cc"
674#include "double-conversion/fixed-dtoa.cc"
675#include "double-conversion/bignum.cc"
676#include "double-conversion/bignum-dtoa.cc"
677#include "double-conversion/cached-powers.cc"
678#include "double-conversion/fast-dtoa.cc"
679#include "double-conversion/strtod.cc"
680#include "double-conversion/double-conversion.cc"
681
682 static double_conversion::DoubleToStringConverter g_dtoa_converter(
683 double_conversion::DoubleToStringConverter::NO_FLAGS,
684 "INF",
685 "NAN",
686 'e',
687 -DoubleConvertor::SIGNIFICANT_DIGITS,
688 DoubleConvertor::SIGNIFICANT_DIGITS,
689 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
690 0);
691
692 static double_conversion::StringToDoubleConverter g_atod_converter(
693 double_conversion::StringToDoubleConverter::NO_FLAGS,
694 std::numeric_limits<double>::quiet_NaN(),
695 std::numeric_limits<double>::quiet_NaN(),
696 "INF",
697 "NAN");
698
699 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
700 {
701 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
702 }
703
704 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
705 {
706 double_conversion::StringBuilder builder( buffer, size );
707 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
708 {
709 builder.Reset();
710 return 0;
711 }
712
713 builder.TrimTrailingZeros();
714 return builder.position();
715 }
716
717 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
718 {
719 double_conversion::StringBuilder builder( buffer, size );
720 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
721 {
722 builder.Reset();
723 return 0;
724 }
725
726 return builder.position();
727 }
728
729}

◆ PlusEqual()

bool FIX::double_conversion::Bignum::PlusEqual ( const Bignum & a,
const Bignum & b,
const Bignum & c )
inlinestatic

Definition at line 89 of file FieldConvertors.cpp.

◆ PlusLess()

bool FIX::double_conversion::Bignum::PlusLess ( const Bignum & a,
const Bignum & b,
const Bignum & c )
inlinestatic

Definition at line 97 of file FieldConvertors.cpp.

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

◆ PlusLessEqual()

bool FIX::double_conversion::Bignum::PlusLessEqual ( const Bignum & a,
const Bignum & b,
const Bignum & c )
inlinestatic

Definition at line 93 of file FieldConvertors.cpp.

◆ ShiftLeft()

void FIX::double_conversion::Bignum::ShiftLeft ( int shift_amount)

Definition at line 239 of file FieldConvertors.cpp.

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

◆ Square()

void FIX::double_conversion::Bignum::Square ( )

Definition at line 341 of file FieldConvertors.cpp.

371{
372
373// we include "double-conversion" project in FIX namespace
374// to avoid linking errors if quickfix is linked statically
375// and "double-conversion" is already used by target project
376
377#include "double-conversion/diy-fp.cc"
378#include "double-conversion/fixed-dtoa.cc"
379#include "double-conversion/bignum.cc"
380#include "double-conversion/bignum-dtoa.cc"
381#include "double-conversion/cached-powers.cc"
382#include "double-conversion/fast-dtoa.cc"
383#include "double-conversion/strtod.cc"
384#include "double-conversion/double-conversion.cc"
385
386 static double_conversion::DoubleToStringConverter g_dtoa_converter(
387 double_conversion::DoubleToStringConverter::NO_FLAGS,
388 "INF",
389 "NAN",
390 'e',
391 -DoubleConvertor::SIGNIFICANT_DIGITS,
392 DoubleConvertor::SIGNIFICANT_DIGITS,
393 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
394 0);
395
396 static double_conversion::StringToDoubleConverter g_atod_converter(
397 double_conversion::StringToDoubleConverter::NO_FLAGS,
398 std::numeric_limits<double>::quiet_NaN(),
399 std::numeric_limits<double>::quiet_NaN(),
400 "INF",
401 "NAN");
402
403 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
404 {
405 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
406 }
407
408 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
409 {
410 double_conversion::StringBuilder builder( buffer, size );
411 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
412 {
413 builder.Reset();
414 return 0;
415 }
416
417 builder.TrimTrailingZeros();
418 return builder.position();
419 }
420
421 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
422 {
423 double_conversion::StringBuilder builder( buffer, size );
424 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
425 {
426 builder.Reset();
427 return 0;
428 }
429
430 return builder.position();
431 }
432
433}

◆ SubtractBignum()

void FIX::double_conversion::Bignum::SubtractBignum ( const Bignum & other)

Definition at line 212 of file FieldConvertors.cpp.

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

◆ SubtractTimes()

void FIX::double_conversion::Bignum::SubtractTimes ( const Bignum & other,
int factor )
private

Definition at line 739 of file FieldConvertors.cpp.

769{
770
771// we include "double-conversion" project in FIX namespace
772// to avoid linking errors if quickfix is linked statically
773// and "double-conversion" is already used by target project
774
775#include "double-conversion/diy-fp.cc"
776#include "double-conversion/fixed-dtoa.cc"
777#include "double-conversion/bignum.cc"
778#include "double-conversion/bignum-dtoa.cc"
779#include "double-conversion/cached-powers.cc"
780#include "double-conversion/fast-dtoa.cc"
781#include "double-conversion/strtod.cc"
782#include "double-conversion/double-conversion.cc"
783
784 static double_conversion::DoubleToStringConverter g_dtoa_converter(
785 double_conversion::DoubleToStringConverter::NO_FLAGS,
786 "INF",
787 "NAN",
788 'e',
789 -DoubleConvertor::SIGNIFICANT_DIGITS,
790 DoubleConvertor::SIGNIFICANT_DIGITS,
791 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
792 0);
793
794 static double_conversion::StringToDoubleConverter g_atod_converter(
795 double_conversion::StringToDoubleConverter::NO_FLAGS,
796 std::numeric_limits<double>::quiet_NaN(),
797 std::numeric_limits<double>::quiet_NaN(),
798 "INF",
799 "NAN");
800
801 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
802 {
803 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
804 }
805
806 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
807 {
808 double_conversion::StringBuilder builder( buffer, size );
809 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
810 {
811 builder.Reset();
812 return 0;
813 }
814
815 builder.TrimTrailingZeros();
816 return builder.position();
817 }
818
819 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
820 {
821 double_conversion::StringBuilder builder( buffer, size );
822 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
823 {
824 builder.Reset();
825 return 0;
826 }
827
828 return builder.position();
829 }
830
831}

◆ Times10()

void FIX::double_conversion::Bignum::Times10 ( )
inline

Definition at line 63 of file FieldConvertors.cpp.

◆ ToHexString()

bool FIX::double_conversion::Bignum::ToHexString ( char * buffer,
int buffer_size ) const

Definition at line 572 of file FieldConvertors.cpp.

602{
603
604// we include "double-conversion" project in FIX namespace
605// to avoid linking errors if quickfix is linked statically
606// and "double-conversion" is already used by target project
607
608#include "double-conversion/diy-fp.cc"
609#include "double-conversion/fixed-dtoa.cc"
610#include "double-conversion/bignum.cc"
611#include "double-conversion/bignum-dtoa.cc"
612#include "double-conversion/cached-powers.cc"
613#include "double-conversion/fast-dtoa.cc"
614#include "double-conversion/strtod.cc"
615#include "double-conversion/double-conversion.cc"
616
617 static double_conversion::DoubleToStringConverter g_dtoa_converter(
618 double_conversion::DoubleToStringConverter::NO_FLAGS,
619 "INF",
620 "NAN",
621 'e',
622 -DoubleConvertor::SIGNIFICANT_DIGITS,
623 DoubleConvertor::SIGNIFICANT_DIGITS,
624 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
625 0);
626
627 static double_conversion::StringToDoubleConverter g_atod_converter(
628 double_conversion::StringToDoubleConverter::NO_FLAGS,
629 std::numeric_limits<double>::quiet_NaN(),
630 std::numeric_limits<double>::quiet_NaN(),
631 "INF",
632 "NAN");
633
634 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
635 {
636 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
637 }
638
639 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
640 {
641 double_conversion::StringBuilder builder( buffer, size );
642 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
643 {
644 builder.Reset();
645 return 0;
646 }
647
648 builder.TrimTrailingZeros();
649 return builder.position();
650 }
651
652 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
653 {
654 double_conversion::StringBuilder builder( buffer, size );
655 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
656 {
657 builder.Reset();
658 return 0;
659 }
660
661 return builder.position();
662 }
663
664}

◆ Zero()

void FIX::double_conversion::Bignum::Zero ( )
private

Definition at line 690 of file FieldConvertors.cpp.

720{
721
722// we include "double-conversion" project in FIX namespace
723// to avoid linking errors if quickfix is linked statically
724// and "double-conversion" is already used by target project
725
726#include "double-conversion/diy-fp.cc"
727#include "double-conversion/fixed-dtoa.cc"
728#include "double-conversion/bignum.cc"
729#include "double-conversion/bignum-dtoa.cc"
730#include "double-conversion/cached-powers.cc"
731#include "double-conversion/fast-dtoa.cc"
732#include "double-conversion/strtod.cc"
733#include "double-conversion/double-conversion.cc"
734
735 static double_conversion::DoubleToStringConverter g_dtoa_converter(
736 double_conversion::DoubleToStringConverter::NO_FLAGS,
737 "INF",
738 "NAN",
739 'e',
740 -DoubleConvertor::SIGNIFICANT_DIGITS,
741 DoubleConvertor::SIGNIFICANT_DIGITS,
742 DoubleConvertor::SIGNIFICANT_DIGITS - 1,
743 0);
744
745 static double_conversion::StringToDoubleConverter g_atod_converter(
746 double_conversion::StringToDoubleConverter::NO_FLAGS,
747 std::numeric_limits<double>::quiet_NaN(),
748 std::numeric_limits<double>::quiet_NaN(),
749 "INF",
750 "NAN");
751
752 double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
753 {
754 return g_atod_converter.StringToDouble( buffer, size, processed_chars );
755 }
756
757 int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
758 {
759 double_conversion::StringBuilder builder( buffer, size );
760 if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
761 {
762 builder.Reset();
763 return 0;
764 }
765
766 builder.TrimTrailingZeros();
767 return builder.position();
768 }
769
770 int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
771 {
772 double_conversion::StringBuilder builder( buffer, size );
773 if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
774 {
775 builder.Reset();
776 return 0;
777 }
778
779 return builder.position();
780 }
781
782}

Member Data Documentation

◆ bigits_

Vector<Chunk> FIX::double_conversion::Bignum::bigits_
private

Definition at line 135 of file FieldConvertors.cpp.

◆ bigits_buffer_

Chunk FIX::double_conversion::Bignum::bigits_buffer_[kBigitCapacity]
private

Definition at line 132 of file FieldConvertors.cpp.

◆ exponent_

int FIX::double_conversion::Bignum::exponent_
private

Definition at line 138 of file FieldConvertors.cpp.

◆ kBigitCapacity

const int FIX::double_conversion::Bignum::kBigitCapacity = kMaxSignificantBits / kBigitSize
staticprivate

Definition at line 112 of file FieldConvertors.cpp.

◆ kBigitMask

const Chunk FIX::double_conversion::Bignum::kBigitMask = (1 << kBigitSize) - 1
staticprivate

Definition at line 109 of file FieldConvertors.cpp.

◆ kBigitSize

const int FIX::double_conversion::Bignum::kBigitSize = 28
staticprivate

Definition at line 108 of file FieldConvertors.cpp.

◆ kChunkSize

const int FIX::double_conversion::Bignum::kChunkSize = sizeof(Chunk) * 8
staticprivate

Definition at line 104 of file FieldConvertors.cpp.

◆ kDoubleChunkSize

const int FIX::double_conversion::Bignum::kDoubleChunkSize = sizeof(DoubleChunk) * 8
staticprivate

Definition at line 105 of file FieldConvertors.cpp.

◆ kMaxSignificantBits

const int FIX::double_conversion::Bignum::kMaxSignificantBits = 3584
static

Definition at line 41 of file FieldConvertors.cpp.

◆ used_digits_

int FIX::double_conversion::Bignum::used_digits_
private

Definition at line 136 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