Enum Format 

pub enum Format {
    Half,
    BFloat16,
    Single,
    Double,
    X87Extended,
    Quad,
    DoubleDouble,
}

A floating point format.

Six of the seven are IEEE 754 binary encodings and the seventh is not, which is why Format::is_ieee exists and why most of the questions below are answerable for six of them. The split is the same one the psABIs make, so this is the enum rucc-abi describes a target’s scalar types with as well as the one Float carries.

Variants

Half

IEEE binary16, which C spells _Float16.

BFloat16

The brain float, an IEEE binary32 with the low sixteen bits of its significand cut off, which C spells __bf16. It has the range of a float and less than half its precision.

Single

IEEE binary32, which C spells float.

Double

IEEE binary64, which C spells double.

X87Extended

The x87 eighty bit format, which is long double on x86. It is the one format here that stores the leading significand bit rather than leaving it implied.

Quad

IEEE binary128, which C spells _Float128, and which is long double on AArch64 Linux, on s390x and on RISC-V.

DoubleDouble

IBM double-double, a pair of doubles whose sum is the value, which is long double on 64-bit PowerPC.

Not an IEEE encoding and not a binary floating point format in IEEE’s sense. It has no exponent field of its own, no significand field of its own, and no single precision: the gap between the two halves is whatever the value needs, so the number of significand bits between the top of the first and the bottom of the second is a hundred and six for some values and two thousand for others. __LDBL_MANT_DIG__ says 106 because a macro has to say something, and 106 is the figure everyone quotes, but it is the precision you get near the top of the significand rather than a property of the format.

Float does not represent one, per Format::is_ieee.

Implementations

impl Format

pub const fn name(self) -> &'static str

The short name this format is written under, which is its width in bits for all of them but the two whose width does not tell them apart from something else.

pub fn from_name(name: &str) -> Option<Self>

The format of that name, and None for a word that is not one.

pub const fn is_ieee(self) -> bool

Whether the format is an IEEE 754 binary encoding, which is every one of them but the double-double.

This is the guard on the rest of this type and on Float. A number in an IEEE encoding is a sign, an exponent and one significand, which is what Float stores, so every format that answers true here has a precision, an exponent range and a bit layout and can be parsed, encoded and folded. The double-double is a pair, so it has none of those and Float refuses it rather than answering with the nominal figures, which are close enough to right to be believed and wrong often enough to matter.

pub const fn precision(self) -> u32

The number of significand bits, counting the leading one whether it is stored or not.

Panics

If the format is not an IEEE encoding, per Format::is_ieee.

pub const fn max_exponent(self) -> i32

The exponent of the largest finite number, which is also the exponent bias.

Panics

If the format is not an IEEE encoding, per Format::is_ieee.

pub const fn min_exponent(self) -> i32

The exponent of the smallest normal number.

Panics

If the format is not an IEEE encoding, per Format::is_ieee.

pub const fn width(self) -> u32

The width of the encoding in bits, which for x87 is the eighty bits that matter and not the ninety six or hundred and twenty eight an ABI pads them out to.

Answered for every format, the double-double included, because a width is the one fact a pair of doubles does have: it is the two of them and nothing else, so it is a hundred and twenty eight bits the same way binary128 is.

pub const fn has_explicit_integer_bit(self) -> bool

Whether the leading significand bit is stored rather than implied.

Panics

If the format is not an IEEE encoding, per Format::is_ieee.

Trait Implementations

impl Clone for Format

fn clone(&self) -> Format

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Format

impl Debug for Format

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Format

impl Hash for Format

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Format

fn eq(&self, other: &Format) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Format