The Fortress Language Specification - CiteSeerX

A numeral containing only digits (let n be the total number of digits) and a radix point (let m be the number of digits
after the radix point) has type RadixPointNumeraln, m, 10, v where v is the value of the numeral, with the radix
point deleted, interpreted in radix ten.
A numeral containing only digits (let n be the total number of digits) and a radix point (let m be the number of digits
after the radix point), then an underscore, then a radix indicator (let r be the radix) has the following type:
RadixPointNumeralWithExplicitRadixn, m, r, v
where v is the value of the n-digit numeral, with the radix point deleted, interpreted in radix r.
Every numeral also has type Numeraln, m, r, v for appropriate values of n , m , r , and v .
Numerals are not directly converted to any of the number types because, as in common mathematical usage, we expect
them to be polymorphic. For example, consider the numeral 3.1415926535897932384 ; converting it immediately to
a floating-point number may lose precision. If that numeral is used in an expression involving floating-point intervals,
it would be better to convert it directly to an interval. Therefore, numerals have their own types as described above.
This approach allows library designers to decide how numerals should interact with other types of objects by defining
coercion operations (see Section 17.1 for an explanation of coercion in Fortress). The Fortress standard libraries define
coercions from numerals to integers (for simple numerals) and rational numbers (for compound numerals).
In Fortress, dividing two integers using the / operator produces a rational number; this is true regardless of whether
the integers are of type Z (or ZZ), Z64 (or ZZ64), N32 (or NN32), or whatever. Addition, subtraction, multiplication,
and division of rationals are always exact; thus values such as 1/3 are represented exactly in Fortress.
Numerals containing a radix point are actually rational literals; thus 3.125 has the rational value 3125/1000 . The
quotient of two integer literals is a constant expression (described in Section 13.27) whose value is rational. Similarly,
a sequence of digits with a radix point followed by the symbol × and an integer literal raised to an integer literal,
such as 6.0221415 × 10 23 is a constant expression whose value is rational. If such constants are mentioned as part
of a floating-point computation, the compiler performs the rational arithmetic exactly and then converts the result to
a floating-point value, thus incurring at most one floating-point rounding error. But in general rational computations
may also be performed at run time, not just at compile time.
A rational number can be thought of as a pair of integers p and q that have been reduced to “standard form in lowest
terms”; that is, q > 0 and there is no nonzero integer k such that p k and q k are integers and ∣ ∣ p ∣
k + q ∣
k < |p| + |q|. The
type Q includes all such rational numbers.
The type Q ∗ relaxes the requirement q > 0 to q ≥ 0 and includes two extra values, 1/0 and −1/0 (sometimes
called “the infinite rational” and “the indefinite rational”). The advantage of Q ∗ is that it is closed under the rational
operations +, −, ×, and /. If a value of type Q ∗ is assigned to a variable of type Q, a DivideByZeroException is
thrown at run time if the value is 1/0 or −1/0 . The type Q # includes all of 1/0 , −1/0 , and 0/0 . In ASCII, Q ,
Q ∗ , and Q # are written as QQ, QQ star, and QQ splat, respectively. See Section 38.1 for definitions of Q , Q ∗ ,
and Q # .
13.1.1 Pi
The object named π (or pi) may be used to represent the ratio of the circumference of a circle to its diameter rather
than a specific floating-point value or interval value. In Fortress, π has type RationalValueTimesPifalse, 1, 1 .
When used in a floating-point computation, it becomes a floating-point value of the appropriate precision; when used
in an interval computation, it becomes an interval of the appropriate precision.
13.1.2 Infinity and Zero
The object named ∞ has type ExtendedIntegerValuetrue, 0,true . One can negate ∞ to get a negative infinity.
92