# Math.Floor Method (Double)

.NET Framework 2.0

Returns the largest integer less than or equal to the specified double-precision floating-point number.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

## Syntax

```public static double Floor (
double d
)
```
```public static double Floor (
double d
)
```
```public static function Floor (
d : double
) : double
```

#### Parameters

d

A double-precision floating-point number.

#### Return Value

The largest integer less than or equal to d. If d is equal to NaN, NegativeInfinity, or PositiveInfinity, that value is returned.

## Remarks

The behavior of this method follows IEEE Standard 754, section 4. This kind of rounding is sometimes called rounding toward negative infinity.

## Example

The following code example demonstrates the Ceiling and Floor methods.

```// This example demonstrates Math.Ceiling()
//                           Math.Floor()

using System;
class Sample
{
public static void Main()
{
double value;
decimal idx;
string nl = Environment.NewLine;

// Return the smallest whole number greater than or equal to the specified number.

// Note that the floating point parameter used in the Math members should not also
// be used as the loop index. The reason is the loop will not terminate as expected
// because a floating point number only approximates a decimal number.

// For the sake of generalizing this example, the decimal index is converted to a
// floating point number with the Convert class instead of a programming language-
// specific type conversion.

Console.WriteLine("{0}Ceiling:", nl);
for (idx = 0.0m; idx <= 1.1m; idx += 0.1m)
{
value = Convert.ToDouble(idx);
Console.WriteLine("Ceiling({0:f}) = {1}", value, Math.Ceiling(value));
}

// Return the largest whole number less than or equal to the specified number.

Console.WriteLine("{0}Floor:", nl);
for (idx = 2.1m; idx >= 1.0m; idx -= 0.1m)
{
value = Convert.ToDouble(idx);
Console.WriteLine("Floor({0:f})   = {1}", value, Math.Floor(value));
}
}
}
/*
This example produces the following results:

Ceiling:
Ceiling(0.00) = 0
Ceiling(0.10) = 1
Ceiling(0.20) = 1
Ceiling(0.30) = 1
Ceiling(0.40) = 1
Ceiling(0.50) = 1
Ceiling(0.60) = 1
Ceiling(0.70) = 1
Ceiling(0.80) = 1
Ceiling(0.90) = 1
Ceiling(1.00) = 1
Ceiling(1.10) = 2

Floor:
Floor(2.10)   = 2
Floor(2.00)   = 2
Floor(1.90)   = 1
Floor(1.80)   = 1
Floor(1.70)   = 1
Floor(1.60)   = 1
Floor(1.50)   = 1
Floor(1.40)   = 1
Floor(1.30)   = 1
Floor(1.20)   = 1
Floor(1.10)   = 1
Floor(1.00)   = 1
*/

```
```// This example demonstrates Math.Ceiling()
//                           Math.Floor()
import System.*;

class Sample
{
public static void main(String[] args)
{
double value;
double idx;
String nl = Environment.get_NewLine();
// Return the smallest whole number greater than or equal to the
// specified number.Note that the floating point parameter used in the
// Math members should not also be used as the loop index. The reason
// is the loop will not terminate as expected because a floating point
// number only approximates a decimal number.For the sake of
// generalizing this example, the decimal index is converted to a
// floating point number with the Convert class instead of a
// programming language-specific type conversion.
Console.WriteLine("{0}Ceiling:", nl);
for (idx = 0.0; idx <= 1.1; idx += 0.1) {
//ToDo: Unsupported feature: assignment within expression
value = Convert.ToDouble(idx);
Console.WriteLine("Ceiling({0:f}) = {1}", (System.Double)value,
(System.Double)System.Math.Ceiling(value));
}
// Return the largest whole number less than or equal to
// the specified number.
Console.WriteLine("{0}Floor:", nl);
for (idx = 2.1; idx >= 1.0; idx -= 0.1) {
//ToDo: Unsupported feature: assignment within expression
value = Convert.ToDouble(idx);
Console.WriteLine("Floor({0:f})   = {1}", (System.Double)value,
(System.Double)System.Math.Floor(value));
}
} //main
} //Sample
/*

This example produces the following results:

Ceiling:
Ceiling(0.00) = 0
Ceiling(0.10) = 1
Ceiling(0.20) = 1
Ceiling(0.30) = 1
Ceiling(0.40) = 1
Ceiling(0.50) = 1
Ceiling(0.60) = 1
Ceiling(0.70) = 1
Ceiling(0.80) = 1
Ceiling(0.90) = 1
Ceiling(1.00) = 1
Ceiling(1.10) = 2

Floor:
Floor(2.10)   = 2
Floor(2.00)   = 2
Floor(1.90)   = 1
Floor(1.80)   = 1
Floor(1.70)   = 1
Floor(1.60)   = 1
Floor(1.50)   = 1
Floor(1.40)   = 1
Floor(1.30)   = 1
Floor(1.20)   = 1
Floor(1.10)   = 1
Floor(1.00)   = 1
*/

```

## Platforms

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

## Version Information

#### .NET Framework

Supported in: 2.0, 1.1, 1.0

#### .NET Compact Framework

Supported in: 2.0, 1.0