# [Nickle]Numeric type heirarchy

**Keith Packard**
keithp@keithp.com

*Fri, 23 Feb 2001 09:58:24 -0800*

Nickle currently incorporates several internal numeric representations and
exposes several numeric datatypes. While these use the same names, the
language groups several representations together as a single datatype.
In the implementation, there are:
type_int 32 bit integer
type_integer arbitrary precision natural + sign
type_rational two naturals + sign
type_double C 'double'.
In the language, there are:
int type_int
integer type_int or type_integer
rational type_int, type_integer or type_rational
double type_int, type_integer, type_rational or type_double
I think I should remove 32-bit integers from the language; they're not
useful.
I'm about to add a 'type_float' which uses a natural mantissa, natural
exponent two signs and a 32-bit integer indicating the number of bits in
the mantissa. This will eliminate the inability to convert large or small
values into an imprecise representation.
Once this new representation is available, I'd like to change the
internal names to:
type_int natural + sign
type_ratio two naturals + sign
type_float two naturals, two signs and a 32-bit precision
The language datatypes become:
integer type_int
rational type_ratio or type_int
real type_float, type_ratio or type_int
As for datatype conversions:
real imprecise (real value, integer bits)
Convert 'value' to an imprecise repsentation using no more than
'bits' bits.
integer floor (real value)
integer ceil (real value)
integer round (real value)
Convert 'value' to the nearest integer in the indicated direction.
Is there any conventional function name for converting an imprecise number
into a nearby rational approximation? Certainly it's easy to do:
rational function nearby (real value, integer denom) {
return round (value * denom) / denom;
}
-keith