# FPBench 1.1 standards

FPBench is a standard benchmark suite for the floating-point community. The benchmark suite contains a common format for floating-point computation and metadata and a common set of accuracy measures:

## Rounding with `cast`

The `cast`

operation is necessary for explicitly rounding values
without performing other numerical operations. Precision annotations specified
with `!`

never cause any numerical operations to occur; they only
change the rounding context.

For example, the expression

will not round the value of the variable `x`

. This expression is the
same as simply specifying

regardless of the rounding context. To round `x`

, it is necessary
to `cast`

it in a context with the desired precision. The expression

will round `x`

to `binary32`

precision (here the outer
annotation for `binary64`

precision is redundant, as it will be overwritten by the
inner one), while the expression

will round `x`

twice, first to `binary32`

precision, and then from `binary32`

to `binary64`

precision.

Because numerical operations already round their outputs, it should not be necessary
to `cast`

in most cases, unless double rounding is specifically intended.
For example, in an expression such as

the value stored in x will already be rounded to `binary64`

precision,
as the addition is done in a context with that precision. Inserting an explicit
`cast`

around either the addition or the use of `x`

would
cause double rounding, and while in the case of `binary64`

precision
this is a no-op, for other rounding contexts it could lead to undesirable behavior.

## Inheriting properties in rounding contexts

All properties not explicitly specified in a `!`

precision annotation
are inherited from the parent context. For the top level expression in an
FPCore benchmark, the parent context includes all the overall properties of the benchmark.

For example, in the following benchmark

the `sin`

operation will take place in a context with `name`

`"foo"`

, `math-library`

`gnu-libm-2.34`

, `spec`

0, and
`binary64`

precision. Even properties that are seemingly unrelated to
rounding, such as the name of the benchmark, are inherited. The FPCore standard does
not prohibit tools from implementing rounding functions that depend on these properties,
or other tool-specific properties, although having a rounding function that depends on
`name`

is not advised.

Properties in the rounding context might come from multiple different annotations. For example, in the expression

the addition will take place as expected in a context with `binary32`

precision,
`toZero`

rounding direction, and the `gnu-libm-2.34`

math library. This
can be useful if some, but not all, of the properties are shared by multiple subexpressions.
For example, in the expression

all of the operations will take place in a context with `binary64`

precision, but the additions
will use different rounding directions.