# 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 10^{38} |
~6-9 digits | 4 bytes | System.Single |

`double` |
±5.0 × 10^{−324} to ±1.7 × 10^{308} |
~15-17 digits | 8 bytes | System.Double |

`decimal` |
±1.0 x 10^{-28} to ±7.9228 x 10^{28} |
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 to`double`

, or to`bool`

in relational and equality comparisons. - If there is no
`double`

type in the expression, the expression evaluates to`float`

, or to`bool`

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`

or`D`

suffix is of type`double`

- The literal with the
`f`

or`F`

suffix is of type`float`

- The literal with the
`m`

or`M`

suffix is of type`decimal`

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: