Float : SimpleNumber : Number : Magnitude : Object

Description

A 64-bit double precision floating point number. Float inherits most of its behaviour from its superclass.// generate 10 random floats between 0 and 1 { 1.0.rand }.dup(10) // Pythagorean comma // expressed as a floating point number resulting from calculations with integers ( var apotome = (3 ** 7) / (2 ** 11); var limma = (2 ** 8) / (3 ** 5); apotome / limma )

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

Class Methods

Float.from32Bits(word)

Float.from64Bits(hiWord, loWord)

Inherited class methods

Instance Methods

.do(function)

.reverseDo(function)

.coin

.xrand2

.isFloat

.asFloat

.as32Bits

.high32Bits

.low32Bits

.asCompileString

.asStringPrec(precision)

Using Floats as replacement for Integers

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).// compare factorial: f = { |x| if(x < 2) { x } { x * f.(x - 1) } }; f.(14); // integer f.(18) // integer overflow: -898433024 f.(18.0) // float is ok. // check the ratio between adjacent factorials: f.(18.0) / f.(17.0) == 18 // true // 18 is already the largest possible factorial representable in 64-bit float (< 2^53) {:x, x<-(1.0..40), f.(x) < (2 ** 53) }.all.last

Here is a classical example for an algorithm:// euclidean algorithm ( g = { |a, b| if(b == 0) { a } { g.(b, mod(a, b)) } } ) // check if a power of two x = 2147483647 * 3; g.(x, 3); // wrong, returns 1 x = 2147483647.0 * 3; g.(x, 3); // correct, returns 3 x = 2007199254740992.0 * 3; g.(x, 3); // correct, returns 3 x = 9007199254740992.0 * 3; g.(x, 3); // still happens to be correct, but better not count on it …

Testing the limits of 64-bit float (2^53)a = 2 ** 53 - 1 b = a + 1; c = a + 2; b - a // correct (1) c - a // incorrect (also 1) // How high you can go depends on the calculation: // here we divide two numbers that follow each other // and it is correct up to f.(170), about 7.25e+306. f = { |x| if(x < 2) { x } { x * f.(x - 1) } }; {:x, x<-(1.0..180), f.(x) / f.(x - 1) == x }.all.last

Inherited instance methods

Undocumented instance methods

*(aNumber, adverb)

+(aNumber, adverb)

-(aNumber, adverb)

.archiveAsCompileString

.clip(lo, hi)

.fold(lo, hi)

.schedBundle(bundle, server, timeOfRequest)

.switch( ... cases)

.wrap(lo, hi)