1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
// Copyright (C) 2002-2009 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
#ifndef __FAST_A_TO_F_H_INCLUDED__
#define __FAST_A_TO_F_H_INCLUDED__
#include "irrMath.h"
namespace irr
{
namespace core
{
// we write [17] here instead of [] to work around a swig bug
const float fast_atof_table[17] = {
0.f,
0.1f,
0.01f,
0.001f,
0.0001f,
0.00001f,
0.000001f,
0.0000001f,
0.00000001f,
0.000000001f,
0.0000000001f,
0.00000000001f,
0.000000000001f,
0.0000000000001f,
0.00000000000001f,
0.000000000000001f,
0.0000000000000001f
};
//! Convert a simple string of base 10 digits into a signed 32 bit integer.
//! \param[in] in: The string of digits to convert. Only a leading - or + followed
//! by digits 0 to 9 will be considered. Parsing stops at the
//! first non-digit.
//! \param[out] out: (optional) If provided, it will be set to point at the first
//! character not used in the calculation.
//! \return The signed integer value of the digits. If the string specifies too many
//! digits to encode in an s32 then +INT_MAX or -INT_MAX will be returned.
inline s32 strtol10(const char* in, const char** out=0)
{
if(!in)
return 0;
bool negative = false;
if('-' == *in)
{
negative = true;
++in;
}
else if('+' == *in)
++in;
u32 unsignedValue = 0;
while ( ( *in >= '0') && ( *in <= '9' ))
{
unsignedValue = ( unsignedValue * 10 ) + ( *in - '0' );
++in;
if(unsignedValue > (u32)INT_MAX)
{
unsignedValue = (u32)INT_MAX;
break;
}
}
if (out)
*out = in;
if(negative)
return -((s32)unsignedValue);
else
return (s32)unsignedValue;
}
//! Converts a sequence of digits into a whole positive floating point value.
//! Only digits 0 to 9 are parsed. Parsing stops at any other character,
//! including sign characters or a decimal point.
//! \param in: the sequence of digits to convert.
//! \param out: (optional) will be set to point at the first non-converted character.
//! \return The whole positive floating point representation of the digit sequence.
inline f32 strtof10(const char* in, const char * * out = 0)
{
if(out)
*out = in;
if(!in)
return 0.f;
static const u32 MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
f32 floatValue = 0.f;
u32 intValue = 0;
// Use integer arithmetic for as long as possible, for speed
// and precision.
while ( ( *in >= '0') && ( *in <= '9' ) )
{
// If it looks like we're going to overflow, bail out
// now and start using floating point.
if(intValue >= MAX_SAFE_U32_VALUE)
break;
intValue = ( intValue * 10) + ( *in - '0' );
++in;
}
floatValue = (f32)intValue;
// If there are any digits left to parse, then we need to use
// floating point arithmetic from here.
while ( ( *in >= '0') && ( *in <= '9' ) )
{
floatValue = ( floatValue * 10.f ) + (f32)( *in - '0' );
++in;
if(floatValue > FLT_MAX) // Just give up.
break;
}
if(out)
*out = in;
return floatValue;
}
//! Provides a fast function for converting a string into a float.
//! This is not guaranteed to be as accurate as atof(), but is
//! approximately 6 to 8 times as fast.
//! \param[in] in: The string to convert.
//! \param[out] out: The resultant float will be written here.
//! \return A pointer to the first character in the string that wasn't
//! use to create the float value.
inline const char* fast_atof_move( const char * in, f32 & out)
{
// Please run this regression test when making any modifications to this function:
// https://sourceforge.net/tracker/download.php?group_id=74339&atid=540676&file_id=298968&aid=1865300
out = 0.f;
if(!in)
return 0;
bool negative = false;
if(*in == '-')
{
negative = true;
++in;
}
f32 value = strtof10 ( in, &in );
if (*in == '.')
{
++in;
const char * afterDecimal = in;
f32 decimal = strtof10 ( in, &afterDecimal );
decimal *= fast_atof_table[afterDecimal - in];
value += decimal;
in = afterDecimal;
}
if ('e' == *in || 'E' == *in)
{
++in;
// Assume that the exponent is a whole number.
// strtol10() will deal with both + and - signs,
// but cast to (f32) to prevent overflow at FLT_MAX
value *= (f32)pow(10.0f, (f32)strtol10(in, &in));
}
if(negative)
out = -value;
else
out = value;
return in;
}
//! Convert a string to a floating point number
//! \param floatAsString: The string to convert.
inline float fast_atof(const char* floatAsString)
{
float ret;
fast_atof_move(floatAsString, ret);
return ret;
}
} // end namespace core
} // end namespace irr
#endif
|
