Diff: FloatValue.cpp

Revision:

11:e1bee9a77652

Parent:

0:099f76422485

--- a/FloatValue.cpp	Thu Oct 23 14:41:58 2014 +0200
+++ b/FloatValue.cpp	Sat Nov 15 11:21:01 2014 +0100
@@ -30,155 +30,167 @@
 #include <math.h>
 #include <stdio.h>
 
+
+/*-------------------------------------------------------------------------*/
 FloatValue::FloatValue(double number, uint8_t digits, bool zflag)
 {
-    _negative = (number < 0.0);
-    _zflag = zflag;
-    if (_negative)
-        _number = -number;
-    else
-        _number = number;
-    if (digits == SMARTREST_FLOATVALUE_DETECTPREC)
-        _digits = detectPrecision(_number);
-    else
-        _digits = digits;
+	_negative = (number < 0.0);
+	_zflag = zflag;
+	if (_negative)
+		_number = -number;
+	else
+		_number = number;
+	if (digits == SMARTREST_FLOATVALUE_DETECTPREC)
+		_digits = detectPrecision(_number);
+	else
+		_digits = digits;
 }
-
+/*-------------------------------------------------------------------------*/
 uint8_t FloatValue::valueType() const
 {
-    return VALUE_FLOAT;
+	return VALUE_FLOAT;
 }
-
+/*-------------------------------------------------------------------------*/
 long FloatValue::integerValue() const
 {
-    return 0L;
+	return 0L;
 }
-
+/*-------------------------------------------------------------------------*/
 double FloatValue::floatValue() const
 {
-    return (_negative) ? -_number : _number;
+	return (_negative) ? -_number : _number;
 }
-
+/*-------------------------------------------------------------------------*/
 const char * FloatValue::characterValue() const
 {
-    return 0;
+	return 0;
 }
-
+/*-------------------------------------------------------------------------*/
 size_t FloatValue::write(AbstractDataSink& sink) const
 {
-    size_t n = 0;
-    double number, rounding;
-    uint8_t i;
-    unsigned long int_part;
-    double remainder;
+	size_t n = 0;
+	double number, rounding;
+	uint8_t i;
+	unsigned long int_part;
+	double remainder;
+
+	if (isnan(_number))
+		return sink.write("nan");
 
-    if (isnan(_number))
-        return sink.write("nan");
+	if (_negative)
+		n += sink.write('-');
 
-    if (_negative)
-        n += sink.write('-');
-
-    if (isinf(_number)) {
-        n += sink.write("inf");
-        return n;
-    }
+	if (isinf(_number))
+	{
+		n += sink.write("inf");
+		return n;
+	}
 
-    number = _number;
-    rounding = 0.5;
-    for (i = 0; i < _digits; ++i)
-        rounding /= 10.0;
-    number += rounding;
+	number = _number;
+	rounding = 0.5;
+	for (i = 0; i < _digits; ++i)
+		rounding /= 10.0;
+	number += rounding;
 
-    int_part = (unsigned long)number;
-    remainder = number - (double)int_part;
+	int_part = (unsigned long)number;
+	remainder = number - (double)int_part;
 
-    if ((_zflag) || (int_part))
-        n += sink.write(int_part);
+	if ((_zflag) || (int_part))
+		n += sink.write(int_part);
 
-    if (_digits == 0)
-        return n;
-    n += sink.write("."); 
+	if (_digits == 0)
+		return n;
+	n += sink.write("."); 
 
-    uint8_t digits = _digits;
-    while (digits-- > 0) {
-        remainder *= 10.0;
-        unsigned long l = (unsigned long)remainder;
-        n += sink.write(l);
-        remainder -= l; 
-    } 
+	uint8_t digits = _digits;
+	while (digits-- > 0)
+	{
+		remainder *= 10.0;
+		unsigned long l = (unsigned long)remainder;
+		n += sink.write(l);
+		remainder -= l; 
+	} 
 
-    return n;
+	return n;
 }
-
+/*-------------------------------------------------------------------------*/
 size_t FloatValue::length() const
 {
-    size_t l = 0;
-    double number, rounding;
-    unsigned long n;
-    uint8_t i;
+	size_t l = 0;
+	double number, rounding;
+	unsigned long n;
+	uint8_t i;
 
-    if (isnan(_number))
-        return 3;
+	if (isnan(_number))
+		return 3;
 
-    if (_negative)
-        l++;
+	if (_negative)
+		l++;
 
-    if (isinf(_number)) {
-        l += 3;
-        return l;
-    }
+	if (isinf(_number))
+	{
+		l += 3;
+		return l;
+	}
 
-    number = _number;
-    rounding = 0.5;
-    for (i = 0; i < _digits; ++i)
-        rounding /= 10.0;
-    number += rounding;
+	number = _number;
+	rounding = 0.5;
+	for (i = 0; i < _digits; ++i)
+		rounding /= 10.0;
+	number += rounding;
 
-    n = (unsigned long)number;
-    if ((_zflag) || (n)) {
-        do {
-            n /= 10;
-            l++;
-        } while(n);
-    }
+	n = (unsigned long)number;
+	if ((_zflag) || (n))
+	{
+		do
+		{
+			n /= 10;
+			l++;
+		} while(n);
+	}
 
-    if (_digits > 0)
-        l += 1 + _digits;
+	if (_digits > 0)
+		l += 1 + _digits;
 
-    return l;
+	return l;
 }
-
+/*-------------------------------------------------------------------------*/
 Value* FloatValue::copy() const
 {
-    double number;
+	double number;
 
-    number = (_negative) ? -_number : _number;
-    return new FloatValue(number, _digits, _zflag);
+	number = (_negative) ? -_number : _number;
+	return new FloatValue(number, _digits, _zflag);
 }
-
+/*-------------------------------------------------------------------------*/
 uint8_t FloatValue::detectPrecision(double n)
 {
-    uint8_t prec = 0, count = 0;
-    int8_t d;
+	uint8_t prec = 0, count = 0;
+	int8_t d;
 
-    if ((isinf(n)) || (isnan(n)))
-        return 0;
+	if ((isinf(n)) || (isnan(n)))
+		return 0;
 
-    n -= (long)n;
+	n -= (long)n;
 
-    while ((prec < 6) && (count < 3)) {
-        n *= 10;
-        d = (uint8_t)n;
+	while ((prec < 6) && (count < 3))
+	{
+		n *= 10;
+		d = (uint8_t)n;
 
-        if (count == 0) {
-            if ((d <= 0) || (d >= 9))
-                count++;
-        } else {
-            count++;
-        }
-        prec++;
-        n -= d;
-    }
+		if (count == 0)
+		{
+			if ((d <= 0) || (d >= 9))
+				count++;
+		}
+		else
+		{
+			count++;
+		}
+		prec++;
+		n -= d;
+	}
 
-    return --prec;
+	return --prec;
 }
+/*-------------------------------------------------------------------------*/