# double

Double-precision arrays

## Description

`double` is the default numeric data type (class) in MATLAB®, providing sufficient precision for most computational tasks. Numeric variables are automatically stored as 64-bit (8-byte) double-precision floating-point values. For example:

```x = 10; whos x```
``` Name Size Bytes Class Attributes x 1x1 8 double ```

MATLAB constructs the `double` data type according to IEEE® Standard 754 for double precision. The range for a negative number of type `double` is between -1.79769 x 10308 and -2.22507 x 10-308, and the range for positive numbers is between 2.22507 x 10-308 and 1.79769 x 10308.

For more information on double- and single-precision floating-point values, see Floating-Point Numbers.

## Creation

You create a double-precision array automatically when you assign a numeric scalar or array to a variable, such as `A = [1 2 3; 4 5 6]`. The variable `A` has type `double`. For more information on creating and combining arrays, see Creating, Concatenating, and Expanding Matrices. In addition, operations on double-precision variables and functions with double-precision input typically return double-precision values, such as `+` or `sin`.

If you have an array of a different data type, such as `single` or `int8`, then you can convert that array to double precision using the `double` function, which then stores the array with more precision for further computations.

### Syntax

``Y = double(X)``

### Description

example

````Y = double(X)` converts the values in `X` to double precision.```

### Input Arguments

expand all

Input array, specified as a scalar, vector, matrix, or multidimensional array.

Data Types: `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `char` | `string`

## Examples

collapse all

By default, numbers in MATLAB are of the data type `double`. You can use the `class` function to verify a variable's type.

```x = 100; xtype = class(x)```
```xtype = 'double' ```

Use the `double` function to convert variables that are not double precision to type `double`.

`y = true`
```y = logical 1 ```
```ydouble = double(y); ynewtype = class(ydouble)```
```ynewtype = 'double' ```

Compare the ranges of numeric values in double-precision to the ranges for single-precision.

Use the `realmin` and `realmax` functions to display the minimum and maximum positives values that can be represented in double precision.

`doublemin = realmin('double')`
```doublemin = 2.2251e-308 ```
`doublemax = realmax('double')`
```doublemax = 1.7977e+308 ```

Now display the minimum and maximum positive values that can be represented in single precision. The range of values is smaller compared to double-precision, but requires less memory.

`singlemin = realmin('single')`
```singlemin = single 1.1755e-38 ```
`singlemax = realmax('single')`
```singlemax = single 3.4028e+38 ```

The `eps` function returns a measure of how close numbers can be in double-precision versus single-precision. Display the distance from the number 1.0 to the next larger double-precision number.

`doubleeps = eps('double')`
```doubleeps = 2.2204e-16 ```

Now display the distance from 1.0 to the next larger single-precision number. Double-precision values are closer to each other, since you can represent more of them.

`singleeps = eps('single')`
```singleeps = single 1.1921e-07 ```

## Tips

• When you are creating a class, overload `double` when it makes sense to convert an object of that class to a double-precision value.

• Converting a `char` array to a numeric type will produce an array of the corresponding Unicode® code values. Text in strings does not convert in this way. Converting a string that does not represent a single numeric value to `double` will produce a `NaN` result. For more information, see Unicode and ASCII Values.

## Version History

Introduced before R2006a