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.
a new Float from a 32-bit word.
a new Float from a 64-bit word.
iterates a Function from 0 to this-1. See also: Integer: -do, Collection: -do
| function |
The function to iterate. |
iterates function from this-1 to 0
| function |
The function to iterate. |
Return this if lo <= this <= hi, otherwise return the nearest boundary: lo if this < lo, hi if this > hi.
| lo |
The low threshold of clipping. |
| hi |
The high threshold of clipping. |
Fold this to [lo, hi].
| lo |
The low threshold of folding. |
| hi |
The high threshold of folding. |
Wrap this around [lo, hi) such that it falls in range. Equivalent to (this % (hi - lo)) + lo.
| 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.
a Boolean
xxxxxxxxxx0.2.coin; // 20 % chance for true.See also: Randomness
a random float from this.neg to this, excluding the value exclude.
true since this is a Float.
this since this is a Float.
an Integer which is the bit pattern of this as a 32bit single precision float
an Integer which is the bit pattern of high 32-bits of the 64-bit double precision floating point value
an Integer which is the bit pattern of high 32-bits of the 64-bit double precision floating point value
a string that when interpreted matches the receiver, if the number is within the range given in storeOn.
xxxxxxxxxxa = 2.81882773638;a.asCompileString.interpret == a;Returns a string representation of the number, with the desired precision (i.e. number of significant figures).
xxxxxxxxxx// example:pipi.asStringPrec(3)pi.asStringPrec(6)(pi * 0.0001).asStringPrec(3)7.4.asStringPrec(5)7.4.asStringPrec(50)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).
xxxxxxxxxx// compare factorial:f = { |x| if(x < 2) { x } { x * f.(x - 1) } };f.(14); // integerf.(18) // integer overflow: -898433024f.(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.lastHere is a classical example for an algorithm:
xxxxxxxxxx// euclidean algorithm(g = { |a, b| if(b == 0) { a } { g.(b, mod(a, b)) }})// check if a power of twox = 2147483647 * 3;g.(x, 3); // wrong, returns 1x = 2147483647.0 * 3;g.(x, 3); // correct, returns 3x = 2007199254740992.0 * 3;g.(x, 3); // correct, returns 3x = 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)
xxxxxxxxxxa = 2 ** 53 - 1b = 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