Structure

# Double

A double-precision, floating-point value type.

## Topics

### Converting Integers

`init<Source>(Source)`

Creates a new value, rounded to the closest possible representation.

`init(Int)`

Creates a new value, rounded to the closest possible representation.

### Converting Strings

`init?<S>(S)`

Creates a new instance from the given string.

### Converting Floating-Point Values

`init<Source>(Source)`

Creates a new instance from the given value, rounded to the closest possible representation.

`init(Double)`

Creates a new instance initialized to the given value.

`init(Float)`

Creates a new instance that approximates the given value.

`init(Float80)`

Creates a new instance that approximates the given value.

`init(CGFloat)`

Creates a new instance initialized to the given value.

`init(sign: FloatingPointSign, exponent: Int, significand: Double)`

Creates a new value from the given sign, exponent, and significand.

`init(signOf: Double, magnitudeOf: Double)`

Creates a new floating-point value using the sign of one value and the magnitude of another.

`init<Source>(Source)`

Creates a new value, rounded to the closest possible representation.

### Converting with No Loss of Precision

These initializers result in `nil` if the value passed can't be represented without any loss of precision.

`init?<Source>(exactly: Source)`

Creates a new instance from the given value, if it can be represented exactly.

`init?<Source>(exactly: Source)`

Creates a new value, if the given integer can be represented exactly.

`init?(exactly: Double)`

Creates a new instance initialized to the given value, if it can be represented without rounding.

`init?(exactly: Float)`

Creates a new instance initialized to the given value, if it can be represented without rounding.

`init?(exactly: Float80)`

Creates a new instance initialized to the given value, if it can be represented without rounding.

### Creating a Random Value

`static func random(in: Range<Double>) -> Double`

Returns a random value within the specified range.

`static func random<T>(in: Range<Double>, using: inout T) -> Double`

Returns a random value within the specified range, using the given generator as a source for randomness.

`static func random(in: ClosedRange<Double>) -> Double`

Returns a random value within the specified range.

`static func random<T>(in: ClosedRange<Double>, using: inout T) -> Double`

Returns a random value within the specified range, using the given generator as a source for randomness.

### Performing Calculations

Floating-Point Operators for Double

Perform arithmetic and bitwise operations or compare values.

`func addingProduct(Double, Double) -> Double`

Returns the result of adding the product of the two given values to this value, computed without intermediate rounding.

`func addProduct(Double, Double)`

Adds the product of the two given values to this value in place, computed without intermediate rounding.

`func squareRoot() -> Double`

Returns the square root of the value, rounded to a representable value.

`func formSquareRoot()`

Replaces this value with its square root, rounded to a representable value.

`func remainder(dividingBy: Double) -> Double`

Returns the remainder of this value divided by the given value.

`func formRemainder(dividingBy: Double)`

Replaces this value with the remainder of itself divided by the given value.

`func truncatingRemainder(dividingBy: Double) -> Double`

Returns the remainder of this value divided by the given value using truncating division.

`func formTruncatingRemainder(dividingBy: Double)`

Replaces this value with the remainder of itself divided by the given value using truncating division.

`func negate()`

Replaces this value with its additive inverse.

### Rounding Values

`func rounded() -> Double`

Returns this value rounded to an integral value using “schoolbook rounding.”

`func rounded(FloatingPointRoundingRule) -> Double`

Returns this value rounded to an integral value using the specified rounding rule.

`func round()`

Rounds this value to an integral value using “schoolbook rounding.”

`func round(FloatingPointRoundingRule)`

Rounds the value to an integral value using the specified rounding rule.

### Comparing Values

Floating-Point Operators for Double

Perform arithmetic and bitwise operations or compare values.

`func isEqual(to: Double) -> Bool`

Returns a Boolean value indicating whether this instance is equal to the given value.

`func isLess(than: Double) -> Bool`

Returns a Boolean value indicating whether this instance is less than the given value.

`func isLessThanOrEqualTo(Double) -> Bool`

Returns a Boolean value indicating whether this instance is less than or equal to the given value.

`func isTotallyOrdered(belowOrEqualTo: Double) -> Bool`

Returns a Boolean value indicating whether this instance should precede or tie positions with the given value in an ascending sort.

`static func minimum(Double, Double) -> Double`

Returns the lesser of the two given values.

`static func maximum(Double, Double) -> Double`

Returns the greater of the two given values.

### Finding the Sign and Magnitude

`var magnitude: Double`

The magnitude of this value.

`var sign: FloatingPointSign`

The sign of the floating-point value.

`typealias Double.Magnitude`

A type that can represent the absolute value of any possible value of this type.

### Querying a Double

`var ulp: Double`

The unit in the last place of this value.

`var significand: Double`

The significand of the floating-point value.

`var exponent: Int`

The exponent of the floating-point value.

`var nextUp: Double`

The least representable value that compares greater than this value.

`var nextDown: Double`

The greatest representable value that compares less than this value.

`var binade: Double`

