Z>Помогите правильно преобразовать 0,9 в формат с плавающей запятой, я был бы очень рад.

0.9*2=1.8 => 0.8*2=1.6 => 0.6*2=1.2 => 0.2*2=0.4 => 0.4*2=0.8 => 0.8*2=1.6 => 0.6 и т.д.
      1            1            1            0            0            1

int f;
f = (int)(10 * 0.9f); //returns 8
f = Convert.ToInt16(10 * 0.9f); //returns 9

1001 = 1*2^0 + 0*2^1 + 0*2^2 + 1*2^3 = 1 + 8 = 9

0.111001 = 1*2^(-1) + 1*2^(-2) + 1*2^(-3) + 0*2^(-4) + 0*2^(-5) + 1*2^(-6) = 0.890625
0.11 = 1*2^(-1) + 1*2^(-2) = 0.75

Z>int f;
Z>f = (int)(10 * 0.9f); //returns 8
Z>f = Convert.ToInt16(10 * 0.9f); //returns 9
Z>

public static short ToInt16 (
    double value
)

double f1 = (10 * 0.9f); // 8
double f2 = (10 * 0.8f); // 8
double f3 = (10 * 0.7f); // 6
double f4 = (10 * 0.6f); // 6
double f5 = (10 * 0.5f); // 5
double f6 = (10 * 0.4f); // 4
double f7 = (10 * 0.3f); // 3
double f8 = (10 * 0.2f); // 2

Console.WriteLine("{0}-{1}", (int)f1, f1);
Console.WriteLine("{0}-{1}", (int)f2, f2);
Console.WriteLine("{0}-{1}", (int)f3, f3);
Console.WriteLine("{0}-{1}", (int)f4, f4);
Console.WriteLine("{0}-{1}", (int)f5, f5);
Console.WriteLine("{0}-{1}", (int)f6, f6);
Console.WriteLine("{0}-{1}", (int)f7, f7);
Console.WriteLine("{0}-{1}", (int)f8, f8);

8-8.99999976158142
8-8.00000011920929
6-6.99999988079071
6-6.00000023841858
5-5
4-4.00000005960464
3-3.00000011920929
2-2.00000002980232

A decimal number is a floating-point value that consists of a sign, a numeric value where each digit in the value ranges from 0 to 9, and a scaling factor that indicates the position of a floating decimal point that separates the integral and fractional parts of the numeric value.

The binary representation of a Decimal value consists of a 1-bit sign, a 96-bit integer number, and a scaling factor used to divide the 96-bit integer and specify what portion of it is a decimal fraction. The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28. Therefore, the binary representation of a Decimal value is of the form, ((-2^96 to 2^96) / 10^(0 to 28)), where -2^96-1 is equal to MinValue, and 2^96-1 is equal to MaxValue.

Console.WriteLine("{0}", (double)0.9f);

float f = 0.9f;
double d = 0.9d;
decimal m = 0.9m;

// вариант 1
Console.WriteLine(f);
Console.WriteLine(d);
Console.WriteLine(m);

// вариант 2
Console.WriteLine("{0:E20}", f);
Console.WriteLine("{0:E20}", d);
Console.WriteLine("{0:E40}", m);

0.9
0.9
0.9

8.99999976000000000000E-001
9.00000000000000020000E-001
9.0000000000000000000000000000000000000000E-001

if (0.9 == 0.9f)
    Console.WriteLine("0.9 == 0.9f - true");
else
    Console.WriteLine("0.9 == 0.9f - false");

if (0.9 == 0.9d)
    Console.WriteLine("0.9 == 0.9d - true");
else
    Console.WriteLine("0.9 == 0.9d - false");

if (0.9 == (double)0.9f)
    Console.WriteLine("0.9 == (double)0.9f - true");
else
    Console.WriteLine("0.9 == (double)0.9f - false");

0.9 == 0.9f - false
0.9 == 0.9d - true
0.9 == (double)0.9f - false

Console.WriteLine("(double)0.9f = {0}", (double)0.9f);

(double)0.9f = 0.899999976158142

Console.WriteLine Method (Double)
The text representation of value is produced by calling the Double.ToString method.

Double.ToString Method
This version of the ToString method implicitly uses the general numeric format specifier ("G") and the NumberFormatInfo for the current culture.

Standard Numeric Format Strings
G or g, General

The number is converted to the most compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated by the following list.
* Byte or SByte: 3
* Int16 or UInt16: 5
* Int32 or UInt32: 10
* Int64 or UInt64: 19
* Single: 7
* Double: 15
* Decimal: 29

Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. The result contains a decimal point if required and trailing zeroes are omitted. If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, then the excess trailing digits are removed by rounding.