MEE1014 Industrial Engineering and Management

Binary Ordering Algorithm

The data format shown in the table below is referred to as a machine-part incidence matrix.
The machine-part incidence matrix forms the basis of many procedures for group formation.
To see why this is true, suppose the data had been presented as shown in the next table.
Observe that both table contain the same information – only the row and column ordering
differs.

We would like to identify dense blocks of 1’s in the matrix where adjacent parts use the same
machines. These form natural machine-part groups. Fortunately, it turns out that efficient
algorithms exist for reordering rows and columns and converting a matrix.

The binary ordering algorithm provides an efficient routine for taking an arbitrary 0-1
machine-part matrix and reordering the machine rows and part columns to obtain a nearly
block diagonal structure. Block diagonal means that we can partition the matrix such that the
“boxes” on the main diagonal contain 0’s and 1’s but the off-diagonal boxes contain only 0’s.
In other words, given a matrix, draw G-1 horizontal lines and G-1 vertical lines to obtain a
G×G partitioned matrix. A block diagonal matrix has some 1’s in the row i column i
partitions for i = 1, . . . , G but only 0’s in the other partitioned boxes.

These on-diagonal boxes are then the natural groups for the plant. Ideally we would like as
many small groups as possible. However, groups may not be totally independent. The
exceptional elements must be handled by other available alternatives.

Think of the rows and columns as binary strings. Each row (column) consists of a string of
0’s and 1’s. We suppose we want to reorder rows to locate similar rows together. If the row is
envisioned as a binary number, then similar rows are those with similar values. Our task is
then one of sorting rows by nonincreasing order. We reorder rows in descending order of
their binary value. After reordering rows, we switch to columns. The process continues until
the ordering does not change. Different starting orderings may yield different ending
orderings.

Algorithm
1. Order rows: Assign value 2N-k to column k. Evaluate each row. Sort rows in
nonincreasing order. If rows were previously ordered, and no change just occurred,
stop; otherwise go to 2.
2. Order columns: Assign value 2M-k to row k. Evaluate each column. Sort columns in
nonincreasing order. If no change, stop; otherwise, go to 1.
Example:

Consider the N = 8 parts and M = 6 machines problem of table given below. Order the part-
machine matrix.

Part
Machine 1 3 4 7 2 5 6 8
A 1 1 1
E 1 1
C 1 1 1 1
F 1 1
D 1 1 1 1
B 1 1 1
Solution:

1. We assign column 8 place value 1, column 7 place value 2, and so on. Row A
receives a value of 128 + 64 + 8 = 200. Evaluate all rows in such a manner.
Part
Machine 1 3 4 7 2 5 6 8 Value
A 1 1 1 200
E 1 1 17
C 1 1 1 1 102
F 1 1 17
D 1 1 1 1 54
B 1 1 1 200

2N-k 128 64 32 16 8 4 2 1
The rows are reordered to A, B, C, D, E, F.
2. Now columns are ordered.
Part
Machine 1 3 4 7 2 5 6 8 2M-k
A 1 1 1 32
B 1 1 1 16
C 1 1 1 1 8
D 1 1 1 1 4
E 1 1 2
F 1 1 1

Value 48 56 12 7 48 12 12 3
Based on the column values, the new ordering is 3, 1, 2, 4, 5, 6, 7, 8.
We return to 1 and repeat row ordering.

Part
Machine 3 1 2 4 5 6 7 8 Value
A 1 1 1 224
B 1 1 1 224
C 1 1 1 1 156
D 1 1 1 1 29
E 1 1 3
F 1 1 3

2N-k 128 64 32 16 8 4 2 1
The row ordering for this step is unchanged and we stop.

The algorithm places part 3 first to accentuate its extra machine visit. This is perhaps
one drawback of the ordering procedure; it accentuates exceptional elements by
moving them as high in the matrix as possible instead of keeping them close to their
neighbours. In the table below we place 3 after parts 1 and 2 to indicate the smooth
transition between nearly diagonal groups.

Suppose we had an industrial problem with 200 machines and 10,000 parts. Most
parts visit less than 20 machines, making the machine-part matrix sparse. We could
store for each row (column) the list of columns (rows) with a one. We might also
include pointers to the next element in its row and column. Adding two “hash” tables
for quick access to the first elements in each row or column gives us complete, easy-
to-retrieve data. Procedures exist to sort n elements (rows or columns) in a
computational effort of O(nlogn), making binary ordering possible for large problems.