The floating-point value with the same sign and exponent as this value, but with a significand of 1.0.

### Accessing Numeric Constants

`static var pi: Double`

The mathematical constant pi.

`static var greatestFiniteMagnitude: Double`

The greatest finite number representable by this type.

`static var nan: Double`

A quiet NaN (“not a number”).

`static var signalingNaN: Double`

A signaling NaN (“not a number”).

`static var ulpOfOne: Double`

The unit in the last place of 1.0.

### Working with Binary Representation

`var bitPattern: UInt64`

The bit pattern of the value’s encoding.

`var significandBitPattern: UInt64`

The raw encoding of the value’s significand field.

`var significandWidth: Int`

The number of bits required to represent the value’s significand.

`var exponentBitPattern: UInt`

The raw encoding of the value’s exponent field.

`static var significandBitCount: Int`

The available number of fractional significand bits.

`static var exponentBitCount: Int`

The number of bits used to represent the type’s exponent.

`static var radix: Int`

The radix, or base of exponentiation, for this floating-point type.

`init(bitPattern: UInt64)`

Creates a new value with the given bit pattern.

`init(nan: Double.RawSignificand, signaling: Bool)`

Creates a NaN (“not a number”) value with the specified payload.

`typealias Double.Exponent`

A type that can represent any written exponent.

`typealias Double.RawSignificand`

A type that represents the encoded significand of a value.

### Querying a Double's State

`var isZero: Bool`

A Boolean value indicating whether the instance is equal to zero.

`var isFinite: Bool`

A Boolean value indicating whether this instance is finite.

`var isInfinite: Bool`

A Boolean value indicating whether the instance is infinite.

`var isNaN: Bool`

A Boolean value indicating whether the instance is NaN (“not a number”).

`var isSignalingNaN: Bool`

A Boolean value indicating whether the instance is a signaling NaN.

`var isNormal: Bool`

A Boolean value indicating whether this instance is normal.

`var isSubnormal: Bool`

A Boolean value indicating whether the instance is subnormal.

`var isCanonical: Bool`

A Boolean value indicating whether the instance’s representation is in the canonical form.

### Encoding and Decoding Values

`func encode(to: Encoder)`

Encodes this value into the given encoder.

`init(from: Decoder)`

Creates a new instance by decoding from the given decoder.

### Creating a Range

`static func ..< (Double, Double) -> Range<Double>`

Returns a half-open range that contains its lower bound but not its upper bound.

`static func ... (Double, Double) -> ClosedRange<Double>`

Returns a closed range that contains both of its bounds.

### Describing a Double

`var description: String`

A textual representation of the value.

`var debugDescription: String`

A textual representation of the value, suitable for debugging.

`var customMirror: Mirror`

A mirror that reflects the `Double` instance.

`func hash(into: inout Hasher)`

Hashes the essential components of this value by feeding them into the given hasher.

### Using a Double as a Data Value

`init?(from: MLDataValue)`

Creates a double from another double wrapped in a data value.

`var dataValue: MLDataValue`

The double wrapped in a data value.

`static var dataValueType: MLDataValue.ValueType`

The underlying type a double uses when it wraps itself in a data value.

### Infrequently Used Functionality

`init()`

Creates a value initialized to zero.

`init(floatLiteral: Double)`

Creates a new value from the given floating-point literal.

`init(integerLiteral: Int64)`

Creates a new value from the given integer literal.

`init(integerLiteral: Double)`

Creates an instance initialized to the specified integer value.

`func advanced(by: Double) -> Double`

Returns a new value advanced by the given distance.

`func distance(to: Double) -> Double`

Returns the distance from this value to the specified value.

`func write<Target>(to: inout Target)`

Writes a textual representation of this instance into the given output stream.

### SIMD-Supporting Types

`struct Double.SIMD2Storage`

Storage for a vector of two floating-point values.

`struct Double.SIMD4Storage`

Storage for a vector of four floating-point values.

`struct Double.SIMD8Storage`

Storage for a vector of eight floating-point values.

`struct Double.SIMD16Storage`

Storage for a vector of 16 floating-point values.

`struct Double.SIMD32Storage`

Storage for a vector of 32 floating-point values.

`struct Double.SIMD64Storage`

Storage for a vector of 64 floating-point values.

### Deprecated

`var customPlaygroundQuickLook: _PlaygroundQuickLook`

A custom playground Quick Look for the `Double` instance.

Deprecated

### Type Aliases

`typealias Double.FloatLiteralType`

A type that represents a floating-point literal.

`typealias Double.IntegerLiteralType`

A type that represents an integer literal.

`typealias Double.RawExponent`

A type that represents the encoded exponent of a value.

`typealias Double.Stride`

A type that represents the distance between two values.

### Standard Library

`struct Int`

A signed integer value type.

`struct String`

A Unicode string value that is a collection of characters.

`struct Array`

An ordered, random-access collection.

`struct Dictionary`

A collection whose elements are key-value pairs.

Swift Standard Library

Solve complex problems and write high-performance, readable code.