baml.Float

(internal) Maps 53 bits of an int draw onto [0.0, 1.0).

Returns Euler's number e, the base of the natural logarithm.

Returns the golden ratio φ = (1 + √5) / 2, about 1.618.

Returns positive infinity. Negate it — -float.inf() — for negative infinity.

Returns a NaN value. Test for it with x.is_nan(), never with equality.

Parses text as a floating-point number.

Accepts decimal notation (1.5, -0.25), scientific notation (1e3, -1.5E-3), and the case-insensitive tokens inf, infinity, and nan, each with an optional leading + or -. No surrounding whitespace, no underscore separators.

Parsing "nan" succeeds and yields a NaN value, so test the result with is_nan() rather than equality.

Throws

• baml.errors.ParseError if text cannot be parsed.

Examples

float.parse("1.5")        // 1.5
float.parse("-0.25")      // -0.25
float.parse("1e3")        // 1000.0
float.parse("inf")        // +infinity
float.parse("NaN")        // NaN
float.parse("")           // throws — empty
float.parse("hello")      // throws — non-numeric
float.parse(" 1.0 ")      // throws — whitespace; trim first

Returns π, the ratio of a circle's circumference to its diameter, to float precision (about 15 decimal digits).

Returns a uniformly distributed random float in the half-open range [0.0, 1.0), drawn from rng.

rng defaults to random.SystemRandom, the host's cryptographic entropy source; pass a seeded generator to make the draw reproducible. Each call consumes one random_int value and uses 53 of its bits.

Examples

float.random()              // some x with 0 <= x < 1
float.random() * 100.0      // some x with 0 <= x < 100

// Reproducible: the same seed replays the same values.
let rng = baml.random.Xoshiro256PlusPlus.new(seed = my_seed);
float.random(rng = rng)

Returns the absolute value of self. NaN stays NaN.

Examples

(-3.5).abs()           // 3.5
(3.5).abs()            // 3.5
(-0.0).abs()           // 0.0
float.nan().abs()      // NaN

Inverse cosine, in [0, π]. NaN if self is outside [-1, 1].

Inverse hyperbolic cosine, defined on [1, ∞). NaN for self < 1.

Inverse sine, in [-π/2, π/2]. NaN if self is outside [-1, 1].

Inverse hyperbolic sine, defined for every real.

Inverse tangent, in (-π/2, π/2).

Returns the angle in radians from the positive x-axis to the point (x = other, y = self), in [-π, π].

Examples

(1.0).atan2(1.0)        // π/4    (45°)
(1.0).atan2(0.0)        // π/2    (90°, due north)
(0.0).atan2(-1.0)       // π      (180°, due west)

Inverse hyperbolic tangent, defined on (-1, 1). ±∞ at the endpoints, NaN outside them.

Returns the smallest integer greater than or equal to self, as a float. The sign of ±0.0 is preserved; NaN and ±inf pass through.

Examples

(3.2).ceil()    // 4.0
(-1.5).ceil()   // -1.0

Cosine of self, in radians.

Hyperbolic cosine.

Returns the largest integer less than or equal to self, as a float. The sign of ±0.0 is preserved; NaN and ±inf pass through.

Examples

(3.7).floor()    // 3.0
(-1.5).floor()   // -2.0
(3.0).floor()    // 3.0

Returns the fractional part of self, self - self.trunc().

Examples

(3.7).fract()    // 0.7
(-3.7).fract()   // -0.7
(5.0).fract()    // 0.0

Returns the Euclidean distance sqrt(self² + other²), computed so that large magnitudes do not overflow along the way.

Examples

(3.0).hypot(4.0)    // 5.0
(0.0).hypot(0.0)    // 0.0

Like ceil, but returns int.

Throws

• baml.errors.InvalidArgument if self is NaN or ±inf, or rounds to a value outside the int range.

Like floor, but returns int.

Throws

• baml.errors.InvalidArgument if self is NaN or ±inf, or rounds to a value outside the int range.

Like round, but returns int.

Throws

• baml.errors.InvalidArgument if self is NaN or ±inf, or rounds to a value outside the int range.

Returns true if self is neither NaN nor infinite. Subnormals and ±0.0 count as finite.

Examples

(3.14).is_finite()         // true
(0.0).is_finite()          // true
float.inf().is_finite()    // false
float.nan().is_finite()    // false

Returns true if self is positive or negative infinity.

Examples

float.inf().is_infinite()                 // true
(-float.inf()).is_infinite()              // true
(1000000.0 * 1000000.0).is_infinite()     // false  (1e12, large but finite)
float.nan().is_infinite()                 // false

Returns true if self is NaN — the "not a number" sentinel invalid operations produce, such as (-1.0).sqrt(), float.inf() - float.inf(), or 0.0 / 0.0.

This predicate is the only way to test for NaN: BAML's == is reflexive, so x != x is false for every float — including NaN, which equals itself and every other NaN.

Examples

(0.0).is_nan()         // false
float.nan().is_nan()   // true
float.inf().is_nan()   // false

Like trunc, but returns int.

Throws

• baml.errors.InvalidArgument if self is NaN or ±inf, or rounds to a value outside the int range.

Returns the logarithm of self in the given base, computed as ln(self) / ln(base).

Every boundary case falls out of that division:

• self < 0 gives NaN, since ln of a negative is NaN.
• self == 0 with base > 1 gives -inf: -inf / positive.
• self == 0 with 0 < base < 1 gives +inf; ln(base) is negative, so the sign flips relative to the case above.
• self == 0 with base == 1 gives -inf, since ln(1) is +0.0.
• base < 0 gives NaN.
• base == 0 with self > 0 gives ±0, signed opposite ln(self), since ±finite / -inf is ∓0.
• base == 1 with self > 0 and self != 1 gives ±inf, signed to match ln(self), since ±finite / +0.0 is ±inf.
• base == 1 with self == 1 gives NaN: 0 / 0.

Examples

(1000.0).log(10.0)   // 3.0
(8.0).log(2.0)       // 3.0
(-1.0).log(10.0)     // NaN
(0.0).log(10.0)      // -infinity
(0.0).log(0.5)       // +infinity
(2.0).log(1.0)       // +infinity
(1.0).log(1.0)       // NaN

Returns self ** exp, computed in floating point.

Gives NaN wherever the mathematical value is not real, such as a negative base raised to a non-integer power.

Examples

(2.0).pow(10.0)         // 1024.0
(2.0).pow(-1.0)         // 0.5
(2.0).pow(0.5)          // sqrt(2)
(-1.0).pow(0.5)         // NaN

Returns the integer nearest to self, as a float, with ties rounded away from zero: 0.5 to 1.0, -0.5 to -1.0, 1.5 to 2.0.

Examples

(1.5).round()    // 2.0
(-1.5).round()   // -2.0
(1.4).round()    // 1.0
(1.6).round()    // 2.0

Sine of self, in radians.

Hyperbolic sine.

Returns the square root of self, or NaN if self is negative.

Examples

(4.0).sqrt()       // 2.0
(2.0).sqrt()       // 1.4142...
(-1.0).sqrt()      // NaN
(0.0).sqrt()       // 0.0

Tangent of self, in radians. Very large near odd multiples of π/2.

Hyperbolic tangent, bounded to (-1, 1).

Converts self from radians to degrees.

Converts self from degrees to radians.

Returns the integer part of self, discarding the fraction — that is, self rounded toward zero.

Examples

(3.7).trunc()    // 3.0
(-3.7).trunc()   // -3.0