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 eight float types. This lesson mostly uses `float64`, with about 16 significant digits,
// and `float32`, with about 7 in half the space. `float` names `float64`, which a number with a
// decimal point becomes when nothing says otherwise. Two narrower types, `float16` and `float8`,
// save space at the cost of digits, and four wider ones, `float80`, `float128`, `float256` and
// `float512`, keep far more digits than a `float64`.
import Core::{ float128, float16, float256, float512, float8, float80 };
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);

    // `f16` and `f8` make the narrow types. A `float16` keeps about three digits, and a `float8`
    // barely one: its largest value is 240. They suit huge tables of approximate numbers, such
    // as the weights of a neural network, where size matters more than any single value.
    let third16 = 1.0f16 / 3.0f16;
    let third8 = 1.0f8 / 3.0f8;
    PrintLine("1/3       {} as float16", third16);
    PrintLine("1/3       {} as float8", third8);
    PrintLine("largest   {} as float16, {} as float8", float16::Max, float8::Max);

    // The wide types have the suffixes `f80`, `f128`, `f256` and `f512`. Their arithmetic runs in
    // code the compiler generates, so it is slower, and `{}` does not print them directly; the
    // Rux Reference shows how to render one. Their sizes print like any other number, and show
    // that a `float80` is stored in 16 bytes, with six of them unused.
    PrintLine("float80   {} bits in {} bytes", float80::Bits, float80::Bytes);
    PrintLine("float128  {} bits in {} bytes", float128::Bits, float128::Bytes);
    PrintLine("float256  {} bits in {} bytes", float256::Bits, float256::Bytes);
    PrintLine("float512  {} bits in {} bytes", float512::Bits, float512::Bytes);

    // 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;
}