DataType

# Double

## Description

A Double is an intrinsic data type. A Double is a number that can contain a decimal value, i.e., a real number. In other languages, a Double may be referred to as a Double precision floating point number. Because Doubles are numbers, you can perform mathematical calculations on them. Doubles use 8 bytes of memory. The default value of a Double is 0.0.

## Methods

Name

Parameters

Returns

Shared

Equals

numValue As Double, maxUIps As Integer

Boolean

FromString

value As String, locale As Locale = Nil

Double

IsInfinite

Boolean

IsNotANumber

Boolean

Parse

value As String, locale As Locale = Nil

Double

ToString

locale As Locale = Nil, Optional format As String

String

## Method descriptions

Double.Equals

Equals(numValue As Double, maxUIps As Integer) As Boolean

Tests whether two Single or Double numbers are equal within a specified tolerance.

Use Equals rather than = when you need to determine whether two floating point numbers are close enough in value to be considered “equal.” This can be used to account for the imprecision of floating point division on computers, for example. It allows for a user-specified rounding error.

For maxUIps, the last position refers to the the last byte in the binary representation of the mantissa. maxUIps is the amount of difference between the last byte of the 2 numbers that is still acceptable. For example, consider these 2 numbers:

```3.1415926535897932 // last byte value is 0x18
3.141592653589795 // last byte value is 0x1C
```

A maxUIps of 3 will result in "not equal", while a maxUIps of 4 will result in "equal".

Compare two values:

```// 2 double values that vary by a tiny bit
Var d1 As Double = 3.1415926535897935
Var d2 As Double = 3.1415926535897933

If d1 = d2 Then
// Will not get here because they are not an exact match
End If

If d1.Equals(d2, 1) Then
// Will get here because they are "close enough"
End If
```

Double.FromString

FromString(value As String, locale As Locale = Nil) As Double

Converts a String value containing a number that can be represented as a Double to a Double value.

This method is shared.

If no locale is specified, then Locale.Raw is used.

Convert values to the Double type:

```Var userValue As String
userValue = "123.45"

Var d As Double
d = Double.FromString(userValue)

Var locale As New Locale("en-US")
Var value As Double

userValue = "123.45"
value = Double.FromString(userValue, locale) ' value = 123.45
```

Double.IsInfinite

IsInfinite As Boolean

Returns True if the value is infinite.

Double.IsNotANumber

IsNotANumber As Boolean

Returns True if the value is Not-A-Number.

Double.Parse

Parse(value As String, locale As Locale = Nil) As Double As Double

Converts a String to a Double value.

This method is shared.

If no locale is specified, then Locale.Raw is used.

Numbers are converted only if they are found at the beginning of the text. Any numbers that follow a non-numeric value are ignored. Empty text returns 0.

```Var d As Double
d = Double.Parse("123ABC")
// d = 123
```

Double.ToString

ToString(locale As Locale = Nil, Optional format As String) As String

Converts a Double value to a String value using the supplied locale and format.

If no locale is specified, then Locale.Raw is used.

Refer to Unicode Number Format Patterns for a list of formats.

Convert Double values to String values:

```Var d As Double = 123.45

Var s As String
s = d.ToString // s = "123.45"

Var n As Double = 1239.4567
Var s1 As String = n.ToString(Locale.Current, "#,###.##") // s1 = 1,239.46

Var n2 As Double = 12
Var s2 As String = n.ToString(Locale.Current, "#.00") // s2 = 12.00
```

## Sample code

The Double data type allows you to store and manage floating point numbers.

```Var d As Double
d = 3.141592653
```

## Compatibility

All project types on all supported operating systems.