A 64-bit double precision floating point number. Float inherits most of its behaviour from its superclass.

Note that despite its name, FloatArray only holds 32-bit (single precision) floats. For a raw array of 64-bit floats, use DoubleArray.

#### Returns:

a new Float from a 32-bit word.

### Float.from64Bits(hiWord, loWord)

#### Returns:

a new Float from a 64-bit word.

### .do(function)

iterates function from this-1 to 0

#### Arguments:

function |
The function to iterate. |

### .clip(lo, hi)

Return this if lo <= this <= hi, otherwise return the nearest boundary: lo if this < lo, hi if this > hi.

#### Arguments:

lo |
The low threshold of clipping. |

hi |
The high threshold of clipping. |

### .fold(lo, hi)

Fold this to [lo, hi].

#### Arguments:

lo |
The low threshold of folding. |

hi |
The high threshold of folding. |

### .wrap(lo, hi)

Wrap this around [lo, hi) such that it falls in range. Equivalent to (this % (hi - lo)) + lo.

#### Arguments:

lo |
The low threshold (inclusive) of wrapping. |

hi |
The high threshold (exclusive) of wrapping. |

Let *x* be the receiver clipped to the range [0, 1]. With probability *x*, return true. With probability 1 - *x*, return false.

#### Returns:

#### Discussion:

See also: Randomness

#### Returns:

a random float from this.neg to this, excluding the value exclude.

#### Returns:

`true`

since this is a Float.

#### Returns:

`this`

since this is a Float.

#### Returns:

an Integer which is the bit pattern of this as a 32bit single precision float

#### Returns:

an Integer which is the bit pattern of high 32-bits of the 64-bit double precision floating point value

#### Returns:

an Integer which is the bit pattern of high 32-bits of the 64-bit double precision floating point value

#### Returns:

a string that when interpreted matches the receiver, if the number is within the range given in `storeOn`

.

Returns a string representation of the number, with the desired precision (i.e. number of significant figures).

#### Discussion:

In SuperCollider, Floats are 64-bit wide. Because an Integer is 32-bit, it can only capture integers in the range `-2147483648 .. +2147483647`

, or about `2 x 10^9`

.

Therefore, in some situations it can be useful to calculate with floats also when only whole numbers are needed. You can use 64-bit floats for integer calculations up to `± 9007199254740992`

(`2^53`

, or about `9 x 10^15`

). Sometimes one can go even further (see example below).

Here is a classical example for an algorithm:

Testing the limits of 64-bit float (2^53)

### *(aNumber, adverb)

### +(aNumber, adverb)

### -(aNumber, adverb)

### .schedBundle(bundle, server, timeOfRequest)

### .switch( ... cases)