Namespace: System

Double

Represents a double-precision floating-point number. This type provides a high-precision representation of real numbers.

Overview

Members

Details

The System.Double structure represents a double-precision 64-bit floating-point number. It is the most commonly used floating-point type in .NET for general-purpose calculations requiring high precision.

Type Information

Struct Implements IComparable<Double>, IConvertible, IEquatable<Double>, IFormattable

Key Features

Precision: Offers 15-17 decimal digits of precision.
Range: Can represent numbers from approximately ±5.0 × 10^-324 to ±1.7 × 10³⁰⁸.
Special Values: Supports special values like PositiveInfinity, NegativeInfinity, and NaN (Not-a-Number).
Comparisons: Supports standard arithmetic operations and comparisons, including handling of floating-point inaccuracies.

Fields

public const double Epsilon
Represents the smallest positive double value such that the expression (x + x * y) != x evaluates to true.
public const double MaxValue
Represents the largest possible value of a double.
public const double MinValue
Represents the smallest positive double value.
public const double NaN
Represents "Not a Number".
public const double NegativeInfinity
Represents negative infinity.
public const double PositiveInfinity
Represents positive infinity.

Methods

public int CompareTo(double value)
Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in sort order as the other object.
public bool Equals(double obj)
Returns a value indicating whether this instance is equal to a specified double value.
public string ToString(string format = null, System.IFormatProvider provider = null)
Converts the numeric value of this instance to its equivalent string representation.
public static double Parse(string s, System.Globalization.NumberStyles style = NumberStyles.Float | NumberStyles.AllowThousands, System.IFormatProvider provider = null)
Converts the string representation of a number to its 64-bit double-precision floating-point equivalent.
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out double result)
Converts the string representation of a number to its 64-bit double-precision floating-point equivalent. A return value indicates whether the conversion succeeded or failed.

Summary

The double keyword is an alias for the System.Double structure. It is used to declare variables that can store real numbers with a wide range and high precision. Floating-point numbers are approximations of real numbers because they cannot represent all real numbers exactly. For example, the number 0.1 cannot be represented precisely as a double.

Remarks

The double data type can be used for calculations that require large numbers or a high degree of precision. Because it is a floating-point type, it might exhibit small precision errors. For applications that require exact decimal representation, such as financial calculations, consider using the decimal type.

The double type supports special values:

double.NaN: Represents a value that is not a number. This typically results from undefined operations like 0/0 or the square root of a negative number.
double.PositiveInfinity: Represents a value that is larger than double.MaxValue.
double.NegativeInfinity: Represents a value that is smaller than double.MinValue.

When comparing floating-point numbers, it is often better to check if the absolute difference between two numbers is less than a small tolerance (epsilon) rather than using direct equality comparison.

Example

Basic Usage

using System;

public class Example
{
    public static void Main()
    {
        // Declaring double variables
        double piApprox = 3.141592653589793;
        double radius = 5.0;

        // Performing calculations
        double area = Math.PI * radius * radius;
        double circumference = 2 * Math.PI * radius;

        // Outputting results
        Console.WriteLine($"Approximation of Pi: {piApprox}");
        Console.WriteLine($"Area of circle with radius {radius}: {area}");
        Console.WriteLine($"Circumference: {circumference}");

        // Special values
        double nanValue = double.NaN;
        double infinityValue = double.PositiveInfinity;

        Console.WriteLine($"NaN value: {nanValue}");
        Console.WriteLine($"Positive Infinity: {infinityValue}");
    }
}