Multiword List Items
W. T. COMFORT
I B M Corporation,* Kingston, New York
The list concept as originally proposed by Newell, Simon
and Shaw specified single computer words as elements of a
list. This report describes the use of two or more consecutive
words as one element. Such use results in a considerable saving
in both the space required to hold a given amount of data,
and in the execution time required to perform a given process
on the data.
Following a brief description of standard list structures with
single-word items, the multiword items are introduced. Then
variable-length items are described, along with the corresponding space-utilization problems. Finally, several examples
are given to illustrate the use of multiword lists.
This paper attempts to draw together various recent papers
which have applied some of these concepts in different ways,
and indicate how they relate to the more general problem.
Introduction
I n an automatic programming effort started in t958, at
I B M ' s Space Guidance Center, Owego, N.Y., it was found
t h a t the technique of organizing a computer memoIT into
list structures, an approach introduced by Newell, Simon
and Shaw [1] in 1957, was particularly pertinent. This report introduces the concept of the multiword list item,
which was developed to offset the inefficiencies of singleword items.
Following a brief description of standard list structures
with single-word items, called singlets, the multiword items
are introduced. Then variable-length items are considered,
along with the corresponding problems involving the utilization of available space. Several examples are given illustrating the use of multiword lists.
There are two objectives of this report. First, and most
important, it will show how multiword list items can
provide considerable savings, both in terms of execution
time and in the m e m o r y space required over normal singleword items. Secondly, it will help the uninitiated reader to
appreciate the simplicity of list structures in themselves,
and the ease with which they m a y be applied.
to (i.e., contains the address of) its successor, successive
list items need not b e - - a n d in general are not--consecutive
words in memory. I n fact, one of the powerful features of
lists is their ability to utilize arbitrary, disjoint sections of
memory. Such a list can be diagrammed as in Figure la.
The arrow indicates the successor of each item. Later it
will be useful to indicate the field in the element which
contains the pointer (i.e., the address of the successor). I n
addition, since the list items are arbitrary storage words,
each list is provided with a head, which is a known location
in m e m o r y ; t h a t is, it is a word the location of which is
known to the programmer, and through which he is able
at all times to locate the list since it points to the first
item on the list. Similarly, a special m a r k is required to
indicate the end of a list. This is usually done by using a
pointer of zero. Thus, a simple list containing three items
would appear as in Figure lb. A list head containing a zero
pointer is an e m p t y list; i.e., it has no items.
The remaining portion of each element m a y contain
data, m a y point to a full word of data, or m a y point to
another list (called a sublist); for example see Figure 2.
Here, the first item points to a data word, the second
points to a 3-item sublist, and the fourth points to a 1-item
sublist, which in turn points to a data word. Such a configuration is called a list structure. I t is necessary t h a t either
the programmer knows what each item represents, or else
t h a t there is sufficient information stored in the list in
order t h a t the program m a y find out what each represents.
Note that, unless the computer word is long enough to
hold two pointers, only the most rudimentary operations
can be performed on the singlet lists. However, a pointer
need not be of full-address length. I t m a y be several bits
shorter, but with a corresponding decrease in the a m o u n t
of storage available for use on lists. An alternate approach
is the use of multiword items, which are described later.
I n normal use, all available storage is initially p u t on a
special "list of available space." As the program progresses
and builds various lists, it obtains e m p t y items from the
available space list. The space list and another list are
shown diagrammatically in Figure 3a. Suppose it is desired
to take an item from the space list and insert it between
H~O I
Lists
I
I
I
I
I
A list is a connected sequence of items. 1 I n the form in
which lists were originally introduced by Newell, Simon
and Shaw [1], and in which they have generally been used,
an item consists of one computer word. These items are
connected through a field within each word which contains
the address of the succeeding item. ~ Since each item points
I
I
I
I
I
I
t o I
I
* Data Systems Division.
I This definition and those to follow are not intended to be
rigorous, but rather to serve as a shorthand for later consideration,
and to orient those who are familiar with a different terminology.
It will be observed that a program for the IBM 650 (or any
machine of the 1-4-1 address type) is such a list; it is a sequence of
computer words (instructions), each of which contains the address
of the next instruction.
V o l u m e 7 / Number 6 / June, 1964
I
FiG. la
FIG. lb
HEAD
Im
I
I
I
'l
¼'l
i
01
I
r
I
I
I
p
I '1
I~
°
J-L
Fro. 2
C o m m u n i c a t i o n s o f t h e ACM
357
the first and second items of the other list. The pointers
would be represented as in Figure 3b. However, the new
diagram would appear as in Figure 3c.
Thus, the most frequent list operations--namely, inserting and deleting items from a list--are accomplished
through simple :manipulation of the pointers. Note t h a t
when an item is removed from a list, it is returned to the
list of available space, for possible later use.
Now, it can be observed that in using singlet lists,
somewhat less than one half of every singlet must be given
over to use as a pointer, thus decreasing the number of bits
available to hold data or other information. To illustrate
this, assume that a pointer requires exactly one half of a
word of a single item. Table I shows the number of singlet
list items required to hold a given amount of data-type
information. There are two ways in which 1½ words of
data can be stored. (Figures 4a and 4b). Similar situations
hold for larger amounts of data.
Thus, about half of storage is used up in pointers. In
more complex problems, this apparent wastage of storage
I
I
I
I
f
I
I
I
i o I
l
I
(ETC.)
FIG. 3a
sP.cE I
I
II
flL-.I
t
I
I
I
I
I
I
I
I
I
l'oj
j
is considerably reduced by the amount of information
implied in the structure, and through the use of "borrowed
sublists" [2]. However, these topics are not pertinent to this
paper.
The other main problem with singlet lists involves the
access time for data. I t is not possible to directly compute
the location of any particular item on a list; rather, the
list must be searched h'om the head until the required
item is reached. I t follows, then, t h a t if each item can
only be located through a pointer, the number of instructions which must be executed to obtain a given
amount of data depends directly upon the number of list
items required to store it.
I t will be shown in the next section t h a t multiword items
for lists will greatly alleviate both of these problems.
Multiword Items
A multiword item is a single list item which is organized
in storage as a sequence of two or more consecutive words
of memory. (It can be observed from the following discussion that the multiword item concept is the basis for
the applicability of the n-component element of Ross [3].)
The simplest form of a mnltiword item is the two-word
item, or doublet, ~ which consists of two consecutive words
in storage. Diagrammatically, two words separated by an
asterisk (*) are in consecutive memory locations (e.g., L
and L + i ) , as in Figure 5a. Thus, a doublet list has the
appearance shown in Figure 5b.
The effect of this simple step is illustrated as follows.
Where a singlet list requires 4 items (and therefore 4 words)
to store 1½ words of information, a doublet list requires
only one two-word item. Also, where a singlet list requires
I
i ''~ I
I o I,,~i
(ETC.)
FIG. 3b
FIG. 4a
I
I
I
I
I
I
I
I
I
I
I
I
(~.~
I ° I
(L,S',TEM, I
1 ",J
I
I0
I
'
]
1"21
FI6.4b
FIG. 3c
TABLE
I.
NUMBER
OF SINGLET ITEMS
R E Q U I R E D TO H O L D A G I V E N AMOUNT
OF D A T A
Number of data words
FIG. 5a
Number of singlet items
{
1
2
4
1
1½
2
1
Li
_
3
I
5
6
7
:
I
I~l
I
[
I
i ![
J~f
,J~i
I
i
¢
FIG. 5b
This is identical to the doublet of E v a n s , et. a L [l], t h e w o r d
p a i r of Weizenbaum [9], and the u n i t cell of Bowlden [10].
358
C o m m u n i c a t i o n s o f t h e ACM
V o l u m e 7 / N u m b e r 6 / J u n e , 1964
8 to 10 instructions to fetch the information, the doublet
requires only 3. Thus, the multiword item reduces the
size of list memory, reduces the program sizes and decreases the program execution time.
Perhaps it is appropriate now to m a k e a comment on
programming techniques. With singlet lists, it is sometimes
debatable whether the process of sequencing down a list
through selection and the use of pointers should be accomplished by brute force modification of addresses (such
as storing a pointer as the address portion of a fetch
instruction) or by the use of index registers (whereby the
pointer is loaded into an index register4). However, with
multiword items the indexing technique is necessary to
obtain the indicated speed increases. I n the case of the
triplet, the index register need be loaded only once, whereupon fetch instructions with tagged addresses of zero,
one and two will m a k e available the first, second and
third words, respectively, of the three-word item. This
is called reverse indexing b y Ross and is discussed b y
him in detail [3].
Figure 2 [2] shows (on the left half) a singlet list structure containing 22 singlet items. However, it appears t h a t
the same information could be stored on a simple list
containing only 13 words when set up with four-word items.
This is illustrated in Figure 6.
As an example of the use of a doublet list, consider the
preparation of a symbol table. For a reasonably standard
two-pass assembly program for a machine with random
access memory, the first pass involves building a table of
all different symbol names (restricting their length to 1
word) and assigning to each an absolute machine address
(½ word). The second pass then requires t h a t every symbol
be looked up in the table as it occurs and the corresponding
HEAD
4'
I
I ~
I ~
~'
I ~ [
~,
]~
[.."" ~,
I
I c
I ~
~
I ~ [
~°
]~
I.... ~°
I
4'
I
Fla. 6
I .......
I
I~[
......
1
Multiple Pointers
FIG. 7
T A B L E OF H E A D S
UBTS
*I
I ,o, I
I
4'
I ××× I ......
[
4,
4'
I ° I~××1
......
I
FIG. 8
4 On IBM 704-9-90 machines, the index register is loaded with
the complement of the address.
V o l u m e 7 / N u m b e r 6 / June, 1964
absolute address be inserted into the instruction being
assembled. The doublet list works very nicely in this case,
as illustrated in Figure 7. As the symbol table is being
built, symbols m a y be sorted into the list alphabetically,
if desired, or merely put into the list in their order of
occurrence. On the second pass of the assembly program,
a simple searching routine wiU effect the translation.
To further illustrate the ad hoc use of lists, the obvious
lack of high execution speed to such a symbol table can be
offset by a "table of lists." Here a table is set up with 26
list heads, one for each letter of the alphabet, and ordered
according to the numerical code corresponding to the 26
letters. Thus, a symbol table would appear as shown in
Figure 8. The advantage of this is t h a t the first character
of the symbol can be extracted, and the location of the
head of the appropriate list in the table can be computed
immediately. 5 This is essentially a technique of blocksorting, which has been used on some occasions with 26
tables rather t h a n lists. But in such cases, it requires the
provision of special overflow procedures when a table becomes full. If all 26 letters have an equal probability of
occurring as the first character of a symbol, the search
time is reduced b y a factor of 26.
This technique can be extended to handle almost any
problem of sorting within the high-speed memory. For
example, suppose it is desired to read in a deck of cards
and sort t h e m on some field prior to some other operation,
e.g. editing a tape file. I n the 7090 computer, 13½ words
of m e m o r y are required to store the contents of one card.
B y simply using a list with 14-word items (the additional
one half word holds the list pointer), the sorting m a y be
accomplished with a m i n i m u m of effort; and since the one
half word would normally be unused, no additional storage
is necessary.
I n the last two examples, the lists are of a continuously
growing nature; i.e., no individual items are removed from
the list until the function of the whole list is complete.
I n such cases, it is not necessary to go through the bookkeeping effort of constructing and maintaining a list of
available space. I t suffices to remember the starting point
of the as yet unused portion of memory, and take a new
item as required.
Probably the most significant contribution of nmltiword
items to the processing of list structures lies in the availability of multiple pointers. For example, a singlet list is a
one-way device; it is possible.to start at the head and move
down the list, but it is not possible to move back up the
list. This m o v e m e n t is easily accomplished with multiword
items, by simply making the item long enough to contain
a pointer for this purpose. Thus, a two-way list of threeword -items might appear as in Figure 9. I t would require
somewhat more work to effect the insertion and deletion
of items. However, this is readily accomplished, and there
5 This is similar to the directory of Baecker (8), but applied to
one specific list structure.
C o m m u n i c a t i o n s o f t h e ACM
359
are situations where a two-way list is exactly what is
desired. 6 An example occurred in a fixed-point folznula
translation routine. Following the normal procedure, an
arithmetic statement was decomposed into a list of
3-address type operations. A two-way list with 5-word
items was used, as shown in Figure 10. The operation word
also contained some coded information on the scaling of
the two operands. The two-way pointers were important
for two reasons.
1. Since program efficiency was of primary importance
(they were real-time control programs), considerable scanning and rescanning of this list was done, trying to improve
the object programs.
2. Since the :programs were for fixed-point arithmetic,
all operands were to be automatically scaled (i.e., shifted
the proper number of places before a n d / o r after the operation), which required considerable manipulation of the
sequence of list items. The two-way list was ideally suited
to the problem.
In [5], the organization for an information processing
system to be used for information retrieval is proposed.
The basic idea is that a large file of items is given, e.g., a
personnel file. Associated with each item are several characteristics such as height, weight, age and sex. Associated
with each characteristic is a set of values. For example, in
a given file, the characteristic age m a y take on values 20,
21, 22, ..., 35. For each such value, there is a list, which
connects every item which has that value. Thus, every
item contains a pointer for each characteristic, connecting
it to the list which represents the proper value of that
characteristic. Such items are readily obtainable through
the multiword technique. Figure 11 illustrates a possible
item of this type. If the file of such items represents a
college student body, an enterprising basketball coach
m a y wish to obtain the names of all male students who
are over 6 feet 1 inch in height and over 160 pounds in
weight. In this configuration, it is necessary to search the
HEAD I
HEAD
I
I o I
?
I
I~L
I~1
t
I
I
I*[
1-1
I
I*[
]*t.
I
¢
I o I
t
list representing the proper values of each characteristic
in sequence selecting those items which appear on all. Ilt
this way, it is unnecessary to search all items in the file;
only those which have the proper value of at least one
characteristic are searched. I t is not proposed at this time
to consider whether or not this is the best techniqne for
solving this type of problem. However, it should be pointed
out that whereas in [5] a machine to operate in this fashion
is proposed, multiword items with multiple pointers allow
the same flexibility on a general-purpose machine with
minimum of space.
Another possible application of multiple pointers might
arise in working with very large but very sparse matrices.
For example, some linear programming problems m a y
involve a 1000 by 5000 matrix with only 10,000 to 25,000
nonzero elements. One way to store only the nonzero elements might be to have a list for each row. T h e n the
nonzero matrix elements would each be represented by art
item of the form shown in Figure 12a. To locate the element at the coordinates (i,j), it is necessary to search the
list representing row i for an item with column number j.
However, to perform the more general computations of
linear programming in a reasonably efficient way, it might
be necessary to provide a list for each column as well, and
convert them into two-way lists. This can also be done
quite readily, as indicated in Figure 12b. Thus, having
located element (i,j), it is relatively easy to locate elements
(i-m,j) and (i,j-n).
A specific application where the multiple pointers proved
most valuable in actual use was in another portion of the
fixed-point compiler mentioned previously. The source
language of the compiler defined all control and statement
sequencing in the form of a flow diagram. A stylized version
of the flow diagram, using a fixed but expandable format,
was punched into cards, and then transferred to tape. I t
was desired to load the flow diagram into core memory
in such a way as to preserve completely the topology of
o I
f
I
t
I
f
I
*[
......
IW]
.......
I*[
.........
[W[
.......
]
*[
......
]*[
.......
I~[
.........
]~[
.......
I
FIG. 9
MISCELLANEOUS
HEIGHT
FIG. 10
WEIGHT W
SEX
IAI B Icl D I IEI
FIG. 11
B - UP POINTER (POINTS TO ITEM REPRESENTING THE BLOCK
ABOVE THIS ONE IN THE FLOW DIAGRAM, IF IT EXISTS).
D,F,H - DOWN, LEFT AND RIGHT POINTERS.
A,C, E,G -CODE FOR EACH POINTER, INDICATING WHETHER
THE CONNECTION IN THE PROPER DIRECTION- I F IT EXISTSIS AN INPUT TO THIS BLOCK, OR AN UNCONDITIONALOR
CONDITIONAL OUTPUT FROM THE BLOCK.
FIG. 12a
~ - - ~
ROW )(I ......
. . . . . . ), [( . ........
. . . . . . )(I . ........
. . E,T),I
( .......
F IGI H I*1 J I K ILl M I*
o ....
,~o:,~. ) c(,o,~E.)
( C. . . . .
I
FiG. 12b
J,K-CO-ORDINATES REPRESENTING THE PHYSICAL POSITION
OF THE BLOCK WITH RESPECT TO THE ORIGINAL
FLOW DIAGRAM.
L,M-SPECIAL INFORMATIONGENERATED BY THE COMPILER.
N - SYMBOLICCONTENTS OF THE BLOCK ON THE FLOW DIAGRAM.
e Two-way lists are proposed b y W e i z e n b a u m (9) and Baecker
(s).
360
FIG. 13
Communications
of the ACM
V o l u m e 7 / N u m b e r 6 / J u n e , 1964
flow. This was accomplished through the use of a list structure with 4-word items and 4-way pointers. The item format
is shown in Figure 13, where each nontrivial block in the
flow diagram is represented b y one item. One item points
to another only if there is a line on the flow diagram
connecting the two corresponding blocks. With the source
program defined in this form, it was quite simple to accomplish a global trace, for interstatement optimization of
the object program, to determine the longest p a t h through
the program (the object program was for a drum computer), and to compute an o p t i m u m order for the programming of the side paths. I t represents a very complex bit of
d a t a manipulation, probably not feasible without multiple
word list items with multiple pointers.
Variable-Length Items
I t has been implicitly assumed in the preceding discussion t h a t if, for example, three-word items are being
used, then all lists have three-word items and the space
list problem is quite simple; namely, it is itself a list with
three-word items. However, this need not be the case.
There might be several lists simultaneously in storage,
each with different-size items. Alternatively, there m a y
only be one list structure which itself has items of various
sizes. I n either case, the problem of how to handle the
space list becomes significant. 7
One approach is to provide a separate space list for each
size item. However, to do this directly requires t h a t the
p r o g r a m m e r decide how much space will be allotted to
each list, and this is directly contrary to one of the basic
ideas behind the list structure concept; namely, the prog r a m m e r does not decide this, and if there is any space
available, it can be used anywhere.
A modification of this approach will improve things
somewhat. Suppose there are three types of items: singlets,
doublets and triplets. Initially, all available space is placed
on the triplet space list (both doublet and singlet space
lists being empty). Thereafter, if a doublet is required,
and the doublet space list is empty, a triplet can be obtained and divided into a doublet and a singlet, or a
doublet can be used to get two singlets. When singlets or
doublets are returned, they go onto the proper space list.
This, to a certain extent, alleviates the problem indicated
above; namely, as long as there is a triplet available, a
doublet or singlet m a y be obtained. However, it is not
unreasonable to expect t h a t some problems m a y require
triplets when the only space left consists of singlets and
doublets. T h e finding of new triplets from a set of doublets
and singlets can be accomplished, but it is quite inconvenient.
Consider now a generalized space list; i.e., one from
which an item of arbitrary length can be taken, if t h a t
m a n y consecutive words exist anywhere in available space.
Such a list can be realized b y having it consist of variablelength items. Initially, it contains only one item which is
made up of all words of available space. When a specific
item is required, the proper number of words are removed
from the space list item, thus reducing its size. (Later
when the space list contains m a n y items, the list m u s t be
searched for the first item which is large enough.) Then,
when an item is to be returned, since it is desired to
determine whether or not this item fits consecutively onto
some current space list item, it is sorted onto the space
list. s
To illustrate how such a list might be handled, suppose
Figure 14a is a portion of the space list. The n u m b e r
represents the length of the item, which is required for the
sorting process; X and Z represent the m e m o r y locations
of the first word of the two items. Suppose a two-word
item, shown in figure 14b, is to be put back onto the space
1
FIG. 14a
I ~ I,
JI ~ II
]~1
I
Jr
FIG. 14d
I[
)1 ~ I,
II
FIG. 14b
FiG. 14e
.[
w i ~ i~l
I~1
I
FIG. 14c
7 As indicated previously, if the list length is monotonic increasing--i.e., no items are returned to the space list--there is no
problem, since there is no space list, as such.
Volume 7 / Number 6 / June, 196¢
FiG. 14f
s Iliffe and Jodeit [11] propose to simply return items and wait
until the condition is reached that a block of the required size
does not exist on the space list. Then the space list items will be
sorted and collected where possible. This has a definite speed
advantage for certain types of problems.
Communications of the ACM
361
list. However, if possible, it is to be put back in order to
make a longer item. Therefore, it is necessary to first
search down the items of the space list to the point where
X < Y < Z . Then, the doublet can go onto the list in four
possible ways:
(1) between the two items; in this
Z - 2 (Figure 14c),
(2) at the end of the preceding
Y = X + 2 (Figure 14d),
(3) at the beginning of the next
Yd-2 = Z (Figure 14e),
(4) a combination of situations 2
X--k2 = Y = Z - 2 (Figure 14f).
item; in this case,
Act~nowledgments. The author wishes to acknowledge
the assistance of F. R. Palm, J. S. Hughes, J. W. Joachim
and E. S. Schulze for much of the programming and establishment of techniques described in this report.
item; in this case,
RECEIVED NOVEMBER, 1963
case, X-4-2 < Y <
and 3; in this case,
I n this way, the space-list items are ahvays of m a x i m u m
length. Admittedly, this operation takes a small but significant amount of time, since the space list m u s t be
searched both coming and going. However, in those cases
where simpler techniques are not sufficient, it is the price
to be paid.
Conclusions
1. A list is basically a simple device, notwithstanding
the pseudomathematical haze which has arisen from some
areas.
2. A structure of multiword items, if applicable, generally requires significantly less storage and operation time
t h a n the corresponding structure of standard singlet items.
3. A large and complex list-processing programming
system, such as I P L [7] or L;sP [6], is not necessary in
order to obtain the advantages which the list concept has
to offer.
4. A list structure can be made, in m a n y instances,
considerably more efficient t h a n has been demonstrated
in the past. All t h a t is needed is some common sense and
ingenuity on the part of the user.
A Parts Breakdown Technique
Using List Structures
W. 5. BRIAN
North American Aviation, Inc., Los Angeles, California
List structured parts breakdown is proposed and discussed.
Implementation facts are presented on operating program using
these techniques.
Introduction
A parts brealcdown is a sequencing problem in which
components of a tree structure are to be arranged into a
single sequence:, while lnaintaining the component to
colnponent relationships. This arrangement is also known
362
Communications of the ACM
5. A list structure is good for some problems; tables
are good for others; and sometimes a combination of both
is appropriate. I n each case, the selection of an approach
should be based upon the details of the problem.
REFERENCES
1. NEWELL, A., AND SHAW,J.C. Programming the logic theory
machine. Proc. Western Joint Comput. Conf., 1957.
2. GELERNTER, I'i., I'IANSEN, J. R., AND GERBERICH, C. L. A
FORTRAN-compiled list-processing language. J. ACM 7,
4 (Apr. 1960).
3. Ross, D . T . A generalized technique for symbol manipulation and numerical calculation. Comm. ACM4, 3 (Mar. 1961).
4. EVANS, A., PERLI8, A. J., AND VAN ZOEREN, I-I. The use of
threaded lists in constructing a combined ALGOL a~ld
machine-like assembly processor. Comm. ACM 4, 1 (Jan.
1961).
5. GRAY, H. J., AND ~RYWES, N. S. Outline for a multi-list
organized system. Presented at the 14th National ACM
Meeting, MIT, Sept. 1959.
6. McCARTHY,J. Recursive functions of symbolic expressions
and their computation by machine, part I. Comm. ACM 3,
4 (Apr. 1960).
7. NEWELL, A. (Ed.) Information Processing Language--V
Manual. Prentice-Hall, 1961.
8. BAECXER, I'i. D. Mapped list structures. Comm. ACM 6, 8
(Aug. 1963).
9. WEIZENBAUM, J. Symmetric list processor. Comm. ACM 6, 9
(Sept. 1963), 524.
10. BOWLDEN, I-I. J. A list-type storage technique for alphameric
information. Comm. ACM 6, 8 (Aug. 1963), 433.
11. ILIFFE, J. K., AND JODEIT, J . G .
A dynamic storage allocation scheme. Comput. J. (Oct. 1962).
as disassembly sequence in t h a t it closely resembles an order
in which a structure could be disassembled. M a n y data
processing problems require this type of ordering to link
elements of the data together, and the technique presented
here would seem to be applicable to a n y such probleln. I n
particular, PEnT Network and engineering drawing control problems, among others, would appear to benefit from
the use of the technique outlined in this p a p e r [1].
Figure 1 illustrates the tree structure by which the
sample, object R, can be depicted [2]. Object R is shown
to be made up of three m a j o r components, two of which
can be further broken down (or disassembled) into three
lower level components and again, two of these can be still
further broken down. The disasselnbly sequence is indicated by the number contained in each component block.
If the blocks shown in Figure 1 were data records and were
arranged in the indicated sequence, the records falling
V o l u m e 7 / Number 6 / June, 1964