Float

// A floating-point number, or float, has a fractional part and an enormous range. The price is
// exactness: a float is stored in binary with a fixed number of significant digits, so most
// decimal fractions are kept as the nearest value it can represent, not the value written.
//
// Rux has two float types. `float64` keeps about 16 significant digits and `float32` about 7, in
// half the space. `float` is another name for `float64`, and it is what a number with a decimal
// point becomes when nothing says otherwise.
import Io::PrintLine;

func Main() -> int {
    // Three ways to end up with a float64.
    let price = 4.99;
    let ratio: float = 0.75;
    let distance: float64 = 384400.0;
    PrintLine("price     {}", price);
    PrintLine("ratio     {}", ratio);
    PrintLine("distance  {}", distance);

    // A float32 value is written with the `f32` suffix. Without it the literal is a float64, and
    // a float64 is never squeezed into a float32 behind your back, because digits would be lost.
    let single: float32 = 0.75f32;
    PrintLine("single    {}", single);

    // The same division at both widths shows the difference in precision. A third has no exact
    // binary form, so each type stops where its digits run out.
    let third64 = 1.0 / 3.0;
    let third32 = 1.0f32 / 3.0f32;
    PrintLine("1/3       {} as float64", third64);
    PrintLine("1/3       {} as float32", third32);

    // Neither 0.1 nor 0.2 is exact in binary either, and their two tiny errors add up to a sum
    // that is not quite 0.3. This is how floats behave in every language that uses them, not a
    // Rux quirk. It is why money is usually counted in whole cents with an integer.
    let sum = 0.1 + 0.2;
    PrintLine("0.1 + 0.2 {}", sum);

    // A float always prints with a decimal point, even when the value is whole, so it cannot be
    // mistaken for an integer.
    let whole = 2.0;
    PrintLine("whole     {}", whole);

    // A float and an integer are different types even when they hold the same number:
    //
    //     let count: int = 2.0;
    //         error: cannot assign 'float64' to 'int'
    //
    //     let single: float32 = 0.75;
    //         error: cannot assign 'float64' to 'float32'
    return 0;
}