Floating-point numeric types (C# reference)
The floating-point numeric types represent real numbers. All floating-point numeric types are value types. They are also simple types and can be initialized with literals. All floating-point numeric types support arithmetic, comparison, and equality operators.
Characteristics of the floating-point types
C# supports the following predefined floating-point types:
C# type/keyword | Approximate range | Precision | Size | .NET type |
---|---|---|---|---|
float |
±1.5 x 10−45 to ±3.4 x 1038 | ~6-9 digits | 4 bytes | System.Single |
double |
±5.0 × 10−324 to ±1.7 × 10308 | ~15-17 digits | 8 bytes | System.Double |
decimal |
±1.0 x 10-28 to ±7.9228 x 1028 | 28-29 digits | 16 bytes | System.Decimal |
In the preceding table, each C# type keyword from the leftmost column is an alias for the corresponding .NET type. They are interchangeable. For example, the following declarations declare variables of the same type:
double a = 12.3;
System.Double b = 12.3;
The default value of each floating-point type is zero, 0
. Each of the floating-point types has the MinValue
and MaxValue
constants that provide the minimum and maximum finite value of that type. The float
and double
types also provide constants that represent not-a-number and infinity values. For example, the double
type provides the following constants: Double.NaN, Double.NegativeInfinity, and Double.PositiveInfinity.
Because the decimal
type has more precision and a smaller range than both float
and double
, it's appropriate for financial and monetary calculations.
You can mix integral types and the float
and double
types in an expression. In this case, integral types are implicitly converted to one of the floating-point types and, if necessary, the float
type is implicitly converted to double
. The expression is evaluated as follows:
- If there is
double
type in the expression, the expression evaluates todouble
, or tobool
in relational and equality comparisons. - If there is no
double
type in the expression, the expression evaluates tofloat
, or tobool
in relational and equality comparisons.
You can also mix integral types and the decimal
type in an expression. In this case, integral types are implicitly converted to the decimal
type and the expression evaluates to decimal
, or to bool
in relational and equality comparisons.
You cannot mix the decimal
type with the float
and double
types in an expression. In this case, if you want to perform arithmetic, comparison, or equality operations, you must explicitly convert the operands either from or to the decimal
type, as the following example shows:
double a = 1.0;
decimal b = 2.1m;
Console.WriteLine(a + (double)b);
Console.WriteLine((decimal)a + b);
You can use either standard numeric format strings or custom numeric format strings to format a floating-point value.
Real literals
The type of a real literal is determined by its suffix as follows:
- The literal without suffix or with the
d
orD
suffix is of typedouble
- The literal with the
f
orF
suffix is of typefloat
- The literal with the
m
orM
suffix is of typedecimal
The following code demonstrates an example of each:
double d = 3D;
d = 4d;
d = 3.934_001;
float f = 3_000.5F;
f = 5.4f;
decimal myMoney = 3_000.5m;
myMoney = 400.75M;
The preceding example also shows the use of _
as a digit separator, which is supported starting with C# 7.0. You can use the digit separator with all kinds of numeric literals.
You can also use scientific notation, that is, specify an exponent part of a real literal, as the following example shows:
double d = 0.42e2;
Console.WriteLine(d); // output 42
float f = 134.45E-2f;
Console.WriteLine(f); // output: 1.3445
decimal m = 1.5E6m;
Console.WriteLine(m); // output: 1500000
Conversions
There is only one implicit conversion between floating-point numeric types: from float
to double
. However, you can convert any floating-point type to any other floating-point type with the explicit cast. For more information, see Built-in numeric conversions.
C# language specification
For more information, see the following sections of the C# language specification: