Convert/Cast Single to double inaccurate.

Question

Whilst I have read some background on floating opint numbers not being able to accurately store numbers such as 0.1, I am not clear why converting from single to double is so inaccurate.
Converting a single 0.1 to a double 0.1 yeilds
0.10000000149011600
But 0.1 can be represented in a double more accurately, even if not perfectly as
0.10000000000000000
This stems from the single representation of 0.1 actually equating to 0.10000000149011600 in binary.
However, we know that the single has a particular level of precision.
I would like a conersion function that converts single 0.10000000 to double 0.1000000000000000.
I can appreciate that the standard conversion functions would need to still exist as real numbers for engineering would suffer less overall inaccuracies with the existing rounding functions.
One other question:
Can the convertsion be affected by the OS/framework/hardware or will it be consistent on different machines?  Are there any settings that can change the conversion behaviour?

Answer 1

There is no reason that we should explicitly convert a single precision number to a double precision number using some function as a simple assignment would do the same. Please review the following code:
float x = 10.5367f;
double a = Convert.ToDouble(x);
double b = (double)x;
double c = x; //same as conversion or casting
In the previous example, when x is declared as float, the memory space that is allocated is sufficient to hold the value of x as float along with precision. Now when we assign the value to some double variable (by conversion/casting/direct assignment), all
what happens is,
1. the space for the double variable is allocated
2. the value is copied from single the single variable to double variable.
Now obviously, the value of the single variable does not span as much memory space as the double variable. So when copied to double the remaining memory space of the double variable is still filled up with garbage data. The actual value of the single variable
is still preserved upto the range of single precision.
So frankly speaking, there is no such straightforward way that can be used to fill the garbage digits with 0s.
I personally recommend that you use "decimal" instead of "double" if any such conversion is required.
Thanks.