previous | contents | next

630 Appendix

rence) or a vector/v, implying a one-dimensional array of a fixed but unspecified number of components. The length-type need not exist, and then this form of the name is not applicable.

Data-types are often of a given precision, especially 'h n r fern to numbers; it has become customary to measure this in terms of the number of components that are used, e.g., triple-precision integers. Names can be formed from the basic data-type-name by prefixing the precision. Note that a double-precision integer, while taking two words, is not the same thing as a two-integer vector; so that the precision and the length-type, although both implying something about the size of the carrier, do not express the same thing. Finally, it is possible to name a data-type by simply listing its components.

The main use of the data-type-name is to permit the short abbreviations which arise by replacing every part with its abbreviation and dropping the periods. Thus, double-precision integers have the data-type-name of double.integer, which can be replaced by d.i and then by di. Similarly, a vector of bits is bit.vector / b.v / by. [The definition of data-type-name is consistent in its use of period with the definition of compound name (see GC 10)].

If a data-type is defined by giving just its name, conventions are required to define the five parameters of the data-type. The carrier is always taken to be the smallest i-unit that can contain the data-type with the following mapping. The format is taken to imply that the components are laid out in order (with no packing) into the subcomponents of the carrier i-unit. The referent of the data-type is given by context, e.g., if the data-type is simply an iteration of some kind of a data-type whose value is already understood, (e.g., in a vector of integers). Thus, there is no need for a referent expression.

1.5 We give below a number of basic data-types that need to be defined explicitly. Table 3 summarizes a large number of data-types and gives their standard abbreviations, as above. Figure 3 of Chap. 2 shows the lattice of data-types in which one data-type is connected to a higher one if it can be obtained by a further specification of the higher one. This is significant, since operations on higher data-types also apply to the lower ones. In the definitions below, which are the standard general data-types, we omit the referent expressions, carriers, and formats except those that are simple. (The fully general definition of radix-complement number representation, for example, is too extensive to be worthwhile here.)

base-data-type / radix : = data-type(referent: (binary / 2÷ octal / 8÷ decimal / 10÷ hexidecimal / 16); component: i-unit: (b÷ o÷ d÷ hex))

+ integer-data-type / ui / unsigned-integer / magnitude : = data-type (referent: + integer; component: radix)

integer-data-type / i : = sign-magnitude ÷ radix-complement ÷ (radix - 1)-complement

number-data-type : = data-type(referent: number; normalization:

(*normalized / n÷ unnormalized / u); name: normalization . number-data-type-name)

Table 3 Examples of commonly used data-types (organized by basic i-units)


bit / boolean / b

bit.array / ba
bit.vector / bv

byte / by

byte.string / by.st
10 byte.vector / 10 by.v

character / char / ch

char.string / char.st
10 char / 10 ch
4 char.vector / 4 ch.v

complex / cx
digit / d

10 digits / 10 d
digit vector / d.v
10 digit, array / 10 d.a

floating point / f / single floating point / sf

unnormalized floating point / uf
double floating point / df
double unnormalized floating point / duf
floating point vector / s.f.v / f.v

field
fraction / fr
integer / i

integer vector / iv
double integer / di

mixed / mx
word / w

half word / hw
double word / dw
triple word / tw
multiple word / mw
word vector / wv
word string / w.string
half word vector / hw.v
7 word / 7 w
8 word vector / 8 w.v


COMMENT The general data-type for number introduces a new parameter (normalization) to prefix the name of all numbers.

mixed / mx / fixed-point : = number-data-type (components: integer-part, fractional-part)
floating-point / f : = number-data-type(components: mantissa, exponent; value-expression: mantissa X radix ­ exponent)

previous | contents | next