Rounding to 2 decimal point not working

[alberk8]

Library/API/IoT binding

nanoframework.System.Math

Visual Studio version

VS2022 17.3.6

.NET nanoFramework extension version

2022.2.0.44

Target name(s)

ESP32_REV3

Firmware version

1.8.0.699

Device capabilities

No response

Description

Rounding a double to two(2) decimal places does not work as expected. The results is the same as the source.

How to reproduce

double tempValue = 36.3999999d;
// This return 3640 which is correct
Console.WriteLine("Round: " + Math.Round(tempValue * 100d) );

double roundedValue = Math.Round(tempValue * 100d) / 100d;

// This return 36.3999999 which is wrong,   Correct value is 36.4
Console.WriteLine("Rounded Value: " + roundedValue);
Console.WriteLine("Rounded Value to String : " + roundedValue.ToString());

Expected behaviour

There result should be 36.4. This result is confirmed correct on .Net 6.

Screenshots

No response

Sample project or code

No response

Aditional information

No response

[Ellerbach]

This is normal as depending on the platform you have a float behind the scene of the double.
Try it with 36.4d of 36.4000001d and quite some equivalents, you'll always get back 36.3999999.
float like double are not precise numbers. There are numbers you'll never be able to get exact regardless of nano or full .NET. I don't have some of those in minds but you could find much much much examples like this.
Proper way of rounding to any decimal with a minimum effect::

double tempValue = 36.3999999d;
// This to avoud rounding up, it will always round to the entier part
double roundedValue = Math.Round(tempValue - 0.5);
double roundedValueAfter = Math.Abs(Math.Round((roundedValue - tempValue) * 100d));
Console.WriteLine($"Rounded Value to String: {roundedValue}.{roundedValueAfter}");

Again, not related to nano, just related to internal usage of float in some platforms and this phenomenon appear for a lot of numbers.

[TerryFogg]

I had a bit of investigation into this as it seemed strange that the C# code
double temp = 36.40d;
Console.WriteLine("temp : " + temp.ToString());
on the PC
--> 36.4
and on nanoFramework
--> 36.9999999.

The debugger when you hover over the value to see the debug current value it returns 36.4 in both cases.

A bit further research looking at the underlying C code, lets me see what is stored for the 36.4 for each case.

The following C Code fragment was run on the PC and nanoframework, and I investigated what was stored at the memory address

int main(int argc, char **argv)
{
double xx = 36.40;
double *xxp = &xx;
}

On both the PC and nanoFramework using Visual Studio C/C++ compiler on PC and Gnu C/C++ compiler on the board I am using both stored the same binary representation which is
33333333 40423333
or
as a 64-bit floating number

36.399999999999999

So, the C# on the PC seems to have a different rule for formatting the number.

The nanoFramework gives the correct output of the internally stored value, since 36.4 seems to be 36.39... repeating 9.

[alberk8]

I have downgraded to Float. it seems to work correctly with rounding.

[TerryFogg]

Down grading may work for this but does it work for all cases?
Without context, I don't know what you are trying to achieve, another Round() of the result to the number of places you require?
Obviously, you need to take into account experimental errors and significant digits in measurements

[alberk8]

Down grading may work for this but does it work for all cases? Without context, I don't know what you are trying to achieve, another Round() of the result to the number of places you require? Obviously, you need to take into account experimental errors and significant digits in measurements

What I am trying to do is to round a float or double to two decimal place. I don't have anything beside the ESP32, if you can test on other Architecture that would be nice. Thank you.

   float f1 = 34.75545f;
   float f2 = (float) Math.Round(f1 * 100) ;
   float f3 = (float)Math.Round(f1 * 100)/100;

   Console.WriteLine($"Float F1: {f1}");
   Console.WriteLine($"Float F2: {f2}");
   Console.WriteLine($"Float F3: {f3}");

[TerryFogg]

This works, seems to be plenty of examples out there, but not all would work.
This one does
double d1 = 34.75545667d;
double answer2 = double.Parse(d1.ToString("f2")); --> 34.75
double answer3 = double.Parse(d1.ToString("f3")); --> 34.755
double answer4 = double.Parse(d1.ToString("f4")); --> 34.7555