//--------------------------------------------------------------------------------------------------
//--- Test ConvertFloats
//--------------------------------------------------------------------------------------------------
void floatTest( double d, char decimalPoint, int minDigitsBeforeDot, int digitsAfterDot, String expectedString, bool forceScientific= false )
{
AString ms= new AString();
NumberFormat nf= new NumberFormat();
nf.ForceScientificFormat= forceScientific;
if ( decimalPoint == '\0' )
{
// reset ALIB' number format to reflect current locale
NumberFormat.Global.SetFromLocale();
nf.DecimalPointCharacter= NumberFormat.Global.DecimalPointCharacter;
}
else
nf.DecimalPointCharacter= decimalPoint;
nf.MinIntegralDigits= minDigitsBeforeDot;
nf.FractionalDigits= digitsAfterDot;
ms._( d, nf );
if ( expectedString != null )
{
UT_EQ( expectedString, ms );
}
double precision= digitsAfterDot < 0 ? Math.Pow( 10, (d != 0.0 ? (int) Math.Floor((Math.Log10( d ) )) : 0 ) - 14 )
: Math.Pow( 10, digitsAfterDot ) / 2.0;
// check with system parsing (only if system specific decimal point format was given)
if ( decimalPoint == '\0' )
{
double dSystem= 0.0;
try
{
dSystem= Double.Parse( ms.ToString(), CultureInfo.CurrentCulture );
}
catch( Exception )
{
UT_TRUE( digitsAfterDot == 0 ); // this is not really allowed in c# when parsing
dSystem= d;
}
UT_EQ( d, dSystem, precision );
}
// check with aworx parsing
double dAWorx= ms.ToFloat();
UT_EQ( d, dAWorx, precision );
}
public void ConvertFloats()
{
AString a= new AString();
int pos;
int posOrig;
// parse on empty
a.Clear();
{
posOrig= pos= 0; UT_EQ( 0.0, a.ToFloat ( pos ) ); UT_EQ( pos, posOrig );
posOrig= pos= -5; UT_EQ( 0.0, a.ToFloat ( pos ) );
}
// parse on non number
a.Clear()._( "Hello");
{
posOrig= pos= 0; UT_EQ( 0.0, a.ToFloat ( pos ) );
posOrig= pos= -5; UT_EQ( 0.0, a.ToFloat ( pos ) );
posOrig= pos= 2; UT_EQ( 0.0, a.ToFloat ( pos ) );
}
// check that leading whitespaces do not move pointer
a.Clear()._( " Hello");
{
posOrig= pos= 0; UT_EQ( 0.0, a.ToFloat ( pos ) );
posOrig= pos= -5; UT_EQ( 0.0, a.ToFloat ( pos ) );
posOrig= pos= 2; UT_EQ( 0.0, a.ToFloat ( pos ) );
}
// parse floats
{
NumberFormat nf= new NumberFormat();
a.Clear()._( "12345.789"); UT_EQ( 12345.789, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 0 + a.Length() , pos );
a.Clear()._( ""); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 0 , pos );
a.Clear()._( "-"); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 0 , pos );
a.Clear()._( "-X"); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 0 , pos );
a.Clear()._( "."); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 1 , pos );
a.Clear()._( ".0"); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "0."); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( ".5"); UT_EQ( 0.5, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "5."); UT_EQ( 5.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "+0"); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "-0"); UT_EQ( 0.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "+6"); UT_EQ( 6.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "-7"); UT_EQ( -7.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "-7"); UT_EQ( 7.0, a.ToFloat( 1, out pos, nf ) ); UT_EQ( 2 , pos );
a.Clear()._( "+42"); UT_EQ( 42.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 3 , pos );
a.Clear()._( " -42 "); UT_EQ(-42.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 4 , pos );
a.Clear()._( " +42. "); UT_EQ( 42.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 6 , pos );
a.Clear()._( " 123"); UT_EQ( 123.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 0 + a.Length() , pos );
a.Clear()._( " -23 "); UT_EQ( -23.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 5 , pos );
a.Clear()._( "123 "); UT_EQ( 123.0, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 3 , pos );
a.Clear()._( "xxx123456789"); UT_EQ( 123456789.0, a.ToFloat( 3, out pos, nf ) ); UT_EQ( 0 + a.Length() , pos );
a.Clear()._( "xxx 1.3"); UT_EQ( 1.3, a.ToFloat( 3, out pos, nf ) ); UT_EQ( 0 + a.Length() , pos );
a.Clear()._( "xxx 1.3 "); UT_EQ( 1.3, a.ToFloat( 3, out pos, nf ) ); UT_EQ( 0 + a.Length()-2 , pos );
a.Clear()._( "xxx1.3 "); UT_EQ( 1.3, a.ToFloat( 3, out pos, nf ) ); UT_EQ( 0 + a.Length()-2 , pos );
nf.DecimalPointCharacters= "@".ToCharArray();
a.Clear()._( "-2495@321"); UT_EQ( -2495.321, a.ToFloat( 0, out pos, nf ) ); UT_EQ( 0 + a.Length() , pos );
}
// write floats, non scientific mode
{
// digits after dot: -1
floatTest( 3.0 ,'.' , -1, -1 , "3.0" );
floatTest( 3.1 ,'.' , -1, -1 , "3.1" );
floatTest( 3.14 ,'.' , -1, -1 , "3.14" );
floatTest( 3.145 ,'.' , -1, -1 , "3.145" );
floatTest( 3.02 ,'.' , -1, -1 , "3.02" );
floatTest( 3.001 ,'.' , -1, -1 , "3.001" );
floatTest( 3.09 ,'.' , -1, -1 , "3.09" );
floatTest( 3.009 ,'.' , -1, -1 , "3.009" );
floatTest( 0.0 ,'.' , -1, -1 , "0.0" );
floatTest( 0.1 ,'.' , -1, -1 , "0.1" );
floatTest( 0.14 ,'.' , -1, -1 , "0.14" );
floatTest( 0.145 ,'.' , -1, -1 , "0.145" );
floatTest( 0.02 ,'.' , -1, -1 , "0.02" );
floatTest( 0.001 ,'.' , -1, -1 , "0.001" );
floatTest( 0.09 ,'.' , -1, -1 , "0.09" );
floatTest( 0.009 ,'.' , -1, -1 , "0.009" );
// forces scientific notation
floatTest( 3.0 ,'.' , -1, -1 , "3.0E00" , true );
floatTest( 3.1 ,'.' , -1, -1 , "3.1E00" , true );
floatTest( 3.14 ,'.' , -1, -1 , "3.14E00" , true );
floatTest( 3.145 ,'.' , -1, -1 , "3.145E00" , true );
floatTest( 3.02 ,'.' , -1, -1 , "3.02E00" , true );
floatTest( 3.001 ,'.' , -1, -1 , "3.001E00" , true );
floatTest( 3.09 ,'.' , -1, -1 , "3.09E00" , true );
floatTest( 3.009 ,'.' , -1, -1 , "3.009E00" , true );
floatTest( 3.145 ,'.' , -1, 1 , "3.1E00" , true );
floatTest( 3.145 ,'.' , 1, 1 , "3.1E00" , true );
floatTest( 3.145 ,'.' , 5, 3 , "00003.145E00" , true );
floatTest( 123.12341234 ,'.' , -1, 6 , "1.231234E02" , true );
floatTest( 0.00123123123 ,'.' , -1, 6 , "1.231231E-03" , true );
floatTest( 0.321 ,'.' , 0, 6 , "3.210000E-01" , true );
floatTest( 3.789 ,'.' , -1, 1 , "3.8E00" , true );
floatTest( 123.78978978 ,'.' , -1, 6 , "1.237898E02" , true );
floatTest( 0.00789789789 ,'.' , -1, 6 , "7.897898E-03" , true );
// many digits after dot
// 123456789 123456789 12345
double RoundDown= 1.123412341234123412341234;
floatTest( RoundDown ,'.' , 1, 12 , "1.123412341234" );
floatTest( RoundDown ,'.' , 1, 13 , "1.1234123412341" );
floatTest( RoundDown ,'.' , 1, 14 , "1.12341234123412" );
floatTest( RoundDown ,'.' , 1, 15 , "1.123412341234123" );
RoundDown= 0.123412341234123412341234;
floatTest( RoundDown ,'.' , 1, 12 , "0.123412341234" );
floatTest( RoundDown ,'.' , 1, 13 , "0.1234123412341" );
floatTest( RoundDown ,'.' , 1, 14 , "0.12341234123412" );
floatTest( RoundDown ,'.' , 1, 15 , "0.123412341234123" );
double RoundUp= 1.678967896789678967896789;
floatTest( RoundUp ,'.' , 1, 12 , "1.678967896790" );
floatTest( RoundUp ,'.' , 1, 13 , "1.6789678967897" );
floatTest( RoundUp ,'.' , 1, 14 , "1.67896789678968" );
floatTest( RoundUp ,'.' , 1, 15 , "1.678967896789679" );
RoundUp= 0.678967896789678967896789;
floatTest( RoundUp ,'.' , 1, 12 , "0.678967896790" );
floatTest( RoundUp ,'.' , 1, 13 , "0.6789678967897" );
floatTest( RoundUp ,'.' , 1, 14 , "0.67896789678968" );
floatTest( RoundUp ,'.' , 1, 15 , "0.678967896789679" );
// 123456789 123456789 123456789 12345
floatTest( 0.00001234123412341234 ,'.' , 1, 15 , "0.000012341234123" );
floatTest( 0.00000123412341234123 ,'.' , 1, 15 , "0.000001234123412" );
floatTest( 0.00000012341234123412 ,'.' , 1, 15 , "0.000000123412341" );
floatTest( 0.00000001234123412341 ,'.' , 1, 15 , "0.000000012341234" );
floatTest( 0.00000000123412341234 ,'.' , 1, 15 , "0.000000001234123" );
floatTest( 0.00000000012341234123 ,'.' , 1, 15 , "0.000000000123412" );
floatTest( 0.00000000001234123412 ,'.' , 1, 15 , "0.000000000012341" );
floatTest( 0.00000000000123412341 ,'.' , 1, 15 , "0.000000000001234" );
floatTest( 0.00000000000012341234 ,'.' , 1, 15 , "0.000000000000123" );
floatTest( 0.00000000000001234123 ,'.' , 1, 15 , "0.000000000000012" );
floatTest( 0.00000000000000123412 ,'.' , 1, 15 , "0.000000000000001" );
floatTest( 0.00000000000000012341 ,'.' , 1, 15 , "0.000000000000000" );
floatTest( 0.00000000000000001234 ,'.' , 1, 15 , "0.000000000000000" );
floatTest( 0.00006789678967896789 ,'.' , 1, 15 , "0.000067896789679" );
floatTest( 0.00000678967896789678 ,'.' , 1, 15 , "0.000006789678968" );
floatTest( 0.00000067896789678967 ,'.' , 1, 15 , "0.000000678967897" );
floatTest( 0.00000006789678967896 ,'.' , 1, 15 , "0.000000067896790" );
floatTest( 0.00000000678967896789 ,'.' , 1, 15 , "0.000000006789679" );
floatTest( 0.00000000067896789678 ,'.' , 1, 15 , "0.000000000678968" );
floatTest( 0.00000000006789678967 ,'.' , 1, 15 , "0.000000000067897" );
floatTest( 0.00000000000678967896 ,'.' , 1, 15 , "0.000000000006790" );
floatTest( 0.00000000000067896789 ,'.' , 1, 15 , "0.000000000000679" );
floatTest( 0.00000000000006789678 ,'.' , 1, 15 , "0.000000000000068" );
floatTest( 0.00000000000000678967 ,'.' , 1, 15 , "0.000000000000007" );
floatTest( 0.00000000000000067896 ,'.' , 1, 15 , "0.000000000000001" );
floatTest( 0.00000000000000006789 ,'.' , 1, 15 , "0.000000000000000" );
floatTest( 0.00000000000000000678 ,'.' , 1, 15 , "0.000000000000000" );
// digits after dot: 0 or positive
floatTest( 300.00050000001 ,'.' , 1, 2 , "300.00" );
floatTest( 300.00050000001 ,'.' , 1, 3 , "300.001" );
floatTest( 300.00050000001 ,'.' , 1, 4 , "300.0005" );
floatTest( 300.00050000001 ,'.' , 1, 5 , "300.00050" );
floatTest( 300.00050000001 ,'.' , 1, 6 , "300.000500" );
floatTest( 5.01 ,'.' , 1, 3 , "5.010" );
floatTest( 0.5 ,'.' , 0, 0 , "." );
floatTest( 0.5 ,'.' , 0, 1 , ".5" );
floatTest( 0.5 ,'.' , 1, 0 , "0." );
floatTest( 0.5 ,'.' , 1, 1 , "0.5" );
floatTest( 0.5 ,'.' , 2, 2 , "00.50" );
floatTest( 0.5 ,'.' , 3, 3 , "000.500" );
floatTest( 0.54 ,'.' , 3, 3 , "000.540" );
floatTest( 0.543 ,'.' , 3, 3 , "000.543" );
floatTest( 0.5432 ,'.' , 3, 3 , "000.543" );
floatTest( 23.37 ,'.' , 2, 1 , "23.4" );
floatTest( 1.5 ,'.' , 0, 0 , "1." );
floatTest( 1.9 ,'.' , 0, 0 , "2." );
floatTest( 1.9 ,'.' , 0, 4 , "1.9000" );
floatTest( 1.500001 ,'.' , 0, 0 , "2." );
floatTest( 1.54 ,'.' , 3, 3 , "001.540" );
floatTest( 1.543 ,'.' , 3, 3 , "001.543" );
floatTest( 1.5432 ,'.' , 3, 3 , "001.543" );
floatTest( 23.37 ,'.' , 2, 3 , "23.370" );
floatTest( 12.345 ,'.' , 0, 3 , "12.345" );
floatTest( 12.345 ,'.' , 5, 1 , "00012.3" );
floatTest( 12.36789 ,'.' , 5, 1 , "00012.4" );
floatTest( 1.5 ,'.' , 0, 0 , "1." );
floatTest( 1.5 ,'.' , 1, 0 , "1." );
floatTest( 1.5 ,'.' , 0, 1 , "1.5" );
floatTest( 1.5 ,'.' , 1, 1 , "1.5" );
floatTest( 1.5 ,'.' , 2, 2 , "01.50" );
floatTest( 1.5 ,'.' , 3, 3 , "001.500" );
floatTest( 1.54 ,'.' , 3, 3 , "001.540" );
floatTest( 1.543 ,'.' , 3, 3 , "001.543" );
floatTest( 1.5432 ,'.' , 3, 3 , "001.543" );
floatTest( 0.0 ,'.' , 0, 0 , "." );
floatTest( 0.0 ,'.' , 1, 0 , "0." );
floatTest( 0.0 ,'.' , 0, 1 , ".0" );
floatTest( 0.0 ,'.' , 1, 1 , "0.0" );
floatTest( 0.0 ,'.' , 2, 2 , "00.00" );
floatTest( 10.0 ,'.' , 2, 2 , "10.00" );
floatTest( 23.37 ,'.' , 2, 1 , "23.4" );
floatTest( 23.37 ,'.' , 2, 3 , "23.370" );
floatTest( 12.345 ,'.' , 0, 3 , "12.345" );
floatTest( - 5.1 ,'.' , 5, 0 , "-00005." );
floatTest( - 5.1 ,'.' , 5, 1 , "-00005.1" );
floatTest( - 53.24 ,'.' , 2, 2 , "-53.24" );
floatTest( - 0.2 ,'.' , 1, 3 , "-0.200" );
floatTest( - 0.6 ,'.' , 1, 3 , "-0.600" );
floatTest( - 0.999 ,'.' , 1, 3 , "-0.999" );
floatTest( 0.999 ,'.' , 1, 3 , "0.999" );
floatTest( 0.99 ,'.' , 1, 3 , "0.990" );
floatTest( 0.999 ,'.' , 1, 3 , "0.999" );
floatTest( 0.9999 ,'.' , 1, 3 , "1.000" );
floatTest( 0.0999 ,'.' , 2, 3 , "00.100" );
floatTest( 0.99999 ,'.' , 1, 3 , "1.000" );
floatTest( 0.099 ,'.' , 2, 3 , "00.099" );
floatTest( 0.0999 ,'.' , 1, 3 , "0.100" );
floatTest( 0.09999 ,'.' , 2, 3 , "00.100" );
floatTest( 0.999 ,'.' , 2, 3 , "00.999" );
floatTest( 0.0099 ,'.' , 1, 3 , "0.010" );
floatTest( 0.00999 ,'.' , 1, 3 , "0.010" );
floatTest( 0.009 ,'.' , 1, 3 , "0.009" );
floatTest( 0.00099 ,'.' , 1, 3 , "0.001" );
floatTest( 0.00009 ,'.' , 1, 3 , "0.000" );
floatTest( 1.0099 ,'.' , 1, 3 , "1.010" );
floatTest( 1.00999 ,'.' , 1, 3 , "1.010" );
floatTest( 1.009 ,'.' , 1, 3 , "1.009" );
floatTest( 1.00099 ,'.' , 1, 3 , "1.001" );
floatTest( 1.00009 ,'.' , 1, 3 , "1.000" );
floatTest( 0.00050 ,'.' , 1, 3 , "0.000" );
floatTest( 0.00051 ,'.' , 1, 3 , "0.001" );
floatTest( 0.00050000001 ,'.' , 1, 3 , "0.001" );
floatTest( 300.00050000001 ,'.' , 1, 3 , "300.001" );
floatTest( 0.10099 ,'.' , 1, 4 , "0.1010" );
floatTest( 0.10099 ,'.' , 1, 4 , "0.1010" );
floatTest( 0.00099 ,'.' , 1, 4 , "0.0010" );
floatTest( 1.099 ,'.' , 1, 1 , "1.1" );
floatTest( 0.00999 ,'.' , 1, 4 , "0.0100" );
// roundtrip -3.0 to 3.0 step 0.001
{
for (int digits= -1 ; digits < 5 ; digits++ )
{
double d= -3.0;
double end= 3.0;
double inc= 0.001;
while ( d <= end )
{
floatTest( d, '\0' , -1, digits, null );
d+= inc;
}
}
}
// roundtrip e-200 to e+200
{
Random r = new Random();
for ( int exp= -200 ; exp <= 200 ; exp+=1 )
{
double expFactor= Math.Pow( 10, exp );
for ( int t= 0 ; t <= 1000 ; t++)
{
// create a random number of type r.rrrrr *10^exp
double d= r.NextDouble();
while ( d < 1.0 )
d*= 10.0;
d*= expFactor;
if ( (t & 1 ) != 0 )
d= -d;
floatTest( d, '\0' , -1, -1, null );
}
}
}
// special exponent symbol
{
int dummy;
NumberFormat nf= new NumberFormat();
nf.DecimalExponentSeparator= "*10^".ToCharArray();
AString s= new AString();
double v= 7.5E42;
s._( v, nf );
UT_EQ( s, "7.5*10^42" );
double back= s.ToFloat( 0, out dummy, nf );
UT_EQ( v, back, 0.0000000001 );
}
}
}
/** ****************************************************************************************
* Reads a floating point number from this object. If successful, the front of
* this \b %Substring is cut to point to first character that is not belonging to the
* floating point number.
* If no number is found, \c false is returned and this object does not change.
*
* Leading whitespace characters are ignored. However, if after leading whitespaces no
* number is found, then also these whitespaces remain.
*
* \note
* If this \b %Substring spans several float values which are separated by
* whitespaces, concatenated calls to this method will read one by one,
* without the need of further trimming or
* \ref cs::aworx::lib::strings::Tokenizer "'tokenizing'").
* Therefore, by providing the parameter \p whitespaces, it is possible to
* easily read several numbers which are separated by user defined characters.
*
* See class \ref cs::aworx::lib::strings::NumberFormat "NumberFormat"
* for more information about conversion methods of floating point values in ALib.
* If no object of this type is provided with optional parameter \p numberFormat,
* the static default object found in
* \ref cs::aworx::lib::strings::NumberFormat::Global "NumberFormat.Global"
* is used.
*
* @param[out] result A reference to the result value.
* @param numberFormat The object performing the conversion and defines the output format.
* Optional and defaults to \c null.
* @param whitespaces White space characters used to trim the substring at the front
* before reading the value.
* Defaults to \ref CString.DefaultWhitespaces
*
* @return \c true if a number was found and, \c false otherwise.
******************************************************************************************/
public bool ConsumeFloat( out double result, NumberFormat numberFormat = null, char[] whitespaces = null )
{
result= 0.0;
if( IsEmpty() )
return false;
if ( whitespaces == null ) whitespaces= CString.DefaultWhitespaces;
if ( numberFormat == null ) numberFormat= NumberFormat.Global;
int origStart= Start;
int origEnd= End;
TrimStart( whitespaces );
int trimStart= Start;
int idx= trimStart;
result= ( numberFormat != null ? numberFormat
: NumberFormat.Global )
.StringToFloat( Buf, ref idx, End );
if( idx != trimStart )
{
Start= idx;
return true;
}
Start= origStart;
End= origEnd;
return false;
}