Algorithms for programmers ideas and source code

Matters Computational
Ideas, Algorithms, Source Code

J¨rg Arndt
o

CONTENTS

iii

Contents
Preface

xi

I

1

Low level algorithms

1 Bit wizardry
1.1 Trivia . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Operations on individual bits . . . . . . . . . . . . .
1.3 Operations on low bits or blocks of a word . . . . .
1.4 Extraction of ones, zeros, or blocks near transitions
1.5 Computing the index of a single set bit . . . . . . .
1.6 Operations on high bits or blocks of a word . . . . .
1.7 Functions related to the base-2 logarithm . . . . . .
1.8 Counting the bits and blocks of a word . . . . . . .
1.9 Words as bitsets . . . . . . . . . . . . . . . . . . . .
1.10 Index of the i-th set bit . . . . . . . . . . . . . . . .
1.11 Avoiding branches . . . . . . . . . . . . . . . . . . .
1.12 Bit-wise rotation of a word . . . . . . . . . . . . . .
1.13 Binary necklaces ‡ . . . . . . . . . . . . . . . . . . .
1.14 Reversing the bits of a word . . . . . . . . . . . . .
1.15 Bit-wise zip . . . . . . . . . . . . . . . . . . . . . . .
1.16 Gray code and parity . . . . . . . . . . . . . . . . .
1.17 Bit sequency ‡ . . . . . . . . . . . . . . . . . . . . .
1.18 Powers of the Gray code ‡ . . . . . . . . . . . . . .
1.19 Invertible transforms on words ‡ . . . . . . . . . . .
1.20 Scanning for zero bytes . . . . . . . . . . . . . . . .
1.21 Inverse and square root modulo 2n . . . . . . . . . .
1.22 Radix −2 (minus two) representation . . . . . . . .
1.23 A sparse signed binary representation . . . . . . . .
1.24 Generating bit combinations . . . . . . . . . . . . .
1.25 Generating bit subsets of a given word . . . . . . .
1.26 Binary words in lexicographic order for subsets . . .
1.27 Fibonacci words ‡ . . . . . . . . . . . . . . . . . . .
1.28 Binary words and parentheses strings ‡ . . . . . . .
1.29 Permutations via primitives ‡ . . . . . . . . . . . . .
1.30 CPU instructions often missed . . . . . . . . . . . .
1.31 Some space ﬁlling curves ‡ . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

2
2
7
8
11
13
14
17
18
23
25
25
27
29
33
38
41
46
48
49
55
56
58
61
62
68
70
74
78
80
82
83

2 Permutations and their operations
102
2.1 Basic deﬁnitions and operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
2.2 Representation as disjoint cycles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
2.3 Compositions of permutations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

iv

CONTENTS
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13

In-place methods to apply permutations
Random permutations . . . . . . . . . .
The revbin permutation . . . . . . . . .
The radix permutation . . . . . . . . .
In-place matrix transposition . . . . . .
Rotation by triple reversal . . . . . . .
The zip permutation . . . . . . . . . . .
The XOR permutation . . . . . . . . .
The Gray permutation . . . . . . . . .
The reversed Gray permutation . . . .

to data
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

109
111
118
121
122
123
125
127
128
131

3 Sorting and searching
3.1 Sorting algorithms . . . . . .
3.2 Binary search . . . . . . . . .
3.3 Variants of sorting methods .
3.4 Searching in unsorted arrays
3.5 Determination of equivalence

. . . .
. . . .
. . . .
. . . .
classes

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

134
134
141
142
147
148

4 Data structures
4.1 Stack (LIFO) . . . . . . . . .
4.2 Ring buffer . . . . . . . . . .
4.3 Queue (FIFO) . . . . . . . .
4.4 Deque (double-ended queue)
4.5 Heap and priority queue . . .
4.6 Bit-array . . . . . . . . . . .
4.7 Left-right array . . . . . . .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

153
153
155
156
158
160
164
166

II

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

Combinatorial generation

171

5 Conventions and considerations
5.1 Representations and orders . . . . . . . . . . .
5.2 Ranking, unranking, and counting . . . . . . .
5.3 Characteristics of the algorithms . . . . . . . .
5.4 Optimization techniques . . . . . . . . . . . . .
5.5 Implementations, demo-programs, and timings

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

172
172
172
173
174
174

. . . .
. . . .
. . . .
. . . .
order
. . . .
. . . .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

176
176
177
180
182
183
186
191

7 Compositions
7.1 Co-lexicographic order . . . . . . . . . . . . . . . . .
7.2 Co-lexicographic order for compositions into exactly
7.3 Compositions and combinations . . . . . . . . . . .
7.4 Minimal-change orders . . . . . . . . . . . . . . . .

.
k
.
.

. . . .
parts
. . . .
. . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

194
194
196
198
199

6 Combinations
6.1 Binomial coefficients . . . . . . . . . . . .
6.2 Lexicographic and co-lexicographic order
6.3 Order by prefix shifts (cool-lex) . . . . .
6.4 Minimal-change order . . . . . . . . . . .
6.5 The Eades-McKay strong minimal-change
6.6 Two-close orderings via endo/enup moves
6.7 Recursive generation of certain orderings

8 Subsets
202
8.1 Lexicographic order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
8.2 Minimal-change order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

CONTENTS
8.3
8.4
8.5

v

Ordering with De Bruijn sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Shifts-order for subsets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
k-subsets where k lies in a given range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

9 Mixed radix numbers
9.1 Counting (lexicographic) order . .
9.2 Minimal-change (Gray code) order
9.3 gslex order . . . . . . . . . . . . .
9.4 endo order . . . . . . . . . . . . .
9.5 Gray code for endo order . . . . .
9.6 Fixed sum of digits . . . . . . . .

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

217
217
220
224
226
228
229

10 Permutations
10.1 Factorial representations of permutations . . . . . . .
10.2 Lexicographic order . . . . . . . . . . . . . . . . . . .
10.3 Co-lexicographic order . . . . . . . . . . . . . . . . . .
10.4 An order from reversing preﬁxes . . . . . . . . . . . .
10.5 Minimal-change order (Heap’s algorithm) . . . . . . .
10.6 Lipski’s Minimal-change orders . . . . . . . . . . . . .
10.7 Strong minimal-change order (Trotter’s algorithm) . .
10.8 Star-transposition order . . . . . . . . . . . . . . . . .
10.9 Minimal-change orders from factorial numbers . . . .
10.10 Derangement order . . . . . . . . . . . . . . . . . . .
10.11 Orders where the smallest element always moves right
10.12 Single track orders . . . . . . . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

232
232
242
243
245
248
250
254
257
258
264
267
271

11 Permutations with special properties
11.1 The number of certain permutations . .
11.2 Permutations with distance restrictions
11.3 Self-inverse permutations (involutions) .
11.4 Cyclic permutations . . . . . . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

277
277
282
284
285

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.

12 k-permutations
291
12.1 Lexicographic order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
12.2 Minimal-change order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
13 Multisets
295
13.1 Subsets of a multiset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
13.2 Permutations of a multiset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
14 Gray codes for strings with restrictions
14.1 List recursions . . . . . . . . . . . . . . . . . . .
14.2 Fibonacci words . . . . . . . . . . . . . . . . . .
14.3 Generalized Fibonacci words . . . . . . . . . . .
14.4 Run-length limited (RLL) words . . . . . . . . .
14.5 Digit x followed by at least x zeros . . . . . . . .
14.6 Generalized Pell words . . . . . . . . . . . . . .
14.7 Sparse signed binary words . . . . . . . . . . . .
14.8 Strings with no two consecutive nonzero digits .
14.9 Strings with no two consecutive zeros . . . . . .
14.10 Binary strings without substrings 1x1 or 1xy1 ‡

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

304
304
305
307
310
311
313
315
317
318
320

15 Parentheses strings
323
15.1 Co-lexicographic order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
15.2 Gray code via restricted growth strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

vi

CONTENTS
15.3 Order by prefix shifts (cool-lex) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
15.4 Catalan numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
15.5 Increment-i RGS, k-ary Dyck words, and k-ary trees . . . . . . . . . . . . . . . . . . . . . 333

16 Integer partitions
16.1 Solution of a generalized problem
16.2 Iterative algorithm . . . . . . . . .
16.3 Partitions into m parts . . . . . .
16.4 The number of integer partitions .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

339
339
341
342
344

17 Set partitions
354
17.1 Recursive generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
17.2 The number of set partitions: Stirling set numbers and Bell numbers . . . . . . . . . . . 358
17.3 Restricted growth strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
18 Necklaces and Lyndon words
18.1 Generating all necklaces . . . . . . . . . . .
18.2 Lex-min De Bruijn sequence from necklaces
18.3 The number of binary necklaces . . . . . .
18.4 Sums of roots of unity that are zero ‡ . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

370
371
377
379
383

19 Hadamard and conference matrices
384
19.1 Hadamard matrices via LFSR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
19.2 Hadamard matrices via conference matrices . . . . . . . . . . . . . . . . . . . . . . . . . . 386
19.3 Conference matrices via finite fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
20 Searching paths in directed graphs ‡
20.1 Representation of digraphs . . . . .
20.2 Searching full paths . . . . . . . . .
20.3 Conditional search . . . . . . . . . .
20.4 Edge sorting and lucky paths . . . .
20.5 Gray codes for Lyndon words . . . .

III

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

Fast transforms

21 The Fourier transform
21.1 The discrete Fourier transform . . . .
21.2 Radix-2 FFT algorithms . . . . . . .
21.3 Saving trigonometric computations .
21.4 Higher radix FFT algorithms . . . . .
21.5 Split-radix algorithm . . . . . . . . .
21.6 Symmetries of the Fourier transform .
21.7 Inverse FFT for free . . . . . . . . . .
21.8 Real-valued Fourier transforms . . . .
21.9 Multi-dimensional Fourier transforms
21.10 The matrix Fourier algorithm (MFA)

391
392
393
398
402
403

409
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

410
410
411
416
418
425
428
430
431
437
438

22 Convolution, correlation, and more FFT algorithms
22.1 Convolution . . . . . . . . . . . . . . . . . . . . . . .
22.2 Correlation . . . . . . . . . . . . . . . . . . . . . . . .
22.3 Correlation, convolution, and circulant matrices ‡ . .
22.4 Weighted Fourier transforms and convolutions . . . .
22.5 Convolution using the MFA . . . . . . . . . . . . . . .
22.6 The z-transform (ZT) . . . . . . . . . . . . . . . . . .

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

440
440
444
447
448
451
454

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

CONTENTS

vii

22.7 Prime length FFTs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
23 The Walsh transform and its relatives
23.1 Transform with Walsh-Kronecker basis . . . . . . . . .
23.2 Eigenvectors of the Walsh transform ‡ . . . . . . . . . .
23.3 The Kronecker product . . . . . . . . . . . . . . . . . .
23.4 Higher radix Walsh transforms . . . . . . . . . . . . . .
23.5 Localized Walsh transforms . . . . . . . . . . . . . . . .
23.6 Transform with Walsh-Paley basis . . . . . . . . . . . .
23.7 Sequency-ordered Walsh transforms . . . . . . . . . . .
23.8 XOR (dyadic) convolution . . . . . . . . . . . . . . . .
23.9 Slant transform . . . . . . . . . . . . . . . . . . . . . .
23.10 Arithmetic transform . . . . . . . . . . . . . . . . . . .
23.11 Reed-Muller transform . . . . . . . . . . . . . . . . . .
23.12 The OR-convolution and the AND-convolution . . . . .
23.13 The MAX-convolution ‡ . . . . . . . . . . . . . . . . . .
23.14 Weighted arithmetic transform and subset convolution .

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

459
459
461
462
465
468
473
474
481
482
483
486
489
491
492

24 The
24.1
24.2
24.3
24.4
24.5
24.6
24.7
24.8

Haar transform
The ‘standard’ Haar transform . . . . . . . . .
In-place Haar transform . . . . . . . . . . . . .
Non-normalized Haar transforms . . . . . . . .
Transposed Haar transforms ‡ . . . . . . . . .
The reversed Haar transform ‡ . . . . . . . . .
Relations between Walsh and Haar transforms
Prefix transform and prefix convolution . . . .
Nonstandard splitting schemes ‡ . . . . . . . .

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

497
497
499
501
503
505
507
510
512

25 The Hartley transform
25.1 Definition and symmetries . . . . . . . . . . . . . .
25.2 Radix-2 FHT algorithms . . . . . . . . . . . . . . .
25.3 Complex FFT by FHT . . . . . . . . . . . . . . . .
25.4 Complex FFT by complex FHT and vice versa . . .
25.5 Real FFT by FHT and vice versa . . . . . . . . . .
25.6 Higher radix FHT algorithms . . . . . . . . . . . . .
25.7 Convolution via FHT . . . . . . . . . . . . . . . . .
25.8 Localized FHT algorithms . . . . . . . . . . . . . .
25.9 2-dimensional FHTs . . . . . . . . . . . . . . . . . .
25.10 Automatic generation of transform code . . . . . . .
25.11 Eigenvectors of the Fourier and Hartley transform ‡

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

515
515
515
521
522
523
524
525
529
530
531
533

26 Number theoretic transforms
26.1 Prime moduli for NTTs . .
26.2 Implementation of NTTs .
26.3 Convolution with NTTs . .
27 Fast
27.1
27.2
27.3

IV

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

(NTTs)
535
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542

wavelet transforms
543
Wavelet filters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Moment conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546

Fast arithmetic

28 Fast multiplication and exponentiation

549
550

viii

CONTENTS
28.1
28.2
28.3
28.4
28.5

Splitting schemes for multiplication . . . . . . . . . . .
Fast multiplication via FFT . . . . . . . . . . . . . . .
Radix/precision considerations with FFT multiplication
The sum-of-digits test . . . . . . . . . . . . . . . . . . .
Binary exponentiation . . . . . . . . . . . . . . . . . . .

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

550
558
560
562
563

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

567
567
570
572
575
576
581
583
586

30 Iterations for the inversion of a function
30.1 Iterations and their rate of convergence . . . . . . . . .
30.2 Schr¨der’s formula . . . . . . . . . . . . . . . . . . . . .
o
30.3 Householder’s formula . . . . . . . . . . . . . . . . . . .
30.4 Dealing with multiple roots . . . . . . . . . . . . . . . .
30.5 More iterations . . . . . . . . . . . . . . . . . . . . . . .
30.6 Convergence improvement by the delta squared process

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

587
587
588
592
593
594
598

AGM, elliptic integrals, and algorithms for computing π
The arithmetic-geometric mean (AGM) . . . . . . . . . . . . . .
The elliptic integrals K and E . . . . . . . . . . . . . . . . . . .
Theta functions, eta functions, and singular values . . . . . . . .
AGM-type algorithms for hypergeometric functions . . . . . . .
Computation of π . . . . . . . . . . . . . . . . . . . . . . . . . .

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

599
599
600
604
611
615

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

622
622
627
630
632
633

29 Root extraction
29.1 Division, square root and cube root . . . . . .
29.2 Root extraction for rationals . . . . . . . . . .
29.3 Divisionless iterations for the inverse a-th root
29.4 Initial approximations for iterations . . . . . .
29.5 Some applications of the matrix square root .
29.6 Goldschmidt’s algorithm . . . . . . . . . . . .
29.7 Products for the a-th root ‡ . . . . . . . . . .
29.8 Divisionless iterations for polynomial roots . .

31 The
31.1
31.2
31.3
31.4
31.5

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

32 Logarithm and exponential function
32.1 Logarithm . . . . . . . . . . . . . . . . . . . . . . . . . .
32.2 Exponential function . . . . . . . . . . . . . . . . . . . .
32.3 Logarithm and exponential function of power series . . .
32.4 Simultaneous computation of logarithms of small primes
32.5 Arctangent relations for π ‡ . . . . . . . . . . . . . . . . .

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

33 Computing the elementary functions with limited resources
641
33.1 Shift-and-add algorithms for logb (x) and bx . . . . . . . . . . . . . . . . . . . . . . . . . . 641
33.2 CORDIC algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646
34 Numerical evaluation of power series
651
34.1 The binary splitting algorithm for rational series . . . . . . . . . . . . . . . . . . . . . . . 651
34.2 Rectangular schemes for evaluation of power series . . . . . . . . . . . . . . . . . . . . . . 658
34.3 The magic sumalt algorithm for alternating series . . . . . . . . . . . . . . . . . . . . . . 662
35 Recurrences and Chebyshev polynomials
666
35.1 Recurrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666
35.2 Chebyshev polynomials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676
36 Hypergeometric series
36.1 Deﬁnition and basic operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36.2 Transformations of hypergeometric series . . . . . . . . . . . . . . . . . . . . . . . . . . .
36.3 Examples: elementary functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

685
685
688
694

CONTENTS

ix

36.4 Transformations for elliptic integrals ‡ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700
36.5 The function xx ‡ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
37 Cyclotomic polynomials, product forms, and continued fractions
37.1 Cyclotomic polynomials, M¨bius inversion, Lambert series . . . . . . . . . . . . . . . . .
o
37.2 Conversion of power series to infinite products . . . . . . . . . . . . . . . . . . . . . . . .
37.3 Continued fractions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

704
704
709
716

38 Synthetic Iterations ‡
38.1 A variation of the iteration for the inverse . . . . . . . . .
38.2 An iteration related to the Thue constant . . . . . . . . .
38.3 An iteration related to the Golay-Rudin-Shapiro sequence
38.4 Iteration related to the ruler function . . . . . . . . . . .
38.5 An iteration related to the period-doubling sequence . . .
38.6 An iteration from substitution rules with sign . . . . . .
38.7 Iterations related to the sum of digits . . . . . . . . . . .
38.8 Iterations related to the binary Gray code . . . . . . . . .
38.9 A function encoding the Hilbert curve . . . . . . . . . . .
38.10 Sparse power series . . . . . . . . . . . . . . . . . . . . .
38.11 An iteration related to the Fibonacci numbers . . . . . .
38.12 Iterations related to the Pell numbers . . . . . . . . . . .

726
726
730
731
733
734
738
739
741
747
750
753
757

V

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

Algorithms for finite fields

39 Modular arithmetic and some number theory
39.1 Implementation of the arithmetic operations .
39.2 Modular reduction with structured primes . .
39.3 The sieve of Eratosthenes . . . . . . . . . . . .
39.4 The Chinese Remainder Theorem (CRT) . . .
39.5 The order of an element . . . . . . . . . . . . .
39.6 Prime modulus: the field Z/pZ = Fp = GF(p)
39.7 Composite modulus: the ring Z/mZ . . . . . .
39.8 Quadratic residues . . . . . . . . . . . . . . . .
39.9 Computation of a square root modulo m . . .
39.10 The Rabin-Miller test for compositeness . . . .
39.11 Proving primality . . . . . . . . . . . . . . . .
39.12 Complex modulus: the field GF(p2 ) . . . . . .
39.13 Solving the Pell equation . . . . . . . . . . . .
39.14 Multiplication of hypercomplex numbers ‡ . .

763
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

764
764
768
770
772
774
776
776
781
784
786
792
804
812
815

40 Binary polynomials
40.1 The basic arithmetical operations . . . . . . . . . . . .
40.2 Multiplying binary polynomials of high degree . . . . .
40.3 Modular arithmetic with binary polynomials . . . . . .
40.4 Irreducible polynomials . . . . . . . . . . . . . . . . . .
40.5 Primitive polynomials . . . . . . . . . . . . . . . . . . .
40.6 The number of irreducible and primitive polynomials .
40.7 Transformations that preserve irreducibility . . . . . . .
40.8 Self-reciprocal polynomials . . . . . . . . . . . . . . . .
40.9 Irreducible and primitive polynomials of special forms ‡
40.10 Generating irreducible polynomials from Lyndon words
40.11 Irreducible and cyclotomic polynomials ‡ . . . . . . . .
40.12 Factorization of binary polynomials . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

822
822
827
832
837
841
843
845
846
848
856
857
858

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

x

CONTENTS

41 Shift registers
41.1 Linear feedback shift registers (LFSR) . . . . . . . . .
41.2 Galois and Fibonacci setup . . . . . . . . . . . . . . .
41.3 Error detection by hashing: the CRC . . . . . . . . .
41.4 Generating all revbin pairs . . . . . . . . . . . . . . .
41.5 The number of m-sequences and De Bruijn sequences
41.6 Auto-correlation of m-sequences . . . . . . . . . . . .
41.7 Feedback carry shift registers (FCSR) . . . . . . . . .
41.8 Linear hybrid cellular automata (LHCA) . . . . . . .
41.9 Additive linear hybrid cellular automata . . . . . . .
42 Binary ﬁnite ﬁelds: GF(2n )
42.1 Arithmetic and basic properties . . . . . .
42.2 Minimal polynomials . . . . . . . . . . . .
42.3 Fast computation of the trace vector . . . .
42.4 Solving quadratic equations . . . . . . . . .
42.5 Representation by matrices ‡ . . . . . . . .
42.6 Representation by normal bases . . . . . .
42.7 Conversion between normal and polynomial
42.8 Optimal normal bases (ONB) . . . . . . . .
42.9 Gaussian normal bases . . . . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

864
864
867
868
873
873
875
876
878
882

. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
representation
. . . . . . . . .
. . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

886
886
892
895
896
899
900
910
912
914

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

A The electronic version of the book

921

B Machine used for benchmarking

922

C The GP language

923

Bibliography

931

Index

951

Preface
This is a book for the computationalist, whether a working programmer or anyone interested in methods
of computation. The focus is on material that does not usually appear in textbooks on algorithms.
Where necessary the underlying ideas are explained and the algorithms are given formally. It is assumed
that the reader is able to understand the given source code, it is considered part of the text. We use the
C++ programming language for low-level algorithms. However, only a minimal set of features beyond
plain C is used, most importantly classes and templates. For material where technicalities in the C++
code would obscure the underlying ideas we use either pseudocode or, with arithmetical algorithms, the
GP language. Appendix C gives an introduction to GP.
Example computations are often given with an algorithm, these are usually made with the demo programs
referred to. Most of the listings and figures in this book were created with these programs. A recurring
topic is practical efficiency of the implementations. Various optimization techniques are described and
the actual performance of many given implementations is indicated.
The accompanying software, the FXT [21] and the hfloat [22] libraries, are written for POSIX compliant
platforms such as the Linux and BSD operating systems. The license is the GNU General Public License
(GPL), version 3 or later, see http://www.gnu.org/licenses/gpl.html.
Individual chapters are self-contained where possible and references to related material are given where
needed. The symbol ‘ ‡ ’ marks sections that can be skipped at first reading. These typically contain
excursions or more advanced material.
Each item in the bibliography is followed by a list of page numbers where citations occur. With papers
that are available for free download the respective URL is given. Note that the URL may point to a
preprint which can differ from the final version of the paper.
An electronic version of this book is available online, see appendix A. Given the amount of material
treated there must be errors in this book. Corrections and suggestions for improvement are appreciated,
the preferred way of communication is electronic mail. A list of errata is online at http://www.jjj.de/
fxt/#fxtbook.
Many people helped to improve this book. It is my pleasure to thank them all, particularly helpful were
Igal Aharonovich, Max Alekseyev, Marcus Blackburn, Nathan Bullock, Dominique Delande,
Mike Engber, Torsten Finke, Sean Furlong, Almaz Gaifullin, Pedro Gimeno, Alexander Glyzov, R. W. Gosper, Andreas Gr¨nbacher, Lance Gurney, Markus Gyger, Christoph Haenel,
u
Tony Hardie-Bick, Laszlo Hars, Thomas Harte, Stephen Hartke, Christian Hey, Jeff Hurchalla,
Derek M. Jones, Gideon Klimer, Richard B. Kreckel, Mike Kundmann, G´l L´szl´, Dirk Lata a o
termann, Avery Lee, Brent Lehman, Marc Lehmann, Paul C. Leopardi, John Lien, Mirko
Liss, Robert C. Long, Fred Lunnon, Johannes Middeke, Doug Moore, F´bio Moreira, Andrew
a
Morris, David Nalepa, Samuel Neves, Matthew Oliver, Miroslaw Osys, Christoph Pacher,
Krisztiń Pacz´ri, Scott Paine, Yves Paradis, Gunther Piez, Andr´ Piotrowski, David Garc´
a
a
e
ıa
Quintas, Andreas Raseghi, Tony Reix, Johan R¨nnblom, Uwe Schmelich, Thomas Schraitle,
o
Clive Scott, Mukund Sivaraman, Michal Staruch, Ralf Stephan, Mikko Tommila, Sebastiano

Vigna, Michael Roby Wetherfield, Jim White, Vinnie Winkler, John Youngquist, Rui Zhang,
and Paul Zimmermann.
Special thanks go to Edith Parzefall and Michael Somos for independently proofreading the whole text
(the remaining errors are mine), and to Neil Sloane for creating the On-Line Encyclopedia of Integer
Sequences [312].
jj

N¨rnberg, Germany, June 2010
u

“Why make things difficult, when it is possible to make them cryptic
and totally illogical, with just a little bit more effort?”
— Aksel Peter Jørgensen

1

Part I

Low level algorithms

2

Chapter 1: Bit wizardry

Chapter 1

Bit wizardry
We give low-level functions for binary words, such as isolation of the lowest set bit or counting all set
bits. Sometimes the term ‘one’ is used for a set bit and ‘zero’ for an unset bit. Where it cannot cause
confusion, the term ‘bit’ is used for a set bit (as in “counting the bits of a word”).
The C-type unsigned long is abbreviated as ulong as defined in [FXT: fxttypes.h]. It is assumed that
BITS_PER_LONG reflects the size of an unsigned long. It is defined in [FXT: bits/bitsperlong.h] and
usually equals the machine word size: 32 on 32-bit architectures, and 64 on 64-bit machines. Further,
the quantity BYTES_PER_LONG reflects the number of bytes in a machine word: it equals BITS_PER_LONG
divided by eight. For some functions it is assumed that long and ulong have the same number of bits.
Many functions will only work on machines that use two’s complement, which is used by all of the current
general purpose computers (the only machines using one’s complement appear to be some successors of
the UNIVAC system, see [358, entry “UNIVAC 1100/2200 series”]).
The examples of assembler code are for the x86 and the AMD64 architecture. They should be simple
enough to be understood by readers who know assembler for any CPU.

1.1

Trivia

1.1.1

Little endian versus big endian

The order in which the bytes of an integer are stored in memory can start with the least significant byte
(little endian machine) or with the most significant byte (big endian machine). The hexadecimal number
0x0D0C0B0A will be stored in the following manner if memory addresses grow from left to right:
adr:
mem:
mem:

z
0D
0A

z+1
0C
0B

z+2
0B
0C

z+3
0A
0D

// big endian
// little endian

The difference becomes visible when you cast pointers. Let V be the 32-bit integer with the value
above. Then the result of char c = *(char *)(&V); will be 0x0A (value modulo 256) on a little
endian machine but 0x0D (value divided by 224 ) on a big endian machine. Though friends of big endian
sometimes refer to little endian as ‘wrong endian’, the desired result of the shown pointer cast is much
more often the modulo operation.
Whenever words are serialized into bytes, as with transfer over a network or to a disk, one will need two
code versions, one for big endian and one for little endian machines. The C-type union (with words and
bytes) may also require separate treatment for big and little endian architectures.

1.1.2

Size of pointer is not size of int

If programming for a 32-bit architecture (where the size of int and long coincide), casting pointers to
integers (and back) will usually work. The same code will fail on 64-bit machines. If you have to cast
pointers to an integer type, cast them to a sufficiently big type. For portable code it is better to avoid
casting pointers to integer types.

1.1: Trivia

1.1.3

3

Shifts and division

With two’s complement arithmetic division and multiplication by a power of 2 is a right and left shift,
respectively. This is true for unsigned types and for multiplication (left shift) with signed types. Division
with signed types rounds toward zero, as one would expect, but right shift is a division (by a power of 2)
that rounds to −∞:
int a = -1;
int c = a >> 1;
int d = a / 2;

// c == -1
// d == 0

The compiler still uses a shift instruction for the division, but with a ‘fix’ for negative values:
9:test.cc
@ int foo(int a)
10:test.cc
@ {
285 0003 8B442410
movl
11:test.cc
@
int s = a >> 1;
289 0007 89C1
movl
290 0009 D1F9
sarl
12:test.cc
@
int d = a / 2;
293 000b 89C2
movl
294 000d C1EA1F
shrl
295 0010 01D0
addl
296 0012 D1F8
sarl

16(%esp),%eax

// move argument to %eax

%eax,%ecx
$1,%ecx
%eax,%edx
$31,%edx // fix: %edx=(%edx<0?1:0)
%edx,%eax // fix: add one if a<0
$1,%eax

For unsigned types the shift would suffice. One more reason to use unsigned types whenever possible.
The assembler listing was generated from C code via the following commands:
# create assembler code:
c++ -S -fverbose-asm -g -O2 test.cc -o test.s
# create asm interlaced with source lines:
as -alhnd test.s > test.lst

There are two types of right shifts: a logical and an arithmetical shift. The logical version (shrl in the
above fragment) always fills the higher bits with zeros, corresponding to division of unsigned types. The
arithmetical shift (sarl in the above fragment) fills in ones or zeros, according to the most significant bit
of the original word.
Computing remainders modulo a power of 2 with unsigned types is equivalent to a bit-and:
ulong a = b % 32;

// == b & (32-1)

All of the above is done by the compiler’s optimization wherever possible.
Division by (compile time) constants can be replaced by multiplications and shifts. The compiler does it
for you. A division by the constant 10 is compiled to:
5:test.cc
@ ulong foo(ulong a)
6:test.cc
@ {
7:test.cc
@
ulong b = a / 10;
290 0000 8B442404
movl 4(%esp),%eax
291 0004 F7250000
mull .LC33
// value == 0xcccccccd
292 000a 89D0
movl %edx,%eax
293 000c C1E803
shrl $3,%eax

Therefore it is sometimes reasonable to have separate code branches with explicit special values. Similar
optimizations can be used for the modulo operation if the modulus is a compile time constant. For
example, using modulus 10,000:
8:test.cc
@ ulong foo(ulong a)
9:test.cc
@ {
53 0000 8B4C2404
movl 4(%esp),%ecx
10:test.cc
@
ulong b = a % 10000;
57 0004 89C8
movl %ecx,%eax
58 0006 F7250000
mull .LC0
// value == 0xd1b71759
59 000c 89D0
movl %edx,%eax
60 000e C1E80D
shrl $13,%eax
61 0011 69C01027
imull $10000,%eax,%eax
62 0017 29C1
subl %eax,%ecx
63 0019 89C8
movl %ecx,%eax

Algorithms to replace divisions by a constant with multiplications and shifts are given in [168], see
also [346].

4


Note that the C standard leaves the behavior of a right shift of a signed integer as ‘implementationdeﬁned’. The described behavior (that a negative value remains negative after right shift) is the default
behavior of many commonly used C compilers.

1.1.4

A pitfall (two’s complement)
c=................
c=...............1
c=..............1.
c=..............11
c=.............1..
c=.............1.1
c=.............11.
[--snip--]
c=.1111111111111.1
c=.11111111111111.
c=.111111111111111
c=1...............
c=1..............1
c=1.............1.
c=1.............11
c=1............1..
c=1............1.1
c=1............11.
[--snip--]
c=1111111111111..1
c=1111111111111.1.
c=1111111111111.11
c=11111111111111..
c=11111111111111.1
c=111111111111111.
c=1111111111111111

-c=................
-c=1111111111111111
-c=111111111111111.
-c=11111111111111.1
-c=11111111111111..
-c=1111111111111.11
-c=1111111111111.1.

c=
c=
c=
c=
c=
c=
c=

0
1
2
3
4
5
6

-c=1.............11
-c=1.............1.
-c=1..............1
-c=1...............
-c=.111111111111111
-c=.11111111111111.
-c=.1111111111111.1
-c=.1111111111111..
-c=.111111111111.11
-c=.111111111111.1.

c= 32765
c= 32766
c= 32767
c=-32768
c=-32767
c=-32766
c=-32765
c=-32764
c=-32763
c=-32762

-c=-32765
-c=-32766
-c=-32767
-c=-32768
-c= 32767
-c= 32766
-c= 32765
-c= 32764
-c= 32763
-c= 32762

-c=.............111
-c=.............11.
-c=.............1.1
-c=.............1..
-c=..............11
-c=..............1.
-c=...............1

c=
c=
c=
c=
c=
c=
c=

-c=
-c=
-c=
-c=
-c=
-c=
-c=

-7
-6
-5
-4
-3
-2
-1

-c=
-c=
-c=
-c=
-c=
-c=
-c=

0
-1
-2
-3
-4
-5
-6

<--=

<--=

7
6
5
4
3
2
1

Figure 1.1-A: With two’s complement there is one nonzero value that is its own negative.
In two’s complement zero is not the only number that is equal to its negative. The value with just
the highest bit set (the most negative value) also has this property. Figure 1.1-A (the output of [FXT:
bits/gotcha-demo.cc]) shows the situation for words of 16 bits. This is why innocent looking code like
the following can simply fail:
if ( x<0 ) x = -x;
// assume x positive here (WRONG!)

1.1.5

Another pitfall (shifts in the C-language)

A shift by more than BITS_PER_LONG−1 is undeﬁned by the C-standard. Therefore the following function
can fail if k is zero:
1
2
3
4
5
6
7

static inline ulong first_comb(ulong k)
// Return the first combination of (i.e. smallest word with) k bits,
// i.e. 00..001111..1 (k low bits set)
{
ulong t = ~0UL >> ( BITS_PER_LONG - k );
return t;
}

Compilers usually emit just a shift instruction which on certain CPUs does not give zero if the shift is
equal to or greater than BITS_PER_LONG. This is why the line
if ( k==0 )

t = 0;

// shift with BITS_PER_LONG is undefined

has to be inserted just before the return statement.

1.1.6

Shortcuts

Test whether at least one of a and b equals zero with
if ( !(a && b) )

This works for both signed and unsigned integers. Check whether both are zero with
if ( (a|b)==0 )

This obviously generalizes for several variables as
if ( (a|b|c|..|z)==0 )

Test whether exactly one of two variables is zero using

1.1: Trivia

5

if ( (!a) ^ (!b) )

1.1.7

Average without overflow

A routine for the computation of the average (x + y)/2 of two arguments x and y is [FXT: bits/average.h]
1
2
3
4
5
6
7

static inline ulong average(ulong x, ulong y)
// Return floor( (x+y)/2 )
// Use:
x+y == ((x&y)<<1) + (x^y)
// that is: sum == carries
+ sum_without_carries
{
return (x & y) + ((x ^ y) >> 1);
}

The function gives the correct value even if (x + y) does not fit into a machine word. If it is known
that x ≥ y, then we can use the simpler statement return y+(x-y)/2. The following version rounds to
infinity:
1
2
3
4
5
6

static inline ulong ceil_average(ulong x, ulong y)
// Use:
x+y == ((x|y)<<1) - (x^y)
// ceil_average(x,y) == average(x,y) + ((x^y)&1))
{
return (x | y) - ((x ^ y) >> 1);
}

1.1.8

Toggling between values

To toggle an integer x between two values a and b, use:
pre-calculate:
toggle:

t = a ^ b;
x ^= t;
// a <--> b

The equivalent trick for floating-point types is
pre-calculate:
toggle:

t = a + b;
x = t - x;

Here an overflow could occur with a and b in the allowed range if both are close to overflow.

1.1.9

Next or previous even or odd value

Compute the next or previous even or odd value via [FXT: bits/evenodd.h]:
1
2
3
4
5

static inline ulong next_even(ulong x)
static inline ulong prev_even(ulong x)
static inline ulong next_odd(ulong x)
static inline ulong prev_odd(ulong x)

{ return x+2-(x&1); }
{ return x-2+(x&1); }
{ return x+1+(x&1); }
{ return x-1-(x&1); }

The following functions return the unmodified argument if it has the required property, else the nearest
such value:
1
2
3
4
5

static inline ulong next0_even(ulong x)
static inline ulong prev0_even(ulong x)

{ return x+(x&1); }
{ return x-(x&1); }

static inline ulong next0_odd(ulong x)
static inline ulong prev0_odd(ulong x)

{ return x+1-(x&1); }
{ return x-1+(x&1); }

Pedro Gimeno gives [priv. comm.] the following optimized versions:
1
2
3
4
5

static inline ulong next_even(ulong x)
static inline ulong prev_even(ulong x)

1
2
3
4
5

static inline ulong next0_even(ulong x)
static inline ulong prev0_even(ulong x)

static inline ulong next_odd(ulong x)
static inline ulong prev_odd(ulong x)

{ return (x|1)+1; }
{ return (x-1)&~1; }

static inline ulong next0_odd(ulong x)
static inline ulong prev0_odd(ulong x)

{ return (x+1)|1; }
{ return (x&~1)-1; }
{ return (x+1)&~1; }
{ return x&~1; }
{ return x|1; }
{ return (x-1)|1; }

6


1.1.10

Integer versus float multiplication

The floating-point multiplier gives the highest bits of the product. Integer multiplication gives the
result modulo 2b where b is the number of bits of the integer type used. As an example we square the
number 111111111 using a 32-bit integer type and floating-point types with 24-bit and 53-bit mantissa
(significand):
a = 111111111
// assignment
a*a == 12345678987654321 // true result
a*a == 1653732529
(a*a)%(2**32) == 1653732529

// result with 32-bit integer multiplication
// ... which is modulo (2**bits_per_int)

a*a == 1.2345679481405440e+16 // result with float multiplication (24 bit mantissa)
a*a == 1.2345678987654320e+16 // result with float multiplication (53 bit mantissa)

1.1.11

Double precision float to signed integer conversion

Conversion of double precision floats that have a 53-bit mantissa to signed integers via [11, p.52-53]
1
2
3
4

#define DOUBLE2INT(i, d)
double x = 123.0;
int i;
DOUBLE2INT(i, x);

{ double t = ((d) + 6755399441055744.0); i = *((int *)(&t)); }

can be a faster alternative to
1
2

double x = 123.0;
int i = x;

The constant used is 6755399441055744 = 252 + 251 . The method is machine dependent as it relies on the
binary representation of the floating-point mantissa. Here it is assumed that, the floating-point number
has a 53-bit mantissa with the most significant bit (that is always one with normalized numbers) omitted,
and that the address of the number points to the mantissa.

1.1.12

Optimization considerations

Never assume that some code is the ‘fastest possible’. There is always another trick that can still improve
performance. Many factors can have an influence on performance, like the number of CPU registers or
cost of branches. Code that performs well on one machine might perform badly on another. The old
trick to swap variables without using a temporary is pretty much out of fashion today:
//
a=0, b=0
a=0, b=1
a ^= b; //
0
0
1
1
b ^= a; //
0
0
1
0
a ^= b; //
0
0
1
0
// equivalent to: tmp = a; a = b;

a=1, b=0
1
0
1
1
0
1
b = tmp;

a=1, b=1
0
1
0
1
1
1

However, under some conditions (like extreme register pressure) it may be the way to go. Note that if
both operands are identical (memory locations) then the result is zero.
The only way to find out which version of a function is faster is to actually do benchmarking (timing). The
performance does depend on the sequence of instructions surrounding the machine code, assuming that
all of these low-level functions get inlined. Studying the generated CPU instructions helps to understand
what happens, but can never replace benchmarking. This means that benchmarks for just the isolated
routine can at best give a rough indication. Test your application using different versions of the routine
in question.
Never ever delete the unoptimized version of some code fragment when introducing a streamlined one.
Keep the original in the source. If something nasty happens (think of low level software failures when
porting to a different platform), you will be very grateful for the chance to temporarily resort to the slow
but correct version.
Study the optimization recommendations for your CPU (like [11] and [12] for the AMD64, see also [144]).
You can also learn a lot from the documentation for other architectures.

1.2: Operations on individual bits

7

Proper documentation is an absolute must for optimized code. Always assume that nobody will understand the code without comments. You may not be able to understand uncommented code written by
yourself after enough time has passed.

1.2

Operations on individual bits

1.2.1

Testing, setting, and deleting bits

The following functions should be self-explanatory. Following the spirit of the C language there is no
check whether the indices used are out of bounds. That is, if any index is greater than or equal to
BITS_PER_LONG, the result is undeﬁned [FXT: bits/bittest.h]:
1
2
3
4
5
6

static inline ulong test_bit(ulong a, ulong i)
// Return zero if bit[i] is zero,
// else return one-bit word with bit[i] set.
{
return (a & (1UL << i));
}

The following version returns either zero or one:
1
2
3
4
5

static inline bool test_bit01(ulong a, ulong i)
// Return whether bit[i] is set.
{
return ( 0 != test_bit(a, i) );
}

Functions for setting, clearing, and changing a bit are:
1
2
3
4
5

static inline ulong set_bit(ulong a, ulong i)
// Return a with bit[i] set.
{
return (a | (1UL << i));
}

1
2
3
4
5

static inline ulong clear_bit(ulong a, ulong i)
// Return a with bit[i] cleared.
{
return (a & ~(1UL << i));
}

1
2
3
4
5

static inline ulong change_bit(ulong a, ulong i)
// Return a with bit[i] changed.
{
return (a ^ (1UL << i));
}

1.2.2

Copying a bit

To copy a bit from one position to another, we generate a one if the bits at the two positions diﬀer. Then
an XOR changes the target bit if needed [FXT: bits/bitcopy.h]:
1
2
3
4
5
6
7
8

static inline ulong copy_bit(ulong a, ulong isrc, ulong idst)
// Copy bit at [isrc] to position [idst].
// Return the modified word.
{
ulong x = ((a>>isrc) ^ (a>>idst)) & 1; // one if bits differ
a ^= (x<<idst); // change if bits differ
return a;
}

The situation is more tricky if the bit positions are given as (one bit) masks:
1
2
3
4
5
6
7
8
9

static inline ulong mask_copy_bit(ulong a, ulong msrc, ulong mdst)
// Copy bit according at src-mask (msrc)
// to the bit according to the dest-mask (mdst).
// Both msrc and mdst must have exactly one bit set.
{
ulong x = mdst;
if ( msrc & a ) x = 0; // zero if source bit set
x ^= mdst; // ==mdst if source bit set, else zero
a &= ~mdst; // clear dest bit

8
10
11
12

a |= x;
return a;
}

The compiler generates branch-free code as the conditional assignment is compiled to a cmov (conditional
move) assembler instruction. If one or both masks have several bits set, the routine will set all bits of
mdst if any of the bits in msrc is one, or else clear all bits of mdst.

1.2.3

Swapping two bits

A function to swap two bits of a word is [FXT: bits/bitswap.h]:
1
2
3
4
5
6
7
8
9

static inline ulong bit_swap(ulong a, ulong k1, ulong k2)
// Return a with bits at positions [k1] and [k2] swapped.
// k1==k2 is allowed (a is unchanged then)
{
ulong x = ((a>>k1) ^ (a>>k2)) & 1; // one if bits differ
a ^= (x<<k2); // change if bits differ
a ^= (x<<k1); // change if bits differ
return a;
}

If it is known that the bits do have diﬀerent values, the following routine should be used:
1
2
3
4
5
6
7
8

static inline ulong bit_swap_01(ulong a, ulong k1, ulong k2)
// Return a with bits at positions [k1] and [k2] swapped.
// Bits must have different values (!)
// (i.e. one is zero, the other one)
// k1==k2 is allowed (a is unchanged then)
{
return a ^ ( (1UL<<k1) ^ (1UL<<k2) );
}

1.3

Operations on low bits or blocks of a word

The underlying idea of functions operating on the lowest set bit is that addition and subtraction of 1 always
changes a burst of bits at the lower end of the word. The functions are given in [FXT: bits/bitlow.h].

1.3.1

Isolating, setting, and deleting the lowest one

The lowest one (set bit) is isolated via
1
2
3
4
5
6

static inline ulong lowest_one(ulong x)
// Return word where only the lowest set bit in x is set.
// Return 0 if no bit is set.
{
return x & -x; // use: -x == ~x + 1
}

The lowest zero (unset bit) is isolated using the equivalent of lowest_one( ~x ):
1
2
3
4
5
6
7

static inline ulong lowest_zero(ulong x)
// Return word where only the lowest unset bit in x is set.
// Return 0 if all bits are set.
{
x = ~x;
return x & -x;
}

Alternatively, we can use either of
return
return

(x ^ (x+1)) & ~x;
((x ^ (x+1)) >> 1 ) + 1;

1.3: Operations on low bits or blocks of a word

9

The sequence of returned values for x = 0, 1, . . . is the highest power of 2 that divides x + 1, entry
A006519 in [312] (see also entry A001511):
x:
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

==
==
==
==
==
==
==
==
==
==
==
==

x
........
.......1
......1.
......11
.....1..
.....1.1
.....11.
.....111
....1...
....1..1
....1.1.

lowest_zero(x)
.......1
......1.
.......1
.....1..
.......1
......1.
.......1
....1...
.......1
......1.
.......1

The lowest set bit in a word can be cleared by
1
2
3
4
5
6

static inline ulong clear_lowest_one(ulong x)
// Return word where the lowest bit set in x is cleared.
// Return 0 for input == 0.
{
return x & (x-1);
}

The lowest unset bit can be set by
1
2
3
4
5
6

static inline ulong set_lowest_zero(ulong x)
// Return word where the lowest unset bit in x is set.
// Return ~0 for input == ~0.
{
return x | (x+1);
}

1.3.2

Computing the index of the lowest one

We compute the index (position) of the lowest bit with an assembler instruction if available [FXT:
bits/bitasm-amd64.h]:
1
2
3
4
5
6

static inline ulong asm_bsf(ulong x)
// Bit Scan Forward
{
asm ("bsfq %0, %0" : "=r" (x) : "0" (x));
return x;
}

Without the assembler instruction an algorithm that involves O (log2 BITS PER LONG) operations can be
used. The function can be implemented as follows (suggested by Nathan Bullock [priv. comm.], 64-bit
version) [FXT: bits/bitlow.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static inline ulong lowest_one_idx(ulong x)
// Return index of lowest bit set.
// Examples:
//
***1 --> 0
//
**10 --> 1
//
*100 --> 2
// Return 0 (also) if no bit is set.
{
ulong r = 0;
x &= -x; // isolate lowest bit
if ( x & 0xffffffff00000000UL ) r += 32;
if ( x & 0xffff0000ffff0000UL ) r += 16;
if ( x & 0xff00ff00ff00ff00UL ) r += 8;
if ( x & 0xf0f0f0f0f0f0f0f0UL ) r += 4;
if ( x & 0xccccccccccccccccUL ) r += 2;
if ( x & 0xaaaaaaaaaaaaaaaaUL ) r += 1;
return r;
}

The function returns zero for two inputs, one and zero. If a special value for the input zero is needed, a
statement as the following should be added as the ﬁrst line of the function:
if ( 1>=x )

return

x-1; // 0 if 1, ~0 if 0

The following function returns the parity of the index of the lowest set bit in a binary word
1
2
3

static inline ulong lowest_one_idx_parity(ulong x)
{

10
4
5

return

0 != (x & 0xaaaaaaaaaaaaaaaaUL);

}

The sequence of values for x = 0, 1, 2, . . . is
0010001010100010001000101010001010100010101000100010001010100010...
This is the complement of the period-doubling sequence, entry A035263 in [312]. See section 38.5.1 on
page 735 for the connection to the towers of Hanoi puzzle.

1.3.3

Isolating blocks of zeros or ones at the low end

Isolate the burst of low ones as follows [FXT: bits/bitlow.h]:
1
2
3
4
5
6
7
8
9
10
11

static inline ulong low_ones(ulong x)
// Return word where all the (low end) ones are set.
// Example: 01011011 --> 00000011
// Return 0 if lowest bit is zero:
//
10110110 --> 0
{
x = ~x;
x &= -x;
--x;
return x;
}

The isolation of the low zeros is slightly cheaper:
1
2
3
4
5
6
7
8
9

static inline ulong low_zeros(ulong x)
// Return word where all the (low end) zeros are set.
// Example: 01011000 --> 00000111
// Return 0 if all bits are set.
{
x &= -x;
--x;
return x;
}

The lowest block of ones (which may have zeros to the right of it) can be isolated by
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong lowest_block(ulong x)
// Isolate lowest block of ones.
// e.g.:
// x
= *****011100
// l
= 00000000100
// y
= *****100000
// x^y = 00000111100
// ret = 00000011100
{
ulong l = x & -x; // lowest bit
ulong y = x + l;
x ^= y;
return x & (x>>1);
}

1.3.4

Creating a transition at the lowest one

Use the following routines to set a rising or falling edge at the position of the lowest set bit [FXT:
bits/bitlow-edge.h]:
1
2
3
4
5
6
7
8

static inline ulong lowest_one_10edge(ulong x)
// Return word where all bits from (including) the
//
lowest set bit to most significant bit are set.
// Example: 00110100 --> 11111100
{
return ( x | -x );
}

1
2
3
4
5

static inline ulong lowest_one_01edge(ulong x)
//
lowest set bit to the least significant are set.
// Example: 00110100 --> 00000111

1.4: Extraction of ones, zeros, or blocks near transitions
6
7
8
9

11

{
if ( 0==x ) return 0;
return x^(x-1);
}

1.3.5

Isolating the lowest run of matching bits

Let x = ∗0W and y = ∗1W , the following function computes W :
1
2
3
4
5
6
7
8

static inline
{
x ^= y;
x &= -x;
x -= 1;
x &= y;
return x;
}

1.4

ulong low_match(ulong x, ulong y)
//
//
//
//

bit-wise difference
lowest bit that differs in both words
mask that covers equal bits at low end
isolate matching bits

Extraction of ones, zeros, or blocks near transitions

We give functions for the creation or extraction of bit-blocks and the isolation of values near transitions.
A transition is a place where adjacent bits have diﬀerent values. A block is a group of adjacent bits of
the same value.

1.4.1

Creating blocks of ones

The following functions are given in [FXT: bits/bitblock.h].
1
2
3
4
5
6
7

static inline ulong bit_block(ulong p, ulong n)
// Return word with length-n bit block starting at bit p set.
// Both p and n are effectively taken modulo BITS_PER_LONG.
{
ulong x = (1UL<<n) - 1;
return x << p;
}

A version with indices wrapping around is
1
2
3
4
5
6
7
8

static inline ulong cyclic_bit_block(ulong p, ulong n)
// Return word with length-n bit block starting at bit p set.
// The result is possibly wrapped around the word boundary.
// Both p and n are effectively taken modulo BITS_PER_LONG.
{
ulong x = (1UL<<n) - 1;
return (x<<p) | (x>>(BITS_PER_LONG-p));
}

1.4.2

Finding isolated ones or zeros

The following functions are given in [FXT: bits/bit-isolate.h]:
1
2
3
4
5

static inline ulong single_ones(ulong x)
// Return word with only the isolated ones of x set.
{
return x & ~( (x<<1) | (x>>1) );
}

We can assume a word is embedded in zeros or ignore the bits outside the word:
1
2
3
4
5

static inline ulong single_zeros_xi(ulong x)
// Return word with only the isolated zeros of x set.
{
return single_ones( ~x ); // ignore outside values
}

1
2
3
4
5

static inline ulong single_zeros(ulong x)
// Return word with only the isolated zeros of x set.
{
return ~x & ( (x<<1) & (x>>1) ); // assume outside values == 0
}

12


1
2
3
4
5

static inline ulong single_values(ulong x)
// Return word where only the isolated ones and zeros of x are set.
{
return (x ^ (x<<1)) & (x ^ (x>>1)); // assume outside values == 0
}

1
2
3
4
5

static inline ulong single_values_xi(ulong x)
// Return word where only the isolated ones and zeros of x are set.
{
return single_ones(x) | single_zeros_xi(x); // ignore outside values
}

1.4.3

Isolating single ones or zeros at the word boundary

1
2
3
4
5

static inline ulong border_ones(ulong x)
// Return word where only those ones of x are set that lie next to a zero.
{
return x & ~( (x<<1) & (x>>1) );
}

1
2
3
4
5

static inline ulong border_values(ulong x)
// Return word where those bits of x are set that lie on a transition.
{
return (x ^ (x<<1)) | (x ^ (x>>1));
}

1.4.4

Isolating transitions

1
2
3
4
5
6

static inline ulong high_border_ones(ulong x)
// Return word where only those ones of x are set
//
that lie right to (i.e. in the next lower bin of) a zero.
{
return x & ( x ^ (x>>1) );
}

1
2
3
4
5
6

static inline ulong low_border_ones(ulong x)
//
that lie left to (i.e. in the next higher bin of) a zero.
{
return x & ( x ^ (x<<1) );
}

1.4.5

Isolating ones or zeros at block boundaries

1
2
3
4
5
6

static inline ulong block_border_ones(ulong x)
//
that are at the border of a block of at least 2 bits.
{
return x & ( (x<<1) ^ (x>>1) );
}

1
2
3
4
5
6
7

static inline ulong low_block_border_ones(ulong x)
// Return word where only those bits of x are set
//
that are at left of a border of a block of at least 2 bits.
{
ulong t = x & ( (x<<1) ^ (x>>1) ); // block_border_ones()
return t & (x>>1);
}

1
2
3
4
5
6
7

static inline ulong high_block_border_ones(ulong x)
//
that are at right of a border of a block of at least 2 bits.
{
ulong t = x & ( (x<<1) ^ (x>>1) ); // block_border_ones()
return t & (x<<1);
}

1
2
3
4
5
6

static inline ulong block_ones(ulong x)
//
that are part of a block of at least 2 bits.
{
return x & ( (x<<1) | (x>>1) );
}

1.5: Computing the index of a single set bit

1.5

13

Computing the index of a single set bit

In the function lowest_one_idx() given in section 1.3.2 on page 9 we first isolated the lowest one of a
word x by first setting x&=-x. At this point, x contains just one set bit (or x==0). The following lines
in the routine compute the index of the only bit set. This section gives some alternative techniques to
compute the index of the one in a single-bit word.

1.5.1

Cohen’s trick

modulus m=11
k = 0 1
mt[k]= 0 0

2
1

Lowest
Lowest
Lowest
Lowest
Lowest
Lowest
Lowest
Lowest

0:
1:
2:
3:
4:
5:
6:
7:

bit
bit
bit
bit
bit
bit
bit
bit

==
==
==
==
==
==
==
==

3
8

4
2

5
4

6
9

7
7

x=
x=
x=
x=
x=
x=
x=
x=

.......1
......1.
.....1..
....1...
...1....
..1.....
.1......
1.......

=
1
=
2
=
4
=
8
= 16
= 32
= 64
= 128

x
x
x
x
x
x
x
x

%
%
%
%
%
%
%
%

m= 1 ==> lookup
m= 2 ==> lookup
m= 4 ==> lookup
m= 8 ==> lookup
m= 5 ==> lookup
m= 10 ==> lookup
m= 9 ==> lookup
m= 7 ==> lookup

=
=
=
=
=
=
=
=

0
1
2
3
4
5
6
7

Figure 1.5-A: Determination of the position of a single bit with 8-bit words.
A nice trick is presented in [110]: for N -bit words find a number m such that all powers of 2 are different
modulo m. That is, the (multiplicative) order of 2 modulo m must be greater than or equal to N . We
use a table mt[] of size m that contains the power of 2: mt[(2**j) mod m] = j for j > 0. To look up
the index of a one-bit-word x it is reduced modulo m and mt[x] is returned.
We demonstrate the method for N = 8 where m = 11 is the smallest number with the required property.
The setup routine for the table is
1
2
3
4
5
6
7
8
9
10
11
12
13

const ulong m = 11; // the modulus
ulong mt[m+1];
static void mt_setup()
{
mt[0] = 0; // special value for the zero word
ulong t = 1;
for (ulong i=1; i<m; ++i)
{
mt[t] = i-1;
t *= 2;
if ( t>=m ) t -= m; // modular reduction
}
}

The entry in mt[0] will be accessed when the input is the zero word. We can use any value to be returned
for input zero. Here we simply use zero to always have the same return value as with lowest_one_idx().
The index can be computed by
1
2
3
4
5
6

static inline ulong m_lowest_one_idx(ulong x)
{
x %= m;
// power of 2 modulo m
return mt[x]; // lookup
}

The code is given in the program [FXT: bits/modular-lookup-demo.cc], the output with N = 8 (edited
for size) is shown in figure 1.5-A. The following moduli m(N ) can be used for N -bit words:
N:
m:

4
5

8
11

16
19

32
37

64
67

128
131

256
269

512
523

1024
1061

The modulus m(N ) is the smallest prime greater than N such that 2 is a primitive root modulo m(N ).

14


db=...1.111 (De Bruijn
k = 0 1 2 3 4
dbt[k] = 0 1 2 4 7
Lowest bit == 0:
x =
Lowest bit == 1:
x =
Lowest bit == 2:
x =
Lowest bit == 3:
x =
Lowest bit == 4:
x =
Lowest bit == 5:
x =
Lowest bit == 6:
x =
Lowest bit == 7:
x =

sequence)
5 6 7
3 6 5
.......1
......1.
.....1..
....1...
...1....
..1.....
.1......
1.......

db
db
db
db
db
db
db
db

*
*
*
*
*
*
*
*

x
x
x
x
x
x
x
x

=
=
=
=
=
=
=
=

...1.111
..1.111.
.1.111..
1.111...
.111....
111.....
11......
1.......

shifted
shifted
shifted
shifted
shifted
shifted
shifted
shifted

=
=
=
=
=
=
=
=

........
.......1
......1.
.....1.1
......11
.....111
.....11.
.....1..

==
==
==
==
==
==
==
==

0
1
2
5
3
7
6
4

==>
==>
==>
==>
==>
==>
==>
==>

lookup
lookup
lookup
lookup
lookup
lookup
lookup
lookup

=
=
=
=
=
=
=
=

0
1
2
3
4
5
6
7

Figure 1.5-B: Computing the position of the single set bit in 8-bit words with a De Bruijn sequence.

1.5.2

Using De Bruijn sequences

The following method (given in [228]) is even more elegant. It uses binary De Bruijn sequences of size N .
A binary De Bruijn sequence of length 2N contains all binary words of length N , see section 41.1 on
page 864. These are the sequences for 32 and 64 bit, as binary words:
#if BITS_PER_LONG == 32
const ulong db = 0x4653ADFUL;
// == 00000100011001010011101011011111
const ulong s = 32-5;
#else
const ulong db = 0x218A392CD3D5DBFUL;
// == 0000001000011000101000111001001011001101001111010101110110111111
const ulong s = 64-6;
#endif

Let wi be the i-th sub-word from the left (high end). We create a table such that the entry with index
wi points to i:
1
2
3
4
5

ulong dbt[BITS_PER_LONG];
static void dbt_setup()
{
for (ulong i=0; i<BITS_PER_LONG; ++i)
}

dbt[ (db<<i)>>s ] = i;

The computation of the index involves a multiplication and a table lookup:
1
2
3
4
5
6
7

static inline ulong db_lowest_one_idx(ulong x)
{
x *= db; // multiplication by a power of 2 is a shift
x >>= s; // use log_2(BITS_PER_LONG) highest bits
return dbt[x]; // lookup
}

The used sequences must start with at least log2 (N ) − 1 zeros because in the line x *= db the word x
is shifted (not rotated). The code is given in the demo [FXT: bits/debruijn-lookup-demo.cc], the output
with N = 8 (edited for size, dots denote zeros) is shown in figure 1.5-B.

1.5.3

Using floating-point numbers

Floating-point numbers are normalized so that the highest bit in the mantissa is set. Therefore if we
convert an integer into a float, the position of the highest set bit can be read off the exponent. By isolating
the lowest bit before that operation, the index can be found with the same trick. However, the conversion
between integers and floats is usually slow. Further, the technique is highly machine dependent.

1.6

Operations on high bits or blocks of a word

For functions operating on the highest bit there is no method as trivial as shown for the lower end of the
word. With a bit-reverse CPU-instruction available life would be significantly easier. However, almost
no CPU seems to have it.

1.6: Operations on high bits or blocks of a word

1.6.1

15

Isolating the highest one and ﬁnding its index
................1111....1111.111
................1...............
................1111111111111111
11111111111111111...............
15
................................
.............................111
...............................1
...............................1
11111111111111111111111111111111
0
.............................111
................1111....1111.11.
............................1...
................1111....11111111
................................
1111111111111111................
1...............................
1...............1111....1111.111

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

0xf0f7 == word
highest_one
highest_one_01edge
highest_one_10edge
highest_one_idx
low_zeros
low_ones
lowest_one
lowest_one_01edge
lowest_one_10edge
lowest_one_idx
lowest_block
clear_lowest_one
lowest_zero
set_lowest_zero
high_ones
high_zeros
highest_zero
set_highest_zero

1111111111111111....1111....1...
1...............................
11111111111111111111111111111111
1...............................
31
.............................111
................................
............................1...
............................1111
11111111111111111111111111111...
3
............................1...
1111111111111111....1111........
...............................1
1111111111111111....1111....1..1
1111111111111111................
................................
................1...............
11111111111111111...1111....1...

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

0xffff0f08 == word
highest_one
highest_one_01edge
highest_one_10edge
highest_one_idx
low_zeros
low_ones
lowest_one
lowest_one_01edge
lowest_one_10edge
lowest_one_idx
lowest_block
clear_lowest_one
lowest_zero
set_lowest_zero
high_ones
high_zeros
highest_zero
set_highest_zero

Figure 1.6-A: Operations on the highest and lowest bits (and blocks) of a binary word for two diﬀerent
32-bit input words. Dots denote zeros.
Isolation of the highest set bit is easy if a bit-scan instruction is available [FXT: bits/bitasm-i386.h]:
1
2
3
4
5
6

static inline ulong asm_bsr(ulong x)
// Bit Scan Reverse
{
asm ("bsrl %0, %0" : "=r" (x) : "0" (x));
return x;
}

Without a bit-scan instruction, we use the auxiliary function [FXT: bits/bithigh-edge.h]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static inline ulong highest_one_01edge(ulong x)
//
highest set bit to bit 0 are set.
{
x |= x>>1;
x |= x>>2;
x |= x>>4;
x |= x>>8;
x |= x>>16;
#if BITS_PER_LONG >= 64
x |= x>>32;
#endif
return x;
}

The resulting code is [FXT: bits/bithigh.h]

16
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong highest_one(ulong x)
// Return word where only the highest bit in x is set.
{
#if defined BITS_USE_ASM
x = asm_bsr(x);
return 1UL<<x;
#else
x = highest_one_01edge(x);
return x ^ (x>>1);
#endif // BITS_USE_ASM
}

To determine the index of the highest set bit, use
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

static inline ulong highest_one_idx(ulong x)
// Return index of highest bit set.
{
return asm_bsr(x);
#else // BITS_USE_ASM
if ( 0==x )

return

0;

ulong r = 0;
BITS_PER_LONG >= 64
if ( x & 0xffffffff00000000UL ) { x >>= 32; r += 32; }
#endif
if ( x & 0xffff0000UL ) { x >>= 16; r += 16; }
if ( x & 0x0000ff00UL ) { x >>= 8; r += 8; }
if ( x & 0x000000f0UL ) { x >>= 4; r += 4; }
if ( x & 0x0000000cUL ) { x >>= 2; r += 2; }
if ( x & 0x00000002UL ) {
r += 1; }
return r;
#endif // BITS_USE_ASM
}
#if

The branches in the non-assembler part of the routine can be avoided by a technique given in [215, rel.96,
sect.7.1.3] (version for 64-bit words):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

{
#define MU0 0x5555555555555555UL // MU0 == ((-1UL)/3UL) == ...01010101_2
#define MU1 0x3333333333333333UL // MU1 == ((-1UL)/5UL)
== ...00110011_2
#define MU2 0x0f0f0f0f0f0f0f0fUL // MU2 == ((-1UL)/17UL) == ...00001111_2
#define MU3 0x00ff00ff00ff00ffUL // MU3 == ((-1UL)/257UL) == (8 ones)
#define MU4 0x0000ffff0000ffffUL // MU4 == ((-1UL)/65537UL) == (16 ones)
#define MU5 0x00000000ffffffffUL // MU5 == ((-1UL)/4294967297UL) == (32 ones)
ulong r = ld_neq(x, x & MU0)
+ (ld_neq(x, x & MU1) << 1)
+ (ld_neq(x, x & MU2) << 2)
+ (ld_neq(x, x & MU3) << 3)
+ (ld_neq(x, x & MU4) << 4)
+ (ld_neq(x, x & MU5) << 5);
return r;
}

The auxiliary function ld_neq() is given in [FXT: bits/bitldeq.h]:
1
2
3

static inline bool ld_neq(ulong x, ulong y)
// Return whether floor(log2(x))!=floor(log2(y))
{ return ( (x^y) > (x&y) ); }

The following version for 64-bit words provided by Sebastiano Vigna [priv. comm.] is an implementation
of Brodal’s algorithm [215, alg.B, sect.7.1.3]:
1
2
3
4
5
6
7
8
9

{
if ( x == 0 ) return 0;
ulong r = 0;
if ( x & 0xffffffff00000000UL ) { x >>= 32;
if ( x & 0xffff0000UL )
{ x >>= 16;
x |= (x << 16);
x |= (x << 32);
const ulong y = x & 0xff00f0f0ccccaaaaUL;

r += 32; }
r += 16; }

1.7: Functions related to the base-2 logarithm
10
11
12
13
14
15
16

17

const ulong z = 0x8000800080008000UL;
ulong t = z & ( y | (( y | z ) - ( x ^ y )));
t |= (t << 15);
t |= (t << 30);
t |= (t << 60);
return r + ( t >> 60 );
}

1.6.2

Isolating the highest block of ones or zeros

Isolate the left block of zeros with the function
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

static inline ulong high_zeros(ulong x)
// Return word where all the (high end) zeros are set.
// e.g.: 00011001 --> 11100000
// Returns 0 if highest bit is set:
//
11011001 --> 00000000
{
x |= x>>1;
x |= x>>2;
x |= x>>4;
x |= x>>8;
x |= x>>16;
x |= x>>32;
#endif
return ~x;
}

The left block of ones can be isolated using arithmetical right shifts:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

static inline ulong high_ones(ulong x)
// Return word where all the (high end) ones are set.
// e.g. 11001011 --> 11000000
// Returns 0 if highest bit is zero:
//
01110110 --> 00000000
{
long y = (long)x;
y &= y>>1;
y &= y>>2;
y &= y>>4;
y &= y>>8;
y &= y>>16;
y &= y>>32;
#endif
return (ulong)y;
}

If arithmetical shifts are more expensive than unsigned shifts, use
1

static inline ulong high_ones(ulong x)

{ return

high_zeros( ~x ); }

A demonstration of selected functions operating on the highest or lowest bit (or block) of binary words
is given in [FXT: bits/bithilo-demo.cc]. Part of its output is shown in ﬁgure 1.6-A.

1.7

Functions related to the base-2 logarithm

The following functions are given in [FXT: bits/bit2pow.h]. A function that returns log2 (x) can be
implemented using the obvious algorithm:
1
2
3
4
5
6
7
8
9

static inline ulong ld(ulong x)
// Return floor(log2(x)),
// i.e. return k so that 2^k <= x < 2^(k+1)
// If x==0, then 0 is returned (!)
{
ulong k = 0;
while ( x>>=1 ) { ++k; }
return k;
}

The result is the same as returned by highest_one_idx():

18
1

static inline ulong ld(ulong x) { return

highest_one_idx(x); }

The bit-wise algorithm can be faster if the average result is known to be small.
Use the function one_bit_q() to determine whether its argument is a power of 2:
1
2
3
4
5
6

static inline bool one_bit_q(ulong x)
// Return whether x in {1,2,4,8,16,...}
{
ulong m = x-1;
return (((x^m)>>1) == m);
}

The following function does the same except that it returns true also for the zero argument:
1
2
3

static inline bool is_pow_of_2(ulong x)
// Return whether x == 0(!) or x == 2**k
{ return !(x & (x-1)); }

With FFTs where the length of the transform is often restricted to power of 2 the following functions are
useful:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

static inline ulong next_pow_of_2(ulong x)
// Return x if x=2**k
// else return 2**ceil(log_2(x))
// Exception: returns 0 for x==0
{
if ( is_pow_of_2(x) ) return x;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x |= x >> 32;
#endif
return x + 1;
}

1
2
3
4
5
6
7

static inline ulong next_exp_of_2(ulong x)
// Return k if x=2**k else return k+1.
// Exception: returns 0 for x==0.
{
if ( x <= 1 ) return 0;
return ld(x-1) + 1;
}

The following version should be faster if inline assembler is used for ld():
1
2
3
4
5
6

static inline ulong next_pow_of_2(ulong x)
{
if ( is_pow_of_2(x) ) return x;
ulong n = 1UL<<ld(x); // n<x
return n<<1;
}

The following routine for comparison of base-2 logarithms without actually computing them is suggested
by [215, rel.58, sect.7.1.3] [FXT: bits/bitldeq.h]:
1
2
3

static inline bool ld_eq(ulong x, ulong y)
// Return whether floor(log2(x))==floor(log2(y))
{ return ( (x^y) <= (x&y) ); }

1.8

Counting the bits and blocks of a word

The following functions count the ones in a binary word. They need O (log2 (BITS PER LONG)) operations.
We give mostly the 64-bit versions [FXT: bits/bitcount.h]:
1
2
3
4
5
6
7

static inline ulong bit_count(ulong x)
// Return number of bits set
{
x = (0x5555555555555555UL & x) + (0x5555555555555555UL
x = (0x3333333333333333UL & x) + (0x3333333333333333UL
x = (0x0f0f0f0f0f0f0f0fUL & x) + (0x0f0f0f0f0f0f0f0fUL
x = (0x00ff00ff00ff00ffUL & x) + (0x00ff00ff00ff00ffUL

&
&
&
&

(x>>
(x>>
(x>>
(x>>

1));
2));
4));
8));

//
//
//
//

0-2 in 2 bits
0-4 in 4 bits
0-8 in 8 bits
0-16 in 16 bits

1.8: Counting the bits and blocks of a word
8
9
10
11

x = (0x0000ffff0000ffffUL & x) + (0x0000ffff0000ffffUL & (x>>16));
x = (0x00000000ffffffffUL & x) + (0x00000000ffffffffUL & (x>>32));
return x;

19
// 0-32 in 32 bits
// 0-64 in 64 bits

}

The underlying idea is to do a search via bit masks. The code can be improved to either
1
2
3
4
5
6
7

x = ((x>>1) & 0x5555555555555555UL) + (x & 0x5555555555555555UL);
x = ((x>>2) & 0x3333333333333333UL) + (x & 0x3333333333333333UL);
x = ((x>>4) + x) & 0x0f0f0f0f0f0f0f0fUL;
x += x>> 8;
x += x>>16;
x += x>>32;
return x & 0xff;

//
//
//
//
//
//

0-2 in 2 bits
0-4 in 4 bits
0-8 in 8 bits
0-16 in 8 bits
0-32 in 8 bits
0-64 in 8 bits

or (taken from [10])
1
2
3
4
5

x -= (x>>1) & 0x5555555555555555UL;
x = ((x>>2) & 0x3333333333333333UL) + (x & 0x3333333333333333UL);
x = ((x>>4) + x) & 0x0f0f0f0f0f0f0f0fUL;
x *= 0x0101010101010101UL;
return x>>56;

// 0-2 in 2 bits
// 0-4 in 4 bits
// 0-8 in 8 bits

Which of the latter two versions is faster mainly depends on the speed of integer multiplication.
The following code for 32-bit words (given by Johan R¨nnblom [priv. comm.]) may be advantageous if
o
loading constants is expensive. Note some constants are in octal notation:
1
2
3
4
5
6
7
8
9

static inline uint CountBits32(uint a)
{
uint mask = 011111111111UL;
a = (a - ((a&~mask)>>1)) - ((a>>2)&mask);
a += a>>3;
a = (a & 070707) + ((a>>18) & 070707);
a *= 010101;
return ((a>>12) & 0x3f);
}

If the table holds the bit-counts of the numbers 0. . . 255, then the bits can be counted as follows:
1
2
3
4
5
6
7
8
9

ulong bit_count(ulong x)
{
unsigned char ct = 0;
ct += tab[ x & 0xff ];
x >>= 8;
x >>= 8;
[--snip--] /* BYTES_PER_LONG times */
return ct;
}

However, while table driven methods tend to excel in synthetic benchmarks, they can be very slow if they
cause cache misses.
We give a method to count the bits of a word of a special form:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

static inline ulong bit_count_01(ulong x)
// Return number of bits in a word
// for words of the special form 00...0001...11
{
ulong ct = 0;
ulong a;
a = (x & (1UL<<32)) >> (32-5); // test bit 32
x >>= a; ct += a;
#endif
a = (x & (1UL<<16)) >> (16-4); // test bit 16
x >>= a; ct += a;
a = (x & (1UL<<8)) >> (8-3);
x >>= a; ct += a;

// test bit 8

a = (x & (1UL<<4)) >> (4-2);
x >>= a; ct += a;

// test bit 4

a = (x & (1UL<<2)) >> (2-1);
x >>= a; ct += a;

// test bit 2

a = (x & (1UL<<1)) >> (1-0);

// test bit 1

20
24
25
26
27
28
29

x >>= a;

ct += a;

ct += x & 1; // test bit 0
return ct;
}

All branches are avoided, thereby the code may be useful on a planet with pink air, for further details
see [301].

1.8.1

Sparse counting

If the (average input) word is known to have only a few bits set, the following sparse count variant can
be advantageous:
1
2
3
4
5
6
7

static inline ulong bit_count_sparse(ulong x)
// Return number of bits set.
{
ulong n = 0;
while ( x ) { ++n; x &= (x-1); }
return n;
}

The loop will execute once for each set bit. Partial unrolling of the loop should be an improvement for
most cases:
1
2
3
4
5
6
7
8
9
10

ulong n = 0;
do
{
n += (x!=0);
n += (x!=0);
n += (x!=0);
n += (x!=0);
}
while ( x );
return n;

x
x
x
x

&=
&=
&=
&=

(x-1);
(x-1);
(x-1);
(x-1);

If the number of bits is close to the maximum, use the given routine with the complement:
1
2
3
4
5
6
7

static inline ulong bit_count_dense(ulong x)
// Return number of bits set.
// The loop (of bit_count_sparse()) will execute once for
//
each unset bit (i.e. zero) of x.
{
return BITS_PER_LONG - bit_count_sparse( ~x );
}

If the number of ones is guaranteed to be less than 16, then the following routine (suggested by Gunther
Piez [priv. comm.]) can be used:
1
2
3
4
5
6
7
8

// Return number of set bits, must have at most 15 set bits.
{
x -= (x>>1) & 0x5555555555555555UL;
x = ((x>>2) & 0x3333333333333333UL) + (x & 0x3333333333333333UL);
x *= 0x1111111111111111UL;
return x>>60;
}

A routine for words with no more than 3 set bits is
1
2
3
4
5
6

{
x -= (x>>1) & 0x5555555555555555UL;
x *= 0x5555555555555555UL;
return x>>62;
}

1.8.2

// 0-2 in 2 bits

Counting blocks

Compute the number of bit-blocks in a binary word with the following function:
1
2
3
4

static inline ulong bit_block_count(ulong x)
// Return number of bit blocks.
// E.g.:
// ..1..11111...111. -> 3

// 0-2 in 2 bits
// 0-4 in 4 bits

1.8: Counting the bits and blocks of a word
5
6
7
8
9
10

// ...1..11111...111
// ......1.....1.1..
// .........111.1111
{
return (x & 1) +
}

21

-> 3
-> 3
-> 2
bit_count( (x^(x>>1)) ) / 2;

Similarly, the number of blocks with two or more bits can be counted via:
1
2
3
4
5
6
7
8
9
10

static inline ulong bit_block_ge2_count(ulong x)
// Return number of bit blocks with at least 2 bits.
// E.g.:
// ..1..11111...111. -> 2
// ...1..11111...111 -> 2
// ......1.....1.1.. -> 0
// .........111.1111 -> 2
{
return bit_block_count( x & ( (x<<1) & (x>>1) ) );
}

1.8.3

GCC built-in functions ‡

Newer versions of the C compiler of the GNU Compiler Collection (GCC [146], starting with version 3.4)
include a function __builtin_popcountl(ulong) that counts the bits of an unsigned long integer. The
following list is taken from [147]:
int __builtin_ffs (unsigned int x)
Returns one plus the index of the least significant 1-bit of x,
or if x is zero, returns zero.
int __builtin_clz (unsigned int x)
Returns the number of leading 0-bits in x, starting at the
most significant bit position. If x is 0, the result is undefined.
int __builtin_ctz (unsigned int x)
Returns the number of trailing 0-bits in x, starting at the
least significant bit position. If x is 0, the result is undefined.
int __builtin_popcount (unsigned int x)
Returns the number of 1-bits in x.
int __builtin_parity (unsigned int x)
Returns the parity of x, i.e. the number of 1-bits in x modulo 2.

The names of the corresponding versions for arguments of type unsigned long are obtained by adding ‘l’
(ell) to the names, for the type unsigned long long append ‘ll’. Two more useful built-ins are:
void __builtin_prefetch (const void *addr, ...)
Prefetch memory location addr
long __builtin_expect (long exp, long c)
Function to provide the compiler with branch prediction information.

1.8.4

Counting the bits of many words ‡

x[ 0]=11111111
x[ 1]=11111111
x[ 2]=11111111
x[ 3]=11111111
x[ 4]=11111111
x[ 5]=11111111
x[ 6]=11111111
x[ 7]=11111111
x[ 8]=11111111
x[ 9]=11111111
x[10]=11111111
x[11]=11111111
x[12]=11111111
x[13]=11111111
x[14]=11111111
x[15]=11111111
x[16]=11111111

a0=11111111
a0=........
a0=11111111
a0=........
a0=11111111
a0=........
a0=11111111
a0=........
a0=11111111
a0=........
a0=11111111
a0=........
a0=11111111
a0=........
a0=11111111
a0=........
a0=11111111

a1=........
a1=11111111
a1=11111111
a1=........
a1=........
a1=11111111
a1=11111111
a1=........
a1=........
a1=11111111
a1=11111111
a1=........
a1=........
a1=11111111
a1=11111111
a1=........
a1=........

a2=........
a2=........
a2=........
a2=11111111
a2=11111111
a2=11111111
a2=11111111
a2=........
a2=........
a2=........
a2=........
a2=11111111
a2=11111111
a2=11111111
a2=11111111
a2=........
a2=........

a3=........
a3=........
a3=........
a3=........
a3=........
a3=........
a3=........
a3=11111111
a3=11111111
a3=11111111
a3=11111111
a3=11111111
a3=11111111
a3=11111111
a3=11111111
a3=........
a3=........

a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=........
a4=11111111
a4=11111111

Figure 1.8-A: Counting the bits of an array (where all bits are set) via vertical addition.

22


For counting the bits in a long array the technique of vertical addition can be useful. For ordinary
addition the following relation holds:
a + b

==

(a^b) + ((a&b)<<1)

The carry term (a&b) is propagated to the left. We now replace this ‘horizontal’ propagation by a ‘vertical’
one, that is, propagation into another word. An implementation of this idea is [FXT: bits/bitcount-vdemo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ulong
bit_count_leq31(const ulong *x, ulong n)
// Return sum(j=0, n-1, bit_count(x[j]) )
// Must have n<=31
{
ulong a0=0, a1=0, a2=0, a3=0, a4=0;
//
1,
3,
7,
15,
31, <--=
for (ulong k=0; k<n; ++k)
{
ulong cy = x[k];
{ ulong t = a0 & cy; a0 ^= cy; cy =
{ a4 ^= cy; }
// [ PRINT x[k], a0, a1, a2, a3, a4 ]
}

max n

t;
t;
t;
t;

}
}
}
}

ulong b = bit_count(a0);
b += (bit_count(a1)<<1);
return b;
}

Figure 1.8-A shows the intermediate values with the computation of a length-17 array of all-ones words.
After the loop the values of the variables a0, . . . , a4 are
a4=11111111
a3=........
a2=........
a1=........
a0=11111111

The columns, read as binary numbers, tell us that in all positions of all words there were a total of
17 = 100012 bits. The remaining instructions compute the total bit-count.
After some simpliﬁcations and loop-unrolling a routine for counting the bits of 15 words can be given as
[FXT: bits/bitcount-v.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

static inline ulong bit_count_v15(const ulong *x)
// Return sum(j=0, 14, bit_count(x[j]) )
// Technique is "vertical" addition.
{
#define VV(A) { ulong t = A & cy; A ^= cy; cy = t; }
ulong a1, a2, a3;
ulong a0=x[0];
{ ulong cy = x[ 1]; VV(a0); a1 = cy; }
{ ulong cy = x[ 2]; VV(a0); a1 ^= cy; }
{ ulong cy = x[ 3]; VV(a0); VV(a1); a2 = cy; }
{ ulong cy = x[ 4]; VV(a0); VV(a1); a2 ^= cy; }
{ ulong cy = x[ 7]; VV(a0); VV(a1); VV(a2); a3
{ ulong cy = x[10]; VV(a0); VV(a1); VV(a2); a3
#undef VV
ulong b = bit_count(a0);

= cy; }
^= cy; }
^= cy; }
^= cy; }
^= cy; }
^= cy; }
^= cy; }
^= cy; }

1.9: Words as bitsets
26
27
28
29

23

return b;
}

Each of the macros VV gives three machine instructions, one AND, XOR, and MOVE. The routine for
the user is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ulong
bit_count_v(const ulong *x, ulong n)
// Return sum(j=0, n-1, bit_count(x[j]) )
{
ulong b = 0;
const ulong *xe = x + n + 1;
while ( x+15 < xe ) // process blocks of 15 elements
{
b += bit_count_v15(x);
x += 15;
}
// process remaining elements:
const ulong r = (ulong)(xe-x-1);
for (ulong k=0; k<r; ++k) b+=bit_count(x[k]);
return

b;

}

Compared to the obvious method of bit-counting
1
2
3
4
5
6

ulong bit_count_v2(const ulong *x, ulong n)
{
ulong b = 0;
for (ulong k=0; k<n; ++k) b += bit_count(x[k]);
return b;
}

our routine uses roughly 30 percent less time when an array of 100,000,000 words is processed. There
are many possible modiﬁcations of the method. If the bit-count routine is rather slow, one may want to
avoid the four calls to it after the processing of every 15 words. Instead, the variables a0, . . . , a3 could
be added (vertically!) to an array of more elements. If that array has n elements, then only with each
block of 2n − 1 words n calls to the bit-count routine are necessary.

1.9
1.9.1

Words as bitsets
Testing whether subset of given bitset

The following function tests whether a word u, as a bitset, is a subset of the bitset given as the word e
[FXT: bits/bitsubsetq.h]:
1
2
3
4
5
6
7
8

static inline bool is_subset(ulong u, ulong e)
// Return whether the set bits of u are a subset of the set bits of e.
// That is, as bitsets, test whether u is a subset of e.
{
return ( (u & e)==u );
//
return ( (u & ~e)==0 );
//
return ( (~u | e)!=0 );
}

If u contains any bits not set in e, then these bits are cleared in the AND-operation and the test for
equality will fail. The second version tests whether no element of u lies outside of e, the third is obtained
by complementing the equality. A proper subset of e is a subset = e:
1
2
3
4
5

static inline bool is_proper_subset(ulong u, ulong e)
// Return whether u (as bitset) is a proper subset of e.
{
return ( (u<e) && ((u & e)==u) );
}

The generated machine code contains a branch:
101
102

xorl
cmpq

%eax, %eax
%rsi, %rdi

# prephitmp.71
# e, u

24


103
104
106
107
108

jae
andq
xorl
cmpq
sete

.L6
%rdi, %rsi
%eax, %eax
%rdi, %rsi
%al

#, /* branch to end of function */
# u, e
# prephitmp.71
# u, e
#, prephitmp.71

Replace the Boolean operator ‘&&’ by the bit-wise operator ‘&’ to obtain branch-free machine code:
101
102
103
105
106
107
108

1.9.2

cmpq
setb
andq
cmpq
sete
andl
movzbl

%rsi, %rdi
%al
%rdi, %rsi
%rdi, %rsi
%dl
%edx, %eax
%al, %eax

# e, u
#, tmp63
# u, e
# u, e
#, tmp66
# tmp66, tmp63
# tmp63, tmp61

Testing whether an element is in a given set

We determine whether a given number is an element of a given set (which must be a subset of the set
{0, 1, 2, . . . , BITS_PER_LONG−1}). For example, to determine whether x is a prime less than 32, use the
function
1
2
3
4
5

ulong m = (1UL<<2) | (1UL<<3) | (1UL<<5) | ... | (1UL<<31);
static inline ulong is_tiny_prime(ulong x)
{
return m & (1UL << x);
}

// precomputed

The same idea can be applied to look up tiny factors [FXT: bits/tinyfactors.h]:
1
2
3
4
5
6
7
8

static inline bool is_tiny_factor(ulong x, ulong d)
// For x,d < BITS_PER_LONG (!)
// return whether d divides x (1 and x included as divisors)
// no need to check whether d==0
//
{
return ( 0 != ( (tiny_factors_tab[x]>>d) & 1 ) );
}

The function uses the precomputed array [FXT: bits/tinyfactors.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

extern const ulong tiny_factors_tab[]
{
0x0UL, // x = 0:
0x2UL, // x = 1:
0x6UL, // x = 2:
0xaUL, // x = 3:
0x16UL, // x = 4:
0x22UL, // x = 5:
0x4eUL, // x = 6:
0x82UL, // x = 7:
0x116UL, // x = 8:
0x20aUL, // x = 9:
[--snip--]
0x20000002UL, // x = 29:
0x4000846eUL, // x = 30:
0x80000002UL, // x = 31:
#if ( BITS_PER_LONG > 32 )
0x100010116UL, // x = 32:
0x20000080aUL, // x = 33:
[--snip--]
0x2000000000000002UL, // x = 61:
0x4000000080000006UL, // x = 62:
0x800000000020028aUL
// x = 63:
#endif // ( BITS_PER_LONG > 32 )
};

=
1
1
1
1
1
1
1
1
1

2
3
2
5
2
7
2
3

4
3 6

(
(
(
(
(
(
(
(

bits:
bits:
bits:
bits:
bits:
bits:
bits:
bits:

........)
......1.)
.....11.)
....1.1.)
...1.11.)
..1...1.)
.1..111.)
1.....1.)

4 8
9

1 29
1 2 3 5 6 10 15 30
1 31
1 2 4 8 16 32
1 3 11 33
1 61
1 2 31 62
1 3 7 9 21 63

Bit-arrays of arbitrary size are discussed in section 4.6 on page 164.

1.10: Index of the i-th set bit

1.10

25

Index of the i-th set bit

To determine the index of the i-th set bit, we use a technique similar to the method for counting the bits
of a word. Only the 64-bit version is shown [FXT: bits/ith-one-idx.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

static inline ulong ith_one_idx(ulong x, ulong i)
// Return index of the i-th set bit of x where 0 <= i < bit_count(x).
{
ulong x2 = x - ((x>>1) & 0x5555555555555555UL);
// 0-2 in 2 bits
ulong x4 = ((x2>>2) & 0x3333333333333333UL) +
(x2 & 0x3333333333333333UL);
// 0-4 in 4 bits
ulong x8 = ((x4>>4) + x4) & 0x0f0f0f0f0f0f0f0fUL; // 0-8 in 8 bits
ulong ct = (x8 * 0x0101010101010101UL) >> 56;
// bit count
++i;
if ( ct >8));
ulong x32 = (0x0000ffff0000ffffUL & x16) + (0x0000ffff0000ffffUL & (x16>>16));

// 0-16
// 0-32

ulong w, s = 0;
w = x32 & 0xffffffffUL;
if ( w >= s;
w = x16 & 0xffff;
if ( w >= s;
w = x8 & 0xff;
if ( w >= s;
w = x4 & 0xf;
if ( w >= s;
w = x2 & 3;
if ( w >= s;
s += ( (x&1) != i );
return s;
}

1.11

Avoiding branches

Branches are expensive operations with many CPUs, especially if the CPU pipeline is very long. A useful
trick is to replace
if ( (x<0) || (x>m) )

{ ... }

where x might be a signed integer, by
if ( (unsigned)x > m )

{ ... }

The obvious code to test whether a point (x, y) lies outside a square box of size m is
if ( (x<0) || (x>m) || (y<0) || (y>m) )

{ ... }

If m is a power of 2, it is better to use
if ( ( (ulong)x | (ulong)y ) > (unsigned)m )

{ ... }

The following functions are given in [FXT: bits/branchless.h]. This function returns max(0, x). That is,
zero is returned for negative input, else the unmodiﬁed input:
1
2
3
4

static inline long max0(long x)
{
return x & ~(x >> (BITS_PER_LONG-1));
}

There is no restriction on the input range. The trick used is that with negative x the arithmetic shift will
give a word of all ones which is then negated and the AND-operation clears all bits. Note this function

26


will only work if the compiler emits an arithmetic right shift, see section 1.1.3 on page 3. The following
routine computes min(0, x):
1
2
3
4
5

static inline long min0(long x)
// Return min(0, x), i.e. return zero for positive input
{
return x & (x >> (BITS_PER_LONG-1));
}

The following upos_*() functions only work for a limited range. The highest bit must not be set as it is
used to emulate the carry flag. Branchless computation of the absolute difference |a − b|:
1
2
3
4
5
6

static inline ulong upos_abs_diff(ulong a, ulong b)
{
long d1 = b - a;
long d2 = (d1 & (d1>>(BITS_PER_LONG-1)))<<1;
return d1 - d2; // == (b - d) - (a + d);
}

The following routine sorts two values:
1
2
3
4
5
6
7
8
9

static inline void upos_sort2(ulong &a, ulong &b)
// Set {a, b} := {min(a, b), max(a,b)}
// Both a and b must not have the most significant bit set
{
long d = b - a;
d &= (d>>(BITS_PER_LONG-1));
a += d;
b -= d;
}

Johan R¨nnblom gives [priv. comm.] the following versions for signed integer minimum, maximum, and
o
absolute value, that can be advantageous for CPUs where immediates are expensive:
1
2
3
4

#define
#define
#define
#define

B1 (BITS_PER_LONG-1) // bits of signed int minus
MINI(x,y) (((x) & (((int)((x)-(y)))>>B1)) + ((y)
MAXI(x,y) (((x) & ~(((int)((x)-(y)))>>B1)) + ((y)
ABSI(x)
(((x) & ~(((int)(x))>>B1))
- ((x)

one
& ~(((int)((x)-(y)))>>B1)))
& (((int)((x)-(y))>>B1))))
& (((int)(x))>>B1)))

Your compiler may be smarter than you thought
The machine code generated for
x =

x & ~(x >> (BITS_PER_LONG-1));

// max0()

is
35:
37:
3b:
3e:

48
48
48
48

99
83 c4 08
f7 d2
21 d0

cqto
add
not
and

$0x8,%rsp
%rdx
%rdx,%rax

// stack adjustment

The variable x resides in the register rAX both at start and end of the function. The compiler uses a
special (AMD64) instruction cqto. Quoting [13]:
Copies the sign bit in the rAX register to all bits of the rDX register. The effect of this
instruction is to convert a signed word, doubleword, or quadword in the rAX register into
a signed doubleword, quadword, or double-quadword in the rDX:rAX registers. This action
helps avoid overflow problems in signed number arithmetic.
Now the equivalent
x = ( x<0 ? 0 : x );

// max0()

"simple minded"

is compiled to:
35:
3a:
3d:

ba 00 00 00 00
48 85 c0
48 0f 48 c2

mov
test
cmovs

$0x0,%edx
%rax,%rax
%rdx,%rax // note %edx is %rdx

A conditional move (cmovs) instruction is used here. That is, the optimized version is (on my machine)
actually worse than the straightforward equivalent.

1.12: Bit-wise rotation of a word

27

A second example is a function to adjust a given value when it lies outside a given range [FXT:
bits/branchless.h]:
1
2
3
4
5
6
7
8
9
10

static inline long clip_range(long x, long mi, long ma)
// Code equivalent to (for mi<=ma):
//
if ( x<mi ) x = mi;
//
else if ( x>ma ) x = ma;
{
x -= mi;
x = clip_range0(x, ma-mi);
x += mi;
return x;
}

The auxiliary function used involves one branch:
1
2
3
4
5
6
7
8
9

static inline long clip_range0(long x, long m)
// Code equivalent (for m>0) to:
//
if ( x<0 ) x = 0;
//
else if ( x>m ) x = m;
//
return x;
{
if ( (ulong)x > (ulong)m ) x = m & ~(x >> (BITS_PER_LONG-1));
return x;
}

The generated machine code is
0:
3:
6:
8:
b:
d:
10:
13:
17:

48
48
31
48
78
48
48
48
48

89
29
c9
29
0a
39
89
0f
8d

f8
f2
f0
d0
d1
4e c8
04 0e

mov
sub
xor
sub
js
cmp
mov
cmovle
lea

%rdi,%rax
%rsi,%rdx
%ecx,%ecx
%rsi,%rax
17 <_Z2CLlll+0x17>
%rdx,%rax
%rdx,%rcx
%rax,%rcx
(%rsi,%rcx,1),%rax

// the branch

Now we replace the code by
1
2
3
4
5
6
7
8
9
10
11

static inline long clip_range(long x, long mi, long ma)
{
x -= mi;
if ( x<0 ) x = 0;
//
else // commented out to make (compiled) function really branchless
{
ma -= mi;
if ( x>ma ) x = ma;
}
x += mi;
}

Then the compiler generates branchless code:
0:
3:
8:
b:
f:
12:
15:
19:

48
b9
48
48
48
48
48
48

89
00
29
0f
29
39
0f
01

f8
00 00 00
f0
48 c1
f2
d0
4f c2
f0

mov
mov
sub
cmovs
sub
cmp
cmovg
add

%rdi,%rax
$0x0,%ecx
%rsi,%rax
%rcx,%rax
%rsi,%rdx
%rdx,%rax
%rdx,%rax
%rsi,%rax

Still, with CPUs that do not have a conditional move instruction (or some branchless equivalent of it)
the techniques shown in this section can be useful.

1.12

Bit-wise rotation of a word

Neither C nor C++ have a statement for bit-wise rotation of a binary word (which may be considered a
missing feature). The operation can be emulated via [FXT: bits/bitrotate.h]:
1
2
3

static inline ulong bit_rotate_left(ulong x, ulong r)
// Return word rotated r bits to the left
// (i.e. toward the most significant bit)

28
4
5
6

{
return

(x<<r) | (x>>(BITS_PER_LONG-r));

}

As already mentioned, GCC emits exactly the CPU instruction that is meant here, even with non-constant
argument r. Explicit use of the corresponding assembler instruction should not do any harm:
1
2
3
4
5
6
7
8
9
10

static inline ulong bit_rotate_right(ulong x, ulong r)
// Return word rotated r bits to the right
// (i.e. toward the least significant bit)
{
// use x86 asm code
return asm_ror(x, r);
#else
return (x>>r) | (x<<(BITS_PER_LONG-r));
#endif
}

Here we use an assembler instruction when available [FXT: bits/bitasm-amd64.h]:
1
2
3
4
5

static inline ulong asm_ror(ulong x, ulong r)
{
asm ("rorq
%%cl, %0" : "=r" (x) : "0" (x), "c" (r));
return x;
}

Rotation using only a part of the word length can be implemented as
1
2
3
4
5
6
7
8
9
10
11

static inline ulong bit_rotate_left(ulong x, ulong r, ulong ldn)
// Return ldn-bit word rotated r bits to the left
// (i.e. toward the most significant bit)
// Must have 0 <= r <= ldn
{
ulong m = ~0UL >> ( BITS_PER_LONG - ldn );
x &= m;
x = (x<<r) | (x>>(ldn-r));
x &= m;
return x;
}

and
1
2
3
4
5
6
7
8
9
10
11

static inline ulong bit_rotate_right(ulong x, ulong r, ulong ldn)
// Return ldn-bit word rotated r bits to the right
// (i.e. toward the least significant bit)
// Must have 0 <= r <= ldn
{
ulong m = ~0UL >> ( BITS_PER_LONG - ldn );
x &= m;
x = (x>>r) | (x<<(ldn-r));
x &= m;
return x;
}

Finally, the functions
1
2
3
4
5
6

static inline ulong bit_rotate_sgn(ulong x, long r, ulong ldn)
// Positive r --> shift away from element zero
{
if ( r > 0 ) return bit_rotate_left(x, (ulong)r, ldn);
else
return bit_rotate_right(x, (ulong)-r, ldn);
}

and (full-word version)
1
2
3
4
5
6

static inline ulong bit_rotate_sgn(ulong x, long r)
// Positive r --> shift away from element zero
{
if ( r > 0 ) return bit_rotate_left(x, (ulong)r);
else
return bit_rotate_right(x, (ulong)-r);
}

are sometimes convenient.

1.13: Binary necklaces ‡

29

Binary necklaces ‡

1.13

We give several functions related to cyclic rotations of binary words and a class to generate binary
necklaces.

1.13.1

Cyclic matching, minimum, and maximum

The following function determines whether there is a cyclic right shift of its second argument so that it
matches the ﬁrst argument. It is given in [FXT: bits/bitcyclic-match.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

static inline ulong bit_cyclic_match(ulong x, ulong y)
// Return r if x==rotate_right(y, r) else return ~0UL.
// In other words: return
//
how often the right arg must be rotated right (to match the left)
// or, equivalently:
//
how often the left arg must be rotated left (to match the right)
{
ulong r = 0;
do
{
if ( x==y ) return r;
y = bit_rotate_right(y, 1);
}
while ( ++r < BITS_PER_LONG );
return ~0UL;
}

The functions shown work on the full length of the words, equivalents for the sub-word of the lowest ldn
bits are given in the respective ﬁles. Just one example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong bit_cyclic_match(ulong x, ulong y, ulong ldn)
// Return r if x==rotate_right(y, r, ldn) else return ~0UL
// (using ldn-bit words)
{
ulong r = 0;
do
{
y = bit_rotate_right(y, 1, ldn);
}
while ( ++r < ldn );
return ~0UL;
}

The minimum among all cyclic shifts of a word can be computed via the following function given in [FXT:
bits/bitcyclic-minmax.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong bit_cyclic_min(ulong x)
// Return minimum of all rotations of x
{
ulong r = 1;
ulong m = x;
do
{
x = bit_rotate_right(x, 1);
if ( x<m ) m = x;
}
while ( ++r < BITS_PER_LONG );
return
}

m;

30


1.13.2

Cyclic period and binary necklaces

Selecting from all n-bit words those that are equal to their cyclic minimum gives the sequence of the
binary length-n necklaces, see chapter 18 on page 370. For example, with 6-bit words we ﬁnd:
word
......
.....1
....11
...1.1
...111
..1..1
..1.11

period
1
6
6
6
6
3
6

word
..11.1
..1111
.1.1.1
.1.111
.11.11
.11111
111111

period
6
6
2
6
3
6
1

The values in each right column can be computed using [FXT: bits/bitcyclic-period.h]:
1
2
3
4
5
6
7
8

static inline ulong bit_cyclic_period(ulong x, ulong ldn)
// Return minimal positive bit-rotation that transforms x into itself.
// (using ldn-bit words)
// The returned value is a divisor of ldn.
{
ulong y = bit_rotate_right(x, 1, ldn);
return bit_cyclic_match(x, y, ldn) + 1;
}

It is possible to completely avoid the rotation of partial words: let d be a divisor of the word length n.
Then the rightmost (n − 1) d bits of the word computed as x^(x>>d) are zero if and only if the word has
period d. So we can use the following function body:
1
2
3
4
5
6
7

ulong sl = BITS_PER_LONG-ldn;
for (ulong s=1; s<ldn; ++s)
{
++sl;
if ( 0==( (x^(x>>s)) << sl ) )
}
return ldn;

return s;

Testing for periods that are not divisors of the word length can be avoided as follows:
1
2
3
4
5
6
7
8
9
10

ulong f = tiny_factors_tab[ldn];
ulong sl = BITS_PER_LONG-ldn;
for (ulong s=1; s<ldn; ++s)
{
++sl;
f >>= 1;
if ( 0==(f&1) ) continue;
if ( 0==( (x^(x>>s)) << sl ) )
}
return ldn;

return s;

The table of tiny factors used is shown in section 1.9.2 on page 24.
The version for ldn==BITS_PER_LONG can be optimized similarly:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static inline ulong bit_cyclic_period(ulong x)
// Return minimal positive bit-rotation that transforms x into itself.
// (same as bit_cyclic_period(x, BITS_PER_LONG) )
//
// The returned value is a divisor of the word length,
//
i.e. 1,2,4,8,...,BITS_PER_LONG.
{
ulong r = 1;
do
{
ulong y = bit_rotate_right(x, r);
r <<= 1;
}
while ( r < BITS_PER_LONG );
return

r;

// == BITS_PER_LONG

}

1.13.3

Generating all binary necklaces

We can generate all necklaces by the FKM algorithm given in section 18.1.1 on page 371. Here we specialize the method for binary words. The words generated are the cyclic maxima [FXT: class bit necklace

1.13: Binary necklaces ‡

31

in bits/bit-necklace.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class bit_necklace
{
public:
ulong a_;
//
ulong j_;
//
ulong n2_; //
ulong j2_; //
ulong n_;
//
ulong mm_; //
ulong tfb_; //

necklace
period of the necklace
bit representing n: n2==2**(n-1)
bit representing j: j2==2**(j-1)
number of bits in words
mask of n ones
for fast factor lookup

public:
bit_necklace(ulong n) { init(n); }
~bit_necklace() { ; }
void init(ulong n)
{
if ( 0==n ) n = 1; // avoid hang
if ( n>=BITS_PER_LONG ) n = BITS_PER_LONG;
n_ = n;
n2_ = 1UL<<(n-1);
mm_ = (~0UL) >> (BITS_PER_LONG-n);
tfb_ = tiny_factors_tab[n] >> 1;
tfb_ |= n2_; // needed for n==BITS_PER_LONG
first();
}
void first()
{
a_ = 0;
j_ = 1;
j2_ = 1;
}
ulong data() const { return a_; }
ulong period() const { return j_; }

The method for computing the successor is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

ulong next()
// Create next necklace.
// Return the period, zero when current necklace is last.
{
if ( a_==mm_ ) { first(); return 0; }
do
{
// next lines compute index of highest zero, same result as
// j_ = highest_zero_idx( a_ ^ (~mm_) );
// but the direct computation is faster:
j_ = n_ - 1;
ulong jb = 1UL << j_;
while ( 0!=(a_ & jb) ) { --j_; jb>>=1; }
j2_ = 1UL << j_;
++j_;
a_ |= j2_;
a_ = bit_copy_periodic(a_, j_, n_);
}
while ( 0==(tfb_ & j2_) );
return

// necklaces only

j_;

}

It uses the following function for periodic copying [FXT: bits/bitperiodic.h]:
1
2
3
4
5
6
7

static inline ulong bit_copy_periodic(ulong a, ulong p, ulong ldn)
// Return word that consists of the lowest p bits of a repeated
// in the lowest ldn bits (higher bits are zero).
// E.g.: if p==3, ldn=7 and a=*****xyz (8-bit), the return 0zxyzxyz.
// Must have p>0 and ldn>0.
{
a &= ( ~0UL >> (BITS_PER_LONG-p) );

32
8
9
10
11

for (ulong s=p; s<ldn; s<<=1) { a |= (a<<s); }
a &= ( ~0UL >> (BITS_PER_LONG-ldn) );
return a;
}

Finally, we can easily detect whether a necklace is a Lyndon word:
1
2
3
4
5
6
7
8
9
10
11

ulong is_lyndon_word()

const

{ return (j2_ & n2_); }

ulong next_lyn()
// Create next Lyndon word.
// Return the period (==n), zero when current necklace is last.
{
if ( a_==mm_ ) { first(); return 0; }
do { next(); } while ( !is_lyndon_word() );
return n_;
}
};

About 54 million necklaces per second are generated (with n = 32), corresponding to a rate of 112 M/s
for pre-necklaces [FXT: bits/bit-necklace-demo.cc].

1.13.4

Computing the cyclic distance

A function to compute the cyclic distance between two words [FXT: bits/bitcyclic-dist.h] is:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

static inline ulong bit_cyclic_dist(ulong a, ulong b)
// Return minimal bitcount of (t ^ b)
// where t runs through the cyclic rotations of a.
{
ulong d = ~0UL;
ulong t = a;
do
{
ulong z = t ^ b;
ulong e = bit_count( z );
if ( e < d ) d = e;
t = bit_rotate_right(t, 1);
}
while ( t!=a );
return d;
}

If the arguments are cyclic shifts of each other, then zero is returned. A version for partial words is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

static inline ulong bit_cyclic_dist(ulong a, ulong b, ulong ldn)
{
ulong d = ~0UL;
const ulong m = (~0UL>>(BITS_PER_LONG-ldn));
b &= m;
a &= m;
ulong t = a;
do
{
ulong z = t ^ b;
ulong e = bit_count( z );
if ( e < d ) d = e;
t = bit_rotate_right(t, 1, ldn);
}
while ( t!=a );
return d;
}

1.13.5

Cyclic XOR and its inverse

The functions [FXT: bits/bitcyclic-xor.h]
1
2
3
4

static inline ulong bit_cyclic_rxor(ulong x)
{
return x ^ bit_rotate_right(x, 1);
}

and

1.14: Reversing the bits of a word
1
2
3
4

33

static inline ulong bit_cyclic_lxor(ulong x)
{
return x ^ bit_rotate_left(x, 1);
}

return a word whose number of set bits is even. A word and its complement produce the same result.
The inverse functions need no rotation at all, the inverse of bit_cyclic_rxor() is the inverse Gray code
(see section 1.16 on page 41):
1
2
3
4
5

static inline ulong bit_cyclic_inv_rxor(ulong x)
// Return v so that bit_cyclic_rxor(v) == x.
{
return inverse_gray_code(x);
}

The argument x must have an even number of bits. If this is the case, the lowest bit of the result is zero.
The complement of the returned value is also an inverse of bit_cyclic_rxor().
The inverse of bit_cyclic_lxor() is the inverse reversed code (see section 1.16.6 on page 45):
1
2
3
4
5

static inline ulong bit_cyclic_inv_lxor(ulong x)
// Return v so that bit_cyclic_lxor(v) == x.
{
return inverse_rev_gray_code(x);
}

We do not need to mask out the lowest bit because for valid arguments (that have an even number of bits)
the high bits of the result are zero. This function can be used to solve the quadratic equation v 2 + v = x
in the finite field GF(2n ) when normal bases are used, see section 42.6.2 on page 903.

1.14

Reversing the bits of a word

The bits of a binary word can efficiently be reversed by a sequence of steps that reverse the order of
certain blocks. For 16-bit words, we need 4 = log2 (16) such steps [FXT: bits/revbin-steps-demo.cc]:
[
[
[
[
[

0
1
3
7
f

1.14.1

1
0
2
6
e

2
3
1
5
d

3
2
0
4
c

4
5
7
3
b

5
4
6
2
a

6
7
5
1
9

7
6
4
0
8

8
9
b
f
7

9
8
a
e
6

a
b
9
d
5

b
a
8
c
4

c
d
f
b
3

d
c
e
a
2

e
f
d
9
1

f
e
c
8
0

]
]
]
]
]

<--=
<--=
<--=
<--=

pairs swapped
groups of 2 swapped
groups of 4 swapped
groups of 8 swapped

Swapping adjacent bit blocks

We need a couple of auxiliary functions given in [FXT: bits/bitswap.h]. Pairs of adjacent bits can be
swapped via
1
2
3
4
5
6
7
8
9
10
11
12

static inline ulong bit_swap_1(ulong x)
// Return x with neighbor bits swapped.
{
ulong m = 0x55555555UL;
#else
ulong m = 0x5555555555555555UL;
#endif
#endif
return ((x & m) << 1) | ((x & (~m)) >> 1);
}

The 64-bit branch is omitted in the following examples. Adjacent groups of 2 bits are swapped by
1
2
3
4
5
6

// Return x with groups of 2 bits swapped.
{
ulong m = 0x33333333UL;
return ((x & m) << 2) | ((x & (~m)) >> 2);
}

Equivalently,

34
1
2
3
4
5
6

{
ulong m = 0x0f0f0f0fUL;
return ((x & m) << 4) | ((x & (~m)) >> 4);
}

and
1
2
3
4
5
6

{
ulong m = 0x00ff00ffUL;
return ((x & m) << 8) | ((x & (~m)) >> 8);
}

When swapping half-words (here for 32-bit architectures)
1
2
3
4
5
6

{
ulong m = 0x0000ffffUL;
return ((x & m) << 16) | ((x & (m<<16)) >> 16);
}

we could also use the bit-rotate function from section 1.12 on page 27, or
return (x << 16) | (x >> 16);

The GCC compiler recognizes that the whole operation is equivalent to a (left or right) word rotation
and indeed emits just a single rotate instruction.

1.14.2

Bit-reversing binary words

The following is a function to reverse the bits of a binary word [FXT: bits/revbin.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong revbin(ulong x)
// Return x with reversed bit order.
{
x = bit_swap_1(x);
x = bit_swap_2(x);
x = bit_swap_4(x);
x = bit_swap_8(x);
x = bit_swap_16(x);
x = bit_swap_32(x);
#endif
return x;
}

The steps after bit_swap_4() correspond to a byte-reverse operation. This operation is just one assembler instruction for many CPUs. The inline assembler with GCC for AMD64 CPUs is given in [FXT:
bits/bitasm-amd64.h]:
1
2
3
4
5

static inline ulong asm_bswap(ulong x)
{
asm ("bswap %0" : "=r" (x) : "0" (x));
return x;
}

We use it for byte reversal if available:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong bswap(ulong x)
// Return word with reversed byte order.
{
#ifdef BITS_USE_ASM
x = asm_bswap(x);
#else
x = bit_swap_8(x);
x = bit_swap_16(x);
x = bit_swap_32(x);
#endif
#endif // def BITS_USE_ASM
return x;

14

35

}

The function actually used for bit reversal is good for both 32 and 64 bit words:
1
2
3
4
5
6
7
8

{
x = bit_swap_1(x);
x = bit_swap_2(x);
x = bit_swap_4(x);
x = bswap(x);
return x;
}

The masks can be generated in the process:
1
2
3
4
5
6
7
8
9
10
11
12

{
ulong s = BITS_PER_LONG >> 1;
ulong m = ~0UL >> s;
while ( s )
{
x = ( (x & m) << s ) ^ ( (x & (~m)) >> s );
s >>= 1;
m ^= (m<<s);
}
return x;
}

The above function will not always beat the obvious, bit-wise algorithm:
1
2
3
4
5
6
7
8
9
10
11

{
ulong r = 0, ldn = BITS_PER_LONG;
while ( ldn-- != 0 )
{
r <<= 1;
r += (x&1);
x >>= 1;
}
return r;
}

Therefore the function
1
2
3
4
5
6
7

static inline ulong revbin(ulong x, ulong ldn)
// Return word with the ldn least significant bits
//
(i.e. bit_0 ... bit_{ldn-1}) of x reversed,
//
the other bits are set to zero.
{
return revbin(x) >> (BITS_PER_LONG-ldn);
}

should only be used if ldn is not too small, else be replaced by the trivial algorithm.
We can use table lookups so that, for example, eight bits are reversed at a time using a 256-byte table.
The routine for full words is
1
2
3
4
5
6
7
8
9
10
11
12

unsigned char revbin_tab[256]; // reversed 8-bit words
ulong revbin_t(ulong x)
{
ulong r = 0;
for (ulong k=0; k<BYTES_PER_LONG; ++k)
{
r <<= 8;
r |= revbin_tab[ x & 255 ];
x >>= 8;
}
return r;
}

The routine can be optimized by unrolling to avoid all branches:
1
2
3
4
5
6

static inline ulong revbin_t(ulong
{
ulong r
= revbin_tab[ x &
r <<= 8; r |= revbin_tab[ x &
r <<= 8; r |= revbin_tab[ x &
#if BYTES_PER_LONG > 4

x)
255 ];
255 ];
255 ];

x >>= 8;
x >>= 8;
x >>= 8;

36
7
8
9
10
11
12
13
14

r <<= 8;
r <<= 8;
r <<= 8;
r <<= 8;
#endif
r <<= 8;
return r;
}

r
r
r
r

|=
|=
|=
|=

revbin_tab[
revbin_tab[
revbin_tab[
revbin_tab[

x
x
x
x

&
&
&
&

255
255
255
255

];
];
];
];

x
x
x
x

>>=
>>=
>>=
>>=

8;
8;
8;
8;

r |= revbin_tab[ x ];

However, reversing the first 230 binary words with this routine takes (on a 64-bit machine) longer than
with the routine using the bit_swap_NN() calls, see [FXT: bits/revbin-tab-demo.cc].

1.14.3

Generating the bit-reversed words in order

If the bit-reversed words have to be generated in the (reversed) counting order, there is a significantly
cheaper way to do the update [FXT: bits/revbin-upd.h]:
1
2
3
4
5
6
7
8

static inline ulong revbin_upd(ulong r, ulong h)
// Let n=2**ldn and h=n/2.
// Then, with r == revbin(x, ldn) at entry, return revbin(x+1, ldn)
// Note: routine will hang if called with r the all-ones word
{
while ( !((r^=h)&h) ) h >>= 1;
return r;
}

Now assume we want to generate the bit-reversed words of all N = 2n − 1 words less than 2n . The total
number of branches with the while-loop can be estimated by observing that for half of the updates just
one bit changes, two bits change for a quarter, three bits change for one eighth of all updates, and so on.
So the loop executes less than 2 N times:
N

4
log2 (N )
1 2 3
+ + +
+ ··· +
2 4 8 16
N

log2 (N )

=

N
j=1

j
< 2N
2j

(1.14-1)

For large values of N the following method can be significantly faster if a fast routine is available for the
computation of the least significant bit in a word. The underlying observation is that for a fixed word of
size n there are just n different patterns of bit-changes with incrementing. We generate a lookup table
of the bit-reversed patterns, utab[], an array of BITS_PER_LONG elements:
1
2
3
4
5
6

static inline void make_revbin_upd_tab(ulong ldn)
// Initialize lookup table used by revbin_tupd()
{
utab[0] = 1UL<<(ldn-1);
for (ulong k=1; k<ldn; ++k) utab[k] = utab[k-1] | (utab[k-1]>>1);
}

The change patterns for n = 5 start as
pattern
....1
...11
....1
..111
....1
...11
....1
.1111
....1
...11

reversed pattern
1....
11...
1....
111..
1....
11...
1....
1111.
1....
11...

The pattern with x set bits is used for the update of k to k + 1 when the lowest zero of k is at position
x − 1:
utab[0]=
utab[1]=
utab[2]=
utab[3]=
utab[4]=

reversed
1....
11...
111..
1111.
11111

used when the lowest
zero of k is at index:
0
1
2
3
4

The update routine can now be implemented as

1
2
3
4
5
6
7
8
9
10
11

37

static inline ulong revbin_tupd(ulong r, ulong k)
// Let r==revbin(k, ldn) then
// return revbin(k+1, ldn).
// NOTE 1: need to call make_revbin_upd_tab(ldn) before usage
//
where ldn=log_2(n)
// NOTE 2: different argument structure than revbin_upd()
{
k = lowest_one_idx(~k); // lowest zero idx
r ^= utab[k];
return r;
}

The revbin-update routines are used for the revbin permutation described in section 2.6.

Update, bit-wise
Update, table
Full, masks
Full, 8-bit table
Full32, 8-bit table
Full16, 8-bit table
Full, generated masks
Full, bit-wise

30 bits
1.00
0.99
0.74
1.77
0.83
—
2.97
8.76

16 bits
1.00
1.08
0.81
1.94
0.90
0.54
3.25
5.77

8 bits
1.00
1.15
0.86
2.06
0.96
0.58
3.45
2.50

revbin upd()
revbin tupd()
revbin()
revbin t()
revbin t le32()
revbin t le16()
[page 35]
[page 35]

Figure 1.14-A: Relative performance of the revbin-update and (full) revbin routines. The timing of the
bit-wise update routine is normalized to 1. Values in each column should be compared, smaller values
correspond to faster routines. A column labeled “N bits” gives the timing for reversing the N least
significant bits of a word.
The relative performance of the different revbin routines is shown in figure 1.14-A. As a surprise, the
full-word revbin function is consistently faster than both of the update routines, mainly because the
machine used (see appendix B on page 922) has a byte swap instruction. As the performance of table
lookups is highly machine dependent your results can be very different.

1.14.4

Alternative techniques for in-order generation

The following loop, due to Brent Lehmann [priv. comm.], also generates the bit-reversed words in succession:
1
2
3
4
5
6
7
8
9

ulong n = 32; // a power of 2
ulong p = 0, s = 0, n2 = 2*n;
do
{
// here: s is the bit-reversed word
p += 2;
s ^= n - (n / (p&-p));
}
while ( p<n2 );

The revbin-increment is branchless but involves a division which usually is an expensive operation. With
a fast bit-scan function the loop should be replaced by
1
2
3
4
5
6

do
{
p += 1;
s ^= n - (n >> (lowest_one_idx(p)+1));
}
while ( p<n );

A recursive algorithm for the generation of the bit-reversed words in order is given in [FXT: bits/revbinrec-demo.cc]:
1
2
3
4
5

ulong N;
void revbin_rec(ulong f, ulong n)
{
// visit( f )
for (ulong m=N>>1; m>n; m>>=1)

revbin_rec(f+m, m);

38
6

}

Call revbin_rec(0, 0) to generate all N-bit bit-reversed words.
A technique to generate all revbin pairs in a pseudo random order is given in section 41.4 on page 873.

1.15

Bit-wise zip

The bit-wise zip (bit-zip) operation moves the bits in the lower half to even indices and the bits in the
upper half to odd indices. For example, with 8-bit words the permutation of bits is
[ a b c d A B C D ]

|-->

[ a A b B c C d D ]

A straightforward implementation is
1
2
3
4
5
6
7
8
9
10
11
12
13

ulong bit_zip(ulong a, ulong b)
{
ulong x = 0;
ulong m = 1, s = 0;
for (ulong k=0; k<(BITS_PER_LONG/2); ++k)
{
x |= (a & m) << s;
++s;
x |= (b & m) << s;
m <<= 1;
}
return x;
}

Its inverse (bit-unzip) moves even indexed bits to the lower half-word and odd indexed bits to the upper
half-word:
1
2
3
4
5
6
7
8
9
10
11
12
13

void bit_unzip(ulong x, ulong &a, ulong &b)
{
a = 0; b = 0;
ulong m = 1, s = 0;
for (ulong k=0; k<(BITS_PER_LONG/2); ++k)
{
a |= (x & m) >> s;
++s;
m <<= 1;
b |= (x & m) >> s;
m <<= 1;
}
}

For a faster implementation we will use the butterfly_*()-functions which are deﬁned in [FXT:
bits/bitbutterﬂy.h] (64-bit version):
1
2
3
4
5
6
7
8
9
10

static inline ulong butterfly_4(ulong x)
// Swap in each block of 16 bits the two central blocks of 4 bits.
{
const ulong ml = 0x0f000f000f000f00UL;
const ulong s = 4;
const ulong mr = ml >> s;
const ulong t = ((x & ml) >> s ) | ((x & mr) << s );
x = (x & ~(ml | mr)) | t;
return x;
}

The following version of the function may look more elegant but is actually slower:
1
2
3
4
5
6
7
8

static inline ulong butterfly_4(ulong x)
{
const ulong m = 0x0ff00ff00ff00ff0UL;
ulong c = x & m;
c ^= (c<<4) ^ (c>>4);
c &= m;
return x ^ c;
}

The optimized versions of the bit-zip and bit-unzip routines are [FXT: bits/bitzip.h]:
1
2

static inline ulong bit_zip(ulong x)
{

1.15: Bit-wise zip
3
4
5
6
7
8
9
10
11

39

#if

BITS_PER_LONG == 64
x = butterfly_16(x);
#endif
x = butterfly_8(x);
x = butterfly_4(x);
x = butterfly_2(x);
x = butterfly_1(x);
return x;
}

and
1
2
3
4
5
6
7
8
9
10
11

static inline ulong bit_unzip(ulong x)
{
x = butterfly_1(x);
x = butterfly_2(x);
x = butterfly_4(x);
x = butterfly_8(x);
x = butterfly_16(x);
#endif
return x;
}

Laszlo Hars suggests [priv. comm.] the following routine (version for 32-bit words), which can be obtained
by making the compile-time constants explicit:
1
2
3
4
5
6
7
8

static inline
{
x = ((x &
x = ((x &
x = ((x &
x = ((x &
return x;
}

uint32 bit_zip(uint32 x)
0x0000ff00)
0x00f000f0)
0x0c0c0c0c)
0x22222222)

<<
<<
<<
<<

8)
4)
2)
1)

|
|
|
|

((x
((x
((x
((x

>>
>>
>>
>>

8)
4)
2)
1)

&
&
&
&

0x0000ff00)
0x00f000f0)
0x0c0c0c0c)
0x22222222)

|
|
|
|

(x
(x
(x
(x

&
&
&
&

0xff0000ff);
0xf00ff00f);
0xc3c3c3c3);
0x99999999);

A bit-zip version for words whose upper half is zero is (64-bit version)
1
2
3
4
5
6
7
8
9
10

static inline ulong bit_zip0(ulong x)
// Return word with lower half bits in even indices.
{
x = (x | (x<<16)) & 0x0000ffff0000ffffUL;
x = (x | (x<<8)) & 0x00ff00ff00ff00ffUL;
x = (x | (x<<4)) & 0x0f0f0f0f0f0f0f0fUL;
x = (x | (x<<2)) & 0x3333333333333333UL;
x = (x | (x<<1)) & 0x5555555555555555UL;
return x;
}

Its inverse is
1
2
3
4
5
6
7
8
9
10

static inline ulong bit_unzip0(ulong x)
// Bits at odd positions must be zero.
{
x = (x | (x>>1)) & 0x3333333333333333UL;
x = (x | (x>>2)) & 0x0f0f0f0f0f0f0f0fUL;
x = (x | (x>>4)) & 0x00ff00ff00ff00ffUL;
x = (x | (x>>8)) & 0x0000ffff0000ffffUL;
x = (x | (x>>16)) & 0x00000000ffffffffUL;
return x;
}

The simple structure of the routines suggests trying the following versions of bit-zip and its inverse:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong bit_zip(ulong x)
{
ulong y = (x >> 32);
x &= 0xffffffffUL;
x = (x | (x<<16)) & 0x0000ffff0000ffffUL;
y = (y | (y<<16)) & 0x0000ffff0000ffffUL;
x = (x | (x<<8)) & 0x00ff00ff00ff00ffUL;
y = (y | (y<<8)) & 0x00ff00ff00ff00ffUL;
x = (x | (x<<4)) & 0x0f0f0f0f0f0f0f0fUL;
y = (y | (y<<4)) & 0x0f0f0f0f0f0f0f0fUL;
x = (x | (x<<2)) & 0x3333333333333333UL;
y = (y | (y<<2)) & 0x3333333333333333UL;
x = (x | (x<<1)) & 0x5555555555555555UL;

40


14
15
16
17

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

static inline ulong bit_unzip(ulong x)
{
ulong y = (x >> 1) & 0x5555555555555555UL;
x &= 0x5555555555555555UL;
x = (x | (x>>1)) & 0x3333333333333333UL;
y = (y | (y>>1)) & 0x3333333333333333UL;
x = (x | (x>>2)) & 0x0f0f0f0f0f0f0f0fUL;
y = (y | (y>>2)) & 0x0f0f0f0f0f0f0f0fUL;
x = (x | (x>>4)) & 0x00ff00ff00ff00ffUL;
y = (y | (y>>4)) & 0x00ff00ff00ff00ffUL;
x = (x | (x>>8)) & 0x0000ffff0000ffffUL;
y = (y | (y>>8)) & 0x0000ffff0000ffffUL;
x = (x | (x>>16)) & 0x00000000ffffffffUL;
y = (y | (y>>16)) & 0x00000000ffffffffUL;
x |= (y<<32);
return x;
}

y = (y | (y<<1))
x |= (y<<1);
return x;

& 0x5555555555555555UL;

As the statements involving the variables x and y are independent the CPU-internal parallelism can be
used. However, these versions turn out to be slightly slower than those given before.
The following function moves the bits of the lower half-word of x into the even positions of lo and the
bits of the upper half-word into hi (two versions given):
1
2
3
4
5
6
7
8
9
10
11
12
13

#define

BPLH

(BITS_PER_LONG/2)

static inline void bit_zip2(ulong x, ulong &lo, ulong &hi)
{
#if 1
x = bit_zip(x);
lo = x & 0x5555555555555555UL;
hi = (x>>1) & 0x5555555555555555UL;
#else
hi = bit_zip0( x >> BPLH );
lo = bit_zip0( (x << BPLH) >> (BPLH) );
#endif
}

The inverse function is
1
2
3
4
5
6
7
8
9

static inline ulong bit_unzip2(ulong lo, ulong hi)
// Inverse of bit_zip2(x, lo, hi).
{
#if 1
return bit_unzip( (hi<<1) | lo );
#else
return bit_unzip0(lo) | (bit_unzip0(hi) << BPLH);
#endif
}

Functions that zip/unzip the bits of the lower half of two words are
1
2
3
4
5
6

static inline ulong bit_zip2(ulong x, ulong y)
// 2-word version:
// only the lower half of x and y are merged
{
return bit_zip( (y<<BPLH) + x );
}

and (64-bit version)
1
2
3
4
5
6
7
8

static inline void bit_unzip2(ulong t, ulong &x, ulong &y)
// 2-word version:
// only the lower half of x and y are filled
{
t = bit_unzip(t);
y = t >> BPLH;
x = t & 0x00000000ffffffffUL;
}

1.16: Gray code and parity

1.16

41

Gray code and parity
k:
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

bin(k)
.......
......1
.....1.
.....11
....1..
....1.1
....11.
....111
...1...
...1..1
...1.1.
...1.11
...11..
...11.1
...111.
...1111
..1....
..1...1
..1..1.
..1..11
..1.1..
..1.1.1
..1.11.
..1.111
..11...
..11..1
..11.1.
..11.11
..111..
..111.1
..1111.
..11111

g(k)
.......
......1
.....11
.....1.
....11.
....111
....1.1
....1..
...11..
...11.1
...1111
...111.
...1.1.
...1.11
...1..1
...1...
..11...
..11..1
..11.11
..11.1.
..1111.
..11111
..111.1
..111..
..1.1..
..1.1.1
..1.111
..1.11.
..1..1.
..1..11
..1...1
..1....

g^-1(k)
.......
......1
.....11
.....1.
....111
....11.
....1..
....1.1
...1111
...111.
...11..
...11.1
...1...
...1..1
...1.11
...1.1.
..11111
..1111.
..111..
..111.1
..11...
..11..1
..11.11
..11.1.
..1....
..1...1
..1..11
..1..1.
..1.111
..1.11.
..1.1..
..1.1.1

g(2*k)
.......
.....11
....11.
....1.1
...11..
...1111
...1.1.
...1..1
..11...
..11.11
..1111.
..111.1
..1.1..
..1.111
..1..1.
..1...1
.11....
.11..11
.11.11.
.11.1.1
.1111..
.111111
.111.1.
.111..1
.1.1...
.1.1.11
.1.111.
.1.11.1
.1..1..
.1..111
.1...1.
.1....1

g(2*k+1)
......1
.....1.
....111
....1..
...11.1
...111.
...1.11
...1...
..11..1
..11.1.
..11111
..111..
..1.1.1
..1.11.
..1..11
..1....
.11...1
.11..1.
.11.111
.11.1..
.1111.1
.11111.
.111.11
.111...
.1.1..1
.1.1.1.
.1.1111
.1.11..
.1..1.1
.1..11.
.1...11
.1.....

Figure 1.16-A: Binary words, their Gray code, inverse Gray code, and Gray codes of even and odd
values (from left to right).
The Gray code of a binary word can easily be computed by [FXT: bits/graycode.h]
1

static inline ulong gray_code(ulong x)

{ return

x ^ (x>>1); }

Gray codes of consecutive values differ in one bit. Gray codes of values that differ by a power of 2 differ
in two bits. Gray codes of even/odd values have an even/odd number of bits set, respectively. This is
demonstrated in [FXT: bits/gray-demo.cc], whose output is given in figure 1.16-A.
To produce a random value with an even/odd number of bits set, set the lowest bit of a random number
to 0/1, respectively, and return its Gray code.
Computing the inverse Gray code is slightly more expensive. As the Gray code is the bit-wise difference
modulo 2, we can compute the inverse as bit-wise sums modulo 2:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong inverse_gray_code(ulong x)
{
// VERSION 1 (integration modulo 2):
ulong h=1, r=0;
do
{
if ( x & 1 ) r^=h;
x >>= 1;
h = (h<<1)+1;
}
while ( x!=0 );
return r;
}

For n-bit words, n-fold application of the Gray code gives back the original word. Using the symbol G
for the Gray code (operator), we have Gn = id, so Gn−1 ◦ G = id = G−1 ◦ G. That is, applying the Gray
code computation n − 1 times gives the inverse Gray code. Thus we can simplify to
1
2
3
4

// VERSION 2 (apply graycode BITS_PER_LONG-1 times):
ulong r = BITS_PER_LONG;
while ( --r ) x ^= x>>1;
return x;

42


Applying the Gray code twice is identical to x^=x>>2;, applying it four times is x^=x>>4;, and the idea
holds for all power of 2. This leads to the most eﬃcient way to compute the inverse Gray code:
1
2
3
4
5
6
7
8
9
10
11
12

// VERSION 3 (use: gray ** BITSPERLONG == id):
x ^= x>>1; // gray ** 1
x ^= x>>2; // gray ** 2
x ^= x>>4; // gray ** 4
x ^= x>>8; // gray ** 8
x ^= x>>16; // gray ** 16
// here: x = gray**31(input)
// note: the statements can be reordered at will
x ^= x>>32; // for 64bit words
#endif
return x;

1.16.1

The parity of a binary word

The parity of a word is its bit-count modulo 2. The lowest bit of the inverse Gray code of a word contains
the parity of the word. So we can compute the parity as [FXT: bits/parity.h]:
1
2
3
4
5

static inline ulong parity(ulong x)
// Return 0 if the number of set bits is even, else 1
{
return inverse_gray_code(x) & 1;
}

Each bit of the inverse Gray code contains the parity of the partial input left from it (including itself).
Be warned that the parity ﬂag of many CPUs is the complement of the above. With the x86-architecture
the parity bit also only takes into account the lowest byte. The following routine computes the parity of
a full word [FXT: bits/bitasm-i386.h]:
1
2
3
4
5
6
7
8
9
10

static inline ulong asm_parity(ulong x)
{
x ^= (x>>16);
x ^= (x>>8);
asm ("addl $0, %0 n"
"setnp %%al
n"
"movzx %%al, %0"
: "=r" (x) : "0" (x) : "eax");
return x;
}

The equivalent code for the AMD64 CPU is [FXT: bits/bitasm-amd64.h]:
1
2
3
4
5
6
7
8
9
10
11

static inline ulong asm_parity(ulong x)
{
x ^= (x>>32);
x ^= (x>>16);
x ^= (x>>8);
asm ("addq $0, %0 n"
"setnp %%al
n"
"movzx %%al, %0"
: "=r" (x) : "0" (x) : "rax");
return x;
}

1.16.2

Byte-wise Gray code and parity

A byte-wise Gray code can be computed using (32-bit version)
1
2
3
4
5

static inline ulong byte_gray_code(ulong x)
// Return the Gray code of bytes in parallel
{
return x ^ ((x & 0xfefefefe)>>1);
}

Its inverse is
1
2
3

static inline ulong byte_inverse_gray_code(ulong x)
// Return the inverse Gray code of bytes in parallel
{

4
5
6
7
8

43

x ^= ((x & 0xfefefefeUL)>>1);
x ^= ((x & 0xfcfcfcfcUL)>>2);
x ^= ((x & 0xf0f0f0f0UL)>>4);
return x;
}

And the parities of all bytes can be computed as
1
2
3
4
5

static inline ulong byte_parity(ulong x)
// Return the parities of bytes in parallel
{
return byte_inverse_gray_code(x) & 0x01010101UL;
}

1.16.3

Incrementing (counting) in Gray code
k:
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

g(k)
.......
......1
.....11
.....1.
....11.
....111
....1.1
....1..
...11..
...11.1
...1111
...111.
...1.1.
...1.11
...1..1
...1...
..11...
..11..1

g(2*k)
.......
.....11
....11.
....1.1
...11..
...1111
...1.1.
...1..1
..11...
..11.11
..1111.
..111.1
..1.1..
..1.111
..1..1.
..1...1
.11....
.11..11

g(k)
......
.....1
....11
....1.
...11.
...111
...1.1
...1..
..11..
..11.1
..1111
..111.
..1.1.
..1.11
..1..1
..1...
.11...
.11..1

p
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1

diff
......
.....+
....+1
....1...+1.
...11+
...1-1
...1...+1..
..11.+
..11+1
..111..1-1.
..1.1+
..1.-1
..1...+1...
.11..+

p
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1

set
{}
{0}
{0,
{1}
{1,
{0,
{0,
{2}
{2,
{0,
{0,
{1,
{1,
{0,
{0,
{3}
{3,
{0,

1}
2}
1, 2}
2}
3}
2,
1,
2,
3}
1,
3}

3}
2, 3}
3}
3}

4}
3, 4}

Figure 1.16-B: The Gray code equals the Gray code of doubled value shifted to the right once. Equivalently, we can separate the lowest bit which equals the parity of the other bits. The last column shows
that the changes with each increment always happen one position left of the rightmost bit.
Let g(k) be the Gray code of a number k. We are interested in eﬃciently generating g(k + 1). We can
implement a fast Gray counter if we use a spare bit to keep track of the parity of the Gray code word,
see ﬁgure 1.16-B The following routine does this [FXT: bits/nextgray.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong next_gray2(ulong x)
// With input x==gray_code(2*k) the return is gray_code(2*k+2).
// Let x1 be the word x shifted right once
// and i1 its inverse Gray code.
// Let r1 be the return r shifted right once.
// Then r1 = gray_code(i1+1).
// That is, we have a Gray code counter.
// The argument must have an even number of bits.
{
x ^= 1;
x ^= (lowest_one(x) << 1);
return x;
}

Start with x=0, increment with x=next_gray2(pg) and use the words g=x>>1:
1
2
3
4
5
6
7
8

ulong x = 0;
for (ulong k=0; k<n2; ++k)
{
ulong g = x>>1;
x = next_gray2(x);
// here: g == gray_code(k);
}

This is shown in [FXT: bits/bit-nextgray-demo.cc]. To start at an arbitrary (Gray code) value g, compute

44

x = (g<<1) ^ parity(g)

Then use the statement x=next_gray2(x) for later increments.
If working with a set whose elements are the set bits in the Gray code, the parity is the set size k modulo
2. Compute the increment as follows:
1. If k is even, then goto step 2, else goto step 3.
2. If the first element is zero, then remove it, else prepend the element zero.
3. If the first element equals the second minus one, then remove the second element, else insert at the
second position the element equal to the first element plus one.
A method to decrement is obtained by simply swapping the actions for even and odd parity.
When working with an array that contains the elements of the set, it is more convenient to do the described
operations at the end of the array. This leads to the (loopless) algorithm for subsets in minimal-change
order given in section 8.2.2 on page 206. Properties of the Gray code are discussed in [127].

1.16.4

The Thue-Morse sequence

The sequence of parities of the binary words
011010011001011010010110011010011001011001101001...
is called the Thue-Morse sequence (entry A010060 in [312]). It appears in various seemingly unrelated contexts, see [8] and section 38.1 on page 726. The sequence can be generated with [FXT: class thue morse
in bits/thue-morse.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class thue_morse
// Thue-Morse sequence
{
public:
ulong k_;
ulong tm_;
public:
thue_morse(ulong k=0)
~thue_morse() { ; }

{ init(k); }

ulong init(ulong k=0)
{
k_ = k;
tm_ = parity(k_);
return tm_;
}
ulong data()

{ return tm_; }

ulong next()
{
ulong x = k_ ^ (k_ + 1);
++k_;
x ^= x>>1;
// highest bit that changed with increment
x &= 0x5555555555555555UL; // 64-bit version
tm_ ^= ( x!=0 ); // change if highest changed bit was at even index
return tm_;
}
};

The rate of generation is about 366 M/s (6 cycles per update) [FXT: bits/thue-morse-demo.cc].

1.16.5

The Golay-Rudin-Shapiro sequence ‡

The function [FXT: bits/grsnegative.h]
1

static inline ulong grs_negative_q(ulong x)

{ return

parity( x & (x>>1) ); }

returns +1 for indices where the Golay-Rudin-Shapiro sequence (or GRS sequence, entry A020985 in
[312]) has the value −1. The algorithm is to count the bit-pairs modulo 2. The pairs may overlap: the

++
++++++- ++-+
+++- ++-+
+++- ++-+
+++- ++-+
^
^
3, 6,

45

+++- --++++- --+- +++- ++-+ ---+ ++-+
+++- --+- +++- ++-+ ---+ ++-+
^ ^^ ^
^
^ ...
11,12,13,15, 19, 22, ...

+++- ++-+

+++- --+- ...

Figure 1.16-C: A construction for the Golay-Rudin-Shapiro (GRS) sequence.
sequence [1111] contains the three bit-pairs [11..], [.11.], and [..11]. The function returns +1 for
x in the sequence
3, 6, 11, 12, 13, 15, 19, 22, 24, 25, 26, 30, 35, 38, 43, 44, 45, 47, 48, 49, 50, 52, 53, ...

This is entry A022155 in [312], see also section 38.3 on page 731. The sequence can be computed by
starting with two ones, and appending the left half and the negated right half of the values so far in each
step, see ﬁgure 1.16-C. To compute the successor in the GRS sequence, use
1
2
3
4
5
6
7
8

static inline ulong grs_next(ulong k, ulong g)
// With g == grs_negative_q(k), compute grs_negative_q(k+1).
{
const ulong cm = 0x5555555555555554UL; // 64-bit version
ulong h = ~k; h &= -h; // == lowest_zero(k);
g ^= ( ((h&cm) ^ ((k>>1)&h)) !=0 );
return g;
}

With incrementing k, the lowest run of ones of k is replaced by a one at the lowest zero of k. If the length
of the lowest run is odd and ≥ 2 then a change of parity happens. This is the case if the lowest zero of k
is at one of the positions
bin

0101 0101 0101 0100

==

hex 5 5 5 4

==

cm

If the position of the lowest zero is adjacent to the next block of ones, another change of parity will occur.
The element of the GRS sequence changes if exactly one of the parity changes takes place.
The update function can be used as shown in [FXT: bits/grs-next-demo.cc]:
1
2
3
4
5
6
7
8

ulong n = 65; // Generate this many values of the sequence.
ulong k0 = 0; // Start point of the sequence.
ulong g = grs_negative_q(k0);
for (ulong k=k0; k<k0+n; ++k)
{
// Do something with g here.
g = grs_next(k, g);
}

The rate of generation is about 347 M/s, direct computation gives a rate of 313 M/s.

1.16.6

The reversed Gray code

We deﬁne the reversed Gray code to be the bit-reversed word of the Gray code of the bit-reversed word.
That is,
rev_gray_code(x) := revbin( gray_code( revbin(x) ) )

It turns out that the corresponding functions are identical to the Gray code versions up to the reversed
shift operations (C-language operators ‘>>’ replaced by ‘<<’). So computing the reversed Gray code is as
easy as [FXT: bits/revgraycode.h]:
1

static inline ulong rev_gray_code(ulong x)

{ return

Its inverse is
1
2
3
4
5
6

static inline ulong inverse_rev_gray_code(ulong x)
{
// use: rev_gray ** BITSPERLONG == id:
x ^= x<<1; // rev_gray ** 1
x ^= x<<2; // rev_gray ** 2
x ^= x<<4; // rev_gray ** 4

x ^ (x<<1); }

46

---------------------------------------------------------111.1111....1111................ = 0xef0f0000 == word
1..11...1...1...1............... = gray_code
..11...1...1...1................ = rev_gray_code
1.11.1.11111.1.11111111111111111 = inverse_gray_code
1.1..1.1.....1.1................ = inverse_rev_gray_code
---------------------------------------------------------...1....1111....1111111111111111 = 0x10f0ffff == word
...11...1...1...1............... = gray_code
..11...1...1...1...............1 = rev_gray_code
...11111.1.11111.1.1.1.1.1.1.1.1 = inverse_gray_code
1111.....1.1.....1.1.1.1.1.1.1.1 = inverse_rev_gray_code
---------------------------------------------------------......1......................... = 0x2000000 == word
......11........................ = gray_code
.....11......................... = rev_gray_code
......11111111111111111111111111 = inverse_gray_code
1111111......................... = inverse_rev_gray_code
---------------------------------------------------------111111.1111111111111111111111111 = 0xfdffffff == word
1.....11........................ = gray_code
.....11........................1 = rev_gray_code
1.1.1..1.1.1.1.1.1.1.1.1.1.1.1.1 = inverse_gray_code
1.1.1.11.1.1.1.1.1.1.1.1.1.1.1.1 = inverse_rev_gray_code
----------------------------------------------------------

Figure 1.16-D: Examples of the Gray code, reversed Gray code, and their inverses with 32-bit words.
7
8
9
10
11
12
13
14
15

x ^= x<<8; // rev_gray ** 8
x ^= x<<16; // rev_gray ** 16
// here: x = rev_gray**31(input)
// note: the statements can be reordered at will
x ^= x<<32; // for 64bit words
#endif
return x;
}

Some examples with 32-bit words are shown in ﬁgure 1.16-D.
Let G and E denote be the Gray code and reversed Gray code of a word X, respectively. Write G−1
and E −1 for their inverses. Then E preserves the lowest bit of X, while E preserves the highest. Also E
preserves the lowest set bit of X, while E preserves the highest. Further, E −1 contains at each bit the
parity of all bits of X right from it, including the bit itself. Especially, the word parity can be found in
the highest bit of E −1 .
Let X denote the complement of X, p its parity, and let S the right shift by one of G−1 . Then we have
G−1 XOR E −1

=

X
X

S XOR E −1

=

0
0

if p = 0
otherwise
if p = 0
otherwise

(1.16-1a)
(1.16-1b)

We note that taking the reversed Gray code of a binary word corresponds to multiplication with the
binary polynomial x + 1 and the inverse reversed Gray code is a method for fast exact division by x + 1,
see section 40.1.6 on page 826. The inverse reversed Gray code can be used to solve the reduced quadratic
equation for binary normal bases, see section 42.6.2 on page 903.

1.17

Bit sequency ‡

The sequency of a binary word is the number of zero-one transitions in the word. A function to determine
the sequency is [FXT: bits/bitsequency.h]:
1

static inline ulong bit_sequency(ulong x)

{ return bit_count( gray_code(x) ); }

1.17: Bit sequency ‡
seq=

0
......

47
1
.....1
....11
...111
..1111
.11111
111111

2
....1.
...11.
...1..
..111.
..11..
..1...
.1111.
.111..
.11...
.1....
11111.
1111..
111...
11....
1.....

3
...1.1
..11.1
..1..1
..1.11
.111.1
.11..1
.11.11
.1...1
.1..11
.1.111
1111.1
111..1
111.11
11...1
11..11
11.111
1....1
1...11
1..111
1.1111

4
..1.1.
.11.1.
.1..1.
.1.11.
.1.1..
111.1.
11..1.
11.11.
11.1..
1...1.
1..11.
1..1..
1.111.
1.11..
1.1...

5
.1.1.1
11.1.1
1..1.1
1.11.1
1.1..1
1.1.11

6
1.1.1.

Figure 1.17-A: 6-bit words of prescribed sequency as generated by next sequency().
The function assumes that all bits to the left of the word are zero and all bits to the right are equal to
the lowest bit, see ﬁgure 1.17-A. For example, the sequency of the 8-bit word [00011111] is one. To take
the lowest bit into account, add it to the sequency (then all sequencies are even).
The minimal binary word with given sequency can be computed as follows:
1
2
3
4
5
6
7
8

static inline ulong first_sequency(ulong k)
// Return the first (i.e. smallest) word with sequency k,
// e.g. 00..00010101010 (seq 8)
// e.g. 00..00101010101 (seq 9)
// Must have: 0 <= k <= BITS_PER_LONG
{
return inverse_gray_code( first_comb(k) );
}

A faster version is (32-bit branch only):
1
2
3

if ( k==0 ) return 0;
const ulong m = 0xaaaaaaaaUL;
return m >> (BITS_PER_LONG-k);

The maximal binary word with given sequency can be computed via
1
2
3
4
5

static inline ulong last_sequency(ulong k)
// Return the last (i.e. biggest) word with sequency k.
{
return inverse_gray_code( last_comb(k) );
}

The functions first_comb(k) and last_comb(k) return a word with k bits set at the low and high end,
respectively (see section 1.24 on page 62).
For the generation of all words with a given sequency, starting with the smallest, we use a function that
computes the next word with the same sequency:
1
2
3
4
5
6
7

static inline ulong next_sequency(ulong x)
{
x = gray_code(x);
x = next_colex_comb(x);
x = inverse_gray_code(x);
return x;
}

The inverse function, returning the previous word with the same sequency, is
1
2
3
4
5
6

static inline ulong prev_sequency(ulong x)
{
x = gray_code(x);
x = prev_colex_comb(x);
return x;

48
7

}

The list of all 6-bit words ordered by sequency is shown in ﬁgure 1.17-A. It was created with the program
[FXT: bits/bitsequency-demo.cc].
The sequency of a word can be complemented as follows (32-bit version):
1
2
3
4
5
6

static inline ulong complement_sequency(ulong x)
// Return word whose sequency is BITS_PER_LONG - s
// where s is the sequency of x
{
return x ^ 0xaaaaaaaaUL;
}

1.18

Powers of the Gray code ‡

1.......
.1......
..1.....
...1....
....1...
.....1..
......1.
.......1
G^0=id

11......
.11.....
..11....
...11...
....11..
.....11.
......11
.......1
G^1=G

1.1.....
.1.1....
..1.1...
...1.1..
....1.1.
.....1.1
......1.
.......1
G^2

1111....
.1111...
..1111..
...1111.
....1111
.....111
......11
.......1
G^3

1...1...
.1...1..
..1...1.
...1...1
....1...
.....1..
......1.
.......1
G^4

11..11..
.11..11.
..11..11
...11..1
....11..
.....11.
......11
.......1
G^5

1.1.1.1.
.1.1.1.1
..1.1.1.
...1.1.1
....1.1.
.....1.1
......1.
.......1
G^6

11111111
.1111111
..111111
...11111
....1111
.....111
......11
.......1
G^7=G^(-1)

1.......
.1......
..1.....
...1....
....1...
.....1..
......1.
.......1
E^0=id

1.......
11......
.11.....
..11....
...11...
....11..
.....11.
......11
E^1=E

1.......
.1......
1.1.....
.1.1....
..1.1...
...1.1..
....1.1.
.....1.1
E^2

1.......
11......
111.....
1111....
.1111...
..1111..
...1111.
....1111
E^3

1.......
.1......
..1.....
...1....
1...1...
.1...1..
..1...1.
...1...1
E^4

1.......
11......
.11.....
..11....
1..11...
11..11..
.11..11.
..11..11
E^5

1.......
.1......
1.1.....
.1.1....
1.1.1...
.1.1.1..
1.1.1.1.
.1.1.1.1
E^6

1.......
11......
111.....
1111....
11111...
111111..
1111111.
11111111
E^7=E^(-1)

Figure 1.18-A: Powers of the matrices for the Gray code (top) and the reversed Gray code (bottom).
The Gray code is a bit-wise linear transform of a binary word. The 2k -th power of the Gray code of x
can be computed as x ^ (x>>k). The e-th power can be computed as the bit-wise sum of the powers
corresponding to the bits in the exponent. This motivates [FXT: bits/graypower.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static inline ulong gray_pow(ulong x, ulong e)
// Return (gray_code**e)(x)
// gray_pow(x, 1) == gray_code(x)
// gray_pow(x, BITS_PER_LONG-1) == inverse_gray_code(x)
{
e &= (BITS_PER_LONG-1); // modulo BITS_PER_LONG
ulong s = 1;
while ( e )
{
if ( e & 1 ) x ^= x >> s; // gray ** s
s <<= 1;
e >>= 1;
}
return x;
}

The Gray code g = [g0 , g1 , . . . , g7 ] of a 8-bit binary word x = [x0 , x1 , . . . , x7 ] can be expressed as a
matrix multiplication over GF(2) (dots for zeros):
g
[g0]
[g1]
[g2]
[g3]
[g4]
[g5]
[g6]
[g7]

=

=

[
[
[
[
[
[
[
[

G
11......
.11.....
..11....
...11...
....11..
.....11.
......11
.......1

]
]
]
]
]
]
]
]

x
[x0]
[x1]
[x2]
[x3]
[x4]
[x5]
[x6]
[x7]

The powers of the Gray code correspond to multiplication with powers of the matrix G, shown in ﬁgure 1.18-A (bottom). The powers of the inverse Gray code for N -bit words (where N is a power of 2)

1.19: Invertible transforms on words ‡

49

can be computed by the relation Ge GN −e = GN = id.
1
2
3
4
5
6
7
8

static inline ulong inverse_gray_pow(ulong x, ulong e)
// Return (inverse_gray_code**(e))(x)
//
== (gray_code**(-e))(x)
// inverse_gray_pow(x, 1) == inverse_gray_code(x)
// inverse_gray_pow(x, BITS_PER_LONG-1) == gray_code(x)
{
return gray_pow(x, -e);
}

The matrices corresponding to the powers of the reversed Gray code are shown in ﬁgure 1.18-A (bottom).
We just have to reverse the shift operator in the functions:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong rev_gray_pow(ulong x, ulong e)
// Return (rev_gray_code**e)(x)
{
e &= (BITS_PER_LONG-1); // modulo BITS_PER_LONG
ulong s = 1;
while ( e )
{
if ( e & 1 ) x ^= x << s; // rev_gray ** s
s <<= 1;
e >>= 1;
}
return x;
}

1
2
3
4
5

static inline ulong inverse_rev_gray_pow(ulong x, ulong e)
// Return (inverse_rev_gray_code**(e))(x)
{
return rev_gray_pow(x, -e);
}

1.19

Invertible transforms on words ‡

The functions presented in this section are invertible transforms on binary words. The names are chosen
as ‘some code’, emphasizing the result of the transforms, similar to the convention used with the name
‘Gray code’. The functions are given in [FXT: bits/bittransforms.h].
In the transform (blue code)
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong blue_code(ulong a)
{
ulong m = ~0UL << s;
do
{
a ^= ( (a&m) >> s );
s >>= 1;
m ^= (m>>s);
}
while ( s );
return a;
}

the masks ‘m’ are (32-bit binary)
1111111111111111................
11111111........11111111........
1111....1111....1111....1111....
11..11..11..11..11..11..11..11..
1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.

The same masks are used in the yellow code
1
2
3
4
5
6
7
8

static inline ulong yellow_code(ulong a)
{
do
{
a ^= ( (a&m) << s );
s >>= 1;

50
9
10
11
12
13

m ^= (m<<s);
}
while ( s );
return a;
}

Both need O (log2 BITS PER LONG) operations. The blue_code can be used as a fast implementation for
the composition of a binary polynomial with x + 1, see section 40.7.2 on page 845. The yellow code can
also be computed by the statement
revbin( blue_code( revbin(x) ) );

So we could have called it reversed blue code. Note the names ‘blue code’ etc. are ad hoc terminology
and not standard. See section 23.11 on page 486 for the closely related Reed-Muller transform.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

blue
......
.....1
....11
....1.
...1.1
...1..
...11.
...111
..1111
..111.
..11..
..11.1
..1.1.
..1.11
..1..1
..1...
.1...1
.1....
.1..1.
.1..11
.1.1..
.1.1.1
.1.111
.1.11.
.1111.
.11111
.111.1
.111..
.11.11
.11.1.
.11...
.11..1

0*
1*
2
1
2
1
2*
3*
4
3
2
3
2
3
2
1
2
1
2*
3*
2*
3*
4
3
4
5
4
3
4
3
2
3

yellow
................................
11111111111111111111111111111111
1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
11..11..11..11..11..11..11..11..
..11..11..11..11..11..11..11..11
.11..11..11..11..11..11..11..11.
1..11..11..11..11..11..11..11..1
1...1...1...1...1...1...1...1...
.111.111.111.111.111.111.111.111
..1...1...1...1...1...1...1...1.
11.111.111.111.111.111.111.111.1
.1...1...1...1...1...1...1...1..
1.111.111.111.111.111.111.111.11
111.111.111.111.111.111.111.111.
...1...1...1...1...1...1...1...1
1111....1111....1111....1111....
....1111....1111....1111....1111
.1.11.1..1.11.1..1.11.1..1.11.1.
1.1..1.11.1..1.11.1..1.11.1..1.1
..1111....1111....1111....1111..
11....1111....1111....1111....11
1..1.11.1..1.11.1..1.11.1..1.11.
.11.1..1.11.1..1.11.1..1.11.1..1
.1111....1111....1111....1111...
1....1111....1111....1111....111
11.1..1.11.1..1.11.1..1.11.1..1.
..1.11.1..1.11.1..1.11.1..1.11.1
1.11.1..1.11.1..1.11.1..1.11.1..
.1..1.11.1..1.11.1..1.11.1..1.11
...1111....1111....1111....1111.
111....1111....1111....1111....1

0
32
16
16
16
16
16
16
8
24
8
24
8
24
24
8
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16

Figure 1.19-A: Blue and yellow transforms of the binary words 0, 1, . . . , 31. Bit-counts are shown at
the right of each column. Fixed points are marked with asterisks.
The transforms of the binary words up to 31 are shown in ﬁgure 1.19-A, the lists were created with the
program [FXT: bits/bittransforms-blue-demo.cc]. The parity of B(a) is equal to the lowest bit of a. Up
to the a = 47 the bit-count varies by ±1 between successive values of B(a), the transition B(47) → B(48)
changes the bit-count by 3. The sequence of the indices a where the bit-count changes by more than one
is
47, 51, 59, 67, 75, 79, 175, 179, 187, 195, 203, 207, 291, 299, 339, 347, 419, 427, ...

The yellow code might be a good candidate for ‘randomization’ of binary words. The blue code maps
any range [0 . . . 2k − 1] onto itself. Both the blue code and the yellow code are involutions (self-inverse).
The transforms (red code)
1
2
3
4
5
6
7
8
9
10
11

static inline ulong red_code(ulong a)
{
do
{
ulong u = a & m;
ulong v = a ^ u;
a = v ^ (u<<s);
a ^= (v>>s);
s >>= 1;

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

red
................................
1...............................
11..............................
.1..............................
1.1.............................
..1.............................
.11.............................
111.............................
1111............................
.111............................
..11............................
1.11............................
.1.1............................
11.1............................
1..1............................
...1............................
1...1...........................
....1...........................
.1..1...........................
11..1...........................
..1.1...........................
1.1.1...........................
111.1...........................
.11.1...........................
.1111...........................
11111...........................
1.111...........................
..111...........................
11.11...........................
.1.11...........................
...11...........................
1..11...........................

51

0
1
2
1
2
1
2
3
4
3
2
3
2
3
2
1
2
1
2
3
2
3
4
3
4
5
4
3
4
3
2
3

green
................................
11111111111111111111111111111111
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.
..11..11..11..11..11..11..11..11
11..11..11..11..11..11..11..11..
.11..11..11..11..11..11..11..11.
1..11..11..11..11..11..11..11..1
...1...1...1...1...1...1...1...1
111.111.111.111.111.111.111.111.
.1...1...1...1...1...1...1...1..
1.111.111.111.111.111.111.111.11
..1...1...1...1...1...1...1...1.
11.111.111.111.111.111.111.111.1
.111.111.111.111.111.111.111.111
1...1...1...1...1...1...1...1...
....1111....1111....1111....1111
1111....1111....1111....1111....
.1.11.1..1.11.1..1.11.1..1.11.1.
1.1..1.11.1..1.11.1..1.11.1..1.1
..1111....1111....1111....1111..
11....1111....1111....1111....11
.11.1..1.11.1..1.11.1..1.11.1..1
1..1.11.1..1.11.1..1.11.1..1.11.
...1111....1111....1111....1111.
111....1111....1111....1111....1
.1..1.11.1..1.11.1..1.11.1..1.11
1.11.1..1.11.1..1.11.1..1.11.1..
..1.11.1..1.11.1..1.11.1..1.11.1
11.1..1.11.1..1.11.1..1.11.1..1.
.1111....1111....1111....1111...
1....1111....1111....1111....111

0
32
16
16
16
16
16
16
8
24
8
24
8
24
24
8
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16

Figure 1.19-B: Red and green transforms of the binary words 0, 1, . . . , 31.
12
13
14
15
16

m ^= (m<<s);
}
while ( s );
return a;
}

and (green code)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

static inline ulong green_code(ulong a)
{
do
{
ulong u = a & m;
ulong v = a ^ u;
a = v ^ (u>>s);
a ^= (v<<s);
s >>= 1;
m ^= (m>>s);
}
while ( s );
return a;
}

use the masks
................1111111111111111
........11111111........11111111
....1111....1111....1111....1111
..11..11..11..11..11..11..11..11
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1

The transforms of the binary words up to 31 are shown in ﬁgure 1.19-B, which was created with the
program [FXT: bits/bittransforms-red-demo.cc]. The red code can also be computed by the statement
revbin( blue_code( x ) );

and the green code by
blue_code( revbin( x ) );

52

i
i
r
B
Y
R
E

i
r
B
Y
R
E

r
B
r
B
i
R*
E* i
R* E*
Y* r*
B* Y*

Y
Y
E*
R*
i
B*
r*

R
E
R
E
B* Y*
Y* r*
r* B*
E
i
i
R

Figure 1.19-C: Multiplication table for the transforms.

1.19.1

Relations between the transforms

We write B for the blue code (transform), Y for the yellow code and r for bit-reversal (the revbinfunction). We have the following relations between B and Y :
B

= Y rY

= rY r

(1.19-1a)

Y

= BrB

= rBr

(1.19-1b)

r

= Y BY

= BY B

(1.19-1c)

As said, B and Y are self-inverse:
B −1

= B,

B B = id

(1.19-2a)

Y −1

= Y,

Y Y = id

(1.19-2b)

We write R for the red code, and E for the green code. The red code and the green code are not
involutions (square roots of identity) but third roots of identity:
RRR
EEE
RE

=
=

R−1 = R R = E

id,
id,

E

−1

=EE =R

= E R = id

(1.19-3a)
(1.19-3b)
(1.19-3c)

Figure 1.19-C shows the multiplication table. The R in the third column of the second row says that
r B = R. The letter i is used for identity (id). An asterisk says that x y = y x.
By construction we have
R

=

rB

(1.19-4a)

E

=

rY

(1.19-4b)

Relations between R and E are:
R

=

ErE

= rEr

(1.19-5a)

E

=

RrR

= rRr

(1.19-5b)

R

=

RER

(1.19-5c)

E

=

ERE

(1.19-5d)

For the bit-reversal we have
r

= Y R = RB = BE = EY

(1.19-6)

Some products for the transforms are
B

= RY = Y E = RBR = EBE

(1.19-7a)

Y

= EB = BR = RY R = EY E

(1.19-7b)

R

= BY =BEB =Y EY

(1.19-7c)

E

= Y B = BRB = Y RY

(1.19-7d)


53

Some triple products that give the identical transform are
id

(1.19-8a)

id

= EBY = BRY

(1.19-8b)

id

1.19.2

= BY E = RY B
= Y EB =Y BR

(1.19-8c)

Relations to Gray code and reversed Gray code

Write g for the Gray code, then:
gBgB

=

id

(1.19-9a)

gBg

=

B

(1.19-9b)

g −1 B g −1
gB

= B
= Bg

(1.19-9c)
−1

(1.19-9d)

Let Sk be the operator that rotates a word by k bits (bit 0 is moved to position k), then
Y S+1 Y

=

g

(1.19-10a)

Y S−1 Y

=

g −1

(1.19-10b)

Y Sk Y

=

gk

(1.19-10c)

Shift in the sequency domain is bit-wise derivative in time domain. Relation 1.19-10c, together with an
algorithm to generate the cycle leaders of the Gray permutation (section 2.12.1 on page 128) gives a
curious method to generate the binary necklaces whose length is a power of 2, described in section 18.1.6
on page 376. Let e be the operator for the reversed Gray code, then
B S+1 B

= e−1

(1.19-11a)

B S−1 B

= e

(1.19-11b)

= e−k

(1.19-11c)

B Sk B

Fixed points of the blue code ‡

1.19.3
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

......
.....1
....1.
....11
...1..
...1.1
...11.
...111
..1...
..1..1
..1.1.
..1.11
..11..
..11.1
..111.
..1111

:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:

..........
.........1
.......11.
.......111
.....1.1..
.....1..1.
.....1.1.1
.....1..11
...1111...
...11.11..
...111111.
...11.1.1.
...1111..1
...11.11.1
...1111111
...11.1.11

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

0
1
6
7
20
18
21
19
120
108
126
106
121
109
127
107

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

.1....
.1...1
.1..1.
.1..11
.1.1..
.1.1.1
.1.11.
.1.111
.11...
.11..1
.11.1.
.11.11
.111..
.111.1
.1111.
.11111

:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:

.1...1....
.1.11.1...
.1.....1..
.1.11111..
.1...1.11.
.1.11.111.
.1......1.
.1.1111.1.
.1...1...1
.1.11.1..1
.1.....1.1
.1.11111.1
.1...1.111
.1.11.1111
.1......11
.1.1111.11

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

272
360
260
380
278
366
258
378
273
361
261
381
279
367
259
379

Figure 1.19-D: The first fixed points of the blue code. The highest bit of all fixed points lies at an even
index. There are 2n/2 fixed points with highest bit at index n.
The sequence of fixed points of the blue code is (entry A118666 in [312])
0, 1, 6, 7, 18, 19, 20, 21, 106, 107, 108, 109, 120, 121, 126, 127, 258, 259, ...

If f is a fixed point, then f XOR 1 is also a fixed point. Further, 2 (f XOR (2 f )) is a fixed point. These
facts can be cast into a function that returns a unique fixed point for each argument [FXT: bits/bluefixed-points.h]:

54
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong blue_fixed_point(ulong s)
{
if ( 0==s ) return 0;
ulong f = 1;
while ( s>1 )
{
f ^= (f<<1);
f <<= 1;
f |= (s&1);
s >>= 1;
}
return f;
}

The output for the first few arguments is shown in figure 1.19-D. Note that the fixed points are not in
ascending order. The list was created by the program [FXT: bits/bittransforms-blue-fp-demo.cc].
Now write f (x) for the binary polynomial corresponding to f (see chapter 40 on page 822), if f (x) is
a fixed point (that is, B f (x) = f (x + 1) = f (x)), then both (x2 + x) f (x) and 1 + (x2 + x) f (x) are
fixed points. The function blue_fixed_point() repeatedly multiplies by x2 + x and adds one if the
corresponding bit of the argument is set.
For the inverse function, we exploit that polynomial division by x + 1 can be done with the inverse
reversed Gray code (see section 1.16.6 on page 45) if the polynomial is divisible by x + 1:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong blue_fixed_point_idx(ulong f)
// Inverse of blue_fixed_point()
{
ulong s = 1;
while ( f )
{
s <<= 1;
s ^= (f & 1);
f >>= 1;
f = inverse_rev_gray_code(f); // == bitpol_div(f, 3);
}
return s >> 1;
}

1.19.4

More transforms by symbolic powering

The idea of powering a transform (as with the Gray code, see section 1.18 on page 48) can be applied to
the ‘color’-transforms as exemplified for the blue code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong blue_xcode(ulong a, ulong x)
{
x &= (BITS_PER_LONG-1); // modulo BITS_PER_LONG
while ( s )
{
if ( x & 1 ) a ^= ( (a&m) >> s );
x >>= 1;
s >>= 1;
m ^= (m>>s);
}
return a;
}

The result is not the power of the blue code which would be pretty boring as B B = id. The transforms
(and the equivalents for Y , R and E, see [FXT: bits/bitxtransforms.h]) are more interesting: all relations
between the transforms are still valid, if the symbolic exponent is identical with all terms in the relation.
For example, we had B B = id, now B x B x = id is true for all x. Similarly, E E = R now has to be
E x E x = Rx . That is, we have BITS_PER_LONG different versions of our four transforms that share their
properties with the ‘simple’ versions. Among them are BITS_PER_LONG transforms B x and Y x that are
involutions and E x and Rx that are third roots of the identity: E x E x E x = Rx Rx Rx = id.
While not powers of the simple versions, we still have B 0 = Y 0 = R0 = E 0 = id. Further, let e be the
‘exponent’ of all ones and Z be any of the transforms, then Z e = Z. Writing ‘+’ for the XOR operation,

1.20: Scanning for zero bytes

55

we have Z x Z y = Z x+y and so Z x Z y = Z whenever x + y = e.

1.19.5

The building blocks of the transforms

Consider the following transforms on 2-bit words where addition is bit-wise (that is, XOR):
id2 v

=

1
0

0
1

a
b

=

a
b

(1.19-12a)

r2 v

=

0
1

1
0

a
b

=

b
a

(1.19-12b)

B2 v

=

1
0

1
1

a
b

=

a+b
b

(1.19-12c)

Y2 v

=

1
1

0
1

a
b

=

a
a+b

(1.19-12d)

R2 v

=

0
1

1
1

a
b

=

b
a+b

(1.19-12e)

E2 v

=

1
1

1
0

a
b

=

a+b
a

(1.19-12f)

It can easily be verified that for these the same relations hold as for id, r, B, Y , R, E. In fact the
‘color-transforms’, bit-reversal, and identity are the transforms obtained as repeated Kronecker-products
of the matrices (see section 23.3 on page 462). The transforms are linear over GF(2):
Z(α a + β b)

=

α Z(a) + β Z(b)

(1.19-13)

The corresponding version of the bit-reversal is [FXT: bits/revbin.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong xrevbin(ulong a, ulong x)
{
x &= (BITS_PER_LONG-1); // modulo BITS_PER_LONG
while ( s )
{
if ( x & 1 ) a = ( (a & m) << s ) ^ ( (a & (~m)) >> s );
x >>= 1;
s >>= 1;
m ^= (m<<s);
}
return a;
}

Then, for example, Rx = rx B x (see relation 1.19-4a on page 52). The yellow code is the bit-wise ReedMuller transform (described in section 23.11 on page 486) of a binary word. The symbolic powering is
equivalent to selecting individual levels of the transform.

1.20

Scanning for zero bytes

The following function (32-bit version) determines if any sub-byte of the argument is zero from [FXT:
bits/zerobyte.h]:
1
2
3
4

static inline ulong contains_zero_byte(ulong x)
{
return ((x-0x01010101UL)^x) & (~x) & 0x80808080UL;
}

It returns zero when x contains no zero-byte and nonzero when it does. The idea is to subtract one from
each of the bytes and then look for bytes where the borrow propagated all the way to the most significant
bit. A simplified version is given in [215, sect.7.1.3, rel.90]:
1

return

0x80808080UL & ( x - 0x01010101UL ) & ~x;

56


To scan for other values than zero (e.g. 0xa5), we can use
contains_zero_byte( x ^ 0xa5a5a5a5UL )

For very long strings and word sizes of 64 or more bits the following function may be a win [FXT:
aux1/bytescan.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ulong long_strlen(const char *str)
// Return length of string starting at str.
{
ulong x;
const char *p = str;
// Alignment: scan bytes up to word boundary:
while ( (ulong)p % BYTES_PER_LONG )
{
if ( 0 == *p ) return (ulong)(p-str);
++p;
}
x = *(ulong *)p;
while ( ! contains_zero_byte(x) )
{
p += BYTES_PER_LONG;
x = *(ulong *)p;
}
// now a zero byte is somewhere in x:
while ( 0 != *p ) { ++p; }
return

(ulong)(p-str);

}

1.21

Inverse and square root modulo 2n

1.21.1

Computation of the inverse

The inverse modulo 2n where n is the number of bits in a word can be computed using an iteration (see
section 29.1.5 on page 569) with quadratic convergence. The number to be inverted has to be odd [FXT:
bits/bit2adic.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static inline ulong inv2adic(ulong x)
// Return inverse modulo 2**BITS_PER_LONG
// x must be odd
// The number of correct bits is doubled with each step
// ==> loop is executed prop. log_2(BITS_PER_LONG) times
// precision is 3, 6, 12, 24, 48, 96, ... bits (or better)
{
if ( 0==(x&1) ) return 0; // not invertible
ulong i = x; // correct to three bits at least
ulong p;
do
{
p = i * x;
i *= (2UL - p);
}
while ( p!=1 );
return i;
}

Let m be the modulus (a power of 2), then the computed value i is the inverse of x modulo m: i ≡
x−1 mod m. It can be used for the exact division: to compute the quotient a/x for a number a that is
known to be divisible by x, simply multiply by i. This works because a = b x (a is divisible by x), so
a i ≡ b x i ≡ b mod m.

1.21: Inverse and square root modulo 2n

1.21.2

57

Exact division by C = 2k ± 1

We use the following relation where Y = 1 − C:
A
C

=

n
A
= A (1 + Y ) (1 + Y 2 ) (1 + Y 4 ) (1 + Y 8 ) . . . (1 + Y 2 )
1−Y

mod Y 2

n+1

(1.21-1)

The relation can be used for eﬃcient exact division over Z by C = 2k ± 1. For C = 2k + 1 use
A
C

u

= A (1 − 2k ) (1 + 2k 2 ) (1 + 2k 4 ) (1 + 2k 8 ) · · · (1 + 2k 2 )

mod 2N

(1.21-2)

where k 2u ≥ N . For C = 2k − 1 use (A/C = −A/ − C)
A
C

=

u

−A (1 + 2k ) (1 + 2k 2 ) (1 + 2k 4 ) (1 + 2k 8 ) · · · (1 + 2k 2 )

mod 2N

(1.21-3)

The equivalent method for exact division by polynomials (over GF(2)) is given in section 40.1.6 on
page 826.

1.21.3

Computation of the square root

x
= ...............................1 =
inv = ...............................1
sqrt = ...............................1
x
inv
x
x
x
inv
x
inv
x
sqrt
x

=
=
=
=
=
=
=
=
=
=

11111111111111111111111111111111
11111111111111111111111111111111
..............................1.
1111111111111111111111111111111.
..............................11
1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.11
111111111111111111111111111111.1
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
.............................1..
..............................1.

1

= -1
= 2
= -2
= 3
= -3
=

4

= 111111111111111111111111111111.. = -4

x
= .............................1.1 =
inv = 11..11..11..11..11..11..11..11.1

5

x
inv
x
x
x
inv
x
inv
sqrt
x

=
=
=
=
=
=
=
=
=
=

11111111111111111111111111111.11
..11..11..11..11..11..11..11..11
.............................11.
11111111111111111111111111111.1.
.............................111
1.11.11.11.11.11.11.11.11.11.111
11111111111111111111111111111..1
.1..1..1..1..1..1..1..1..1..1..1
1..111..1..11...11......1.11.1.1
............................1...

= -5

x
x
inv
sqrt

=
=
=
=

11111111111111111111111111111... = -8
............................1..1 = 9
..111...111...111...111...111..1
111111111111111111111111111111.1

= 6
= -6
= 7
= -7
=

8

Figure 1.21-A: Examples of the inverse and square root modulo 2n of x where −9 ≤ x ≤ +9. Where
no inverse or square root is given, it does not exist.
With the inverse square root we choose the start value to match d/2 + 1 as that guarantees four bits
of initial precision. Moreover, we control which of the two possible values of the inverse square root is
computed. The argument modulo 8 has to be equal to 1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

static inline ulong invsqrt2adic(ulong d)
// Return inverse square root modulo 2**BITS_PER_LONG
// Must have: d==1 mod 8
// The number of correct bits is doubled with each step
// ==> loop is executed prop. log_2(BITS_PER_LONG) times
// precision is 4, 8, 16, 32, 64, ... bits (or better)
{
if ( 1 != (d&7) ) return 0; // no inverse sqrt
// start value: if d == ****10001 ==> x := ****1001
ulong x = (d >> 1) | 1;
ulong p, y;
do
{
y = x;
p = (3 - d * y * y);
x = (y * p) >> 1;
}
while ( x!=y );
return x;
}

58


√
The square root is computed as d · 1/ d:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong sqrt2adic(ulong d)
// Return square root modulo 2**BITS_PER_LONG
// Must have: d==1 mod 8 or d==4 mod 32, d==16 mod 128
//
... d==4**k mod 4**(k+3)
// Result undefined if condition does not hold
{
if ( 0==d ) return 0;
ulong s = 0;
while ( 0==(d&1) ) { d >>= 1; ++s; }
d *= invsqrt2adic(d);
d <<= (s>>1);
return
d;
}

Note that the square root modulo 2n is something completely diﬀerent from the integer square root in
√
general. If the argument d is a perfect square, then the result is ± d. The output of the program [FXT:
bits/bit2adic-demo.cc] is shown in ﬁgure 1.21-A. For further information see [213, ex.31, p.213], [135,
chap.6, p.126], and also [208].

1.22

Radix −2 (minus two) representation

The radix −2 representation of a number n is
∞

tk (−2)k

n =

(1.22-1)

k=0

where the tk are zero or one. For integers n the sum is terminating: the highest nonzero tk is at most
two positions beyond the highest bit of the binary representation of the absolute value of n (with two’s
complement).

1.22.1

Conversion from binary
k:
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

bin(k)
.......
......1
.....1.
.....11
....1..
....1.1
....11.
....111
...1...
...1..1
...1.1.
...1.11
...11..
...11.1
...111.
...1111
..1....
..1...1
..1..1.
..1..11
..1.1..
..1.1.1
..1.11.
..1.111
..11...
..11..1
..11.1.
..11.11
..111..
..111.1
..1111.
..11111

m=bin2neg(k)
.......
......1
....11.
....111
....1..
....1.1
..11.1.
..11.11
..11...
..11..1
..1111.
..11111
..111..
..111.1
..1..1.
..1..11
..1....
..1...1
..1.11.
..1.111
..1.1..
..1.1.1
11.1.1.
11.1.11
11.1...
11.1..1
11.111.
11.1111
11.11..
11.11.1
11...1.
11...11

g=gray(m)
.......
......1
....1.1
....1..
....11.
....111
..1.111
..1.11.
..1.1..
..1.1.1
..1...1
..1....
..1..1.
..1..11
..11.11
..11.1.
..11...
..11..1
..111.1
..111..
..1111.
..11111
1.11111
1.1111.
1.111..
1.111.1
1.11..1
1.11...
1.11.1.
1.11.11
1.1..11
1.1..1.

dec(g)
0 <=
1 <=
5
4
2
3 <=
19
18
20
21
17
16
14
15
7
6
8
9
13
12
10
11 <=
75
74
76
77
73
72
70
71
79
78

0
1
5

21

Figure 1.22-A: Radix −2 representations and their Gray codes. Lines ending in ‘<=N’ indicate that all
values ≤ N occur in the last column up to that point.

1.22: Radix −2 (minus two) representation

59

A surprisingly simple algorithm to compute the coefficients tk of the radix −2 representation of a binary
number is [39, item 128] [FXT: bits/negbin.h]:
1
2
3
4
5
6
7
8

static inline ulong bin2neg(ulong x)
// binary --> radix(-2)
{
const ulong m = 0xaaaaaaaaUL; // 32 bit version
x += m;
x ^= m;
return x;
}

An example:
14 --> ..1..1. == 16 - 2 == (-2)^4 + (-2)^1
The inverse routine executes the inverse of the two steps in reversed order:
1
2
3
4
5
6
7
8
9

static inline ulong neg2bin(ulong x)
// radix(-2) --> binary
// inverse of bin2neg()
{
const ulong m = 0xaaaaaaaaUL; // 32-bit version
x ^= m;
x -= m;
return x;
}

Figure 1.22-A shows the output of the program [FXT: bits/negbin-demo.cc]. The sequence of Gray codes
of the radix −2 representation is a Gray code for the numbers in the range 0, . . . , k for the following
values of k (entry A002450 in [312]):
k

1, 5, 21, 85, 341, 1365, 5461, 21845, 87381, 349525, 1398101, . . . , (4n − 1)/3

Fixed points of the conversion ‡

1.22.2
0:
1:
4:
5:
16:
17:
20:
21:

=

...........
..........1
........1..
........1.1
......1....
......1...1
......1.1..
......1.1.1

64:
65:
68:
69:
80:
81:
84:
85:

....1......
....1.....1
....1...1..
....1...1.1
....1.1....
....1.1...1
....1.1.1..
....1.1.1.1

256:
257:
260:
261:
272:
273:
276:
277:

..1........
..1.......1
..1.....1..
..1.....1.1
..1...1....
..1...1...1
..1...1.1..
..1...1.1.1

320:
321:
324:
325:
336:
337:
340:
341:

..1.1......
..1.1.....1
..1.1...1..
..1.1...1.1
..1.1.1....
..1.1.1...1
..1.1.1.1..
..1.1.1.1.1

Figure 1.22-B: The fixed points of the conversion and their binary representations (dots denote zeros).
The sequence of fixed points of the conversion starts as
0, 1, 4, 5, 16, 17, 20, 21, 64, 65, 68, 69, 80, 81, 84, 85, 256, ...

The binary representations have ones only at even positions (see figure 1.22-B). This is the Moser –
De Bruijn sequence, entry A000695 in [312]. The generating function of the sequence is
1
1−x

∞

j=0

j

4j x2
1 + x2j

x + 4 x2 + 5 x3 + 16 x4 + 17 x5 + 20 x6 + 21 x7 + 64 x8 + 65 x9 + . . . (1.22-2)

=

The sequence also appears as exponents in the power series (see also section 38.10.1 on page 750)
∞

1 + x4

k

=

1 + x + x4 + x5 + x16 + x17 + x20 + x21 + x64 + x65 + x68 + . . . (1.22-3)

k=0

The k-th fixed point is computed by moving all bits of the binary representation of k to position 2 x
where x ≥ 0 is the index of the bit under consideration:

60
1
2
3
4

static inline ulong negbin_fixed_point(ulong k)
{
return bit_zip0(k);
}

The bit-zip function is given in section 1.15 on page 39. The sequence of radix −2 representations of
0, 1, 2, . . ., interpreted as binary numbers, is entry A005351 in [312]:
0,1,6,7,4,5,26,27,24,25,30,31,28,29,18,19,16,17,22,23,20,21,106,107,104,105,110,111, ...

The corresponding sequence for the negative numbers −1, −2, −3, . . . is entry A005352:
3,2,13,12,15,14,9,8,11,10,53,52,55,54,49,48,51,50,61,60,63,62,57,56,59,58,37,36,39,38, ...

More information about ‘non-standard’ representations of numbers can be found in [213].

1.22.3

Generating negbin words in order

................................................................
......................111111111111111111111111111111111111111111
......................11111111111111111111111111111111..........
......1111111111111111................1111111111111111..........
......11111111........11111111........11111111........11111111..
..1111....1111....1111....1111....1111....1111....1111....1111..
..11..11..11..11..11..11..11..11..11..11..11..11..11..11..11..11
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
................................................................
...........................................111111111111111111111
...........................................111111111111111111111
...........11111111111111111111111111111111.....................
...........1111111111111111................1111111111111111.....
...11111111........11111111........11111111........11111111.....
...1111....1111....1111....1111....1111....1111....1111....1111.
.11..11..11..11..11..11..11..11..11..11..11..11..11..11..11..11.
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
Figure 1.22-C: Radix −2 representations of the numbers 0 . . . + 63 (top) and 0 . . . − 63 (bottom).
A radix −2 representation can be incremented by the function [FXT: bits/negbin.h] (32-bit versions in
what follows):
1
2
3
4
5
6
7
8
9
10

static inline ulong next_negbin(ulong x)
// With x the radix(-2) representation of n
// return radix(-2) representation of n+1.
{
x ^= m;
++x;
x ^= m;
return x;
}

A version without constants is
1
2
3
4
5

ulong s = x << 1;
ulong y = x ^ s;
y += 1;
s ^= y;
return s;

Decrementing can be done via
1
2
3
4
5
6
7
8
9
10

static inline ulong prev_negbin(ulong x)
// With x the radix(-2) representation of n
// return radix(-2) representation of n-1.
{
x ^= m;
--x;
x ^= m;
return x;
}

or via

1.23: A sparse signed binary representation
1
2
3
4
5

61

const ulong m = 0x55555555UL;
x ^= m;
++x;
x ^= m;
return x;

The functions are quite fast, about 730 million words per second are generated (3 cycles per increment
or decrement). Figure 1.22-C shows the generated words in forward (top) and backward (bottom) order.
It was created with the program [FXT: bits/negbin2-demo.cc].

1.23

A sparse signed binary representation
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

.......
......1
.....1.
.....11
....1..
....1.1
....11.
....111
...1...
...1..1
...1.1.
...1.11
...11..
...11.1
...111.
...1111
..1....
..1...1
..1..1.
..1..11
..1.1..
..1.1.1
..1.11.
..1.111
..11...
..11..1
..11.1.
..11.11
..111..
..111.1
..1111.
..11111
.1.....

.......
......P
.....P.
....P.M
....P..
....P.P
...P.M.
...P..M
...P...
...P..P
...P.P.
..P.M.M
..P.M..
..P.M.P
..P..M.
..P...M
..P....
..P...P
..P..P.
..P.P.M
..P.P..
..P.P.P
.P.M.M.
.P.M..M
.P.M...
.P.M..P
.P.M.P.
.P..M.M
.P..M..
.P..M.P
.P...M.
.P....M
.P.....

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

+1
+2
+4 -1
+4
+4 +1
+8 -2
+8 -1
+8
+8 +1
+8 +2
+16 -4
+16 -4
+16 -4
+16 -2
+16 -1
+16
+16 +1
+16 +2
+16 +4
+16 +4
+16 +4
+32 -8
+32 -8
+32 -8
+32 -8
+32 -8
+32 -4
+32 -4
+32 -4
+32 -2
+32 -1
+32

-1
+1

-1
+1
-2
-1
+1
+2
-1
+1

Figure 1.23-A: Sparse signed binary representations (nonadjacent form, NAF). The symbols ‘P’ and ‘M’
are respectively used for +1 and −1, dots denote zeros.
0:
1:
2:
4:
5:
8:
9:
10:
16:
17:
18:
20:
21:
32:
33:
34:
36:
37:
40:
41:
42:
64:

........
.......1
......1.
.....1..
.....1.1
....1...
....1..1
....1.1.
...1....
...1...1
...1..1.
...1.1..
...1.1.1
..1.....
..1....1
..1...1.
..1..1..
..1..1.1
..1.1...
..1.1..1
..1.1.1.
.1......

........
.......P
......P.
.....P..
.....P.P
....P...
....P..P
....P.P.
...P....
...P...P
...P..P.
...P.P..
...P.P.P
..P.....
..P....P
..P...P.
..P..P..
..P..P.P
..P.P...
..P.P..P
..P.P.P.
.P......

0
1
2
4
5
8
9
10
16
17
18
20
21
32
33
34
36
37
40
41
42
64

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

+1
+2
+4
+4 +1
+8
+8 +1
+8 +2
+16
+16 +1
+16 +2
+16 +4
+16 +4
+32
+32 +1
+32 +2
+32 +4
+32 +4
+32 +8
+32 +8
+32 +8
+64

+1

+1
+1
+2

Figure 1.23-B: The numbers whose negative part in the NAF representation is zero.

62


An algorithm to compute a representation of a number x as
∞

x

sk · 2k

=

sk ∈ {−1, 0, +1}

where

(1.23-1)

k=0

such that two consecutive digits sk , sk+1 are never simultaneously nonzero is given in [275]. Figure 1.23-A
gives the representation of several small numbers. It is the output of [FXT: bits/bin2naf-demo.cc].
We can convert the binary representation of x into a pair of binary numbers that correspond to the
positive and negative digits [FXT: bits/bin2naf.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static inline void bin2naf(ulong x, ulong &np, ulong &nm)
// Compute (nonadjacent form, NAF) signed binary representation of x:
// the unique representation of x as
//
x=sum_{k}{d_k*2^k} where d_j in {-1,0,+1}
//
and no two adjacent digits d_j, d_{j+1} are both nonzero.
// np has bits j set where d_j==+1
// nm has bits j set where d_j==-1
// We have: x = np - nm
{
ulong xh = x >> 1; // x/2
ulong x3 = x + xh; // 3*x/2
ulong c = xh ^ x3;
np = x3 & c;
nm = xh & c;
}

Converting back to binary is trivial:
1

static inline ulong naf2bin(ulong np, ulong nm)

{ return ( np - nm ); }

The representation is one example of a nonadjacent form (NAF). A method for the computation of certain
nonadjacent forms (w-NAF) is given in [255]. A Gray code for the signed binary words is described in
section 14.7 on page 315.
If a binary word contains no consecutive ones, then the negative part of the NAF representation is zero.
The sequence of values is [0, 1, 2, 4, 5, 8, 9, 10, 16, . . .], entry A003714 in [312], see ﬁgure 1.23-B. The
numbers are called the Fibbinary numbers.

1.24

Generating bit combinations

1.24.1

Co-lexicographic (colex) order

Given a binary word with k bits set the following routine computes the binary word that is the next
combination of k bits in co-lexicographic order. In the co-lexicographic order the reversed sets are sorted,
see ﬁgure 1.24-A. The method to determine the successor is to determine the lowest block of ones and
move its highest bit one position up. Then the rest of the block is moved to the low end of the word
[FXT: bits/bitcombcolex.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong next_colex_comb(ulong x)
{
ulong r = x & -x;
// lowest set bit
x += r;
// replace lowest block by a one left to it
if ( 0==x )

return 0;

ulong z = x & -x;
z -= r;

// input was last combination
// first zero beyond lowest block
// lowest block (cf. lowest_block())

while ( 0==(z&1) ) { z >>= 1; } // move block to low end of word
return x | (z>>1);
// need one bit less of low block
}

One could replace the while-loop by a bit scan and shift combination. The combinations 32 are generated
20
at a rate of about 142 million per second. The rate is about 120 M/s for the combinations 32 , the rate
12
with 60 is 70 M/s, and with 60 it is 160 M/s.
7
53

1.24: Generating bit combinations

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

word
...111
..1.11
..11.1
..111.
.1..11
.1.1.1
.1.11.
.11..1
.11.1.
.111..
1...11
1..1.1
1..11.
1.1..1
1.1.1.
1.11..
11...1
11..1.
11.1..
111...

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

set
0, 1,
0, 1,
0, 2,
1, 2,
0, 1,
0, 2,
1, 2,
0, 3,
1, 3,
2, 3,
0, 1,
0, 2,
1, 2,
0, 3,
1, 3,
2, 3,
0, 4,
1, 4,
2, 4,
3, 4,

63

2
3
3
3
4
4
4
4
4
4
5
5
5
5
5
5
5
5
5
5

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

Figure 1.24-A: Combinations

6
3

set (reversed)
{ 2, 1, 0 }
{ 3, 1, 0 }
{ 3, 2, 0 }
{ 3, 2, 1 }
{ 4, 1, 0 }
{ 4, 2, 0 }
{ 4, 2, 1 }
{ 4, 3, 0 }
{ 4, 3, 1 }
{ 4, 3, 2 }
{ 5, 1, 0 }
{ 5, 2, 0 }
{ 5, 2, 1 }
{ 5, 3, 0 }
{ 5, 3, 1 }
{ 5, 3, 2 }
{ 5, 4, 0 }
{ 5, 4, 1 }
{ 5, 4, 2 }
{ 5, 4, 3 }

in co-lexicographic order. The reversed sets are sorted.

A variant of the method which involves a division appears in [39, item 175]. The routine given here is
due to Doug Moore and Glenn Rhoads.
The following routine computes the predecessor of a combination:
1
2
3
4
5
6
7

static inline ulong prev_colex_comb(ulong x)
// Inverse of next_colex_comb()
{
x = next_colex_comb( ~x );
if ( 0!=x ) x = ~x;
return x;
}

The first and last combination can be computed via
1
2
3
4
5
6
7
8
9

static inline ulong first_comb(ulong k)
// Return the first combination of (i.e. smallest word with) k bits,
// i.e. 00..001111..1 (k low bits set)
// Must have: 0 <= k <= BITS_PER_LONG
{
ulong t = ~0UL >> ( BITS_PER_LONG - k );
if ( k==0 ) t = 0; // shift with BITS_PER_LONG is undefined
return t;
}

and
1
2
3
4
5
6
7

static inline ulong last_comb(ulong k, ulong n=BITS_PER_LONG)
// return the last combination of (biggest n-bit word with) k bits
// i.e. 1111..100..00 (k high bits set)
// Must have: 0 <= k <= n <= BITS_PER_LONG
{
return first_comb(k) << (n - k);
}

The if-statement in first_comb() is needed because a shift by more than BITS_PER_LONG−1 is undefined
by the C-standard, see section 1.1.5 on page 4.
The listing in figure 1.24-A can be created with the program [FXT: bits/bitcombcolex-demo.cc]:
1
2
3
4
5
6
7
8

ulong n = 6, k = 3;
ulong last = last_comb(k, n);
ulong g = first_comb(k);
ulong gg = 0;
do
{
// visit combination given as word g
gg = g;

64
9
10
11

g = next_colex_comb(g);
}
while ( gg!=last );

1.24.2

Lexicographic (lex) order

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

lex (5, 3)
word =
set
..111 = { 0, 1, 2 }
.1.11 = { 0, 1, 3 }
1..11 = { 0, 1, 4 }
.11.1 = { 0, 2, 3 }
1.1.1 = { 0, 2, 4 }
11..1 = { 0, 3, 4 }
.111. = { 1, 2, 3 }
1.11. = { 1, 2, 4 }
11.1. = { 1, 3, 4 }
111.. = { 2, 3, 4 }

colex (5, 2)
word =
set
...11 = { 0, 1 }
..1.1 = { 0, 2 }
..11. = { 1, 2 }
.1..1 = { 0, 3 }
.1.1. = { 1, 3 }
.11.. = { 2, 3 }
1...1 = { 0, 4 }
1..1. = { 1, 4 }
1.1.. = { 2, 4 }
11... = { 3, 4 }

Figure 1.24-B: Combinations 5 in lexicographic order (left). The sets are sorted. The binary words
3
with lex order are the bit-reversed complements of the words with colex order (right).
The binary words corresponding to combinations n in lexicographic order are the bit-reversed comk
n
plements of the words for the combinations n−k in co-lexicographic order, see figure 1.24-B. A more
precise term for the order is subset-lex (for sets written with elements in increasing order). The sequence
is identical to the delta-set-colex order backwards.
The program [FXT: bits/bitcomblex-demo.cc] shows how to compute the subset-lex sequence efficiently:
1
2
3
4
5
6
7
8
9
10
11
12
13

ulong n = 5, k = 3;
ulong x = first_comb(n-k);
// first colex (n-k choose n)
const ulong m = first_comb(n);
// aux mask
const ulong l = last_comb(k, n); // last colex
ulong ct = 0;
ulong y;
do
{
y = revbin(~x, n) & m; // lex order
// visit combination given as word y
x = next_colex_comb(x);
}
while ( y != l );

The bit-reversal routine revbin() is shown in section 1.14 on page 33. Sections 6.2.1 on page 177 and
section 6.2.2 give iterative algorithms for combinations (represented by arrays) in lex and colex order,
respectively.

1.24.3

Shifts-order
1:
2:
3:
4:
5:

1....
.1...
..1..
...1.
....1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

11...
.11..
..11.
...11
1.1..
.1.1.
..1.1
1..1.
.1..1
1...1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Figure 1.24-C: Combinations

111..
.111.
..111
11.1.
.11.1
11..1
1.11.
.1.11
1.1.1
1..11
5
k

1:
2:
3:
4:
5:

1111.
.1111
111.1
11.11
1.111

, for k = 1, 2, 3, 4 in shifts-order.

Figure 1.24-C shows combinations in shifts-order. The order for combinations n is obtained from the
k
shifts-order for subsets (section 8.4 on page 208) by discarding all subsets whose number of elements are
= k and reversing the list order. The first combination is [1k 0n−k ] and the successor is computed as
follows (see figure 1.24-D):

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

1111...
.1111..
..1111.
...1111
111.1..
.111.1.
..111.1
111..1.
.111..1
111...1
11.11..
.11.11.
..11.11
11.1.1.
.11.1.1
11.1..1
11..11.
.11..11

< S
< S
< S
< S-2
< S
< S
< S-2

65
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

Figure 1.24-D: Updates with combinations

7
4

.11..11
11..1.1
11...11
1.111..
.1.111.
..1.111
1.11.1.
.1.11.1
1.11..1
1.1.11.
.1.1.11
1.1.1.1
1.1..11
1..111.
.1..111
1..11.1
1..1.11
1...111

< S
< S-2
< S-2
< S
< S
< S-2
< S
< S-2
< S-2
< S
< S-2
< S-2

: simple split ‘S’, split second ‘S-2’, easy case unmarked.

1. Easy case: if the rightmost one is not in position zero (least signiﬁcant bit), then shift the word to
the right and return the combination.
2. Finished?: if the combination is the last one ([0n ], [0n−1 1], [10n−k 1k−1 ]), then return zero.
3. Shift back: shift the word to the left such that the leftmost one is in the leftmost position (this can
be a no-op).
4. Simple split: if the rightmost one is not the least signiﬁcant bit, then move it one position to the
right and return the combination.
5. Split second block: move the rightmost bit of the second block (from the right) of ones one position
to the right and attach the lowest block of ones and return the combination.
An implementation is given in [FXT: bits/bitcombshifts.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class bit_comb_shifts
{
public:
ulong x_; // the
ulong s_; // how
ulong n_, k_; //
ulong last_;
//

combination
far shifted to the right
combinations (n choose k)
last combination

public:
bit_comb_shifts(ulong n, ulong k)
{
n_ = n; k_ = k;
first();
}
ulong first(ulong n, ulong k)
{
s_ = 0;
x_ = last_comb(k, n);
if ( k>1 )
else

last_ = first_comb(k-1) | (1UL<<(n_-1));
last_ = k; // [000001] or [000000]

return x_;
}
ulong first()

{ return first(n_, k_); }

ulong next()
{
if ( 0==(x_&1) ) // easy case:
{
++s_;
x_ >>= 1;
return x_;
}
else // splitting cases:

// [10000111]

66
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

{
if ( x_ == last_ )
x_ <<= s_; s_ = 0;
ulong b = x_ & -x_;

return 0;

// combination was last

// shift back to the left
// lowest bit

if ( b!=1UL ) // simple split
{
x_ -= (b>>1); // move rightmost bit to the right
return x_;
}
else // split second block and attach first
{
ulong t = low_ones(x_); // block of ones at lower end
x_ ^= t; // remove block
ulong b2 = x_ & -x_; // (second) lowest bit
b2 >>= 1;
x_ -= b2;

// move bit to the right

// attach block:
do { t<<=1; } while ( 0==(t&x_) );
x_ |= (t>>1);
return x_;
}
}
}
};

The combinations 32 are generated at a rate of about 150 M/s, for the combinations 32 the rate is
20
12
about 220 M/s [FXT: bits/bitcombshifts-demo.cc]. The rate with the combinations 60 is 415 M/s and
7
with 60 it is 110 M/s. The generation is very fast for the sparse case.
53

1.24.4

Minimal-change order ‡

The following routine is due to Doug Moore [FXT: bits/bitcombminchange.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

static inline ulong igc_next_minchange_comb(ulong x)
// Return the inverse Gray code of the next combination in minimal-change order.
// Input must be the inverse Gray code of the current combination.
{
ulong g = rev_gray_code(x);
ulong i = 2;
ulong cb; // ==candidate bits;
do
{
ulong y = (x & ~(i-1)) + i;
ulong j = lowest_one(y) << 1;
ulong h = !!(y & j);
cb = ((j-h) ^ g) & (j-i);
i = j;
}
while ( 0==cb );
return

x + lowest_one(cb);

}

It can be used as suggested by the routine
1
2
3
4
5
6
7
8
9

static inline ulong next_minchange_comb(ulong x, ulong last)
// Not efficient, just to explain the usage of igc_next_minchange_comb()
// Must have: last==igc_last_comb(k, n)
{
if ( x==last ) return 0;
x = igc_next_minchange_comb(x);
return gray_code(x);
}

The auxiliary function igc_last_comb() is (32-bit version only)
1
2

static inline ulong igc_last_comb(ulong k, ulong n)
// Return the (inverse Gray code of the) last combination

3
4
5
6
7
8
9
10
11
12

67

// as in igc_next_minchange_comb()
{
if ( 0==k ) return 0;

//
}

const ulong f = 0xaaaaaaaaUL >> (BITS_PER_LONG-k); // == first_sequency(k);
const ulong c = ~0UL >> (BITS_PER_LONG-n); // == first_comb(n);
return c ^ (f>>1);
// =^= (by Doug Moore)
return ((1UL<<n) - 1) ^ (((1UL<<k) - 1) / 3);

Successive combinations differ in exactly two positions. For example, with n = 5 and k = 3:
x
..111
.11.1
.111.
.1.11
11..1
11.1.
111..
1.1.1
1.11.
1..11

inverse_gray_code(x)
..1.1 == first_sequency(k)
.1..1
.1.11
.11.1
1...1
1..11
1.111
11..1
11.11
111.1 == igc_last_comb(k, n)

The same run of bit combinations would be generated by going through the Gray codes and omitting all
words where the bit-count is not equal to k. The algorithm shown here is much more efficient.
For greater efficiency one may prefer code which avoids the repeated computation of the inverse Gray
code, for example:
1
2
3
4
5
6
7
8
9
10

ulong last = igc_last_comb(k, n);
ulong c, nc = first_sequency(k);
do
{
c = nc;
nc = igc_next_minchange_comb(c);
ulong g = gray_code(c);
// Here g contains the bit-combination
}
while ( c!=last );

n = 6 k = 2
....11 ....1.
...11. ...1..
...1.1 ...11.
..11.. ..1...
..1.1. ..11..
..1..1 ..111.
.11... .1....
.1.1.. .11...
.1..1. .111..
.1...1 .1111.
11.... 1.....
1.1... 11....
1..1.. 111...
1...1. 1111..
1....1 11111.

....1.
....1.
....1.
...1..
....1.
....1.
..1...
...1..
....1.
....1.
.1....
..1...
...1..
....1.
....1.

n = 6 k = 3
...111 ...1.1
..11.1 ..1..1
..111. ..1.11
..1.11 ..11.1
.11..1 .1...1
.11.1. .1..11
.111.. .1.111
.1.1.1 .11..1
.1.11. .11.11
.1..11 .111.1
11...1 1....1
11..1. 1...11
11.1.. 1..111
111... 1.1111
1.1..1 11...1
1.1.1. 11..11
1.11.. 11.111
1..1.1 111..1
1..11. 111.11
1...11 1111.1

...1..
....1.
....1.
...1..
....1.
...1..
....1.
....1.
....1.
...1..
....1.
...1..
..1...
....1.
....1.
...1..
....1.
....1.
....1.
...1..

n = 6 k = 4
..1111 ..1.1.
.11.11 .1..1.
.1111. .1.1..
.111.1 .1.11.
.1.111 .11.1.
11..11 1...1.
11.11. 1..1..
11.1.1 1..11.
1111.. 1.1...
111.1. 1.11..
111..1 1.111.
1.1.11 11..1.
1.111. 11.1..
1.11.1 11.11.
1..111 111.1.

..1...
....1.
....1.
...1..
..1...
....1.
....1.
....1.
...1..
....1.
...1..
....1.
....1.
...1..
..1...

Figure 1.24-E: Minimal-change combinations, their inverse Gray codes, and the differences of the inverse
Gray codes. The differences are powers of 2.
The difference of the inverse Gray codes of two successive combinations is always a power of 2, see
figure 1.24-E (the listings were created with the program [FXT: bits/bitcombminchange-demo.cc]). With
this observation we can derive a different version that checks the pattern of the change:
1
2
3
4
5
6
7

static inline ulong igc_next_minchange_comb(ulong x)
// Alternative version.
{
ulong gx = gray_code( x );
ulong i = 2;
do
{

68
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ulong
i <<=
ulong
ulong
//
//
if
//
//

y = x + i;
1;
gy = gray_code( y );
r = gx ^ gy;

Check that change consists of exactly one bit
of the new and one bit of the old pattern:
( is_pow_of_2( r & gy ) && is_pow_of_2( r & gx ) ) break;
is_pow_of_2(x):=((x & -x) == x) returns 1 also for x==0.
But this cannot happen for both tests at the same time

}
while ( 1 );
return y;
}

This version is the fastest: the combinations 32 are generated at a rate of about 96 million per second,
12
the combinations 32 at a rate of about 83 million per second.
20
Here is another version which needs the number of set bits as a second parameter:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong igc_next_minchange_comb(ulong x, ulong k)
// Alternative version, uses the fact that the difference
// of two successive x is the smallest possible power of 2.
{
ulong y, i = 2;
do
{
y = x + i;
i <<= 1;
}
while ( bit_count( gray_code(y) ) != k );
return y;
}

The routine will be fast if the CPU has a bit-count instruction. The necessary modiﬁcation for the
generation of the previous combination is trivial:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong igc_prev_minchange_comb(ulong x, ulong k)
// Returns the inverse graycode of the previous combination in minimal-change order.
// Input must be the inverse graycode of the current combination.
// With input==first the output is the last for n=BITS_PER_LONG
{
ulong y, i = 2;
do
{
y = x - i;
i <<= 1;
}
while ( bit_count( gray_code(y) ) != k );
return y;
}

1.25

Generating bit subsets of a given word

1.25.1

Counting order

To generate all subsets of the set of ones of a binary word we use the sparse counting idea shown in
section 1.8.1 on page 20. The implementation is [FXT: class bit subset in bits/bitsubset.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

class bit_subset
{
public:
ulong u_; // current subset
ulong v_; // the full set
public:
bit_subset(ulong v) : u_(0), v_(v) { ; }
~bit_subset() { ; }
ulong current() const { return u_; }
ulong next() { u_ = (u_ - v_) & v_; return u_; }
ulong prev() { u_ = (u_ - 1 ) & v_; return u_; }

1.25: Generating bit subsets of a given word
14
15
16
17
18
19

69

ulong first(ulong v) { v_=v; u_=0; return u_; }
ulong first() { first(v_); return u_; }
ulong last(ulong v) { v_=v; u_=v; return u_; }
ulong last() { last(v_); return u_; }
};

With the word [...11.1.] the following sequence of words is produced by subsequent next()-calls:
......1.
....1...
....1.1.
...1....
...1..1.
...11...
...11.1.
........

A block of ones at the right will result in the binary counting sequence. About 1.1 billion subsets per
second are generated with both next() and prev() [FXT: bits/bitsubset-demo.cc].

1.25.2

Minimal-change order

We use a method to isolate the changing bit from counting order that does not depend on shifting:
*******0111
*******1000
00000001111
00000001000

= u
= u+1
= (u+1) ^ u
= ((u+1) ^ u) & (u+1)

<--= bit to change

The method still works if the set bits are separated by any amount of zeros. In fact, we want to ﬁnd
the single bit that changed from 0 to 1. The bits that switched from 0 to 1 in the transition from the
word A to B can also be isolated via X=B&~A. The implementation is [FXT: class bit subset gray in
bits/bitsubset-gray.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class bit_subset_gray
{
public:
bit_subset S_;
ulong g_; // subsets in Gray code order
ulong h_; // highest bit in S_.v_; needed for the prev() method
public:
bit_subset_gray(ulong v) : S_(v), g_(0), h_(highest_one(v))
~bit_subset_gray() { ; }

{ ; }

ulong current() const { return g_; }
ulong next()
{
ulong u0 = S_.current();
if ( u0 == S_.v_ ) return first();
ulong u1 = S_.next();
ulong x = ~u0 & u1;
g_ ^= x;
return g_;
}
ulong first(ulong v) { S_.first(v); h_=highest_one(v);
ulong first() { S_.first(); g_=0; return g_; }
[--snip--]

g_=0;

return g_; }

With the word [...11.1.] the following sequence of words is produced by subsequent next()-calls:
......1.
....1.1.
....1...
...11...
...11.1.
...1..1.
...1....
........

A block of ones at the right will result in the binary Gray code sequence, see [FXT: bits/bitsubset-graydemo.cc]. The method prev() computes the previous word in the sequence, note the swapped roles of
the variables u0 and u1:
1
2
3

[--snip--]
ulong prev()
{

70
4
5
6
7
8
9
10
11
12
13
14

ulong u1 = S_.current();
if ( u1 == 0 ) return last();
ulong u0 = S_.prev();
ulong x = ~u0 & u1;
g_ ^= x;
return g_;
}
ulong last(ulong v) { S_.last(v);
ulong last() { S_.last(); g_=h_;

h_=highest_one(v);
return g_; }

g_=h_;

return g_; }

};

About 365 million subsets per second are generated with both next() and prev().

1.26

Binary words in lexicographic order for subsets

1.26.1

Next and previous word in lexicographic order
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

1...
11..
111.
1111
11.1
1.1.
1.11
1..1
.1..
.11.
.111
.1.1
..1.
..11
...1

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

8
12
14
15
13
10
11
9
4
6
7
5
2
3
1

{0}
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{1}
{1,
{1,
{1,
{2}
{2,
{3}

1}
1,
1,
1,
2}
2,
3}

2}
2, 3}
3}
3}

2}
2, 3}
3}
3}

Figure 1.26-A: Binary words corresponding to nonempty subsets of the 4-element set in lexicographic
order with respect to subsets. Note the ﬁrst element of the subsets corresponds to the highest set bit.
[0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

......
.....1
....11
....1.
...1.1
...111
...11.
...1..
..1..1
..1.11
..1.1.
..11.1
..1111
..111.
..11..
..1...

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

0
1
3
2
5
7
6
4
9
11
10
13
15
14
12
8

*]
*

*
*

16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

.1...1
.1..11
.1..1.
.1.1.1
.1.111
.1.11.
.1.1..
.11..1
.11.11
.11.1.
.111.1
.11111
.1111.
.111..
.11...
.1....

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

17
19
18 *
21
23
22
20
25
27
26
29
31
30
28
24
16

32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:

1....1
1...11
1...1.
1..1.1
1..111
1..11.
1..1..
1.1..1
1.1.11
1.1.1.
1.11.1
1.1111
1.111.
1.11..
1.1...
11...1

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

33
35
34 *
37
39
38
36
41
43
42
45
47
46
44
40
49

48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

11..11
11..1.
11.1.1
11.111
11.11.
11.1..
111..1
111.11
111.1.
1111.1
111111
11111.
1111..
111...
11....
1.....

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

51
50
53
55
54
52
57
59
58
61
63
62
60 *
56
48
32

Figure 1.26-B: Binary words corresponding to the subsets of the 6-element set, as generated by
prev lexrev(). Fixed points are marked with asterisk.
The (bit-reversed) binary words in lexicographic order with respect to the subsets shown in ﬁgure 1.26-A
can be generated by successive calls to the following function [FXT: bits/bitlex.h]:
1
2
3
4
5
6
7
8
9

static inline ulong next_lexrev(ulong x)
// Return next word in subset-lex order.
{
ulong x0 = x & -x; // lowest bit
if ( 1!=x0 ) // easy case: set bit right of lowest bit
{
x0 >>= 1;
x ^= x0;
return x;

1.26: Binary words in lexicographic order for subsets
10
11
12
13
14
15
16
17
18

71

}
else // lowest bit at word end
{
x ^= x0; // clear lowest bit
x0 = x & -x; // new lowest bit ...
x0 >>= 1; x -= x0; // ... is moved one to the right
return x;
}
}

The bit-reversed representation was chosen because the isolation of the lowest bit is often cheaper than
the same operation on the highest bit. Starting with a one-bit word at position n − 1, we generate the
2n subsets of the word of n ones. The function is used as follows [FXT: bits/bitlex-demo.cc]:
ulong n = 4; // n-bit binary words
ulong x = 1UL<<(n-1); // first subset
do
{
// visit word x
}
while ( (x=next_lexrev(x)) );

The following function goes backward:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

static inline ulong prev_lexrev(ulong x)
// Return previous word in subset-lex order.
{
ulong x0 = x & -x; // lowest bit
if ( x & (x0<<1) ) // easy case: next higher bit is set
{
x ^= x0; // clear lowest bit
return x;
}
else
{
x += x0; // move lowest bit to the left
x |= 1;
// set rightmost bit
return x;
}
}

The sequence of all n-bit words is generated by 2n calls to prev_lexrev(), starting with zero. The words
corresponding to subsets of the 6-element set are shown in ﬁgure 1.26-B. The sequence [1, 3, 2, 5, 7, 6,
4, 9, . . . ] in the right column is entry A108918 in [312].
The rate of generation using next() is about 274 million per second and about 253 million per second
with prev(). An equivalent routine for arrays is given in section 8.1.2 on page 203. The routines are
useful for a special version of fast Walsh transforms described in section 23.5.3 on page 472.

1.26.2

Conversion between binary and lex-ordered words

A little contemplation on the structure of the binary words in lexicographic order leads to the routine
that allows random access to the k-th lex-rev word (unrank algorithm) [FXT: bits/bitlex.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong negidx2lexrev(ulong k)
{
ulong z = 0;
ulong h = highest_one(k);
while ( k )
{
while ( 0==(h&k) ) h >>= 1;
z ^= h;
++k;
k &= h - 1;
}
return z;
}

Let the inverse function be T (x), then we have T (0) = 0 and, with h(x) being the highest power of 2 not
greater than x,
T (x)

=

h(x) − 1 +

T (x − h(x)) if x − h(x) = 0
h(x)
otherwise

(1.26-1)

72


The ranking algorithm starts with the lowest bit:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline ulong lexrev2negidx(ulong x)
{
ulong h = x & -x; // lowest bit
ulong r = (h-1);
while ( x^=h )
{
r += (h-1);
h = x & -x; // next higher bit
}
r += h; // highest bit
return r;
}

1.26.3

Minimal decompositions into terms 2k − 1 ‡
....1
...11
...1.
..1.1
..111
..11.
..1..
.1..1
.1.11
.1.1.
.11.1
.1111
.111.
.11..
.1...
1...1
1..11
1..1.
1.1.1
1.111
1.11.
1.1..
11..1
11.11
11.1.
111.1
11111
1111.
111..
11...
1....

1
2
1
2
3
2
1
2
3
2
3
4
3
2
1
2
3
2
3
4
3
2
3
4
3
4
5
4
3
2
1

....1
...1.
...11
..1..
..1.1
..11.
..111
.1...
.1..1
.1.1.
.1.11
.11..
.11.1
.111.
.1111
1....
1...1
1..1.
1..11
1.1..
1.1.1
1.11.
1.111
11...
11..1
11.1.
11.11
111..
111.1
1111.
11111

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

1
1
3
3
3
3
7
7
7
7
7
7
7
7
15
15
15
15
15
15
15
15
15
15
15
15
15
15
15
15
31

+ 1
+ 1
+ 1 + 1
+ 3
+
+
+
+
+
+
+

1
1
3
3
3
3
7

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

1
1 +
3
3 +
3 +
3 +
7
7 +
7 +
7 +
7 +
7 +
7 +
7 +
15

+ 1
+ 1
+ 1 + 1
+ 3
1
1
1 + 1
3
1
1
3
3
3
3
7

+ 1
+ 1
+ 1 + 1
+ 3

Figure 1.26-C: Binary words in subset-lex order and their bit counts (left columns). The least number
of terms of the form 2k − 1 needed in the sum x = k 2k − 1 (right columns) equals the bit count.
The least number of terms needed in the sum x = k 2k − 1 equals the number of bits of the lex-word
as shown in ﬁgure 1.26-C. The number can be computed as
c = bit_count( negidx2lexrev( x ) );

Alternatively, we can subtract the greatest integer of the form 2k − 1 until x is zero and count the number
of subtractions. The sequence of these numbers is entry A100661 in [312]:
1,2,1,2,3,2,1,2,3,2,3,4,3,2,1,2,3,2,3,4,3,2,3,4,3,4,5,4,3,2,1,2,3,2,3,...
The following function can be used to compute the sequence:
1
2
3
4
5
6
7
8
9

void S(ulong f, ulong n) // A100661
{
static int s = 0;
++s;
cout << s << ",";
for (ulong m=1; m<n; m<<=1) S(f+m, m);
--s;
cout << s << ",";
}

1.26: Binary words in lexicographic order for subsets

73

If called with arguments f = 0 and n = 2k , it prints the first 2k+1 − 1 numbers of the sequence followed
by a zero. A generating function of the sequence is given by
∞

Z(x)

:=

n

−1 + 2 (1 − x) n=1 1 + x2
(1 − x)2

−1

=

1 + 2x + x2 + 2x3 + 3x4 + 2x5 + x6 + 2x7 + 3x8 + 2x9 + 3x10 + 4x11 + 3x12 + 2x13

1.26.4

(1.26-2)
+ ...

The sequence of fixed points ‡
0:
1:
6:
10:
18:
34:
60:
66:
92:
108:
116:
130:
156:
172:
180:
204:
212:
228:
258:
284:
300:
308:
332:
340:
356:
396:
404:
420:
452:

...........
..........1
........11.
.......1.1.
......1..1.
.....1...1.
.....1111..
....1....1.
....1.111..
....11.11..
....111.1..
...1.....1.
...1..111..
...1.1.11..
...1.11.1..
...11..11..
...11.1.1..
...111..1..
..1......1.
..1...111..
..1..1.11..
..1..11.1..
..1.1..11..
..1.1.1.1..
..1.11..1..
..11...11..
..11..1.1..
..11.1..1..
..111...1..

514:
.1.......1.
540:
.1....111..
556:
.1...1.11..
[--snip--]
1556:
.11....1.1..
1572:
.11...1..1..
1604:
.11..1...1..
1668:
.11.1....1..
1796:
.111.....1..
2040:
.11111111...
2050:
1.........1.
2076:
1......111..
2092:
1.....1.11..
2100:
1.....11.1..
2124:
1....1..11..
2132:
1....1.1.1..
2148:
1....11..1..
[--snip--]
4644: 1..1...1..1..
4676: 1..1..1...1..
4740: 1..1.1....1..
4868: 1..11.....1..
5112: 1..1111111...
5132: 1.1......11..
5140: 1.1.....1.1..
5156: 1.1....1..1..
5188: 1.1...1...1..
5252: 1.1..1....1..
5380: 1.1.1.....1..

Figure 1.26-D: Fixed points of the binary to lex-rev conversion.
The sequence of fixed points of the conversion to and from indices starts as
0, 1, 6, 10, 18, 34, 60, 66, 92, 108, 116, 130, 156, 172, 180, 204, 212,
228, 258, 284, 300, 308, 332, 340, 356, 396, 404, 420, 452, 514, 540, 556, ...

This sequence is entry A079471 in [312]. The values as bit patterns are shown in figure 1.26-D. The
crucial observation is that a word is a fixed point if it equals zero or its bit-count equals 2j where j is
the index of the lowest set bit.
Now we can find out whether x is a fixed point of the sequence by the following function:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

static inline bool is_lexrev_fixed_point(ulong x)
// Return whether x is a fixed point in the prev_lexrev() - sequence
{
if ( x & 1 )
{
if ( 1==x ) return true;
else
return false;
}
else
{
ulong w = bit_count(x);
if ( w != (w & -w) ) return false;
if ( 0==x ) return true;
return 0 != ( (x & -x) & w );
}
}

Alternatively, use either of the following tests:
x == negidx2lexrev(x)
x == lexrev2negidx(x)

74


1.26.5

Recursive generation and relation to a power series ‡

Start: 1
Rules:
0 --> 0
1 --> 110
------------0:
(#=2)
1
1:
(#=4)
110
2:
(#=8)
1101100
3:
(#=16)
110110011011000
4:
(#=32)
1101100110110001101100110110000
5:
(#=64)
110110011011000110110011011000011011001101100011011001101100000

Figure 1.26-E: String substitution with rules {0 → 0, 1 → 110}.
The following function generates the bit-reversed binary words in reversed lexicographic order:
1
2
3
4
5

void C(ulong f, ulong n, ulong w)
{
for (ulong m=1; m<n; m<<=1) C(f+m, m, w^m);
print_bin(" ", w, 10); // visit
}

By calling C(0, 64, 0) we generate the list of words shown in figure 1.26-B with the all-zeros word
moved to the last position. A slight modification of the function
1
2
3
4
5
6

void A(ulong f, ulong n)
{
cout << "1,";
for (ulong m=1; m<n; m<<=1)
cout << "0,";
}

A(f+m, m);

generates the power series (sequence A079559 in [312])
∞

1 + x2

n

−1

=

1 + x + x3 + x4 + x7 + x8 + x10 + x11 + x15 + x16 + . . .

(1.26-3)

n=1

By calling A(0, 32) we generate the sequence
1,1,0,1,1,0,0,1,1,0,1,1,0,0,0,1,1,0,1,1,0,0,1,1,0,1,1,0,0,0,0, ...
Indeed, the lowest bit of the k-th word of the bit-reversed sequence in reversed lexicographic order equals
the (k −1)-st coefficient in the power series. The sequence can also be generated by the string substitution
shown in figure 1.26-E.
The sequence of sums, prepended by 1,
1+x

∞
n=1

n

1 + x2
1−x

−1

=

1 + 1 x + 2 x2 + 2 x3 + 3 x4 + 4 x5 + 4 x6 + . . .

(1.26-4)

has series coefficients
1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 6, 7, 8, 8, 8, 8, 9, 10, 10, 11, 12, 12, 12, 13, ...
This sequence is entry A046699 in [312]. We have a(1) = a(2) = 1 and the sequence satisfies the peculiar
recurrence
a(n)

1.27

= a(n − a(n − 1)) + a(n − 1 − a(n − 2))

for n > 2

(1.26-5)

Fibonacci words ‡

A Fibonacci word is a word that does not contain two successive ones. Whether a given binary word is
a Fibonacci word can be tested with the function [FXT: bits/fibrep.h]

1.27: Fibonacci words ‡
1
2
3
4

75

static inline bool is_fibrep(ulong f)
{
return ( 0==(f&(f>>1)) );
}

The following functions convert between the binary and the Fibonacci representation:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static inline ulong bin2fibrep(ulong b)
// Return Fibonacci representation of b
// Limitation: the first Fibonacci number greater
// than b must be representable as ulong.
// 32 bit: b < 2971215073=F(47) [F(48)=4807526976 > 2^32]
// 64 bit: b < 12200160415121876738=F(93) [F(94) > 2^64]
{
ulong f0=1, f1=1, s=1;
while ( f1<=b ) { ulong t = f0+f1; f0=f1; f1=t; s<<=1; }
ulong f = 0;
while ( b )
{
s >>= 1;
if ( b>=f0 ) { b -= f0; f^=s; }
{ ulong t = f1-f0; f1=f0; f0=t; }
}
return f;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong fibrep2bin(ulong f)
// Return binary representation of f
// Inverse of bin2fibrep().
{
ulong f0=1, f1=1;
ulong b = 0;
while ( f )
{
if ( f&1 )
b += f1;
{ ulong t=f0+f1; f0=f1; f1=t; }
f >>= 1;
}
return b;
}

1.27.1
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Lexicographic order
........
.......1
......1.
.....1..
.....1.1
....1...
....1..1
....1.1.
...1....
...1...1
...1..1.

11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

...1.1..
...1.1.1
..1.....
..1....1
..1...1.
..1..1..
..1..1.1
..1.1...
..1.1..1
..1.1.1.
.1......

22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

.1.....1
.1....1.
.1...1..
.1...1.1
.1..1...
.1..1..1
.1..1.1.
.1.1....
.1.1...1
.1.1..1.
.1.1.1..

33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:

.1.1.1.1
1.......
1......1
1.....1.
1....1..
1....1.1
1...1...
1...1..1
1...1.1.
1..1....
1..1...1

44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:

1..1..1.
1..1.1..
1..1.1.1
1.1.....
1.1....1
1.1...1.
1.1..1..
1.1..1.1
1.1.1...
1.1.1..1
1.1.1.1.

Figure 1.27-A: All 55 Fibonacci words with 8 bits in lexicographic order.
The 8-bit Fibonacci words are shown in ﬁgure 1.27-A. To generate all Fibonacci words in lexicographic
order, use the function [FXT: bits/ﬁbrep.h]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong next_fibrep(ulong x)
// With x the Fibonacci representation of n
// return Fibonacci representation of n+1.
{
// 2 examples:
// ex. 1
//
// x == [*]0 010101
ulong y = x | (x>>1); // y == [*]? 011111
ulong z = y + 1;
// z == [*]? 100000
z = z & -z;
// z == [0]0 100000
x ^= z;
// x == [*]0 110101
x &= ~(z-1);
// x == [*]0 100000
return x;
}

//
//
//
//
//
//
//

ex.2
== [*]0
== [*]?
== [*]?
== [0]0
== [*]0
== [*]0

x
y
z
z
x
x

01010
01111
10000
10000
11010
10000

76


The routine can be used to generate all n-bit words as shown in [FXT: bits/fibrep2-demo.cc]:
const ulong f = 1UL << n;
ulong t = 0;
do
{
// visit(t)
t = next_fibrep(t);
}
while ( t!=f );

The reversed order can be generated via
ulong f = 1UL << n;
do
{
f = prev_fibrep(f);
// visit(f)
}
while ( f );

which uses the function (64-bit version)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong prev_fibrep(ulong x)
// With x the Fibonacci representation of n
// return Fibonacci representation of n-1.
{
// 2 examples:
// ex. 1
// ex.2
//
// x == [*]0 100000
// x == [*]0 10000
ulong y = x & -x;
// y == [0]0 100000
// y == [0]0 10000
x ^= y;
// x == [*]0 000000
// x == [*]0 00000
ulong m = 0x5555555555555555UL; // m == ...01010101
if ( m & y ) m >>= 1; // m == ...01010101
// m == ...0101010
m &= (y-1);
// m == [0]0 010101
// m == [0]0 01010
x ^= m;
// x == [*]0 010101
// x == [*]0 01010
return x;
}

The forward version generates about 180 million words per second, the backward version about 170
million words per second.

1.27.2

Gray code order ‡

A Gray code for the binary Fibonacci words (shown in figure 1.27-B) can be derived from the Gray code
of the radix −2 representations (see section 1.22 on page 58) of binary words whose difference is of the
form
1
3
5
9
19
37
73
147
293

................1
...............11
..............1.1
.............1..1
............1..11
...........1..1.1
..........1..1..1
.........1..1..11
........1..1..1.1

The algorithm is to try these values as increments starting from the least, same as for the minimal-change
combination described in section 1.24.4 on page 66. The next valid word is encountered if it is a valid
Fibonacci word, that is, if it does not contain two consecutive set bits. The implementation is [FXT:
class bit fibgray in bits/bitfibgray.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class bit_fibgray
// Fibonacci Gray code with binary words.
{
public:
ulong x_; // current Fibonacci word
ulong k_; // aux
ulong fw_, lw_; // first and last Fibonacci word in Gray code
ulong mw_; // max(fw_, lw_)
ulong n_;
// Number of bits
public:
bit_fibgray(ulong n)
{
n_ = n;
fw_ = 0;

1.27: Fibonacci words ‡
j:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

77

k(j)
....11...1
....11....
....1.1111
....1.11..
....1.1.11
....1.1.1.
....1.1..1
....1.1...
....1...11
....1...1.
....1....1
....1.....
.....11111
......11..
......1.11
......1.1.
......1..1
......1...
........11
........1.
.........1
..........
1111111111
11111111..
1111111.11
1111111.1.
111111...1
111111....
11111.1111
11111.11..
11111.1.11
11111.1.1.
11111.1..1
11111.1...

k(j)-k(j-1)
..........
.........1
.........1
........11
.........1
.........1
.........1
.........1
.......1.1
.........1
.........1
.........1
.........1
.....1..11
.........1
.........1
.........1
.........1
.......1.1
.........1
.........1
.........1
.........1
........11
.........1
.........1
......1..1
.........1
.........1
........11
.........1
.........1
.........1
.........1

x=bin2neg(k)
...111...1
...111....
...111..11
...11111..
...1111111
...111111.
...1111..1
...1111...
...11..111
...11..11.
...11....1
...11.....
...11...11
.....111..
.....11111
.....1111.
.....11..1
.....11...
.......111
.......11.
.........1
..........
........11
......11..
......1111
......111.
....11...1
....11....
....11..11
....1111..
....111111
....11111.
....111..1
....111...

gray(x)
...1..1..1
...1..1...
...1..1.1.
...1....1.
...1......
...1.....1
...1...1.1
...1...1..
...1.1.1..
...1.1.1.1
...1.1...1
...1.1....
...1.1..1.
.....1..1.
.....1....
.....1...1
.....1.1.1
.....1.1..
.......1..
.......1.1
.........1
..........
........1.
......1.1.
......1...
......1..1
....1.1..1
....1.1...
....1.1.1.
....1...1.
....1.....
....1....1
....1..1.1
....1..1..

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

27
26
28
23
21
22
25
24
32
33
30
29
31
10
8
9
12
11
3
4
1
0
2
7
5
6
19
18
20
15
13
14
17
16

Figure 1.27-B: Gray code for the binary Fibonacci words (rightmost column).
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

for (ulong m=(1UL<<(n-1)); m!=0; m>>=3) fw_ |= m;
lw_ = fw_ >> 1;
if ( 0==(n&1) ) { ulong t=fw_; fw_=lw_; lw_=t; } // swap first/last
mw_ = ( lw_>fw_ ? lw_ : fw_ );
x_ = fw_;
k_ = inverse_gray_code(fw_);
k_ = neg2bin(k_);
}
~bit_fibgray()

{;}

ulong next()
// Return next word in Gray code.
// Return ~0 if current word is the last one.
{
if ( x_ == lw_ ) return ~0UL;
ulong s = n_; // shift
while ( 1 )
{
--s;
ulong c = 1 | (mw_ >> s); // possible difference for negbin word
ulong i = k_ - c;
ulong x = bin2neg(i);
x ^= (x>>1);
if ( 0==(x&(x>>1)) )
{
k_ = i;
x_ = x;
return x;
}

// is_fibrep(x)

}
}
};

About 130 million words per second are generated. The program [FXT: bits/bitﬁbgray-demo.cc] shows
how to use the class, ﬁgure 1.27-B was created with it. Section 14.2 on page 305 gives a recursive
algorithm for Fibonacci words in Gray code order.

78


1.28

Binary words and parentheses strings ‡
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

....
...1
..1.
..11
.1..
.1.1
.11.
.111
1...
1..1
1.1.
1.11
11..
11.1
111.
1111

P
P

[empty string]
()

P

(())

P

()()

P

((()))

P

(()())

P
P

()(())
(((())))

.....
....1
...11
..1.1
..111
.1.11
.11.1
.1111
1..11
1.1.1
1.111
11.11
111.1
11111

[empty string]
()
(())
()()
((()))
(()())
()(())
(((())))
(())()
()()()
((()()))
(()(()))
()((()))
((((()))))

Figure 1.28-A: Left: some of the 4-bit binary words can be interpreted as a string parentheses (marked
with ‘P’). Right: all 5-bit words that correspond to well-formed parentheses strings.
A subset of the binary words can be interpreted as a (well formed) string of parentheses. The 4-bit
binary words that have this property are marked with a ‘P’ in figure 1.28-A (left) [FXT: bits/parenworddemo.cc]. The strings are constructed by scanning the word from the low end and printing a ‘(’ with
each one and a ‘)’ with each zero. To find out when to terminate, one adds up +1 for each opening
parenthesis and −1 for a closing parenthesis. After the ones in the binary word have been scanned, the
s closing parentheses have to be added where s is the value of the sum [FXT: bits/parenwords.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline void parenword2str(ulong x, char *str)
{
int s = 0;
ulong j = 0;
for (j=0; x!=0; ++j)
{
s += ( x&1 ? +1 : -1 );
str[j] = ")("[x&1];
x >>= 1;
}
while ( s-- > 0 ) str[j++] = ’)’; // finish string
str[j] = 0; // terminate string
}

The 5-bit binary words that are valid ‘paren words’ together with the corresponding strings are shown
in figure 1.28-A (right). Note that the lower bits in the word (right end) correspond to the beginning of
the string (left end). If a negative value for the sums occurs at any time of the computation, the word is
not a paren word. A function to determine whether a word is a paren word is
1
2
3
4
5
6
7
8
9
10
11

static inline bool is_parenword(ulong x)
{
int s = 0;
for (ulong j=0; x!=0; ++j)
{
s += ( x&1 ? +1 : -1 );
if ( s<0 ) break; // invalid word
x >>= 1;
}
return (s>=0);
}

The sequence
1, 3, 5, 7, 11, 13, 15, 19, 21, 23, 27, 29, 31, 39, 43, 45, 47, 51, 53, 55, 59, 61, 63, ...

of nonzero integers x so that is_parenword(x) returns true is entry A036991 in [312]. If we fix the
number of paren pairs, then the following functions generate the least and biggest valid paren words.
The first paren word is a block of n ones at the low end:
1
2
3

static inline ulong first_parenword(ulong n)
// Return least binary word corresponding to n pairs of parens
// Example, n=5: .....11111
((((()))))

1.28: Binary words and parentheses strings ‡
4
5
6

79

{
return first_comb(n);
}

The last paren word is the word with a sequence of n blocks ‘01’ at the low end:
1
2
3
4
5
6
7

static inline ulong last_parenword(ulong n)
// Return biggest binary word corresponding to n pairs of parens.
// Must have: 1 <= n <= BITS_PER_LONG/2.
// Example, n=5: .1.1.1.1.1
()()()()()
{
return 0x5555555555555555UL >> (BITS_PER_LONG-2*n);
}

......11111
.....1.1111
.....11.111
.....111.11
.....1111.1
....1..1111
....1.1.111
....1.11.11
....1.111.1
....11..111
....11.1.11
....11.11.1
....111..11
....111.1.1

=
=
=
=
=
=
=
=
=
=
=
=
=
=

((((()))))
(((()())))
((()(())))
(()((())))
()(((())))
(((())()))
((()()()))
(()(()()))
()((()()))
((())(()))
(()()(()))
()(()(()))
(())((()))
()()((()))

...1...1111
...1..1.111
...1..11.11
...1..111.1
...1.1..111
...1.1.1.11
...1.1.11.1
...1.11..11
...1.11.1.1
...11...111
...11..1.11
...11..11.1
...11.1..11
...11.1.1.1

=
=
=
=
=
=
=
=
=
=
=
=
=
=

(((()))())
((()())())
(()(())())
()((())())
((())()())
(()()()())
()(()()())
(())(()())
()()(()())
((()))(())
(()())(())
()(())(())
(())()(())
()()()(())

..1....1111
..1...1.111
..1...11.11
..1...111.1
..1..1..111
..1..1.1.11
..1..1.11.1
..1..11..11
..1..11.1.1
..1.1...111
..1.1..1.11
..1.1..11.1
..1.1.1..11
..1.1.1.1.1

=
=
=
=
=
=
=
=
=
=
=
=
=
=

(((())))()
((()()))()
(()(()))()
()((()))()
((())())()
(()()())()
()(()())()
(())(())()
()()(())()
((()))()()
(()())()()
()(())()()
(())()()()
()()()()()

Figure 1.28-B: The 42 binary words corresponding to all valid pairings of 5 parentheses, in colex order.
The sequence of all binary words corresponding to n pairs of parens in colex order can be generated with
the following (slightly cryptic) function:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

static inline ulong next_parenword(ulong x)
// Next (colex order) binary word that is a paren word.
{
if ( x & 2 ) // Easy case, move highest bit of lowest block to the left:
{
ulong b = lowest_zero(x);
x ^= b;
x ^= (b>>1);
return x;
}
else // Gather all low "01"s and split lowest nontrivial block:
{
if ( 0==(x & (x>>1)) ) return 0;
ulong w = 0; // word where the bits are assembled
ulong s = 0; // shift for lowest block
ulong i = 1; // == lowest_one(x)
do // collect low "01"s:
{
x ^= i;
w <<= 1;
w |= 1;
++s;
i <<= 2; // == lowest_one(x);
}
while ( 0==(x&(i<<1)) );
ulong z = x ^ (x+i);
x ^= z;
z &= (z>>1);
z &= (z>>1);
w ^= (z>>s);
x |= w;
return x;

// lowest block

}
}

The program [FXT: bits/parenword-colex-demo.cc] shows how to create a list of binary words corresponding to n pairs of parens (code slightly shortened):
1

ulong n = 4;

// Number of paren pairs

80


2
3
4
5
6
7
8
9
10
11
12

ulong pn = 2*n+1;
char *str = new char[n+1]; str[n] = 0;
ulong x = first_parenword(n);
while ( x )
{
print_bin(" ", x, pn);
parenword2str(x, str);
cout << " = " << str << endl;
x = next_parenword(x);
}

Its output with n = 5 is shown in figure 1.28-B. The 1,767,263,190 paren words for n = 19 are generated
at a rate of about 169 million words per second. Chapter 15 on page 323 gives a different formulation of
the algorithm.
Knuth [215, ex.23, sect.7.1.3] gives a very elegant routine for generating the next paren word, the comments are MMIX instructions:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline ulong next_parenword(ulong x)
{
const ulong m0 = -1UL/3;
ulong t = x ^ m0;
// XOR t, x, m0;
if ( (t&x)==0 ) return 0;
// current is last
ulong u = (t-1) ^ t;
// SUBU u, t, 1; XOR u, t, u;
ulong v = x | u;
// OR v, x, u;
ulong y = bit_count( u & m0 ); // SADD y, u, m0;
ulong w = v + 1;
// ADDU w, v, 1;
t = v & ~w;
// ANDN t, v, w;
y = t >> y;
// SRU y, t, y;
y += w;
// ADDU y, w, y;
return y;
}

The routine is slower, however, about 81 million words per second are generated. A bit-count instruction
in hardware would speed it up significantly. Treating the case of easy update separately as in the other
version, we get a rate of about 137 million words per second.

1.29

Permutations via primitives ‡

We give two methods to specify permutations of the bits of a binary word via one or more control words.
The methods are suggestions for machine instructions that can serve as primitives for permutations of
the bits of a word.

1.29.1

A restricted method

................1111111111111111
........11111111........11111111
....1111....1111....1111....1111
..11..11..11..11..11..11..11..11
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
................1...............
........1...............1.......
....1.......1.......1.......1...
..1...1...1...1...1...1...1...1.
.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1

bits
bits
bits
bits
bits

15 ...
7 ...
3 11 ...
1
5
9
0
2
4

13 ...
6
8

10

12

14 ...

Figure 1.29-A: Mask with primitives for permuting bits with 32-bit words (top), and words with ones
at the highest bit of each block (bottom).
We can specify a subset of all permutations by selecting bit-blocks of the masks as shown for 32-bit words
in figure 1.29-A (top). Subsets of the blocks of the masks can be determined with the bits of a word by
considering the highest bit of each block (bottom of the figure). We use all bits of a word (except for
the highest bit) to select the blocks where the bits defined by the block and those left to it should be

1.29: Permutations via primitives ‡

81

swapped. An implementation of the implied algorithm is given in [FXT: bits/bitperm1-demo.cc]. Arrays
are used to give more readable code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void perm1(uchar *a, ulong ldn, const uchar *x)
// Permute a[] according to the ’control word’ x[].
// The length of a[] must be 2**ldn.
{
long n = 1L<<ldn;
for (long s=n/2; s>0; s/=2)
{
for (long k=0; k<n; k+=s+s)
{
if ( x[k+s-1]!=’0’ )
{
// swap regions [a+k,...,a+k+s-1], [a+k+s,...,a+k+2*s-1]:
swap(a+k, a+k+s, s);
}
}
}
}

The routine for the inverse permutation differs in a single line:
for (long s=1; s<n; s+=s)

No attempt has been made to optimize or parallelize the algorithm. We just explore how useful a machine
instruction for the permutation of bits would be.
The program uses a fixed size of 16 bits, an ‘x’ is printed whenever the corresponding bit is set:
a=0123456789ABCDEF
x=0010011000110110
8:
7
4:
3 11x
2:
1
5x 9
1:
0
2x 4
a=01326754CDFEAB98

bits of the input word
control word
13x
6x 8 10x 12
result

14x

This control word leads to the Gray permutation (see 2.12 on page 128). Assume we use words with N
bits. We cannot (for N > 2) specify all N ! permutations as we can choose between only 2N −1 control
words. Now set the word length to N := 2n . The reachable permutations are those where the intervals
[k · 2j , . . . , (k + 1) · 2j − 1] contain all numbers [p · 2j , . . . , (p + 1) · 2j − 1] for all j ≤ n and 0 ≤ k < 2n−j ,
choosing p for each interval arbitrarily (0 ≤ p < 2n−j ). For example, the lower half of the permuted array
must contain a permutation of either the lower or the upper half (j = n − 1) and each pair a2y , a2y+1
must contain two elements 2z, 2z + 1 (j = 1). The bit-reversal is computed with a control word where all
bits are set. Alas, the (important!) zip permutation (bit-zip, see section 1.15 on page 38) is unreachable.
A machine instruction could choose between the two routines via the highest bit in the control word.

1.29.2

A general method

All permutations of N = 2n elements can be specified with n control words of N bits. Assume we have
a machine instruction that collects bits according to a control word. An eight bit example:
a = abcdefgh
x = ..1.11.1
cefh
abdg
abdgcefh

input data
control word (dots for zeros)
bits of a where x has a one
bits of a where x has a zero
result, bits separated according to x

We need n such instructions that work on all length-2k sub-words for 1 ≤ k ≤ n. For example, the
instruction working on half words of a 16-bit word would work as
a = abcdefgh
x = ..1.11.1
cefh
abdg
abdgcefh

ABCDEFGH
1111....
ABCD
EFGH
EFGHABCD

input data
control word (dots for zeros)
bits of a where x has a one
bits of a where x has a zero
result, bits separated according to x

Note the bits of the different sub-words are not mixed. Now all permutations can be reached if the control
word for the 2k -bit sub-words have exactly 2k−1 bits set in all ranges [j · 2k , . . . , (j + 1) · 2k ].

82


A control word together with the specification of the instruction used defines the action taken. The
following leads to a swap of adjacent bit pairs
1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.

k= 1

(2-bit sub-words)

while this
1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.

k= 5 (32 bit sub-words)

results in gathering the even and odd indexed bits in the halfwords.
A complete set of permutation primitives for 16-bit words and their effect on a symbolic array of bits
(split into groups of four elements for readability) is
11111111........
1111....1111....
11..11..11..11..
1.1.1.1.1.1.1.1.

k=
k=
k=
k=

4
3
2
1

==>
==>
==>
==>

0123
89ab
cdef
efcd
fedc

4567
cdef
89ab
ab89
ba98

89ab
0123
4567
6745
7654

cdef
4567
0123
2301
3210

The top primitive leads to a swap of the left and right half of the bits, the next to a swap of the halves of
the half words and so on. The computed permutation is array reversal. Note that we use array notation
(least index left) here.
The resulting permutation depends on the order in which the primitives are used. When starting with
full words we get:
1.1. 1.1. 1.1. 1.1. k= 4
1.1. 1.1. 1.1. 1.1. k= 3
1.1. 1.1. 1.1. 1.1. k= 2
1.1. 1.1. 1.1. 1.1. k= 1
The result is different when starting
1.1.
1.1.
1.1.
1.1.

1.1.
1.1.
1.1.
1.1.

1.1.
1.1.
1.1.
1.1.

1.1.
1.1.
1.1.
1.1.

k=
k=
k=
k=

1
2
3
4

0123 4567 89ab
==>
1357 9bdf 0246
==>
37bf 159d 26ae
==>
7f3b 5d19 6e2a
==>
f7b3 d591 e6a2
with 2-bit sub-words:
==>
==>
==>
==>

0123
1032
0213
2367
3715

4567
5476
4657
0145
bf9d

89ab
98ba
8a9b
abef
2604

cdef
8ace
048c
4c08
c480
cdef
dcfe
cedf
89cd
ae8c

There are 2z possibilities to have z bits set in a 2z-bit word. There are 2n−k length-2k sub-words in a
z
2n -bit word so the number of valid control words for that step is
2k

2n−k

2k−1
The product of the number of valid words in all steps gives the number of permutations:
n
n

(2 )!

=
k=1

2k

2n−k

2k−1

1.30

CPU instructions often missed

1.30.1

(1.29-1)

Essential

• Bit-shift and bit-rotate instructions that work properly for shifts greater than or equal to the word
length: the shift instruction should zero the word, the rotate instruction should take the shift
modulo word length. The C-language standards leave the results for these operations undefined
and compilers simply emit the corresponding assembler instructions. The resulting CPU dependent
behavior is both a source of errors and makes certain optimizations impossible.
• A bit-reverse instruction. A fast byte-swap mitigates the problem, see section 1.14 on page 33.
• Instructions that return the index of highest or lowest set bit in a word. They must execute fast.
• Fast conversion from integer to float and double (both directions).

1.31: Some space filling curves ‡

83

• A fused multiply-add instruction for floats.
• Instructions for the multiplication of complex floating-point numbers, computing A · C − B · D and
A · D + B · C from A, B, C, and D.
• A sum-diff instruction, computing A + B and A − B from A and B. This can serve as a primitive
for fast orthogonal transforms.
• An instruction to swap registers. Even better, a conditional version of that.

1.30.2

Nice to have

• A parity bit for the complete machine word. The parity of a word is the number of bits modulo 2,
not the complement of it. Even better, an instruction for the inverse Gray code, see section 1.16
on page 41.
• A bit-count instruction, see section 1.8 on page 18. This would also give the parity at bit zero.
• An instruction for computing the index of the i-th set bit of a word, see section 1.10 on page 25.
This would be useful even if execution takes a dozen cycles.
• A random number generator, LHCAs (see section 41.8 on page 878) may be candidates. At the
very least: a decent entropy source.
• A conditional version of more than just the move instruction, possibly as an instruction prefix.
• A bit-zip and a bit-unzip instruction, see section 1.15 on page 38. Note this is polynomial squaring
over GF(2).
• Primitives for permutations of bits, see section 1.29.2 on page 81. A bit-gather and a bit-scatter
instruction for sub-words of all sizes a power of 2 would allow for arbitrary permutations (see [FXT:
bits/bitgather.h] and [FXT: bits/bitseparate.h] for versions working on complete words).
• Multiplication corresponding to XOR as addition. This is the multiplication without carries used
for polynomials over GF(2), see section 40.1 on page 822.

1.31

Some space filling curves ‡

1.31.1

The Hilbert curve

A rendering of the Hilbert curve (named after David Hilbert [182]) is shown in figure 1.31-A. An efficient
algorithm to compute the direction of the n-th move of the Hilbert curve is based on the parity of the
number of threes in the radix-4 representation of n (see section 38.9.1 on page 748).
Let dx and dy correspond to the moves at step n in the Hilbert curve. Then dx , dy ∈ {−1, 0, +1} and
exactly one of them is zero. So for both p := dx + dy and m := dx − dy we have p, m ∈ {−1, +1}.
The following function computes p and returns 0, 1 if p = −1, +1, respectively [FXT: bits/hilbert.h]:
1
2
3
4
5
6
7
8
9

static inline ulong hilbert_p(ulong t)
// Let dx,dy be the horizontal,vertical move
// with step t of the Hilbert curve.
// Return zero if (dx+dy)==-1, else one (then: (dx+dy)==+1).
// Algorithm: count number of threes in radix 4
{
ulong d = (t & 0x5555555555555555UL) & ((t & 0xaaaaaaaaaaaaaaaaUL) >> 1);
return parity( d );
}

If 1 is returned the step is to the right or upwards. The function can be slightly optimized as follows
(64-bit version only):
1
2
3

static inline ulong hilbert_p(ulong t)
{
t &= ((t & 0xaaaaaaaaaaaaaaaaUL) >> 1);

84


Figure 1.31-A: The ﬁrst 255 segments of the Hilbert curve.
dx+dy:
dx-dy:
dir:
turn:

++-+++-+++----++++-+++-+++----++++-+++-+++----+---+---+---+++++----+++-+++-+++-++++---+---+----++++---+---+----++++---+---+->^<^^>v>^>vv<v>>^>v>>^<^>^<<v<^^^>v>>^<^>^<<v<^<<v>vv<^<v<^^>^<
0--+0++--++0+--0-++-0--++--0-++00++-0--++--0-++-0--+0++--++0+-Figure 1.31-B: Moves and turns of the Hilbert curve.

4
5
6
7
8
9
10

t ^= t>>2;
t ^= t>>4;
t ^= t>>8;
t ^= t>>16;
t ^= t>>32;
return t & 1;
}

The corresponding value for m can be computed as:
1
2
3
4
5
6
7

static inline ulong hilbert_m(ulong t)
// Let dx,dy be the horizontal,vertical move
// with step t of the Hilbert curve.
// Return zero if (dx-dy)==-1, else one (then: (dx-dy)==+1).
{
return hilbert_p( -t );
}

If the values for p and m are equal the step is in horizontal direction. It remains to merge the values of
p and m into a 2-bit value d that encodes the direction of the move:
1
2
3
4
5
6
7
8
9
10

static inline ulong hilbert_dir(ulong t)
// Return d encoding the following move with the Hilbert curve.
//
// d in {0,1,2,3} as follows:
//
d : direction
//
0 : right (+x: dx=+1, dy= 0)
//
1 : down (-y: dx= 0, dy=-1)
//
2 : up
(+y: dx= 0, dy=+1)
//
3 : left (-x: dx=-1, dy= 0)
{

11
12
13
14
15

ulong p
ulong m
ulong d
return

85

= hilbert_p(t);
= hilbert_m(t);
= p ^ (m<<1);
d;

}

To print the value of d symbolically, we can print the value of (">v^<")[d]. The sequence of moves can
also be generated by the string substitution process shown in figure 1.31-C.
Start: A
Rules:
A --> D>AÂ<C
B --> C<BvB>D
C --> BvC<CÂ
D --> A^D>DvB
> --> >
< --> <
^ --> ^
v --> v
------------0:
(#=1)
A
1:
(#=7)
D>AÂ<C
2:
(#=31)
A^D>DvB>D>AÂ<C^D>AÂ<C<BvC<CÂ
3:
(#=127)
D>AÂ<CÂ^D>DvB>A^D>DvBvC<BvB>D>A^D>DvB>D>AÂ<C^D>AÂ<C<BvC<CÂÂ^D>DvB>D>AÂ<C^D> ...

Figure 1.31-C: Moves of the Hilbert curve by a string substitution process, the symbols ‘A’, ‘B’, ‘C’, and
‘D’, are ignored when drawing the curve.
The turn u between steps can be computed as
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static inline int hilbert_turn(ulong t)
// Return the turn (left or right) with the steps
//
t and t-1 of the Hilbert curve.
// Returned value is
//
0 for no turn
// +1 for right turn
// -1 for left turn
{
ulong d1 = hilbert_dir(t);
ulong d2 = hilbert_dir(t-1);
d1 ^= (d1>>1);
d2 ^= (d2>>1);
ulong u = d1 - d2;
// at this point, symbolically: cout << ("+.-0+.-")[ u + 3 ];
if ( 0==u ) return 0;
if ( (long)u<0 ) u += 4;
return (1==u ? +1 : -1);
}

To print the value of u symbolically, we can print ("-0+")[u+1];.
The values of p and m, followed by the direction and turn of the Hilbert curve are shown in figure 1.31-B.
The list was created with the program [FXT: bits/hilbert-moves-demo.cc]. Figure 1.31-A was created with
the program [FXT: bits/hilbert-texpic-demo.cc]. The computation of a function whose series coefficients
are ±1 and ±i according to the Hilbert curve is described in section 38.9 on page 747.
A finite state machine (FSM) for the conversion from a 1-dimensional coordinate (linear coordinate of
the curve) to the pair of coordinates x and y of the Hilbert curve is described in [39, item 115]. At each
step two bits of input are processed. The array htab[] serves as lookup table for the next state and two
bits of the result. The FSM has an internal state of two bits [FXT: bits/lin2hilbert.cc]:
1
2
3
4
5
6
7
8
9
10

void
lin2hilbert(ulong t, ulong &x, ulong &y)
// Transform linear coordinate t to Hilbert x and y
{
ulong xv = 0, yv = 0;
ulong c01 = (0<<2); // (2<<2) for transposed output (swapped x, y)
for (ulong i=0; i<(BITS_PER_LONG/2); ++i)
{
ulong abi = t >> (BITS_PER_LONG-2);
t <<= 2;

86
11
12
13
14
15
16
17
18
19
20
21


ulong st = htab[ (c01<<2) | abi ];
c01 = st & 3;
yv
yv
xv
xv

<<= 1;
|= ((st>>2) & 1);
<<= 1;
|= (st>>3);

}
x = xv;

y = yv;

}

OLD
C C
0 1
0 0
0 0
0 0
0 0
0 1
0 1
0 1
0 1
1 0
1 0
1 0
1 0
1 1
1 1
1 1
1 1

A
I
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1

B
I
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1

NEW
X Y
I I
0 0
0 1
1 1
1 0
1 1
0 1
0 0
1 0
0 0
1 0
1 1
0 1
1 1
1 0
0 0
0 1

C
0
1
0
0
0
1
0
0
0
0
1
1
1
0
1
1
1

C
1
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0

NEW
C C
0 1
0 0
0 0
0 0
0 0
0 1
0 1
0 1
0 1
1 0
1 0
1 0
1 0
1 1
1 1
1 1
1 1

X
I
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1

Y
I
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1

OLD
A B
I I
0 0
0 1
1 1
1 0
1 0
0 1
1 1
0 0
0 0
1 1
0 1
1 0
1 0
1 1
0 1
0 0

C
0
1
0
0
0
0
0
0
1
0
1
1
1
1
1
1
0

C
1
0
0
1
0
1
1
0
1
0
1
0
0
1
0
1
1

Figure 1.31-D: The original table from [39] for the finite state machine for the 2-dimensional Hilbert
curve (left). All sixteen 4-bit words appear in both the ‘OLD’ and the ‘NEW’ column. So the algorithm is
invertible. Swap the columns and sort numerically to obtain the two columns at the right, the table for
the inverse function.
The table used is defined (see figure 1.31-D) as
1
2
3
4
5
6
7
8
9
10
11

static const ulong htab[] = {
#define HT(xi,yi,c0,c1) ((xi<<3)+(yi<<2)+(c0<<1)+(c1))
// index == HT(c0,c1,ai,bi)
HT( 0, 0, 1, 0 ),
HT( 0, 1, 0, 0 ),
HT( 1, 1, 0, 0 ),
HT( 1, 0, 0, 1 ),
[--snip--]
HT( 0, 0, 1, 1 ),
HT( 0, 1, 1, 0 )
};

As indicated in the code, the table maps every four bits c0,c1,ai,bi to four bits xi,yi,c0,c1. The
table for the inverse function (again, see figure 1.31-D) is
1
2
3
4
5
6
7
8
9
10
11

static const ulong ihtab[] = {
#define IHT(ai,bi,c0,c1) ((ai<<3)+(bi<<2)+(c0<<1)+(c1))
// index == HT(c0,c1,xi,yi)
IHT( 0, 0, 1, 0 ),
IHT( 0, 1, 0, 0 ),
IHT( 1, 1, 0, 1 ),
IHT( 1, 0, 0, 0 ),
[--snip--]
IHT( 0, 1, 1, 1 ),
IHT( 0, 0, 0, 1 )
};

The words have to be processed backwards:
1
2
3
4
5
6

ulong
hilbert2lin(ulong x, ulong y)
// Transform Hilbert x and y to linear coordinate t
{
ulong t = 0;
ulong c01 = 0;

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

87

for (ulong i=0; i<(BITS_PER_LONG/2); ++i)
{
t <<= 2;
ulong xi = x >> (BITS_PER_LONG/2-1);
xi &= 1;
ulong yi = y >> (BITS_PER_LONG/2-1);
yi &= 1;
ulong xyi = (xi<<1) | yi;
x <<= 1;
y <<= 1;
ulong st = ihtab[ (c01<<2) | xyi ];
c01 = st & 3;
t |= (st>>2);
}
return t;
}

1.31.2

The Z-order

Figure 1.31-E: The ﬁrst 255 segments of the Z-order curve.
A 2-dimensional space-ﬁlling curve in Z-order traverses all points in each quadrant before it enters the
next. Figure 1.31-E shows a rendering of the Z-order curve, created with the program [FXT: bits/zordertexpic-demo.cc]. The conversion between a linear parameter to a pair of coordinates is done by separating
the bits at the even and odd indices [FXT: bits/zorder.h]:
static inline void lin2zorder(ulong t, ulong &x, ulong &y)

{ bit_unzip2(t, x, y); }

The routine bit_unzip2() is described in section 1.15 on page 38. The inverse is
static inline ulong zorder2lin(ulong x, ulong y)

{ return bit_zip2(x, y); }

The next pair can be computed with the following (constant amortized time) routine:
1
2

static inline void zorder_next(ulong &x, ulong &y)
{

88
3
4
5
6
7
8
9
10
11

ulong
do
{
x
y
b
}
while

b = 1;
^= b; b &= ~x;
^= b; b &= ~y;
<<= 1;
( b );

}

The previous pair is computed similarly:
1
2
3
4
5
6
7
8
9
10
11

static inline void zorder_prev(ulong &x, ulong &y)
{
ulong b = 1;
do
{
x ^= b; b &= x;
y ^= b; b &= y;
b <<= 1;
}
while ( b );
}

The routines are written in a way that generalizes easily to more dimensions:
1
2
3
4
5
6
7
8
9
10
11
12

static inline void
{
ulong b = 1;
do
{
x ^= b; b
y ^= b; b
z ^= b; b
b <<= 1;
}
while ( b );
}

1
2
3
4
5
6
7
8
9
10
11
12

static inline void
{
ulong b = 1;
do
{
x ^= b; b
y ^= b; b
z ^= b; b
b <<= 1;
}
while ( b );
}

zorder3d_next(ulong &x, ulong &y, ulong &z)

&= ~x;
&= ~y;
&= ~z;

zorder3d_prev(ulong &x, ulong &y, ulong &z)

&= x;
&= y;
&= z;

Unlike with the Hilbert curve there are steps where the curve advances more than one unit.

1.31.3

Curves via paper-folding sequences

The paper-folding sequence, entry A014577 in [312], starts as [FXT: bits/bit-paper-fold-demo.cc]:
11011001110010011101100011001001110110011100100011011000110010011 ...
The k-th element (k > 0) is one if k = 2t · (4u + 1), entry A091072 in [312]:
1, 2, 4, 5, 8, 9, 10, 13, 16, 17, 18, 20, 21, 25, 26, 29, 32, 33, ...
The k-th element of the paper-folding sequence can be computed by testing the value of the bit left to
the lowest (that is, rightmost) one in the binary expansion of k [FXT: bits/bit-paper-fold.h]:
1
2
3
4
5
6

static inline bool bit_paper_fold(ulong k)
{
ulong h = k & -k; // == lowest_one(k)
k &= (h<<1);
return ( k==0 );
}

About 550 million values per second are generated. We use bool as return type to indicate that only
zero or one is returned. The value can be used as an integer of arbitrary type, there is no need for a cast.


Figure 1.31-F: The ﬁrst 1024 segments of the dragon curve (two diﬀerent renderings).

89

90


1.31.3.1

The dragon curve

Another name for the sequence is dragon curve sequence, because a space filling curve known as dragon
curve (or Heighway dragon) can be generated if we interpret a one as ‘turn left’ and a zero as ‘turn right’.
The top of figure 1.31-F shows the first 1024 segments of the curve (created with [FXT: bits/dragoncurve-texpic-demo.cc]). As some points are visited twice we draw the turns with cut off corners, for the
(left) turn A → B → C:
C
|
|
|
A --- B

drawn as

C
|
|
/
A --/B

The code is given in [FXT: aux0/tex-line.cc]. The first few moves of the curve can be found by repeatedly
folding a strip of paper. Always pick up the right side and fold to the left. Unfold the paper and adjust
all corners to be 90 degrees. This gives the first few segments of the dragon curve.
When all angles are replaced by diagonals between the midpoints of the lines
C
|
|
|
A --- B

C
drawn as
A

/
/
/ B

then the curve appears as shown at the bottom of figure 1.31-F.
Start: 0
Rules:
0 --> 01
1 --> 21
2 --> 23
3 --> 03
------------0: 0
1: 01
2: 0121
3: 01212321
4: 0121232123032321
5: 01212321230323212303010323032321
6: 0121232123032321230301032303232123030103012101032303010323032321
+^-^-v-^-v+v-v-^-v+v+^+v-v+v-v-^-v+v+^+v+^-^+^+v-v+v+^+v-v+v-v-^
Figure 1.31-G: Moves of the dragon curve generated by a string substitution process.
The net rotation of the dragon-curve after k steps, as multiple of the right angle, can be computed by
counting the ones in the Gray code of k. Take the result modulo 4 to ignore multiples of 360 degree
[FXT: bits/bit-paper-fold.h]:
1

static inline bool bit_dragon_rot(ulong k)

{ return

bit_count( k ^ (k>>1) ) & 3; }

The sequence of rotations is entry A005811 in [312]:
seq
= 0 1 2 1 2 3 2 1 2 3 4 3 2 3 2 1 2 3 4 3 4 5 4 3 2 3 4 3 2 3 2 1 2 3 ...
mod 4 = 0 1 2 1 2 3 2 1 2 3 0 3 2 3 2 1 2 3 0 3 0 1 0 3 2 3 0 3 2 3 2 1 2 3 ...
move = + ^ - ^ - v - ^ - v + v - v - ^ - v + v + ^ + v - v + v - v - ^ - v ...
The sequence of moves (as symbols, last row) can be computed with [FXT: bits/dragon-curve-movesdemo.cc]. A function related to the paper-folding sequence is described in section 38.8.3 on page 744.
1.31.3.2

The alternate paper-folding sequence

If the strip of paper is folded alternately from the left and right, then another paper-folding sequence is
obtained. It is entry A106665 in [312] and it starts as [FXT: bits/bit-paper-fold-alt-demo.cc]:
10011100100011011001110110001100100111001000110010011101100011011 ...
Compute the sequence via [FXT: bits/bit-paper-fold.h]
1
2
3

static inline bool bit_paper_fold_alt(ulong k)
{
ulong h = k & -k; // == lowest_one(k)


Figure 1.31-H: The ﬁrst 512 segments of the curve from the alternate paper-folding sequence.

Start: 0
Rules:
0 --> 01
1 --> 03
2 --> 23
3 --> 21
------------0: 0
1: 01
2: 0103
3: 01030121
4: 0103012101032303
5: 01030121010323030103012123210121
6: 0103012101032303010301212321012101030121010323032321230301032303
+^+v+^-^+^+v-v+v+^+v+^-^-v-^+^-^+^+v+^-^+^+v-v+v-v-^-v+v+^+v-v+v
Figure 1.31-I: Moves of the alternate curve generated by a string substitution process.

91

92


Start: L
Rules:
L --> L+R+L-R
R --> L+R-L-R
+ --> +
- --> ------------0:
(#=1)
L
1:
(#=7)
L+R+L-R
2:
(#=31)
L+R+L-R+L+R-L-R+L+R+L-R-L+R-L-R
3:
(#=127)
L+R+L-R+L+R-L-R+L+R+L-R-L+R-L-R+L+R+L-R+L+R-L-R-L+R+L-R-L+R-L-R+L+R+L-R+L+R-L-R+L+ ...
Start: L
Rules:
L --> R+L+R-L
R --> R+L-R-L
+ --> +
- --> ------------0:
(#=1)
L
1:
(#=7)
R+L+R-L
2:
(#=31)
R+L-R-L+R+L+R-L+R+L-R-L-R+L+R-L
3:
(#=127)
R+L-R-L+R+L+R-L-R+L-R-L-R+L+R-L+R+L-R-L+R+L+R-L+R+L-R-L-R+L+R-L+R+L-R-L+R+L+R-L-R+ ...

Figure 1.31-J: Moves and turns of the dragon curve (top) and alternate dragon curve (bottom).
4
5
6
7

h <<= 1;
ulong t = h & (k ^ 0xaaaaaaaaUL);
return ( t!=0 );

// 32-bit version

}

About 413 million values per second are generated. By interpreting the sequence of zeros and ones as
turns we again obtain triangular space-filling curves shown in figure 1.31-H. The orientations can be
computed as
1
2
3
4
5
6
7
8
9
10
11
12

static inline ulong bit_paper_fold_alt_rot(ulong k)
// Return total rotation (as multiple of the right angle)
//
after k steps in the alternate paper-folding curve.
// k=
0, 1, 2, 3, 4, 5, ...
// seq(k)= 0, 1, 0, 3, 0, 1, 2, 1, 0, 1, 0, 3, 2, 3, 0, ...
// move = + ^ + v + ^ - ^ + ^ + v - v +
// (+==right, -==left, ^==up, v==down).
// Algorithm: count the ones in (w ^ gray_code(k)).
{
const ulong w = 0xaaaaaaaaUL; // 32-bit version
return bit_count( w ^ (k ^ (k>>1)) ) & 3; // modulo 4
}

Figure 1.31-J shows a different string substitution process for the generation of the rotations (symbols
‘+’ and ‘-’) for the paper-folding sequences, both symbols ‘L’ and ‘R’ are interpreted as a unit move in
the current direction.
If the constant in the routine is replaced by a parameter w, then its bits determine whether a left or a
right fold was made at each step:
1
2
3
4
5
6
7

static inline
{
ulong h =
h <<= 1;
ulong t =
return (
}

1.31.4

bool bit_paper_fold_general(ulong k, ulong w)
k & -k;

// == lowest_one(k)

h & (k^w);
t!=0 );

Terdragon and hexdragon

The terdragon curve turns to the left or right by 120 degrees depending to the sequence
0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, ...


Figure 1.31-K: The ﬁrst 729 segments of the terdragon (two diﬀerent renderings).

93

94


Figure 1.31-L: The ﬁrst 729 segments of the hexdragon.

Start: 0
Rules:
0 --> 010
1 --> 011
------------0:
(#=1)
0
1:
(#=3)
010
2:
(#=9)
010011010
3:
(#=27)
010011010010011011010011010
4:
(#=81)
010011010010011011010011010010011010010011011010011011010011010010011011010011010
Start: F
Rules:
F --> F+F-F
+ --> +
- --> ------------0:
(#=1)
F
1:
(#=5)
F+F-F
2:
(#=17)
F+F-F+F+F-F-F+F-F
3:
(#=53)
F+F-F+F+F-F-F+F-F+F+F-F+F+F-F-F+F-F-F+F-F+F+F-F-F+F-F
4:
(#=161)
F+F-F+F+F-F-F+F-F+F+F-F+F+F-F-F+F-F-F+F-F+F+F-F-F+F-F+F+F-F+F+F-F-F+F-F+F+F-F+F+F- ...

Figure 1.31-M: Turns of the terdragon curve, generated by string substitution (top), alternative process
for the moves and turns (bottom, identify ‘+’ with ‘0’ and ‘-’ with ‘1’).

95

Start: F
Rules:
F --> F+L+F-L-F
+ --> +
- --> L --> L
------------0:
(#=1)
F
1:
(#=9)
F+L+F-L-F
2:
(#=33)
F+L+F-L-F+L+F+L+F-L-F-L-F+L+F-L-F
3:
(#=105)
F+L+F-L-F+L+F+L+F-L-F-L-F+L+F-L-F+L+F+L+F-L-F+L+F+L+F-L-F-L-F+L+F-L-F-L-F+L+F-L-F+ ...

Figure 1.31-N: String substitution process for the hexdragon.
The sequence is entry A080846 in [312], it can be generated via the string substitution with rules 0 → 101
and 1 → 011, see figure 1.31-M. A fast method to compute the sequence is based on radix-3 counting:
let C1 (k) be the number of ones in the radix-3 expansion of k, the sequence is one if C1 (k + 1) < C1 (k)
[FXT: bits/bit-dragon3.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

static inline bool bit_dragon3_turn(ulong &x)
// Increment the radix-3 word x and
// return whether the number of ones in x is decreased.
{
ulong s = 0;
while ( (x & 3) == 2 ) { x >>= 2; ++s; } // scan over nines
//
if ( (x & 3) == 0 ) ==> incremented word will have one more 1
//
if ( (x & 3) == 1 ) ==> incremented word will have one less 1
bool tr = ( (x & 3) != 0 ); // incremented word will have one less 1
++x; // increment next digit
x <<= (s<<1); // shift back
return tr;
}

About 220 million values per second are generated. Two renderings of the first 729 segments of the curve
are shown in figure 1.31-K (created with [FXT: bits/dragon3-texpic-demo.cc]).
If we replace each turn by 120 degrees (followed by a line) by two turns by 60 degrees (each followed by a
line) we obtain what may be called a hexdragon, shown in figure 1.31-L (created with [FXT: bits/dragonhex-texpic-demo.cc]). A string substitution process for the hexdragon is shown in figure 1.31-N.

1.31.5

Dragon curves based on radix-R counting

Another dragon curve can be generated on radix-5 counting (we will call the curve R5-dragon) [FXT:
bits/bit-dragon-r5.h]:
1
2
3
4
5
6
7
8
9
10
11
12

static inline bool bit_dragon_r5_turn(ulong &x)
// return (tr) whether the lowest nonzero digit
// of the incremented word is > 2.
{
ulong s = 0;
bool tr = ( (x & 7) >= 2 ); // whether digit will be > 2
x <<= (3*s); // shift back
return tr;
}

About 310 million values per second are generated. The turns are by 90 degrees. Two renderings of the
R5-dragon are shown in figure 1.31-O (created with [FXT: bits/dragon-r5-texpic-demo.cc]). The sequence
of returned values (entry A175337 in [312]) can be computed via the string substitution shown in figure
1.31-R (top).
Based on radix-7 counting we can generate a curve that will be called the R7-dragon, the turns are be
120 degrees [FXT: bits/bit-dragon-r7.h]:
1
2

96


Figure 1.31-O: The ﬁrst 625 segments of the R5-dragon (two diﬀerent renderings).


Figure 1.31-P: The ﬁrst 2401 segments of the R7-dragon (two diﬀerent renderings).
3
4

// of the incremented word is either 2, 3, or 6.

97

98


Figure 1.31-Q: The ﬁrst 2401 segments of the second R7-dragon (two diﬀerent renderings).


99

Start: 0
Rules:
0 --> 00110
1 --> 00111
------------0:
(#=1)
0
1:
(#=5)
00110
2:
(#=25)
0011000110001110011100110
3:
(#=125)
00110001100011100111001100011000110001110011100110001100011000111001110011100
110001100011100111001110011000110001110011100110
Start: 0
Rules:
0 --> 0100110
1 --> 0110110
------------0:
(#=1)
0
1:
(#=7)
0100110
2:
(#=49)
0100110011011001001100100110011011001101100100110
3:
(#=343)
010011001101100100110010011001101100110110010011001001100110110011011001001 ...
Start: 0
Rules:
0 --> 0++--00
+ --> 0++--0+
- --> 0++--0------------0:
(#=1)
0
1:
(#=7)
0++--00
2:
(#=49)
0++--000++--0+0++--0+0++--0-0++--0-0++--000++--00
3:
(#=343)
0++--000++--0+0++--0+0++--0-0++--0-0++--000++--000++--000++--0+0++--0+0++-- ...

Figure 1.31-R: Turns of the R5-dragon (top), the R7-dragon (middle), and the second R7-dragon
(bottom), generated by string substitution.
5
6
7
8
9
10
11
12
13

{
ulong s = 0;
bool tr = ( x & 2 ); // whether digit is either 2, 3, or 6
return tr;
}

Two renderings of the R7-dragon are shown in figure 1.31-P (created with [FXT: bits/dragon-r7-texpicdemo.cc]). The sequence of returned values (entry A176405 in [312]) can be computed via the string
substitution shown in figure 1.31-R (middle). Turns for another curve based on radix-7 counting (shown
in figure 1.31-Q, created with [FXT: bits/dragon-r7-2-texpic-demo.cc]) can be computed as follows:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

static inline int bit_dragon_r7_2_turn(ulong &x)
// return (tr) according to the lowest nonzero digit d
// of the incremented word:
// d==[1,2,3,4,5,6] ==> rt:=[0,+1,+1,-1,-1,0]
// (tr * 120deg) is the turn with the second R7-dragon.
{
ulong s = 0;
int tr = 2 - ( (0x2f58 >> (2*(x&7)) ) & 3 );
return tr;
}

The sequence of turns can be generated by the string substitution shown in figure 1.31-R (bottom), it is

100


Start: F
Rules: F --> F+F+F-F-F
+ --> +
- --> ------------0:
(#=1)
F
1:
(#=9)
F+F+F-F-F
2:
(#=49)
F+F+F-F-F+F+F+F-F-F+F+F+F-F-F-F+F+F-F-F-F+F+F-F-F
3:
(#=249)
F+F+F-F-F+F+F+F-F-F+F+F+F-F-F-F+F+F-F-F-F+F+F-F-F+F+F+F-F-F+F+F+F-F-F+F+F+F-F-F-F+ ...
Start: F
Rules: F --> F+F-F-F+F+F-F
+ --> +
- --> ------------0:
(#=1)
F
1:
(#=13)
F+F-F-F+F+F-F
2:
(#=97)
F+F-F-F+F+F-F+F+F-F-F+F+F-F-F+F-F-F+F+F-F-F+F-F-F+F+F-F+F+F-F-F+F+F-F+F+F-F-F+F+F- ...
Start: F
Rules: F --> F0F+F+F-F-F0F
+ --> +
- --> 0 --> 0
------------0:
(#=1)
F
1:
(#=13)
F0F+F+F-F-F0F
2:
(#=97)
F0F+F+F-F-F0F0F0F+F+F-F-F0F+F0F+F+F-F-F0F+F0F+F+F-F-F0F-F0F+F+F-F-F0F-F0F+F+F-F-F0 ...

Figure 1.31-S: String substitution processes for the turns (symbols ‘+’ and ‘-’) and moves (symbol ‘F’
is a unit move in the current direction) of the R5-dragon (top), the R7-dragon (middle), and the second
R7-dragon (bottom).
entry A176416 in [312].
Two curves respectively based on radix-9 and radix-13 counting are shown in ﬁgure 1.31-T. The corresponding routines are given in [FXT: bits/bit-dragon-r9.h]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// of the incremented word is either 2, 3, 5, or 8.
// tr determines whether to turn left or right (by 120 degrees)
// with the R9-dragon fractal.
// The sequence tr is the fixed point
// of the morphism 0 |--> 011010010, 1 |--> 011010011.
// Also fixed point of morphism (identify + with 0 and - with 1)
// F |--> F+F-F-F+F-F+F+F-F, + |--> +, - |--> // Also fixed point of morphism
// F |--> G+G-G, G |--> F-F+F, + |--> +, - |--> {
ulong s = 0;
bool tr = ( (0x12c >> (x&15)) & 1 ); // whether digit is either 2, 3, 5, or 8
return tr;
}

and [FXT: bits/bit-dragon-r13.h]
1
2
3
4
5
6
7
8
9
10
11
12

// of the incremented word is either 3, 6, 8, 9, 11, or 12.
// tr determines whether to turn left or right (by 90 degrees)
// with the R13-dragon fractal.
// The sequence tr is the fixed point
// of the morphism 0 |--> 0010010110110, 1 |--> 0010010110111.
// Also fixed point of morphism (identify + with 0 and - with 1)
// F |--> F+F+F-F+F+F-F+F-F-F+F-F-F, + |--> +, - |--> {
ulong s = 0;

13
14
15
16
17
18

101

bool tr = ( (0x1b48 >> (x&15)) & 1 ); // whether digit is either 3, 6, 8, 9, 11, or 12
return tr;
}

Figure 1.31-T: The R9-dragon (top) and the R13-dragon (bottom).

102

Chapter 2: Permutations and their operations

Chapter 2

Permutations and their operations
We study permutations together with the operations on them, like composition and inversion. We
further discuss the decomposition of permutations into cycles and give methods for generating random
permutations, cyclic permutations, involutions, and derangements. In-place algorithms for applying
several special permutations like the revbin permutation, the Gray permutation, and matrix transposition
are given.
Algorithms for the generation of all permutations of a given number of objects and bijections between
permutations and mixed radix numbers in factorial base are given in chapter 10.

2.1

Basic definitions and operations

A permutation of n elements can be represented by an array X = [x0 , x1 , . . . , xn−1 ]. When the permutation X is applied to F = [f0 , f1 , . . . , fn−1 ], then the element at position k is moved to position xk . A
routine for the operation is [FXT: perm/permapply.h]:
1
2
3
4
5
6
7

template <typename Type>
void apply_permutation(const ulong *x, const Type *f, Type * restrict g, ulong n)
// Apply the permutation x[] to the array f[],
// i.e. set g[x[k]] <-- f[k] for all k
{
for (ulong k=0; k<n; ++k) g[x[k]] = f[k];
}

Routines to test various properties of permutations are given in [FXT: perm/permq.cc]. The lengthn sequence [0, 1, 2, . . . , n − 1] represents the identical permutation which leaves all elements in their
position. To check whether a given permutation is the identity is trivial:
1
2
3
4
5
6
7

bool is_identity(const ulong *f, ulong n)
// Return whether f[] is the identical permutation,
// i.e. whether f[k]==k for all k= 0...n-1
{
for (ulong k=0; k<n; ++k) if ( f[k] != k ) return false;
return true;
}

A fixed point of a permutation is an index where the element is not moved:
1
2
3
4
5
6
7

ulong count_fixed_points(const ulong *f, ulong n)
// Return number of fixed points in f[]
{
ulong ct = 0;
for (ulong k=0; k<n; ++k) ct += ( f[k] == k );
return ct;
}

A derangement is a permutation that has no fixed points. A routine to check whether a permutation is
a derangement is
1
2
3
4
5

bool is_derangement(const ulong *f, ulong n)
// Return whether f[] is a derangement of identity,
// i.e. whether f[k]!=k for all k
{
for (ulong k=0; k<n; ++k) if ( f[k] == k ) return false;

2.1: Basic deﬁnitions and operations
6
7

103

return true;
}

Whether two arrays are mutual derangements (that is, fk = gk for all k) can be determined by:
1
2
3
4
5
6
7

bool is_derangement(const ulong *f, const ulong *g, ulong n)
// Return whether f[] is a derangement of g[],
// i.e. whether f[k]!=g[k] for all k
{
for (ulong k=0; k<n; ++k) if ( f[k] == g[k] ) return false;
return true;
}

A connected (or indecomposable) permutation contains no proper preﬁx mapped to itself. We test whether
max(f0 , f1 , . . . , fk ) > k for all k < n − 1:
1
2
3
4
5
6
7
8
9
10
11
12
13

bool
is_connected(const ulong *f, ulong n)
{
if ( n<=1 ) return true;
ulong m = 0; // maximum
for (ulong k=0; k<n-1; ++k) // for all proper prefixes
{
const ulong fk = f[k];
if ( fk>m ) m = fk;
if ( m<=k ) return false;
}
return true;
}

To check whether an array is a valid permutation, we need to verify that each index in the valid range
appears exactly once. The bit-array described in section 4.6 on page 164 allows doing the job without
modifying the input:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

bool
is_valid_permutation(const ulong *f, ulong n, bitarray *bp/*=0*/)
// Return whether all values 0...n-1 appear exactly once,
// i.e. whether f represents a permutation of [0,1,...,n-1].
{
// check whether any element is out of range:
for (ulong k=0; k<n; ++k) if ( f[k]>=n ) return false;
// check whether values are unique:
bitarray *tp = bp;
if ( 0==bp ) tp = new bitarray(n);
tp->clear_all();
ulong k;
for (k=0; k<n; ++k)
if ( 0==bp )
return

// tags

if ( tp->test_set(f[k]) )

break;

delete tp;

(k==n);

}

The complement of a permutation is computed by replacing every element v by n − 1 − v [FXT:
perm/permcomplement.h]:
1
2
3
4
5
6

inline void make_complement(const ulong *f, ulong *g, ulong n)
// Set (as permutation) g to the complement of f.
// Can have f==g.
{
for (ulong k=0; k<n; ++k) g[k] = n - 1 - f[k];
}

The reversal of a permutation is simply the reversed array [FXT: perm/reverse.h]:
1
2
3
4
5
6

inline void reverse(Type *f, ulong n)
// Reverse order of array f.
{
for (ulong k=0, i=n-1; k<i; ++k, --i)
}

swap2(f[k], f[i]);

104


2.2

Representation as disjoint cycles

Every permutation consists entirely of disjoint cycles. A cycle of a permutation is a subset of the indices
that is rotated (by one position) by the permutation. The term disjoint means that the cycles do not
‘cross’ each other. While this observation may appear trivial it gives a recipe for many operations: follow
the cycles of the permutation, one by one, and do the necessary operation on each of them.
Consider the following permutation of length 8:
[ 0, 2, 4, 6, 1, 3, 5, 7 ]
There are two fixed points (0 and 7, which we omit) and these cycles:
( 1 --> 2 --> 4 )
( 3 --> 6 --> 5 )

The cycles do ‘wrap around’, for example, the final 4 of the fist cycle goes to position 1, the first element
of the cycle. The inverse permutation is found by reversing every arrow in each cycle:
( 1 <-- 2 <-- 4 )
( 3 <-- 6 <-- 5 )

Equivalently, we can reverse the order of the elements in each cycle:
( 4 --> 2 --> 1 )
( 5 --> 6 --> 3 )

If we begin each cycle with its smallest element, the inverse permutation is written as
( 1 --> 4 --> 2 )
( 3 --> 5 --> 6 )

This form is obtained by reversing all elements except the first in each cycle of the (forward) permutation.
The last three sets of cycles all describe the same permutation, it is
[ 0, 4, 1, 5, 2, 6, 3, 7 ]
Permutation:
[ 0 2 4 6 1 3 5 7 ]
Inverse:
[ 0 4 1 5 2 6 3 7 ]
Cycles:
(0) #=1
(1, 2, 4) #=3
(3, 6, 5) #=3
(7) #=1
Code:
inline void foo_perm_8(Type *f)
{
{ Type t=f[1]; f[1]=f[4]; f[4]=f[2];
{ Type t=f[3]; f[3]=f[5]; f[5]=f[6];
}

f[2]=t; }
f[6]=t; }

Figure 2.2-A: A permutation of 8 elements, its inverse, its cycles, and code for the permutation.
The cycles form of a permutation can be printed with [FXT: perm/printcycles.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void
print_cycles(const ulong *f, ulong n, bitarray *tb/*=0*/)
// Print cycle form of the permutation in f[].
// Examples (first permutations of 4 elements in lex order):
//
array form
cycle form
//
0: [ 0 1 2 3 ]
(0) (1) (2) (3)
//
1: [ 0 1 3 2 ]
(0) (1) (2, 3)
//
2: [ 0 2 1 3 ]
(0) (1, 2) (3)
//
3: [ 0 2 3 1 ]
(0) (1, 2, 3)
//
4: [ 0 3 1 2 ]
(0) (1, 3, 2)
//
5: [ 0 3 2 1 ]
(0) (1, 3) (2)
//
6: [ 1 0 2 3 ]
(0, 1) (2) (3)
//
7: [ 1 0 3 2 ]
(0, 1) (2, 3)
//
8: [ 1 2 0 3 ]
(0, 1, 2) (3)
{
bitarray *b = tb;

2.3: Compositions of permutations
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

105

if ( tb==0 ) b = new bitarray(n);
b->clear_all();
{
if ( b->test(k) ) continue; // already processed
cout << "(";
ulong i = k; // next in cycle
const char *cm = "";
do
{
cout << cm << i;
cm = ", ";
b->set(i);
}
while ( (i=f[i]) != k ); // until we meet cycle leader again
cout << ") ";
}
if ( tb==0 )

delete b;

}

The bit-array (see section 4.6 on page 164 for the implementation) is used to keep track of the elements
already processed. The routine can be modified to generate code for applying a given permutation to
an array. The program [FXT: perm/cycles-demo.cc] prints cycles and code for a permutation, see figure
2.2-A.

2.2.1

Cyclic permutations

A permutation consisting of exactly one cycle is called cyclic. Whether a given permutation has this
property can be tested with [FXT: perm/permq.cc]:
1
2
3
4
5
6
7
8
9

bool
is_cyclic(const ulong *f, ulong n)
// Return whether permutation is exactly one cycle.
{
if ( n<=1 ) return true;
ulong k = 0, e = 0;
do { e=f[e]; ++k; } while ( e!=0 );
return (k==n);
}

The method used is to follow the cycle starting at position zero and counting how long it is. If the length
found equals the array length, then the permutation is cyclic. There are (n − 1)! cyclic permutations of
n elements.

2.2.2

Sign and parity of a permutation

Every permutation can be written as a composition of transpositions (cycles of length 2). This number
of transpositions is not unique, but modulo 2 it is unique. The sign of a permutation is defined to be
+1 if the number is even and −1 if the number is odd. The minimal number of transpositions whose
composition give a cycle of length l is l − 1. So the minimal number of transpositions for a permutation
k
k
consisting of k cycles where the length of the j-th cycle is lj equals j=1 (lj − 1) = ( j=1 lj ) − k. The
transposition count modulo 2 is called the parity of a permutation.

2.3

Compositions of permutations

We can apply several permutations to an array, one by one. The resulting permutation is called the
composition of the applied permutations. The operation of composition is not commutative: in general
f · g = g · f for f = g. We note that the permutations of n elements form a group (of n! elements), the
group operation is composition.

106


2.3.1

The inverse of a permutation

A permutation f is the inverse of the permutation g if it undoes its effect: f · g = id. A test whether
two permutations f and g are mutual inverses is
1
2
3
4
5
6

bool is_inverse(const ulong *f, const ulong *g, ulong n)
// Return whether f[] is the inverse of g[]
{
for (ulong k=0; k<n; ++k) if ( f[g[k]] != k ) return false;
return true;
}

We have g · f = f · g = id, in a group the left-inverse is equal to the right-inverse, so we can simply call
g ‘the inverse’ of f .
A permutation which is its own inverse is called an involution. Checking for this is easy:
1
2
3
4
5
6
7

bool is_involution(const ulong *f, ulong n)
// Return whether max cycle length is <= 2,
// i.e. whether f * f = id.
{
for (ulong k=0; k<n; ++k) if ( f[f[k]] != k )
return true;
}

return false;

The following routine computes the inverse of a given permutation [FXT: perm/perminvert.cc]:
1
2
3
4
5

void make_inverse(const ulong *f, ulong * restrict g, ulong n)
// Set (as permutation) g to the inverse of f
{
for (ulong k=0; k<n; ++k) g[f[k]] = k;
}

For the in-place computation of the inverse we have to reverse each cycle [FXT: perm/perminvert.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void make_inverse(ulong *f, ulong n, bitarray *bp/*=0*/)
// Set (as permutation) f to its own inverse.
{
bitarray *tp = bp;
if ( 0==bp ) tp = new bitarray(n); // tags
tp->clear_all();
{
if ( tp->test_clear(k) )
tp->set(k);

continue;

// already processed

// invert a cycle:
ulong i = k;
ulong g = f[i]; // next index
while ( 0==(tp->test_set(g)) )
{
ulong t = f[g];
f[g] = i;
i = g;
g = t;
}
f[g] = i;
}
if ( 0==bp )

delete tp;

}

The extra array of tag-bits can be avoided by using the highest bit of each word as a tag-bit. The scheme
would fail if any word of the permutation array had the highest bit set. However, on byte-addressable
machines such an array will not fit into memory (for word sizes of 16 or more bits). To keep the code
similar to the version using the bit-array, we define
1
2
3
4
5
6

static const ulong s1 = 1UL << (BITS_PER_LONG - 1); // highest bit is tag-bit
static const ulong s0 = ~s1; // all bits but tag-bit
static inline void SET(ulong *f, ulong k) { f[k&s0] |= s1; }
static inline void CLEAR(ulong *f, ulong k) { f[k&s0] &= s0; }
static inline bool TEST(ulong *f, ulong k) { return (0!=(f[k&s0]&s1)); }

2.3: Compositions of permutations

107

We have to mask out the tag-bit when using the index variable k. The routine can be implemented as
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

void
make_inverse(ulong *f, ulong n)
// Set (as permutation) f to its own inverse.
// In-place version using highest bits of array as tag-bits.
{
{
if ( TEST(f, k) ) { CLEAR(f, k); continue; } // already processed
SET(f, k);
// invert a cycle:
ulong i = k;
while ( 0==TEST(f, g) )
{
ulong t = f[g];
f[g] = i;
SET(f, g);
i = g;
g = t;
}
f[g] = i;
CLEAR(f, k);

// leave no tag-bits set

}
}

The extra CLEAR() statement at the end removes the tag-bit of the cycle minima. Its eﬀect is that
no tag-bits are set after the routine has ﬁnished. This routine has about the same performance as the
bit-array version.

2.3.2

The square of a permutation

The square of a permutation is the composition with itself.
perm/permcompose.cc]
1
2
3
4
5

The routine for squaring is [FXT:

void make_square(const ulong *f, ulong * restrict g, ulong n)
// Set (as permutation) g = f * f
{
for (ulong k=0; k<n; ++k) g[k] = f[f[k]];
}

The in-place version is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void make_square(ulong *f, ulong n, bitarray *bp/*=0*/)
// Set (as permutation) f = f * f
// In-place version.
{
bitarray *tp = bp;
tp->clear_all();
{
tp->set(k);

continue;

// square a cycle:
ulong i = k;
ulong t = f[i]; // save
while ( 0==(tp->test_set(g)) )
{
f[i] = f[g];
i = g;
g = f[g];
}
f[i] = t;
}
if ( 0==bp )

delete tp;

108
28


}

2.3.3

Composing and powering permutations

The composition of two permutations can be computed as
1
2
3
4
5
6

void
compose(const ulong *f, const ulong *g, ulong * restrict h, ulong n)
// Set (as permutation) h = f * g
{
for (ulong k=0; k<n; ++k) h[k] = f[g[k]];
}

The following version will be used in the powering routine for permutations:
1
2
3
4
5
6

void
compose(const ulong *f, ulong * restrict g, ulong n)
// Set (as permutation) g = f * g
{
for (ulong k=0; k<n; ++k) g[k] = f[g[k]]; // yes, this works
}

The e-th power of a permutation f is computed (and returned in g) by a version of the binary exponentiation algorithm described in section 28.5 on page 563 [FXT: perm/permcompose.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

void
power(const ulong *f, ulong * restrict g, ulong n, long e,
ulong * restrict t/*=0*/)
// Set (as permutation) g = f ** e
{
if ( e==0 )
{
for (ulong k=0; k<n; ++k) g[k] = k;
return;
}
if ( e==1 )
{
acopy(f, g, n);
return;
}
if ( e==-1 )
{
make_inverse(f, g, n);
return;
}
// here: abs(e) > 1
ulong x = e>0 ? e : -e;
if ( is_pow_of_2(x) ) // special case x==2^n
{
make_square(f, g, n);
while ( x>2 ) { make_square(g, n); x /= 2; }
}
else
{
ulong *tt = t;
if ( 0==t ) { tt = new ulong[n]; }
acopy(f, tt, n);
int firstq = 1;
while ( 1 )
{
if ( x&1 ) // odd
{
if ( firstq ) // avoid multiplication by 1
{
acopy(tt, g, n);
firstq = 0;
}
else compose(tt, g, n);
if ( x==1 )
}

goto dort;

2.4: In-place methods to apply permutations to data
53
54
55
56
57
58
59
60
61
62

109

make_square(tt, n);
x /= 2;
}
dort:
if ( 0==t )
}
if ( e<0 )

delete [] tt;

make_inverse(g, n);

}

The routine involves O (n log(n)) operations. By extracting the cycles of the permutation, computing
their e-th powers, and copying them back, we could reduce the complexity to only O(n). The e-th power
of a cycle is a cyclic shift by e positions, as described in section 2.9 on page 123.

2.4

In-place methods to apply permutations to data

We repeat the routine for applying a permutation [FXT: perm/permapply.h]:
1
2
3
4
5
6
7

void apply_permutation(const ulong *x, const Type *f, Type * restrict g, ulong n)
// Apply the permutation x[] to the array f[],
// i.e. set g[x[k]] <-- f[k] for all k
{
for (ulong k=0; k<n; ++k) g[x[k]] = f[k];
}

The in-place version follows the cycles of the permutation:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

void apply_permutation(const ulong *x, Type * restrict f, ulong n, bitarray *bp=0)
{
bitarray *tp = bp;
tp->clear_all();
{
tp->set(k);

continue;


// --- do cycle: --ulong i = k; // start of cycle
Type t = f[i];
ulong g = x[i];
while ( 0==(tp->test_set(g)) ) // cf. gray_permute()
{
Type tt = f[g];
f[g] = t;
t = tt;
g = x[g];
}
f[g] = t;
// --- end (do cycle) --}
if ( 0==bp )

delete tp;

}

To apply the inverse of a permutation without inverting the permutation itself, use
1
2
3
4
5

void apply_inverse_permutation(const ulong *x, const Type *f, Type * restrict g, ulong n)
{
for (ulong k=0; k<n; ++k) g[k] = f[x[k]];
}

The in-place version is
1
2
3
4

void apply_inverse_permutation(const ulong *x, Type * restrict f, ulong n, bitarray *bp=0)
{
bitarray *tp = bp;

110
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

if ( 0==bp ) tp = new bitarray(n);
tp->clear_all();
{
tp->set(k);

// tags

continue;


// --- do cycle: --ulong i = k; // start of cycle
Type t = f[i];
ulong g = x[i];
while ( 0==(tp->test_set(g)) ) // cf. inverse_gray_permute()
{
f[i] = f[g];
i = g;
g = x[i];
}
f[i] = t;
if ( 0==bp )

delete tp;

}

A permutation of n elements can be given as a function X(k) (where 0 ≤ X(k) <= n for 0 ≤ k < n, and
X(i) = X(j) for i = j). The permutation given as function X can be applied to an array f via [FXT:
perm/permapplyfunc.h]:
1
2
3
4
5
6

void apply_permutation(ulong (*x)(ulong), const Type *f, Type * restrict g, ulong n)
// Set g[x(k)] <-- f[k] for all k
{
for (ulong k=0; k<n; ++k) g[x(k)] = f[k];
}

For example, the following statements are equivalent:
apply_permutation(gray_code, f, g, n);
gray_permute(f, g, n);

The inverse routine is
1
2
3
4
5

void apply_inverse_permutation(ulong (*x)(ulong), const Type *f, Type * restrict g, ulong n)
{
for (ulong k=0; k<n; ++k) g[k] = f[x(k)];
}

The in-place versions of these routines are almost identical to the routines that apply permutations given
as arrays. Only a tiny change must be made in the processing of the cycles. For example, the fragment
1
2
3
4
5
6
7
8
9
10
11
12
13
14

void apply_permutation(const ulong *x, Type * restrict f, ulong n, bitarray *bp=0)
[--snip--]
ulong i = k; // start of cycle
Type t = f[i];
ulong g = x[i];
{
Type tt = f[g];
f[g] = t;
t = tt;
g = x[g];
}
f[g] = t;
[--snip--]

must be modiﬁed by replacing all occurrences of ‘x[i]’ with ‘x(i)’:
1
2
3
4
5
6

void apply_permutation(ulong (*x)(ulong), Type *f, ulong n, bitarray *bp=0)
[--snip--]
ulong i = k; // start of cycle
Type t = f[i];
ulong g = x(i); // <--=

2.5: Random permutations
7
8
9
10
11
12
13
14

111

{
Type tt = f[g];
f[g] = t;
t = tt;
g = x(g); // <--=
}
f[g] = t;
[--snip--]

2.5

Random permutations

The following routine randomly permutes an array with arbitrary elements [FXT: perm/permrand.h]:
1
2
3
4
5
6
7
8
9

void random_permute(Type *f, ulong n)
{
for (ulong k=n; k>1; --k)
{
const ulong i = rand_idx(k);
swap2(f[k-1], f[i]);
}
}

An alternative version for the loop is:
1
2
3
4
5

{
const ulong i = rand_idx(k+1);
swap2(f[k], f[i]);
}

The method is given in [132], it is sometimes called Knuth shuffle or Fisher-Yates shuffle, see [213, alg.P,
sect.3.4.2]. We use the auxiliary routine [FXT: aux0/rand-idx.h]
1
2
3
4
5
6
7
8
9

inline ulong rand_idx(ulong m)
// Return random number in the range [0, 1, ..., m-1].
// Must have m>0.
{
if ( m==1 ) return 0; // could also use % 1
ulong x = (ulong)rand();
x ^= x>>16;
// avoid using low bits of rand() alone
return x % m;
}

A random permutation is computed by applying the function to the identical permutation:
1
2
3
4
5
6

void random_permutation(ulong *f, ulong n)
// Create a random permutation
{
for (ulong k=0; k<n; ++k) f[k] = k;
random_permute(f, n);
}

A slight modification of the underlying idea can be used for a routine for random selection from a list
with only one linear read. Let L be a list of n items L1 , . . . , Ln .
1. Set t = L1 , set k = 1.
2. Set k = k + 1. If k > n return t.
3. With probability 1/k set t = Lk .
4. Go to step 2.
Note that one does not need to know n, the number of elements in the list, in advance: replace the second
statement in step 2 by “If there are no more elements, return t”.

112

2.5.1


Random cyclic permutation

A routine to apply a random cyclic permutation (as defined in section 2.2.1 on page 105) to an array is
[FXT: perm/permrand-cyclic.h]
1
2
3
4
5
6
7
8
9
10

void random_permute_cyclic(Type *f, ulong n)
// Permute the elements of f by a random cyclic permutation.
{
for (ulong k=n-1; k>0; --k)
{
const ulong i = rand_idx(k);
swap2(f[k], f[i]);
}
}

The method is called Sattolo’s algorithm, see [296], and also [171] and [362]. It can be described as a
method to arrange people in a cycle: Assume there are n people in a room. Let the first person choose
a successor out of the remaining persons not yet chosen. Then let the person just chosen make the next
choice of a successor. Repeat until everyone has been chosen. Finally, let the first person be the successor
of the last person chosen.
The cycle representation of a random cyclic permutation can be computed by applying a random permutation to all elements (of the identical permutation) except for the first element.

2.5.2

Random prefix of a permutation

A length-m prefix of a random permutation of n elements is computed by the following routine that uses
just O(m) operations [FXT: perm/permrand-pref.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void random_permute_pref(Type *f, ulong n, ulong m)
// Set the first m elements to a prefix of a random permutation.
// Same as: set the first m elements of f to a random permutation
// of a random selection of all n elements.
// Must have m<=n-1.
// Same as random_permute() if m>=n-1.
{
if ( m>n-1 ) m = n-1; // m>n is not admissable
for (ulong k=0,j=n; k<m; ++k,--j)
{
const ulong i = k + rand_idx(j); // k<=i<n
swap2(f[k], f[i]);
}
}

The first element is randomly selected from all n elements, the second from the remaining n − 1 elements,
and so on. Thus there are n (n − 1) . . . (n − m + 1) = n!/(n − m)! length-m prefixes of permutations of
n elements.

2.5.3

Random permutation with prescribed parity

To compute a random permutation with prescribed parity (as defined in section 2.2.2 on page 105) we
keep track of the parity of the generated permutation and change it via a single transposition if necessary
[FXT: perm/permrand-parity.h]:
1
2
3
4
5
6
7
8
9
10
11
12

void random_permute_parity(Type *f, ulong n, bool par)
// Randomly permute the elements of f, such that the
// parity of the permutation equals par.
// I.e. the minimal number of transpositions of the
// permutation is even if par==0, else odd.
// Note: with n<=1 there is no odd permutation.
{
if ( (par==1) && (n<2) ) return; // not admissable
bool pr = 0; // identity has even parity

13
14
15
16
17
18
19
20

113

{
const ulong i = rand_idx(k+1);
swap2(f[k], f[i]);
pr ^= ( k != i );
// parity changes with swap
}
if ( par!=pr )

swap2(f[0], f[1]);

// need to change parity

}

2.5.4

Random permutation with m smallest elements in prescribed order

In the last algorithm we conditionally changed the positions 0 and 1. Now we conditionally change the
elements 0 and 1 to preserve their relative order [FXT: perm/permrand-ord.h]:
1
2
3
4
5
6
7
8
9
10
11
12

void random_ord01_permutation(Type *f, ulong n)
// Random permutation such that elements 0 and 1 are in order.
{
random_permutation(f, n);
ulong t = 0;
while ( f[t]>1 ) ++t;
if ( f[t]==0 ) return; // already in correct order
f[t] = 0;
do { ++t; } while ( f[t]!=0 );
f[t] = 1;
}

The routine generates half of all the permutations but not their reversals. The following routine ﬁxes the
relative order of the m smallest elements:
1
2
3
4
5
6
7
8

void random_ordm_permutation(Type *f, ulong n, ulong m)
// Random permutation such that the m smallest elements are in order.
// Must have m<=n.
{
for (ulong t=0,j=0; j<m; ++t) if ( f[t]<m ) { f[t]=j; ++j; }
}

A random permutation where 0 appears as the last of the m smallest elements is computed by:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

void random_lastm_permutation(Type *f, ulong n, ulong m)
// Random permutation such that 0 appears as last of the m smallest elements.
// Must have m<=n.
{
if ( m<=1 ) return;
ulong p0=0, pl=0; // position of 0, and last (in m smallest elements)
for (ulong t=0, j=0; j<m; ++t)
{
if ( f[t]<m )
{
pl = t; // update position of last
if ( f[t]==0 ) { p0 = t; } // record position of 0
++j;
// j out of m smallest found
}
}
// here t is the position of the last of the m smallest elements
swap2( f[p0], f[pl] );
}

2.5.5

Random permutation with prescribed cycle type

To create a random permutation with given cycle type (see section 11.1.2 on page 278) we ﬁrst give a
routine for permuting by one cycle of prescribed length. We need to keep track of the set of unprocessed
elements. The positions of those (available) elements are stored in an array r[]. After an element is
processed its index is swapped with the last available index [FXT: perm/permrand-cycle-type.h]:
1
2
3

inline ulong random_cycle(Type *f, ulong cl, ulong *r, ulong nr)
// Permute a random set of elements (whose positions are given in

114
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


// r[0], ..., r[nr-1]) by a random cycle of length cl.
// Must have nr >= cl and cl != 0.
{
if ( cl==1 ) // just remove a random position from r[]
{
const ulong i = rand_idx(nr);
--nr; swap2( r[nr], r[i] ); // remove position from set
}
else // cl >= 2
{
const ulong i0 = rand_idx(nr);
const ulong k0 = r[i0]; // position of cycle leader
const Type f0 = f[k0]; // cycle leader
--cl;
--nr; swap2( r[nr], r[i0] ); // remove position from set
ulong kp = k0; // position of predecessor in cycle
do // create cycle
{
const ulong i = rand_idx(nr);
const ulong k = r[i]; // random available position
f[kp] = f[k];
// move element
--nr; swap2( r[nr], r[i] ); // remove position from set
kp = k; // update predecessor
}
while ( --cl );
f[kp] = f0;

// close cycle

}
return nr;
}

To permute according to a cycle type, we call the routine according to the elements of an array c[] that
specifies how many cycles of each length are required:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

inline void random_permute_cycle_type(Type *f, ulong n, const ulong *c, ulong *tr=0)
// Permute the elements of f by a random permutation of prescribed cycle type.
// The permutation will have c[k] cycles of length k+1.
// Must have s <= n where s := sum(k=0, n-1, c[k]).
// If s < n then the permutation will have n-s fixed points.
{
ulong *r = tr;
if ( tr==0 ) r = new ulong[n];
for (ulong k=0; k<n; ++k) r[k] = k; // initialize set
ulong nr = n; // number of elements available
// available positions are r[0], ..., r[nr-1]
{
ulong nc = c[k]; // number of cycles of length k+1;
if ( nc==0 ) continue; // no cycles of this length
const ulong cl = k+1; // cycle length
do
{
nr = random_cycle(f, cl, r, nr);
}
while ( --nc );
}
if ( tr==0 )

delete [] r;

}

2.5.6

Random self-inverse permutation

For the self-inverse permutations (involutions) we need to compute certain branch probabilities. At each
step either a 2-cycle or a fixed point is generated. The probability that the next step generates a fixed
point is R(n) = I(n − 1)/I(n) where I(n) is the number of involutions of n elements. This can be seen
by dividing relation 11.1-6 on page 279 by I(n):
1

=

I(n − 1) (n − 1) I(n − 2)
+
I(n)
I(n)

(2.5-1)

115

At each step we generate a random number t where 0 ≤ t < 1, if t > R(n) then a 2-cycle is created, else
a fixed point. The quantities I(n) cannot be used with fixed precision arithmetic because an overflow
would occur for large n. Instead, we update R(n) via
R(n + 1)

=

1
1 + n R(n)

(2.5-2)

The recurrence is numerically stable [FXT: perm/permrand-self-inverse.h]:
1
2
3
4
5

inline void next_involution_branch_ratio(double &rat, double &n1)
{
n1 += 1.0;
rat = 1.0/( 1.0 + n1*rat );
}

The following routine initializes the array of values R(n):
1
2
3
4
5
6
7
8
9
10

inline void init_involution_branch_ratios(double *b, ulong n)
{
b[0] = 1.0;
double rat = 0.5, n1 = 1.0;
{
b[k] = rat;
next_involution_branch_ratio(rat, n1);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

inline void random_permute_self_inverse(Type *f, ulong n,
ulong *tr=0, double *tb=0, bool bi=false)
// Permute the elements of f by a random self-inverse permutation (an involution).
// Set bi:=true to signal that the branch probabilities in tb[]
//
have been precomputed (via init_involution_branch_ratios()).
{
ulong *r = tr;
for (ulong k=0; k<n; ++k) r[k] = k;
double *b = tb;
if ( tb==0 ) { b = new double[n]; bi=false; }
if ( !bi ) init_involution_branch_ratios(b, n);
while ( nr>=2 )
{
const ulong x1 = nr-1;
const ulong r1 = r[x1]; // available position
--nr; // no swap needed if x1==last
const double rat = b[nr];

// probability to choose fixed point

const double t = rnd01(); // 0 <= t < 1
if ( t > rat ) // 2-cycle
{
const ulong x2 = rand_idx(nr);
const ulong r2 = r[x2]; // random available position != r1
--nr; swap2(r[x2], r[nr]);
swap2( f[r1], f[r2] );
}
// else // fixed point, nothing to do
}
if ( tr==0 )
if ( tb==0 )

delete [] r;
delete [] b;

}

The auxiliary function rand01() returns a random number t where 0 ≤ t < 1 [FXT: aux0/randf.cc].

2.5.7

Random derangement

In each step of the routine for a random permutation without fixed points (a derangement) we join two
cycles and decide whether to close the resulting cycle. The probability of closing is B(n) = (n − 1) D(n −

116


2)/D(n) where D(n) is the number of derangements of n elements. This can be seen by dividing relation
11.1-12a on page 280 by D(n):
1

=

(n − 1) D(n − 1) (n − 1) D(n − 2)
+
D(n)
D(n)

(2.5-3)

The probability B(n) is close to 1/n for large n. Already for n > 30 the relative error (for B(n) versus
1/n) is less than 10−32 , so B(n) is indistinguishable from 1/n with ﬂoating-point types where the mantissa
has at most 106 bits. We compute a table of just 32 values B(n) [FXT: perm/permrand-derange.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// number of precomputed branch ratios:
#define NUM_PBR 32 // OK for up to 106-bit mantissa
inline void init_derange_branch_ratios(double *b)
{
b[0] = 0.0; b[1] = 1.0;
double dn0 = 1.0, dn1 = 0.0, n1 = 1.0;
for (ulong k=2; k<NUM_PBR; ++k)
{
const double dn2 = dn1;
next_num_derangements(dn0, dn1, n1);
const double rat = (n1) * dn2/dn0; // == (n-1) * D(n-2) / D(n)
b[k] = rat;
}
}

The D(n) are updated using D(n) = (n − 1) [D(n − 1) + D(n − 2)]:
1
2
3
4
5

inline void next_num_derangements(double &dn0, double &dn1, double &n1)
{
const double dn2 = dn1; dn1 = dn0; n1 += 1.0;
dn0 = n1*(dn1 + dn2);
}

Now the B(n) are computed as
1
2
3
4
5

inline double derange_branch_ratio(const double *b, ulong n)
{
if ( n<NUM_PBR ) return b[n];
else
return 1.0/(double)n; // relative error < 1.0e-32
}

The routine for a random derangement is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

inline void random_derange(Type *f, ulong n,
ulong *tr=0,
double *tb=0, bool bi=false)
// Permute the elements of f by a random derangement.
// Set bi:=true to signal that the branch probabilities in tb[]
//
have been precomputed (via init_derange_branch_ratios()).
// Must have n > 1.
{
ulong *r = tr;
for (ulong k=0; k<n; ++k) r[k] = k;
double *b = tb;
if ( tb==0 ) { b = new double[NUM_PBR]; bi=false; }
if ( !bi ) init_derange_branch_ratios(b);
while ( nr>=2 )
{
const ulong x1 = nr-1; // last element
const ulong r1 = r[x1];
const ulong x2 = rand_idx(nr-1);
const ulong r2 = r[x2];
swap2( f[r1], f[r2] );

// random element !=last

// join cycles containing f[r1] and f[r2]

// remove r[x1]=r1 from set:
--nr; // swap2(r[x1], r[nr]);

// swap not needed if x1==last

32
33
34
35
36
37
38
39
40
41
42
43
44
45

117

const double rat = derange_branch_ratio(b, nr);
const double t = rnd01(); // 0 <= t < 1
if ( t < rat ) // close cycle
{
// remove r[x2]=r2 from set:
--nr; swap2(r[x2], r[nr]);
}
// else cycle stays open
}
if ( tr==0 )
if ( tb==0 )

delete [] r;
delete [] b;

}

The method is (essentially) given in [245]. A generalization for permutations with all cycles of length
≥ m is given in [24].

2.5.8

Random connected permutation

A random connected (indecomposable) permutation can be computed via the rejection method : create
a random permutation, if it is not connected, repeat. An implementation is [FXT: perm/permrandconnected.h]
1
2
3
4
5

inline void random_connected_permutation(ulong *f, ulong n)
{
do { random_permute(f, n); } while ( ! is_connected(f, n) );
}

The method is efficient because the number of connected permutations is (asymptotically) given by
C(n)

= n!

1−

2
−O
n

1
n2

(2.5-4)

That is, the test for connectedness is expected to fail with a probability of about 2/n for large n. The
probability of failure can be reduced to about 2/n2 by avoiding the permutations that fix either the first
or the last element. The small cases (n ≤ 3) are treated separately:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

if ( n<=3 )
{
if ( n<2 ) return;
// [] or [0]
swap2(f[0], f[n-1]);
if ( n==2 ) return; // [1,0]
// here: [2,1,0]
const ulong i = rand_idx(3);
swap2(f[1], f[i]);
// i = 0 ==> [1,2,0]
// i = 1 ==> [2,1,0]
// i = 2 ==> [2,0,1]
return;
}
do
{

f[k] = k;

while ( 1 )
{
const ulong i0 = 1 + rand_idx(n-1); // first element must move
const ulong i1 = 1 + rand_idx(n-1); // f[1] will be last element
swap2( f[0], f[i0] );
swap2( f[1], f[i1] );
if ( f[1]==n-1 ) // undo swap and repeat (here: f[0]!=0)
{
swap2( f[1], f[i1] );
swap2( f[0], f[i0] );
continue;
// probability 1/n but work only O(1)
}
else break;
}

118
34
35
36
37
38
39


swap2(f[1], f[n-1]); // move f[1] to last
// here: f[0] != 0 and f[n-1] != n-1
random_permute(f+1, n-2); // permute 2nd ... 2nd last element
}
while ( ! is_connected(f, n) );

2.6

The revbin permutation
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[ *
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

0:
1:
2:
3:
4:
5:
6:
7:

[ *
[
*
[
*
[
*
[
*
[
*
[
*
[
*

]
]
]
]
]
]
]
]

0:
1:
2:
3:

[ *
[
*
[
*
[
*

]
]
]
]

Figure 2.6-A: Permutation matrices of the revbin permutation for sizes 16, 8 and 4. The permutation
is self-inverse.
The permutation that swaps elements whose binary indices are mutual reversals is called revbin permutation (sometimes also bit-reversal or bitrev permutation). For example, for length n = 256 the element
with index x = 4310 = 001010112 is swapped with the element whose index is x = 110101002 = 21210 .
˜
Note that x depends on both x and on n. Pseudocode for a naive implementation is
˜
1
2
3
4
5
6
7
8
9

procedure revbin_permute(a[], n)
// a[0..n-1] input,result
{
for x:=0 to n-1
{
r := revbin(x, n)
if r>x then swap(a[x], a[r])
}
}

The condition r>x before the swap() statement makes sure that the swapping is not undone later when
the loop variable x has the value of the present r.

2.6.1

Computation using revbin-update

The key ingredient for a fast permutation routine is the observation that we only need to update the
bit-reversed values: given x we can compute x + 1 eﬃciently as described in section 1.14.3 on page 36.
˜
A faster routine will be of the form
1
2
3
4
5
6
7
8
9
10
11

// a[0..n-1] input,result
{
if n<=2 return
r := 0 // the reversed 0
for x:=1 to n-1
{
r := revbin_upd(r, n/2)
}
}

√
About (n − n)/2 swap() statements are executed with the revbin permutation of n elements. That is,
almost every element is moved for large n, as there are only a few numbers with symmetric bit patterns:

2.6: The revbin permutation

119
n:
2:
4:
8:
16:
32:
64:
210 :
220 :
∞:

2 # swaps
0
2
4
12
24
56
992
0.999 · √
220
n− n

# symm. pairs
2
2
4
4
8
8
32
210
√
n

The sequence is entry A045687 in [312]:
0, 2, 4, 12, 24, 56, 112, 238, 480, 992, 1980, 4032, 8064, 16242, 32512, 65280, ...

2.6.2

Exploiting the symmetries of the permutation

˜
Symmetry can be used for further optimization: if for even x < n there is a swap for the pair (x, x),
2
then there is also a swap for the pair (n − 1 − x, n − 1 − x). As x < n and x < n , one has n − 1 − x > n
˜
˜
2
2
2
and n − 1 − x > n . That is, the swaps are independent. A routine that uses these observations is
˜
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
if n<=2 return
nh := n/2
x := 1
while x<nh
{
// x odd:
r := r + nh
swap(a[x], a[r])
x := x + 1
// x even:
r := revbin_upd(r, n/2)
if r>x then
{
swap(a[x], a[r])
swap(a[n-1-x], a[n-1-r])
}
x := x + 1
}
}

The code above can be used to derive an optimized version for zero padded data (used with linear
convolution, see section 22.1.4 on page 443):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

procedure revbin_permute0(a[], n)
{
if n<=2 return
nh := n/2
x := 1
while x<nh
{
// x odd:
r := r + nh
a[r] := a[x]
a[x] := 0
x := x + 1
// x even:
r := revbin_upd(r, n)
// Omit swap of a[n-1-x] and a[n-1-r] as both are zero
x := x + 1
}
}

We can carry the scheme further, distinguishing whether x mod 4 = 0, 1, 2, or 3, as done in the implementation [FXT: perm/revbinpermute.h]. The following parameters determine how much of the symmetry
is used and which version of the revbin-update routine is chosen:

120
1
2


#define
#define

RBP_SYMM 4
FAST_REVBIN

// amount of symmetry used: 1, 2, 4 (default is 4)
// define if using revbin(x, ldn) is faster than updating

We further deﬁne a macro to swap elements:
1

#define

idx_swap(k, r)

{ ulong kx=(k), rx=(r);

swap2(f[kx], f[rx]); }

The main routine uses unrolled versions of the revbin permutation for small values of n. These are given
in [FXT: perm/shortrevbinpermute.h]. For example, the unrolled routine for n = 16 is
1
2
3
4
5
6
7
8
9
10

inline void revbin_permute_16(Type *f)
{
swap2(f[1], f[8]);
swap2(f[2], f[4]);
swap2(f[3], f[12]);
swap2(f[5], f[10]);
swap2(f[7], f[14]);
swap2(f[11], f[13]);
}

The code was generated with the program [FXT: perm/cycles-demo.cc], see section 2.2 on page 104. The
routine revbin_permute_leq_64(f,n), which is called for n ≤ 64, selects the correct routine for the
parameter n:
1
2
3
4
5
6
7
8
9

void revbin_permute(Type *f, ulong n)
{
if ( n<=64 )
{
revbin_permute_leq_64(f, n);
return;
}
[--snip--]

In what follows we set RBP_SYMM to 4, deﬁne FAST_REVBIN, and omit the corresponding preprocessor
statements. Some auxiliary constants have to be computed:
1
2
3
4
5

const
const
const
const
const

ulong
ulong
ulong
ulong
ulong

ldn = ld(n);
nh = (n>>1);
n1 = n - 1;
// = 11111111
nx1 = nh - 2;
// = 01111110
nx2 = n1 - nx1; // = 10111101

The main loop is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

ulong k = 0, r = 0;
while ( k < (n/RBP_SYMM) ) // n>=16, n/2>=8, n/4>=4
{
// ----- k%4 == 0:
if ( r>k )
{
idx_swap(k, r); // <nh, <nh 11
idx_swap(n1^k, n1^r); // >nh, >nh 00
idx_swap(nx1^k, nx1^r); // <nh, <nh 11
idx_swap(nx2^k, nx2^r); // >nh, >nh 00
}
++k;
r ^= nh;
// ----- k%4 == 1:
if ( r>k )
{
idx_swap(k, r); // <nh, >nh 10
idx_swap(n1^k, n1^r); // >nh, <nh 01
}
++k;
r = revbin(k, ldn);
// ----- k%4 == 2:
if ( r>k )
{
idx_swap(k, r); // <nh, <nh 11
idx_swap(n1^k, n1^r); // >nh, >nh 00

2.7: The radix permutation
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

121

}
++k;
r ^= nh;
// ----- k%4 == 3:
if ( r>k )
{
idx_swap(k, r);
// <nh, >nh 10
idx_swap(nx1^k, nx1^r);
// <nh, >nh 10
}
++k;
r = revbin(k, ldn);
}

}
// end of the routine

For large n the routine takes about six times longer than a simple array reversal. Much of the time
is spent waiting for memory which suggests that further optimizations would best be attempted with
special machine instructions to bypass the cache or with non-temporal writes.
A specialized implementation optimized for zero padded data is given in [FXT: perm/revbinpermute0.h].
Some memory accesses can be avoided for that case. For example, revbin-pairs with both indices greater
than n/2 need no processing at all.

2.6.3

A pitfall

When working with separate arrays for the real and imaginary parts of complex data, one could remove
half of the bookkeeping as follows:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

procedure revbin_permute(a[], b[], n)
{
if n<=2 return
for x:=1 to n-1
{
r := revbin_upd(r, n/2) // inline me
if r>x then
{
swap(a[x], a[r])
swap(b[x], b[r])
}
}
}

If both the real and the imaginary part ﬁt into level-1 cache the method can lead to a speedup. However,
for large arrays the routine can be much slower than two separate calls of the simple method: with FFTs
the real and imaginary element for the same index typically lie apart in memory by a power of 2, leading
to a high percentage of cache misses with large arrays.

2.7

The radix permutation

The radix permutation is the generalization of the revbin permutation to arbitrary radices. Pairs of
elements are swapped when their indices, written in radix r, are reversed. For example, in radix 10 and
n = 1000 the elements with indices 123 and 321 will be swapped. The radix permutation is self-inverse.
Code for the radix r permutation of the array f[ ] is given in [FXT: perm/radixpermute.h]. The routine
must be called with n a perfect power of the radix r. Radix r = 2 gives the revbin permutation.
1
2
3
4
5
6
7
8
9
10
11

extern ulong
extern ulong
#define NT
#define KT

radix_permute_nt[];
radix_permute_kt[];
radix_permute_nt
radix_permute_kt

// == 9, 90, 900, ...
// == 1, 10, 100, ...

void radix_permute(Type *f, ulong n, ulong r)
{
ulong x = 0;
NT[0] = r-1;
KT[0] = 1;

for r=10
for r=10

122
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

while ( 1 )
{
ulong z = KT[x] * r;
if ( z>n ) break;
++x;
KT[x] = z;
NT[x] = NT[x-1] * r;
}
// here: n == p**x
for (ulong i=0, j=0; i < n-1; i++)
{
if ( i<j ) swap2(f[i], f[j]);
ulong t = x - 1;
ulong k = NT[t];
while ( k<=j )
{
j -= k;
k = NT[--t];
}

// =^=

k = (r-1) * n / r;

// =^=

k /= r;

j += KT[t]; // =^=

j += (k/(r-1));

}
}

2.8

In-place matrix transposition

Transposing a matrix is easy when it is not done in-place. The following routine does the job [FXT:
aux2/transpose.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void transpose(const Type * restrict f, Type * restrict g, ulong nr, ulong nc)
// Transpose nr x nc matrix f[] into an nc x nr matrix g[].
{
for (ulong r=0; r<nr; r++)
{
ulong isrc = r * nc;
ulong idst = r;
for (ulong c=0; c<nc; c++)
{
g[idst] = f[isrc];
isrc += 1;
idst += nr;
}
}
}

Matters get more complicated for the in-place equivalent. We have to ﬁnd the cycles (see section 2.2 on
page 104) of the underlying permutation. To transpose a nr × nc matrix ﬁrst identify the position i of
the entry in row r and column c:
i

= r · nc + c

(2.8-1)

After the transposition the element will be at position i in the transposed nr × nc matrix
i

r · nc + c

(2.8-2)

= c · nr + r

(2.8-3)

=

We have r = c, c = r, nr = nc and nc = nr , so
i
Multiplying the last equation by nc gives
i · nc

=

c · nr · nc + r · nc

(2.8-4)

2.9: Rotation by triple reversal

123

With n := nr · nc and r · nc = i − c we find
i · nc
i

= c·n+i−c

(2.8-5)

= i · nc − c · (n − 1)

(2.8-6)

Take the equation modulo n − 1 to obtain
i

≡

i · nc mod n − 1

(2.8-7)

That is, the transposition moves the element i = i · nc to position i . Multiply by nr to find the inverse:
i · nr

≡ i · nc · nr ≡ i · (n − 1 + 1) ≡ i

(2.8-8)

That is, element i will be moved to i = i · nr mod n − 1. The following routine uses a bit-array to keep
track of the elements processed so far [FXT: aux2/transpose.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#define

SRC(k)

(((unsigned long long)(k)*nc)%n1)

void transpose(Type *f, ulong nr, ulong nc, bitarray *ba=0)
// In-place transposition of an nr X nc array
//
that lies in contiguous memory.
{
if ( 1>=nr ) return;
if ( 1>=nc ) return;
if ( nr==nc ) transpose_square(f, nr);
else
{
const ulong n1 = nr * nc - 1;
bitarray *tba = 0;
if ( 0==ba ) tba = new bitarray(n1);
else
tba = ba;
tba->clear_all();
for (ulong k=1; k<n1;
{
// do a cycle:
ulong ks = SRC(k);
ulong kd = k;
tba->set(kd);
Type t = f[kd];
while ( ks != k )
{
f[kd] = f[ks];
kd = ks;
tba->set(kd);
ks = SRC(ks);
}
f[kd] = t;
}
if ( 0==ba )

k=tba->next_clear(++k) )

//

0 and n1 are fixed points

delete tba;

}
}

One should take care of possible overflows in the calculation of i · nc . In case that n is a power of
2 (and so are both nr and nc ) the multiplications modulo n − 1 are cyclic shifts. Thus any overflow
can be avoided and the computation is also significantly cheaper. An implementation is given in [FXT:
aux2/transpose2.h].

2.9

Rotation by triple reversal

To rotate a length-n array by s positions without using any temporary memory, reverse three times as
in the following routine [FXT: perm/rotate.h]:
1
2

void rotate_left(Type *f, ulong n, ulong s)

124

Rotate left
[ 1 2 3 4
[ 3 2 1 4
[ 3 2 1 8
[ 4 5 6 7

by 3 positions:
5 6 7 8 ] original array
5 6 7 8 ] reverse first 3 elements
7 6 5 4 ] reverse last 8-3=5 elements
8 1 2 3 ] reverse whole array

Rotate right by
[ 1 2 3 4 5 6
[ 5 4 3 2 1 6
[ 5 4 3 2 1 8
[ 6 7 8 1 2 3

3
7
7
7
4

positions:
8 ] original array
8 ] reverse first 8-3=5 elements
6 ] reverse last 3 elements
5 ] reverse whole array

Figure 2.9-A: Rotation of a length-8 array by 3 positions to the left (top) and right (bottom).
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Rotate towards element #0
// Shift is taken modulo n
{
if ( s>=n )
{
if (n<2) return;
s %= n;
}
if ( s==0 ) return;
reverse(f,
s);
reverse(f+s, n-s);
reverse(f,
n);
}

We will call this trick the triple reversal technique. For example, left-rotating an 8-element array by
3 positions is achieved by the steps shown in figure 2.9-A (top). A right rotation of an n-element array
by s positions is identical to a left rotation by n − s positions (bottom of figure 2.9-A):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void rotate_right(Type *f, ulong n, ulong s)
// Rotate away from element #0
// Shift is taken modulo n
{
if ( s>=n )
{
if (n<2) return;
s %= n;
}
if ( s==0 ) return;
reverse(f,
n-s);
reverse(f+n-s, s);
reverse(f,
n);
}

We could also execute the (self-inverse) steps of the left-shift routine in reversed order:
reverse(f,
n);
reverse(f+s, n-s);
reverse(f,
s);

[
[
[
[
[

0
0
0
0
0

1
1
1
1
1

2
2
2
2
2

3
3
3
3
3

4
4
4
4
4

v
a
e
e
e
w
^

v
b
d
d
d
x
^

v
c
c
c
c
y
^

v
d
b
b
b
z
^

v
e
a
a
a
7

7
7
8
8
8

8
8
7
7
a
^

v
w
w
w
z
b
^

v
x
x
x
y
c
^

v
y
y
y
x
d
^

v
z
z
z
w
e
^

N
N
N
N
N

N
N
N
N
N

]
]
]
]
]

<--= want to swap these blocks
original array
reverse first block
reverse range between blocks
reverse second block
reverse whole range
<--= the swapped blocks

Figure 2.9-B: Swapping the blocks [a b c d e] and [w x y z] via 4 reversals.
The triple reversal trick can also be used to swap two blocks in an array: first reverse the three ranges (first
blocks, range between blocks, last block), then reverse the range that consists of all three. We will call this
trick the quadruple reversal technique. The corresponding code is given in [FXT: perm/swapblocks.h]:

2.10: The zip permutation
1
2
3
4
5
6
7
8
9
10
11
12
13
14

125

void swap_blocks(Type *f, ulong x1, ulong n1, ulong x2, ulong n2)
// Swap the blocks starting at indices x1 and x2
// n1 and n2 are the block lengths
{
if ( x1>x2 ) { swap2(x1,x2); swap2(n1,n2); }
f += x1;
x2 -= x1;
ulong n = x2 + n2;
reverse(f, n1);
reverse(f+n1, n-n1-n2);
reverse(f+x2, n2);
reverse(f, n);
}

The elements before x1 and after x2+n2 are not accessed. An example is shown in ﬁgure 2.9-B. The
listing was created with the program [FXT: perm/swap-blocks-demo.cc].
A routine to undo the eﬀect of swap_blocks(f, x1, n1, x2, n2) can be obtained by reversing the
order of the steps:
1
2
3
4
5
6
7
8
9
10
11
12

void inverse_swap_blocks(Type *f, ulong x1, ulong n1, ulong x2, ulong n2)
{
if ( x1>x2 ) { swap2(x1,x2); swap2(n1,n2); }
f += x1;
x2 -= x1;
ulong n = x2 + n2;
reverse(f, n);
reverse(f+x2, n2);
reverse(f+n1, n-n1-n2);
reverse(f, n1);
}

An alternative method is to call swap_blocks(f, x1, n2, x2+n2-n1, n1).

2.10

The zip permutation
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[ *
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[ *
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 2.10-A: Permutation matrices of the zip permutation (left) and its inverse (right).
The zip permutation moves the elements from the lower half to the even indices and the elements from
the upper half to the odd indices. Symbolically,
[ a b c d A B C D ]

|--> [ a A b B c C d D ]

The size of the array must be even. A routine for the permutation is [FXT: perm/zip.h]
1
2
3
4
5

void zip(const Type * restrict f, Type * restrict g, ulong n)
{
ulong nh = n/2;
for (ulong k=0, k2=0; k<nh; ++k, k2+=2) g[k2] = f[k];

126
6
7

for (ulong k=nh, k2=1;

k<n;

++k, k2+=2)

g[k2] = f[k];

}

The inverse of the zip permutation is the unzip permutation, it moves the even indices to the lower half
and the odd indices to the upper half:
1
2
3
4
5
6
7

void unzip(const Type * restrict f, Type * restrict g, ulong n)
{
ulong nh = n/2;
for (ulong k=0, k2=0;
k<nh; ++k, k2+=2) g[k] = f[k2];
for (ulong k=nh, k2=1;
k<n;
++k, k2+=2) g[k] = f[k2];
}
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[ *
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[ *
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*
[
*

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 2.10-B: Revbin permutation matrices that, when multiplied together, give the zip permutation
and its inverse. Let L and R be the permutations given on the left and right side, respectively. Then
Z = R L and Z −1 = L R.
If the array size n is a power of 2, we can compute the zip permutation as a transposition of a 2 × n/2matrix:
1
2
3
4
5
6
7

void zip(Type *f, ulong n)
{
ulong nh = n/2;
revbin_permute(f, nh);
revbin_permute(f, n);
}

revbin_permute(f+nh, nh);

The in-place version for the unzip permutation for arrays whose size is a power of 2 is
1
2
3
4
5
6
7

void unzip(Type *f, ulong n)
{
ulong nh = n/2;
revbin_permute(f, nh); revbin_permute(f+nh, nh);
}

If the type Complex consists of two doubles lying contiguous in memory, then we can optimize the
procedures as follows:
1
2
3
4
5

void zip(double *f, long n)
{
revbin_permute((Complex *)f, n/2);
}

1
2
3
4
5

void unzip(double *f, long n)
{
revbin_permute((Complex *)f, n/2);
}

2.11: The XOR permutation

127

For arrays whose size n is not a power of 2 the in-place zip permutation can be computed by transposing
the data as a 2 × n/2 matrix:
transpose(f, 2, n/2);

// =^= zip(f, n)

The routines for in-place transposition are given in section 2.8 on page 122. The inverse is computed by
transposing the data as an n/2 × 2 matrix:
transpose(f, n/2, 2);

// =^= unzip(f, n)

While the above mentioned technique is usually not a gain for doing a transposition it may be used to
speed up the revbin permutation itself.

2.11

The XOR permutation

0:
1:
2:
3:
4:
5:
6:
7:

[ *
[
*
[
*
[
*
[
*
[
*
[
*
[
*
x = 0

]
]
]
]
]
]
]
]

[
*
]
[ *
]
[
*
]
[
*
]
[
*
]
[
*
]
[
* ]
[
*
]
x = 1

[
*
]
[
*
]
[ *
]
[
*
]
[
*
]
[
* ]
[
*
]
[
*
]
x = 2

[
*
]
[
*
]
[
*
]
[ *
]
[
* ]
[
*
]
[
*
]
[
*
]
x = 3

0:
1:
2:
3:
4:
5:
6:
7:

[
*
]
[
*
]
[
*
]
[
* ]
[ *
]
[
*
]
[
*
]
[
*
]
x = 4

[
*
]
[
*
]
[
* ]
[
*
]
[
*
]
[ *
]
[
*
]
[
*
]
x = 5

[
*
]
[
* ]
[
*
]
[
*
]
[
*
]
[
*
]
[ *
]
[
*
]
x = 6

[
* ]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[ *
]
x = 7

Figure 2.11-A: Permutation matrices of the XOR permutation for length 8 with parameter x = 0 . . . 7.
Compare to the table for the dyadic convolution shown in ﬁgure 23.8-A on page 481.
The XOR permutation (with parameter x) swaps the element at index k with the element at index
x XOR k (see ﬁgure 2.11-A). The implementation is easy [FXT: perm/xorpermute.h]:
1
2
3
4
5
6
7
8
9
10

void xor_permute(Type *f, ulong n, ulong x)
{
if ( 0==x ) return;
{
ulong r = k^x;
if ( r>k ) swap2(f[r], f[k]);
}
}

The XOR permutation is clearly self-inverse. The array length n must be divisible by the smallest power
of 2 that is greater than x. For example, n must be even if x = 1 and n must be divisible by 4 if x = 2
or x = 3. With n a power of 2 and x < n one is on the safe side.
The XOR permutation contains a few other permutations as important special cases (for simplicity
assume that the array length n is a power of 2): If the third argument x equals n − 1, the permutation
is the reversal. With x = 1 neighboring even and odd indexed elements are swapped. With x = n/2 the
upper and the lower half of the array are swapped.
We have
Xa Xb

=

Xb Xa = Xc

where

c = a XOR b

(2.11-1)

128


For the special case a = b the relation does express the self-inverse property as X0 is the identity. The
XOR permutation occurs in relations between other permutations where we will use the symbol Xa , the
subscript a denoting the third argument in the given routine.

2.12

The Gray permutation
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[ *
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
* ]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[ *
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
* ]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]

Figure 2.12-A: Permutation matrices of the Gray permutation (left) and its inverse (right).
The Gray permutation reorders (length-2n ) arrays according to the binary Gray code described in section 1.16 on page 41. A routine for the permutation is [FXT: perm/graypermute.h]:
1
2
3
4
5
6

inline void gray_permute(const Type *f, Type * restrict g, ulong n)
// Put Gray permutation of f[] to g[], i.e. g[gray_code(k)] == f[k]
{
for (ulong k=0; k<n; ++k) g[gray_code(k)] = f[k];
}

Its inverse is
1
2
3
4
5
6
7

inline void inverse_gray_permute(const Type *f, Type * restrict g, ulong n)
// Put inverse Gray permutation of f[] to g[], i.e. g[k] == f[gray_code(k)]
// (same as: g[inverse_gray_code(k)] == f[k])
{
for (ulong k=0; k<n; ++k) g[k] = f[gray_code(k)];
}

We again use calls to the routine to compute the Gray code because they are cheaper than the computations of the inverse Gray code.

2.12.1

Cycles of the permutation

We want to create in-place versions of the Gray permutation routines. It is necessary to identify the cycle
leaders of the permutation (see section 2.2 on page 104) and find an efficient way to generate them.
It is instructive to study the complementary masks that occur for cycles of different lengths. The cycles of the Gray permutation for length 128 are shown in figure 2.12-B. No structure is immediately
visible. However, we can generate the cycle maxima as follows: for each range 2k . . . 2k+1 − 1 generate a bit-mask z that consists of the k + 1 leftmost bits of the infinite word that has ones at positions
0, 1, 2, 4, 8, . . . , 2i , . . . :
[111010001000000010000000000000001000 ... ]
An example: for k = 6 we have z =[1110100]. Then take v to be k + 1 leftmost bits of the complement,
v =[0001011] in our example. Now the set of words c = z + s where s is a subset of v contains exactly
one element of each cycle in the range 2k . . . 2k+1 − 1 = 64 . . . 127, indeed the maximum of the cycle:

2.12: The Gray permutation

129

cycle
#=length
0: ( 2, 3 ) #=2
1: ( 4, 7, 5, 6 ) #=4
2: ( 8, 15, 10, 12 ) #=4
3: ( 9, 14, 11, 13 ) #=4
4: ( 16, 31, 21, 25, 17, 30,
5: ( 18, 28, 23, 26, 19, 29,
6: ( 32, 63, 42, 51, 34, 60,
7: ( 33, 62, 43, 50, 35, 61,
8: ( 36, 56, 47, 53, 38, 59,
9: ( 37, 57, 46, 52, 39, 58,
10: ( 64,127, 85,102, 68,120,
11: ( 65,126, 84,103, 69,121,
12: ( 66,124, 87,101, 70,123,
13: ( 67,125, 86,100, 71,122,
14: ( 72,112, 95,106, 76,119,
15: ( 73,113, 94,107, 77,118,
16: ( 74,115, 93,105, 78,116,
17: ( 75,114, 92,104, 79,117,
126 elements in 18 nontrivial
cycle lengths:
2 ... 8;
2

20, 24 ) #=8
22, 27 ) #=8
40, 48 ) #=8
41, 49 ) #=8
45, 54 ) #=8
44, 55 ) #=8
80, 96 ) #=8
81, 97 ) #=8
82, 99 ) #=8
83, 98 ) #=8
90,108 ) #=8
91,109 ) #=8
88,111 ) #=8
89,110 ) #=8
cycles.
fixed points: [0. 1]

cycle-min
2
4
8
9
16
18
32
33
36
37
64
65
66
67
72
73
74
75

cycle-max
3
7
15
14
31
29
63
62
59
58
127
126
124
125
119
118
116
117

Figure 2.12-B: Cycles of the Gray permutation of length 128.
.111.1.. = 116
.111.1.1 = 117
.111.11. = 118
.111.111 = 119
.11111.. = 124
.11111.1 = 125
.111111. = 126
.1111111 = 127
maxima := z XOR subsets(v)

where

z = .111.1..

and

v = ....1.11

The sequence of cycle maxima is entry A175339 in [312]. The minima (entry A175338) of the cycles can
be computed similarly:
.1...... =
.1.....1 =
.1....1. =
.1....11 =
.1..1... =
.1..1..1 =
.1..1.1. =
.1..1.11 =
minima := z

64
65
66
67
72
73
74
75
XOR subsets(v)

where

z = .1......

and

v = ....1.11

The list can be generated with the program [FXT: perm/permgray-leaders-demo.cc] which uses the
routine [FXT: class gray cycle leaders in comb/gray-cycle-leaders.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class gray_cycle_leaders
// Generate cycle leaders for Gray permutation
// where highest bit is at position ldn.
{
public:
bit_subset b_;
ulong za_; // mask for cycle maxima
ulong zi_; // mask for cycle minima
ulong len_; // cycle length
ulong num_; // number of cycles
public:
gray_cycle_leaders(ulong ldn)
: b_(0)
{ init(ldn); }

// 0<=ldn<BITS_PER_LONG

~gray_cycle_leaders() {;}
void init(ulong ldn)
{
za_ = 1;
ulong cz = 0;
// ~z
len_ = 1;
num_ = 1;
for (ulong ldm=1; ldm<=ldn; ++ldm)

130
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

{
za_ <<= 1;
cz <<= 1;
if ( is_pow_of_2(ldm) )
{
++za_;
len_ <<= 1;
}
else
{
++cz;
num_ <<= 1;
}
}
zi_ = 1UL << ldn;
b_.first(cz);
}
ulong current_max()
ulong current_min()
bool next()

const
const

{ return b_.current() | za_; }
{ return b_.current() | zi_; }

{ return ( 0!=b_.next() ); }

ulong num_cycles() const { return num_; }
ulong cycle_length() const { return len_; }
};

The implementation uses the class for subsets of a bitset described in section 1.25 on page 68.

2.12.2

In-place routines

The in-place versions of the permutation routines are obtained by inlining the generation of the cycle
leaders. The forward version is [FXT: perm/graypermute.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

void gray_permute(Type *f, ulong n)
{
ulong z = 1; // mask for cycle maxima
ulong v = 0; // ~z
ulong cl = 1; // cycle length
for (ulong ldm=1, m=2; m<n; ++ldm, m<<=1)
{
z <<= 1;
v <<= 1;
if ( is_pow_of_2(ldm) )
{
++z;
cl <<= 1;
}
else ++v;
bit_subset b(v);
do
{
// --- do cycle: --ulong i = z | b.next(); // start of cycle
Type t = f[i];
// save start value
ulong g = gray_code(i); // next in cycle
for (ulong k=cl-1; k!=0; --k)
{
Type tt = f[g];
f[g] = t;
t = tt;
g = gray_code(g);
}
f[g] = t;
while ( b.current() );
}
}

The function is_pow_of_2() is described in section 1.7 on page 17. The inverse routine diﬀers only in
the block that processes the cycles:

2.13: The reversed Gray permutation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

131

void inverse_gray_permute(Type *f, ulong n)
{
[--snip--]
// --- do cycle: --ulong i = z | b.next(); // start of cycle
Type t = f[i];
// save start value
{
f[i] = f[g];
i = g;
g = gray_code(i);
}
f[i] = t;
// --- end (do cycle) --[--snip--]
}

The Gray permutation is used with certain Walsh transforms, see section 23.7 on page 474.

2.12.3

Performance of the routines

We use the convention that the time for an array reversal is 1.0. The operation is completely cache-friendly
and therefore fast. A simple benchmark gives for 16 MB arrays:
arg 1: 21 == ldn [Using 2**ldn elements] default=21
arg 2: 10 == rep [Number of repetitions] default=10
Memsize = 16384 kiloByte == 2097152 doubles
reverse(f,n);
dt= 0.0103524
MB/s= 1546
revbin_permute(f,n);
dt= 0.0674235
MB/s= 237
revbin_permute0(f,n);
dt=
0.061507
MB/s= 260
gray_permute(f,n);
dt= 0.0155019
MB/s= 1032
inverse_gray_permute(f,n);
dt= 0.0150641
MB/s= 1062

rel=
rel=
rel=
rel=
rel=

1
6.51282
5.94131
1.49742
1.45512

The revbin permutation takes about 6.5 units, due to its memory access pattern that is very problematic
with respect to cache usage. The Gray permutation needs only 1.50 units. The diﬀerence gets bigger for
machines with relatively slow memory with respect to the CPU.
The relative speeds are quite diﬀerent for small arrays. With 16 kB (2048 doubles) we obtain
arg 1: 11 == ldn [Using 2**ldn elements] default=21
arg 2: 100000 == rep [Number of repetitions] default=512
Memsize = 16 kiloByte == 2048 doubles
reverse(f,n);
dt=1.88726e-06
MB/s= 8279
revbin_permute(f,n);
dt=3.22166e-06
MB/s= 4850
revbin_permute0(f,n);
dt=2.69212e-06
MB/s= 5804
gray_permute(f,n);
dt=4.75155e-06
MB/s= 3288
inverse_gray_permute(f,n);
dt=3.69237e-06
MB/s= 4232

rel=
rel=
rel=
rel=
rel=

1
1.70706
1.42647
2.51769
1.95647

Due to the small size, the cache problems are gone.

2.13

The reversed Gray permutation

The reversed Gray permutation of a length-n array is computed by permuting the elements in the way
that the Gray permutation would permute the upper half of an array of length 2n. The array size n must
be a power of 2. An implementation is [FXT: perm/grayrevpermute.h]:
1
2
3
4
5
6
7

inline void gray_rev_permute(const Type *f, Type * restrict g, ulong n)
// gray_rev_permute() =^=
// { reverse(); gray_permute(); }
{
for (ulong k=0, m=n-1; k<n; ++k, --m) g[gray_code(m)] = f[k];
}

All cycles have the same length, the cycles with n = 64 elements are

132

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[
* ]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[ *
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
* ]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[
*
]
[ *
]

Figure 2.13-A: Permutation matrices of the reversed Gray permutation (left) and its inverse (right).

0: ( 0, 63, 21, 38, 4, 56,
1: ( 1, 62, 20, 39, 5, 57,
2: ( 2, 60, 23, 37, 6, 59,
3: ( 3, 61, 22, 36, 7, 58,
4: ( 8, 48, 31, 42, 12, 55,
5: ( 9, 49, 30, 43, 13, 54,
6: ( 10, 51, 29, 41, 14, 52,
7: ( 11, 50, 28, 40, 15, 53,
64 elements in
8 nontrivial
cycle length is == 8
No fixed points.

16, 32)
17, 33)
18, 35)
19, 34)
26, 44)
27, 45)
24, 47)
25, 46)
cycles.

#=8
#=8
#=8
#=8
#=8
#=8
#=8
#=8

If 64 is added to the indices, the cycles in the upper half of the array as in gray_permute(f, 128) are
reproduced. The in-place version of the permutation routine is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

void gray_rev_permute(Type *f, ulong n)
// n must be a power of 2, n<=2**(BITS_PER_LONG-2)
{
f -= n; // note!
ulong z = 1; // mask for cycle maxima
ulong v = 0; // ~z
ulong cl = 1; // cycle length
ulong ldm, m;
for (ldm=1, m=2; m<=n; ++ldm, m<<=1)
{
z <<= 1; v <<= 1;
if ( is_pow_of_2(ldm) ) { ++z; cl<<=1; }
else ++v;
}
ulong tv = v, tu = 0; // cf. bitsubset.h
do
{
tu = (tu-tv) & tv;
ulong i = z | tu; // start of cycle
// --- do cycle: --ulong g = gray_code(i);
Type t = f[i];
{
Type tt = f[g];
f[g] = t;
t = tt;
g = gray_code(g);
}
f[g] = t;
while ( tu );

2.13: The reversed Gray permutation
38

133

}

The routine for the inverse permutation again diﬀers only in the way the cycles are processed:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void inverse_gray_rev_permute(Type *f, ulong n)
{
[--snip--]
// --- do cycle: --Type t = f[i];
// save start value
{
f[i] = f[g];
i = g;
g = gray_code(i);
}
f[i] = t;
// --- end (do cycle) --[--snip--]
}

Let G denote the Gray permutation, G the reversed Gray permutation, r be the reversal, h the swap
of the upper and lower halves, and Xa the XOR permutation (with parameter a) from section 2.11 on
page 127. We have
G = Gr = hG
−1

G

−1

G

G = G

−1

GG

= rG

−1

−1

= GG

(2.13-1b)

G = r = Xn−1

−1

(2.13-1a)

= h = Xn/2

(2.13-1c)
(2.13-1d)

134

Chapter 3: Sorting and searching

Chapter 3

Sorting and searching
We give various sorting algorithms and some practical variants of them, like sorting index arrays and
pointer sorting. Searching methods both for sorted and for unsorted arrays are described. Finally we
give methods for the determination of equivalence classes.

3.1

Sorting algorithms

We give sorting algorithms like selection sort, quicksort, merge sort, counting sort and radix sort. A
massive amount of literature exists about the topic so we will not explore the details. Very readable texts
are [115] and [306], while in-depth information can be found in [214].

3.1.1

Selection sort
[ n o w s o r t m e ]
[ e o w s o r t m n ]
[
m w s o r t o n ]
[
n s o r t o w ]
[
o o r t s w ]
[
o r t s w ]
[
r t s w ]
[
s t w ]
[
t w ]
[
w ]
[ e m n o o r s t w ]
Figure 3.1-A: Sorting the string ‘nowsortme’ with the selection sort algorithm.

There are a several algorithms for sorting that have complexity O n2 where n is the size of the array
to be sorted. Here we use selection sort, where the idea is to find the minimum of the array, swap it
with the first element, and repeat for all elements but the first. A demonstration of the algorithm is
shown in figure 3.1-A, this is the output of [FXT: sort/selection-sort-demo.cc]. The implementation is
straightforward [FXT: sort/sort.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

void selection_sort(Type *f, ulong n)
// Sort f[] (ascending order).
// Algorithm is O(n*n), use for short arrays only.
{
for (ulong i=0; i<n; ++i)
{
Type v = f[i];
ulong m = i; // position of minimum
ulong j = n;
while ( --j > i ) // search (index of) minimum
{
if ( f[j]<v )
{
m = j;
v = f[m];
}
}

3.1: Sorting algorithms
19
20
21
22

135

swap2(f[i], f[m]);
}
}

A verification routine is always handy:
1
2
3
4
5
6
7

bool is_sorted(const Type *f, ulong n)
// Return whether the sequence f[0], f[1], ..., f[n-1] is ascending.
{
for (ulong k=1; k<n; ++k) if ( f[k-1] > f[k] ) return false;
return true;
}

A test for descending order is
1
2
3
4
5
6
7

bool is_falling(const Type *f, ulong n)
// Return whether the sequence f[0], f[1], ..., f[n-1] is descending.
{
for (ulong k=1; k<n; ++k) if ( f[k-1] < f[k] ) return false;
return true;
}

3.1.2

Quicksort

The quicksort algorithm is given in [183], it has complexity O (n log(n)) (in the average case). It does
not obsolete the simpler schemes, because for small arrays the simpler algorithms are usually faster, due
to their minimal bookkeeping overhead.
The main activity of quicksort is partitioning the array. The corresponding routine reorders the array
and returns a pivot index p so that max(f0 , . . . , fp−1 ) ≤ min(fp , . . . , fn−1 ) [FXT: sort/sort.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ulong partition(Type *f, ulong n)
{
// Avoid worst case with already sorted input:
const Type v = median3(f[0], f[n/2], f[n-1]);
ulong i
ulong j
while (
{
do
do

= 0UL - 1;
= n;
1 )
{ ++i; }
{ --j; }

if ( i<j )
else

while ( f[i]<v );
while ( f[j]>v );
swap2(f[i], f[j]);
return j;

}
}

The function median3() is defined in [FXT: sort/minmaxmed23.h]:
1
2
3
4

static inline Type median3(const Type &x, const Type &y, const Type &z)
// Return median of the input values
{ return x<y ? (y<z ? y : (x<z ? z : x)) : (z<y ? y : (z<x ? z : x)); }

The function does 2 or 3 comparisons, depending on the input. One could simply use the element f[0]
as pivot. However, the algorithm will need O(n2 ) operations when the array is already sorted.
Quicksort calls partition on the whole array, then on the two parts left and right from the partition
index, then for the four, eight, etc. parts, until the parts are of length one. Note that the sub-arrays are
usually of different lengths.
1
2
3
4
5
6
7
8

void quick_sort(Type *f, ulong n)
{
if ( n<=1 ) return;
ulong p = partition(f, n);
ulong ln = p + 1;
ulong rn = n - ln;

136
9
10
11

quick_sort(f, ln); // f[0] ... f[ln-1] left
quick_sort(f+ln, rn); // f[ln] ... f[n-1]
right

}

The actual implementation uses two optimizations: Firstly, if the number of elements to be sorted is less
than a certain threshold, selection sort is used. Secondly, the recursive calls are made for the smaller of
the two sub-arrays, thereby the stack size is bounded by log2 (n) .
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

void quick_sort(Type *f, ulong n)
{
start:
if ( n<8 ) // parameter: threshold for nonrecursive algorithm
{
selection_sort(f, n);
return;
}
ulong p = partition(f, n);
ulong ln = p + 1;
ulong rn = n - ln;
if ( ln>rn ) // recursion for shorter sub-array
{
quick_sort(f+ln, rn); // f[ln] ... f[n-1]
right
n = ln;
}
else
{
quick_sort(f, ln); // f[0] ... f[ln-1] left
n = rn;
f += ln;
}
goto start;
}

The quicksort algorithm will be quadratic with certain inputs. A clever method to construct such inputs
is described in [247]. The heapsort algorithm is in-place and O (n log(n)) (also in the worst case). It is
described in section 3.1.5 on page 141. Inputs that lead to quadratic time for the quicksort algorithm
with median-of-3 partitioning are described in [257]. The paper suggests to use quicksort, but to detect
problematic behavior during runtime and switch to heapsort if needed. The corresponding algorithm is
called introsort (for introspective sorting).

3.1.3

Counting sort and radix sort

We want to sort an n-element array F of (unsigned) 8-bit values. A sorting algorithm which involves
only 2 passes through the data proceeds as follows:
1. Allocate an array C of 256 integers and set all its elements to zero.
2. Count: for k = 0, 1, . . . , n − 1 increment C[F [k]].
Now C[x] contains the number of bytes in F with the value x.
3. Set r = 0. For j = 0, 1, . . . , 255
set k = C[j], then set the elements F [r], F [r + 1], . . . , F [r + k − 1] to j, and add k to r.
For large values of n this method is signiﬁcantly faster than any other sorting algorithm. Note that no
comparisons are made between the elements of F . Instead they are counted, the algorithm is the counting
sort algorithm.
It might seem that the idea applies only to very special cases but with a little care it can be used in more
general situations. We modify the method so that we are able to sort also (unsigned) integer variables
whose range of values would make the method impractical with respect to a subrange of the bits in each
word. We need an array G that has as many elements as F :
1. Choose any consecutive run of b bits, these will be represented by a bit mask m. Allocate an array
C of 2b integers and set all its elements to zero.

137

2. Let M be a function that maps the (2b ) values of interest (the bits masked out by m) to the range
0, 1, . . . , 2b − 1.
3. Count: for k = 0, 1, . . . , n − 1 increment C[M (F [k])].
Now C[x] contains how many values of M (F [.]) equal x.
4. Cumulate: for j = 1, 2, . . . , 2b − 1 (second to last) add C[j − 1] to C[j].
Now C[x] contains the number of values M (F [.]) less than or equal to x.
5. Copy: for k = n − 1, . . . , 2, 1, 0 (last to first), do as follows:
set x := M (F [k]), decrement C[x], set i := C[x], and set G[i] := F [x].
A crucial property of the algorithm is that it is stable: if two (or more) elements compare equal (with
respect to a certain bit-mask m), then the relative order between these elements is preserved.
Input
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:

11111.11<
....1...
...1.1.1
..1...1.
..1.1111<
..1111..
.1..1..1
.1.1.11.
.11...11<
.111....

Counting sort wrt. two lowest bits
m = ......11
0:
....1...
1:
..1111..
2:
.111....
3:
...1.1.1
4:
.1..1..1
5:
..1...1.
6:
.1.1.11.
7:
11111.11<
8:
..1.1111<
9:
.11...11<

The relative order of the three words ending with two set bits (marked with ‘<’) is preserved.
A routine that verifies whether an array is sorted with respect to a bit range specified by the variable b0
and m is [FXT: sort/radixsort.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

bool
is_counting_sorted(const ulong *f, ulong n, ulong b0, ulong m)
// Whether f[] is sorted wrt. bits b0,...,b0+z-1
// where z is the number of bits set in m.
// m must contain a single run of bits starting at bit zero.
{
m <<= b0;
{
ulong xm = (f[k-1] & m ) >> b0;
ulong xp = (f[k] & m ) >> b0;
if ( xm>xp ) return false;
}
return true;
}

The function M is the combination of a mask-out and a shift operation. A routine that sorts according
to b0 and m is:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

void
counting_sort_core(const ulong * restrict f, ulong n, ulong * restrict g, ulong b0, ulong m)
// Write to g[] the array f[] sorted wrt. bits b0,...,b0+z-1
// where z is the number of bits set in m.
// m must contain a single run of bits starting at bit zero.
{
ulong nb = m + 1;
m <<= b0;
ALLOCA(ulong, cv, nb);
for (ulong k=0; k<nb; ++k) cv[k] = 0;
// --- count:
{
ulong x = (f[k] & m ) >> b0;
++cv[ x ];
}
// --- cumulative sums:
for (ulong k=1; k<nb; ++k)

cv[k] += cv[k-1];

// --- reorder:
ulong k = n;
while ( k-- ) // backwards ==> stable sort
{

138
26
27
28
29
30
31
32

ulong fk = f[k];
ulong x = (fk & m) >> b0;
--cv[x];
ulong i = cv[x];
g[i] = fk;
}

}

Input
111.11
..1...
.1.1.1
1...1.
1.1111
1111..
..1..1
.1.11.
1...11
11....

Stage 1
m = ....11
vv
..1...
1111..
11....
.1.1.1
..1..1
1...1.
.1.11.
111.11
1.1111
1...11

Stage 2
m = ..11..
vv
11....
1...1.
1...11
.1.1.1
.1.11.
..1...
..1..1
111.11
1111..
1.1111

Stage 3
m = 11....
vv
..1...
..1..1
.1.1.1
.1.11.
1...1.
1...11
1.1111
11....
111.11
1111..

Figure 3.1-B: Radix sort of 10 six-bit values when using two-bit masks.
Now we can apply counting sort to a set of bit masks that cover the whole range. Figure 3.1-B shows an
example with 10 six-bit values and 3 two-bit masks, starting from the least signiﬁcant bits. This is the
output of the program [FXT: sort/radixsort-demo.cc].
The following routine uses 8-bit masks to sort unsigned integers [FXT: sort/radixsort.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

void
radix_sort(ulong *f, ulong n)
{
ulong nb = 8; // Number of bits sorted with each step
ulong tnb = BITS_PER_LONG; // Total number of bits
ulong *fi = f;
ulong *g = new ulong[n];
ulong m = (1UL<<nb) - 1;
for (ulong k=1, b0=0; b0<tnb; ++k, b0+=nb)
{
counting_sort_core(f, n, g, b0, m);
swap2(f, g);
}
if ( f!=fi ) // result is actually in g[]
{
swap2(f, g);
for (ulong k=0; k<n; ++k) f[k] = g[k];
}
delete [] g;
}

There is room for optimization. Combining copying with counting for the next pass (where possible)
would reduce the number of passes almost by a factor of 2.
A version of radix sort that starts from the most signiﬁcant bits is given in [306].

3.1.4

Merge sort

The merge sort algorithm is a method for sorting with complexity O (n log(n)). We need a routine
that copies two sorted arrays A and B into an array T such that T is in sorted order. The following
implementation requires that A and B are adjacent in memory [FXT: sort/merge-sort.h]:
1
2
3
4
5
6

void merge(Type * const restrict f, ulong na, ulong nb, Type * const restrict t)
// Merge the (sorted) arrays
//
A[] := f[0], f[1], ..., f[na-1] and B[] := f[na], f[na+1], ..., f[na+nb-1]
// into t[] := t[0], t[1], ..., t[na+nb-1] such that t[] is sorted.
// Must have: na>0 and nb>0

139

[ n o w s o r t m e A D B A C D 5 4 3 2 1 ]
[ n o o s w
[
A e m r t
[ A e m n o o r s t w
[
[
[

]
]
]
A B C D D

]
1 2 3 4 5 ]
1 2 3 4 5 A B C D D ]

]
[
1 2 3 4 5 A B C D D ]
[ 1 2 3 4 5 A A B C D D e m n o o r s t w ]
Figure 3.1-C: Sorting with the merge sort algorithm.
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

{
const Type * const A = f;
const Type * const B = f + na;
ulong nt = na + nb;
Type ta = A[--na], tb = B[--nb];
while ( true )
{
if ( ta > tb ) // copy ta
{
t[--nt] = ta;
if ( na==0 ) // A[] empty?
{
for (ulong j=0; j<=nb; ++j)
return;
}

t[j] = B[j];

ta = A[--na]; // read next element of A[]
}
else // copy tb
{
t[--nt] = tb;
if ( nb==0 ) // B[] empty?
{
for (ulong j=0; j<=na; ++j) t[j] = A[j];
return;
}
tb = B[--nb];

// copy rest of B[]

// copy rest of A[]

// read next element of B[]

}
}
}

Two branches are involved, the unavoidable branch with the comparison of the elements, and the test
for empty array where an element has been removed.
We could sort by merging adjacent blocks of growing size as follows:
[
[
[
[

h
g
e
a

g
h
f
b

f
e
g
c

e
f
h
d

d
c
a
e

c
d
b
f

b
a
c
g

a
b
d
h

]
]
]
]

//
//
//
//

input
merge pairs
merge adjacent runs of two
merge adjacent runs of four

For a more localized memory access, we use a depth ﬁrst recursion (compare with the binsplit recursion
in section 34.1.1.1 on page 651):
1
2
3
4
5
6
7
8
9
10
11
12

void merge_sort_rec(Type *f, ulong n, Type *t)
{
if ( n<8 )
{
return;
}
const ulong na = n>>1;
const ulong nb = n - na;

140
13
14
15
16
17
18
19
20
21

// PRINT f[0], f[1], ..., f[na-1]
merge_sort_rec(f, na, t);
// PRINT f[na], f[na+1], ..., f[na+nb-1]
merge_sort_rec(f+na, nb, t);
merge(f, na, nb, t);
for (ulong j=0; j<n; ++j) f[j] = t[j];
// PRINT f[0], f[1], ..., f[na+nb-1]

// copy back

}

The comments PRINT indicate the print statements in the program [FXT: sort/merge-sort-demo.cc] that
was used to generate ﬁgure 3.1-C. The method is (obviously) not in-place. The routine called by the user
is
1
2
3
4
5
6
7
8

void merge_sort(Type *f, ulong n, Type *tmp=0)
{
Type *t = tmp;
if ( tmp==0 ) t = new Type[n];
merge_sort_rec(f, n, t);
if ( tmp==0 ) delete [] t;
}

Optimized algorithm
F: [ n o w s o r t m e A D B A C D 5 4 3 2 1 ]
F:
F:
T:
F:
F:
T:
F:

[ n o o s w
]
[
A e m r t
]
]
[
A B C D D
]
[
1 2 3 4 5 ]
[
1 2 3 4 5 A B C D D ]
[ 1 2 3 4 5 A A B C D D e m n o o r s t w ]
Figure 3.1-D: Sorting with the 4-way merge sort algorithm.

The copying from T to F in the recursive routine can be avoided by a 4-way splitting scheme. We sort
the left two quarters and merge them into T , then we sort the right two quarters and merge them into
T + na . Then we merge T and T + na into F . Figure 3.1-D shows an example where only one recursive
step is involved. It was generated with the program [FXT: sort/merge-sort4-demo.cc]. The recursive
routine is [FXT: sort/merge-sort.h]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

void merge_sort_rec4(Type *f, ulong n, Type *t)
{
if ( n<8 ) // threshold must be at least 8
{
return;
}
// left and right half:
const ulong na = n>>1;
const ulong nb = n - na;
// left quarters:
const ulong na1 = na>>1;
const ulong na2 = na - na1;
merge_sort_rec4(f, na1, t);
merge_sort_rec4(f+na1, na2, t);
// right quarters:
const ulong nb1 = nb>>1;
const ulong nb2 = nb - nb1;
merge_sort_rec4(f+na, nb1, t);
merge_sort_rec4(f+na+nb1, nb2, t);
// merge quarters (F-->T):
merge(f, na1, na2, t);
merge(f+na, nb1, nb2, t+na);

3.2: Binary search
30
31
32

141

// merge halves (T-->F):
merge(t, na, nb, f);
}

The routine called by the user is merge_sort4().

3.1.5

Heapsort

The heapsort algorithm has complexity O (n log(n)). It uses the heap data structure introduced in
section 4.5.2 on page 160. A heap can be sorted by swapping the first (and biggest) element with the
last and restoring the heap property for the array of size n − 1. Repeat until there is nothing more to
sort [FXT: sort/heapsort.h]:
1
2
3
4
5
6
7
8
9
10
11
12

void heap_sort(Type *x, ulong n)
{
build_heap(x, n);
Type *p = x - 1;
{
swap2(p[1], p[k]); // move largest to end of array
--n;
// remaining array has one element less
heapify(p, n, 1);
// restore heap-property
}
}

Sorting into descending order is not any harder:
1
2
3
4
5
6
7
8
9
10
11
12

void heap_sort_descending(Type *x, ulong n)
// Sort x[] into descending order.
{
build_heap(x, n);
Type *p = x - 1;
{
++p; --n;
// remaining array has one element less
heapify(p, n, 1); // restore heap-property
}
}

A program that demonstrates the algorithm is [FXT: sort/heapsort-demo.cc].

3.2

Binary search

Searching for an element in a sorted array can be done in O (log(n)) operations. The binary search
algorithm uses repeated subdivision of the data [FXT: sort/bsearch.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

ulong bsearch(const Type *f, ulong n, const Type v)
// Return index of first element in f[] that equals v
// Return n if there is no such element.
// f[] must be sorted in ascending order.
// Must have n!=0
{
ulong nlo=0, nhi=n-1;
while ( nlo != nhi )
{
ulong t = (nhi+nlo)/2;
if ( f[t] < v )
else

nlo = t + 1;
nhi = t;

}
if ( f[nhi]==v )
else

return nhi;
return n;

}

Only simple modifications are needed to search, for example, for the first element greater than or equal
to a given value:

142
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15


ulong bsearch_geq(const Type *f, ulong n, const Type v)
{
ulong nlo=0, nhi=n-1;
while ( nlo != nhi )
{
ulong t = (nhi+nlo)/2;
if ( f[t] < v )
else

nlo = t + 1;
nhi = t;

}
if ( f[nhi]>=v )
else

return nhi;
return n;

}

For very large arrays the algorithm can be improved by selecting the new index t diﬀerent from the
midpoint (nhi+nlo)/2, depending on the value sought and the distribution of the values in the array. As
a simple example consider an array of ﬂoating-point numbers that are equally distributed in the interval
[min(v), max(v)]. If the sought value equals v, one starts with the relation
n − min(n)
max(n) − min(n)

=

v − min(v)
max(v) − min(v)

(3.2-1)

where n denotes an index and min(n), max(n) denote the minimal and maximal index of the current
interval. Solving for n gives the linear interpolation formula
n

=

min(n) +

max(n) − min(n)
(v − min(v))
max(v) − min(v)

(3.2-2)

The corresponding interpolation binary search algorithm would select the new subdivision index t according to the given relation. One could even use quadratic interpolation schemes for the selection of t.
For the majority of practical applications the midpoint version of the binary search will be good enough.
Approximate matches are found by the following routine [FXT: sort/bsearchapprox.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

ulong bsearch_approx(const Type *f, ulong n, const Type v, Type da)
// Return index of first element x in f[] for which |(x-v)| <= da
// Return n if there is no such element.
// f[] must be sorted in ascending order.
// da must be positive.
//
// Makes sense only with inexact types (float or double).
// Must have n!=0
{
ulong k = bsearch_geq(f, n, v-da);
if ( k<n ) k = bsearch_leq(f+k, n-k, v+da);
return k;
}

3.3

Variants of sorting methods

Some practical variants of sorting algorithms are described, like sorting index arrays, pointer sorting, and
sorting with a supplied comparison function.

3.3.1

Index sorting

With normal sorting we order the elements of an array f so that f [k] ≤ f [k + 1]. The index-sort
routines order the indices in an array x so that the sequence f [x[k]] is in ascending order, we have
f [x[k]] ≤ f [x[k + 1]]. The implementation for the selection sort algorithm is [FXT: sort/sortidx.h]:
1
2
3
4

void idx_selection_sort(const Type *f, ulong n, ulong *x)
// Sort x[] so that the sequence f[x[0]], f[x[1]], ... f[x[n-1]] is ascending.
// Algorithm is O(n*n), use for short arrays only.

3.3: Variants of sorting methods
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

143

{
{
Type v = f[x[i]];
ulong m = i; // position-ptr of minimum
ulong j = n;
{
if ( f[x[j]]<v )
{
m = j;
v = f[x[m]];
}
}
swap2(x[i], x[m]);
}
}

The veriﬁcation code is
1
2
3
4
5
6
7

bool is_idx_sorted(const Type *f, ulong n, const ulong *x)
// Return whether the sequence f[x[0]], f[x[1]], ... f[x[n-1]] is ascending order.
{
for (ulong k=1; k<n; ++k) if ( f[x[k-1]] > f[x[k]] ) return false;
return true;
}

The transformation of the partition() routine is straightforward:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

ulong idx_partition(const Type *f, ulong n, ulong *x)
// rearrange index array, so that for some index p
// max(f[x[0]] ... f[x[p]]) <= min(f[x[p+1]] ... f[x[n-1]])
{
// Avoid worst case with already sorted input:
const Type v = median3(*x[0], *x[n/2], *x[n-1], cmp);
ulong i = 0UL - 1;
ulong j = n;
while ( 1 )
{
do ++i;
while ( f[x[i]]<v );
do --j;
while ( f[x[j]]>v );
if ( i<j )
else

swap2(x[i], x[j]);
return j;

}
}

The index-quicksort itself deserves a minute of contemplation comparing it to the plain version:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

void idx_quick_sort(const Type *f, ulong n, ulong *x)
// Sort x[] so that the sequence f[x[0]], f[x[1]], ... f[x[n-1]] is ascending.
{
start:
if ( n<8 ) // parameter: threshold for nonrecursive algorithm
{
idx_selection_sort(f, n, x);
return;
}
ulong p = idx_partition(f, n, x);
ulong ln = p + 1;
ulong rn = n - ln;
if ( ln>rn ) // recursion for shorter sub-array
{
idx_quick_sort(f, rn, x+ln); // f[x[ln]] ... f[x[n-1]]
n = ln;
}
else
{

right

144
23
24
25
26
27
28
29
30

idx_quick_sort(f, ln, x);

// f[x[0]]

... f[x[ln-1]]

left

n = rn;
x += ln;
}
goto start;
}

Note that the index-sort routines work perfectly for non-contiguous data. The index-analogues of the
binary search algorithms are again straightforward, they are given in [FXT: sort/bsearchidx.h].
The sorting routines do not change the array f , the actual data is not modiﬁed. To bring f into sorted
order, apply the inverse permutation of x to f (see section 2.4 on page 109):
apply_inverse_permutation(x, f, n);

To copy f in sorted order into g, use:
apply_inverse_permutation(x, f, n, g);

Input:
f[] key[]
A
0
B
1
C
1
D
3
E
1
F
3
E
3
G
7

After sort_by_key(f, n, key, 1):
f[] key[]
A
0
E
1
C
1
B
1
D
3
F
3
E
3
G
7

Figure 3.3-A: Sorting an array according to an array of keys.
The array x can be used for sorting by keys, see ﬁgure 3.3-A. The routine is [FXT: sort/sortbykey.h]:
1
2
3
4
5
6
7
8
9
10
11
12

template <typename Type1, typename Type2>
void sort_by_key(Type1 *f, ulong n, Type2 *key, bool skq=true)
// Sort f[] according to key[] in ascending order:
//
f[k] precedes f[j] if key[k]<key[j].
// If skq is true then key[] is also sorted.
{
ALLOCA(ulong, x, n);
for (ulong k=0; k<n; ++k) x[k] = k;
idx_quick_sort(key, n, x);
apply_inverse_permutation(x, f, n);
if ( skq ) apply_inverse_permutation(x, key, n);
}

3.3.2

Pointer sorting

Pointer sorting is similar to index sorting. The array of indices is replaced by an array of pointers [FXT:
sort/sortptr.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

void ptr_selection_sort(/*const Type *f,*/ ulong n, const Type **x)
// Sort x[] so that the sequence *x[0], *x[1], ..., *x[n-1] is ascending.
{
{
Type v = *x[i];
ulong j = n;
{
if ( *x[j]<v )
{
m = j;
v = *x[m];
}
}
swap2(x[i], x[m]);

3.3: Variants of sorting methods
19
20

145

}
}

The first argument (const Type *f) is not necessary with pointer sorting, it is indicated as a comment
to make the argument structure uniform. The verification routine is
1
2
3
4
5
6
7

bool is_ptr_sorted(/*const Type *f,*/ ulong n, Type const*const*x)
// Return whether the sequence *x[0], *x[1], ..., *x[n-1] is ascending.
{
for (ulong k=1; k<n; ++k) if ( *x[k-1] > *x[k] ) return false;
return true;
}

The pointer versions of the search routines are given in [FXT: sort/bsearchptr.h].

3.3.3

Sorting by a supplied comparison function

The routines in [FXT: sort/sortfunc.h] are similar to the C-quicksort qsort that is part of the standard
library. A comparison function cmp has to be supplied by the caller. This allows, for example, sorting
compound data types with respect to some key contained within them. Citing the manual page for qsort:
The comparison function must return an integer less than, equal to, or greater than
zero if the first argument is considered to be respectively less than, equal to, or
greater than the second. If two members compare as equal, their order in the
sorted array is undefined.

As a prototypical example we give the selection sort routine:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

void selection_sort(Type *f, ulong n, int (*cmp)(const Type &, const Type &))
// Sort f[] (ascending order) with respect to comparison function cmp().
{
{
Type v = f[i];
ulong m = i; // position of minimum
ulong j = n;
{
if ( cmp(f[j],v) < 0 )
{
m = j;
v = f[m];
}
}
swap2(f[i], f[m]);
}
}

The other routines are rather straightforward translations of the (plain) sort analogues. Replace the
comparison operations involving elements of the array as follows:
(a
(a
(a
(a
(a

< b)
> b)
== b)
<= b)
>= b)

cmp(a,b)
cmp(a,b)
cmp(a,b)
cmp(a,b)
cmp(a,b)

< 0
> 0
== 0
<= 0
>= 0

The verification routine is
1
2
3
4
5
6
7
8

bool is_sorted(const Type *f, ulong n, int (*cmp)(const Type &, const Type &))
// Return whether the sequence f[0], f[1], ..., f[n-1]
// is sorted in ascending order with respect to comparison function cmp().
{
for (ulong k=1; k<n; ++k) if ( cmp(f[k-1], f[k]) > 0 ) return false;
return true;
}

The numerous calls to cmp() do have a negative impact on the performance. With C++ you can provide
a comparison ‘function’ for a class by overloading the comparison operators <, <, <=, >=, and == and use

146


the plain sort version. That is, the comparisons are inlined and the performance should be fine.
3.3.3.1

Sorting complex numbers

You want to sort complex numbers? Fine with me, but don’t tell your local mathematician. To see the
mathematical problem, we ask whether i is less than or greater than zero. Assuming i > 0 it follows that
i · i > 0 (we multiplied with a positive value) which is −1 > 0 and that is false. So, is i < 0? Then i · i > 0
(multiplication with a negative value, as assumed), thereby −1 > 0. Oops! The lesson is that there is no
way to impose an order on the complex numbers that would justify the usage of the symbols ‘<’ and ‘>’
consistent with the rules to manipulate inequalities.
Nevertheless we can invent a relation for sorting: arranging (sorting) the complex numbers according to
their absolute value (modulus) leaves infinitely many numbers in one ‘bucket’, namely all those that have
the same distance from zero. However, one could use the modulus as the major ordering parameter, the
argument (angle) as the minor. Or the real part as the major and the imaginary part as the minor. The
latter is realized in
1
2
3
4
5
6
7
8
9
10
11

static inline int
cmp_complex(const Complex &f, const Complex &g)
{
const double fr = f.real(), gr = g.real();
if ( fr!=gr ) return (fr>gr ? +1 : -1);
const double fi = f.imag(), gi = g.imag();
if ( fi!=gi ) return (fi>gi ? +1 : -1);
return

0;

}

This function, when used as comparison with the following routine, can indeed be the practical tool you
had in mind:
1
2
3
4
5
6

void complex_sort(Complex *f, ulong n)
// major order wrt. real part
// minor order wrt. imag part
{
quick_sort(f, n, cmp_complex);
}

3.3.3.2

Index and pointer sorting

The index sorting routines that use a supplied comparison function are given in [FXT: sort/sortidxfunc.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

void idx_selection_sort(const Type *f, ulong n, ulong *x,
int (*cmp)(const Type &, const Type &))
// Sort x[] so that the sequence f[x[0]], f[x[1]], ... f[x[n-1]]
// is ascending with respect to comparison function cmp().
{
{
Type v = f[x[i]];
ulong j = n;
{
if ( cmp(f[x[j]], v) < 0 )
{
m = j;
v = f[x[m]];
}
}
swap2(x[i], x[m]);
}
}

The verification routine is:
1
2
3
4

bool is_idx_sorted(const Type *f, ulong n, const ulong *x,
// Return whether the sequence f[x[0]], f[x[1]], ... f[x[n-1]] is ascending

3.4: Searching in unsorted arrays
5
6
7
8
9

// with respect to comparison function cmp().
{
for (ulong k=1; k<n; ++k) if ( cmp(f[x[k-1]], f[x[k]]) > 0 )
return true;
}

147

return false;

The pointer sorting versions are given in [FXT: sort/sortptrfunc.h]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

void ptr_selection_sort(/*const Type *f,*/ ulong n, const Type **x,
// Sort x[] so that the sequence *x[0], *x[1], ..., *x[n-1]
{
{
Type v = *x[i];
ulong j = n;
{
if ( cmp(*x[j],v)<0 )
{
m = j;
v = *x[m];
}
}
swap2(x[i], x[m]);
}
}

The verification routine is:
1
2
3
4
5
6
7
8
9

bool is_ptr_sorted(/*const Type *f,*/ ulong n, Type const*const*x,
// Return whether the sequence *x[0], *x[1], ..., *x[n-1]
{
for (ulong k=1; k<n; ++k) if ( cmp(*x[k-1],*x[k]) > 0 ) return false;
return true;
}

The corresponding versions of the binary search algorithm are given in [FXT: sort/bsearchidxfunc.h] and
[FXT: sort/bsearchptrfunc.h].

3.4

Searching in unsorted arrays

To find the first occurrence of a certain value in an unsorted array use the routine [FXT: sort/usearch.h]
1
2
3
4
5
6
7
8
9

inline ulong first_geq_idx(const Type *f, ulong n, Type v)
// Return index of first element == v
// Return n if all !=v
{
ulong k = 0;
while ( (k<n) && (f[k]!=v) ) k++;
return k;
}

The functions first_neq_idx(), first_geg_idx() and first_leq_idx() find the first occurrence of
an element unequal (to v), greater than or equal and less than or equal, respectively.
If the last bit of speed matters, one could use a sentinel, as suggested in [210, p.267]:
1
2
3
4
5
6
7

inline ulong first_eq_idx(/* NOT const */ Type *f, ulong n, Type v)
{
Type s = f[n-1];
f[n-1] = v; // sentinel to guarantee that the search stops
ulong k = 0;
while ( f[k]!=v ) ++k;

148
8
9
10
11

f[n-1] = s; // restore value
if ( (k==n-1) && (v!=s) ) ++k;
return k;

}

There is only one branch in the inner loop, this can give a significant speedup. However, the technique
is only applicable if writing to the array ‘f[]’ is allowed.
Another way to optimize the search is partial unrolling of the loop:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

inline ulong first_eq_idx_large(const Type *f, ulong n, Type v)
{
ulong k;
for (k=0; k<(n&3); ++k) if ( f[k]==v ) return k;
while ( k!=n ) // 4-fold unrolled
{
Type t0 = f[k], t1 = f[k+1], t2 = f[k+2], t3 = f[k+3];
bool qa = ( (t0==v) | (t1==v) ); // note bit-wise OR to avoid branch
bool qb = ( (t2==v) | (t3==v) );
if ( qa | qb ) // element v found
{
while ( 1 ) { if ( f[k]==v ) return k; else ++k; }
}
k += 4;
}
return n;
}

The search requires only two branches with every four elements. By using two variables qa and qb better
usage of the CPU internal parallelism is attempted. Depending on the data type and CPU architecture
8-fold unrolling may give a speedup.

3.5

Determination of equivalence classes

Let S be a set and C := S × S the set of all ordered pairs (x, y) with x, y ∈ S. A binary relation R on S
is a subset of C. An equivalence relation is a binary relation with the following properties:
• reflexive: x ≡ x ∀x.
• symmetric: x ≡ y ⇐⇒ y ≡ x ∀x, y.
• transitive: x ≡ y, y ≡ z =⇒ x ≡ z ∀x, y, z.
Here we wrote x ≡ y for (x, y) ∈ R where x, y ∈ S.
We want to determine the equivalence classes: an equivalence relation partitions a set into 1 ≤ q ≤ n
subsets E1 , E2 , . . . , Eq so that x ≡ y whenever both x and y are in the same subset but x ≡ y if x and
y are in different subsets.
For example, the usual equality relation is an equivalence relation, with a set of (different) numbers each
number is in its own class. With the equivalence relation that x ≡ y whenever x − y is a multiple of some
fixed integer m > 0 and the set Z of all natural numbers we obtain m subsets and x ≡ y if and only if
x ≡ y mod m.

3.5.1

Algorithm for decomposition into equivalence classes

Let S be a set of n elements, represented as a vector. On termination of the following algorithm Qk = j
if j is the least index such that Sj ≡ Sk (note that we consider the elements of S to be in a fixed but
arbitrary order here):
1. Put each element in its own equivalence class: Qk := k for all 0 ≤ k < n
2. Set k := 1 (index of the second element).

3.5: Determination of equivalence classes

149

3. (Search for an equivalent element:)
(a) Set j := 0.
(b) If Sk ≡ Sj set Qk = Qj and goto step 4.
(c) Set j := j + 1 and goto step 3b
4. Set k := k + 1 and if k < n goto step 3, else terminate.
The algorithm needs n − 1 equivalence tests when all elements are in the same equivalence class and
n (n − 1)/2 equivalence tests when each element is alone in its own equivalence class.
In the following implementation the equivalence relation must be supplied as a function equiv_q() that
returns true when its arguments are equivalent [FXT: sort/equivclasses.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

void equivalence_classes(const Type *s, ulong n, bool (*equiv_q)(Type,Type), ulong *q)
// Given an equivalence relation ’==’ (as function equiv_q())
// and a set s[] with n elements,
// write to q[k] the index j of the first element s[j] such that s[k]==s[j].
{
for (ulong k=0; k<n; ++k) q[k] = k; // each in own class
{
ulong j = 0;
while ( ! equiv_q(s[j], s[k]) ) ++j;
q[k] = q[j];
}
}

3.5.2

Examples of equivalence classes

3.5.2.1

Integers modulo m

Choose an integer m ≥ 1 and let any two integers a and b be equivalent if a − b is an integer multiple
of m (with m = 1 all integers are in the same class). We can choose the numbers 0, 1 . . . , m − 1
as representatives of the m classes obtained. Now we can do computations with those classes via the
modular arithmetic as described in section 39.1 on page 764. This is easily the most important example
of all equivalence relations.
The concept also make sense for a real (non-integral) modulus m > 0. We still put two numbers a and
b into the same class if a − b is an integer multiple of m. Finally, the modulus m = 0 leads to the
equivalence relation ‘equality’.
3.5.2.2

Binary necklaces

Consider the set S of n-bit binary words with the equivalence relation in which two words x and y are
equivalent if and only if there is a cyclic shift hk (x) by 0 ≤ k < n positions such that hk (x) = y. The
equivalence relation is supplied as the function [FXT: sort/equivclass-necklaces-demo.cc]:
1
2
3
4
5
6

static ulong nb; // number of bits
bool n_equiv_q(ulong x, ulong y) // necklaces
{
ulong d = bit_cyclic_dist(x, y, nb);
return (0==d);
}

The function bit_cyclic_dist() is given in section 1.13.4 on page 32. For n = 4 we ﬁnd the following
list of equivalence classes:
0:
.... [#=1]
1:
1... .1.. ...1 ..1.
3:
1..1 11.. ..11 .11.
5:
.1.1 1.1. [#=2]
7:
11.1 111. 1.11 .111
15:
1111 [#=1]
# of equivalence classes = 6

[#=4]
[#=4]
[#=4]

150


These correspond to the binary necklaces of length 4. One usually chooses the cyclic minima (or maxima)
among equivalent words as representatives of the classes.
3.5.2.3

Unlabeled binary necklaces

Same set but the equivalence relation is defined to identify two words x and y when there is a cyclic shift
hk (x) by 0 ≤ k < n positions so that either hk (x) = y or hk (x) = y where y is the complement of y:
1
2
3
4
5
6
7

static ulong mm; // mask to complement
bool nu_equiv_q(ulong x, ulong y) // unlabeled necklaces
{
ulong d = bit_cyclic_dist(x, y, nb);
if ( 0!=d ) d = bit_cyclic_dist(mm^x, y, nb);
return (0==d);
}

With n = 4 we find
0:
1111 .... [#=2]
1:
111. 11.1 1.11 1...
3:
.11. 1..1 11.. ..11
5:
.1.1 1.1. [#=2]
# of equivalence classes = 4

.111 ...1
[#=4]

..1.

.1..

[#=8]

These correspond to the unlabeled binary necklaces of length 4.
3.5.2.4

Binary bracelets

The binary bracelets are obtained by identifying two words that are identical up to rotation and possible
reversal. The corresponding comparison function is
1
2
3
4
5
6

bool b_equiv_q(ulong x, ulong y) // bracelets
{
ulong d = bit_cyclic_dist(x, y, b);
if ( 0!=d ) d = bit_cyclic_dist(revbin(x,b), y, b);
return (0==d);
}

There are six binary bracelets of length 4:
0:
1:
3:
5:
7:
15:

....
1...
1..1
.1.1
11.1
1111

[#=1]
.1..
11..
1.1.
111.
[#=1]

...1 ..1.
..11 .11.
[#=2]
1.11 .111

[#=4]
[#=4]
[#=4]

The unlabeled binary bracelets are obtained by additionally allowing for bit-wise complementation:
1
2
3
4
5
6
7
8
9
10
11
12
13

bool bu_equiv_q(ulong x, ulong y) // unlabeled bracelets
{
ulong d = bit_cyclic_dist(x, y, b);
x ^= mm;
if ( 0!=d ) d = bit_cyclic_dist(x, y, b);
x = revbin(x,b);
x ^= mm;
return

(0==d);

}

There are four unlabeled binary bracelets of length 4:
0:
1:
3:
5:

1111
111.
.11.
.1.1

....
11.1
1..1
1.1.

[#=2]
1.11 1...
11.. ..11
[#=2]

.111 ...1
[#=4]

..1.

.1..

[#=8]

The shown functions are given in [FXT: sort/equivclass-bracelets-demo.cc] which can be used to produce
listings of the equivalence classes.
The sequences of numbers of labeled and unlabeled necklaces and bracelets are shown in figure 3.5-A.

3.5: Determination of equivalence classes
n:
[312]#
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

N
A000031
2
3
4
6
8
14
20
36
60
108
188
352
632
1182
2192

151
B
A000029
2
3
4
6
8
13
18
30
46
78
126
224
380
687
1224

N/U
A000013
1
2
2
4
4
8
10
20
30
56
94
180
316
596
1096

B/U
A000011
1
2
2
4
4
8
9
18
23
44
63
122
190
362
612

Figure 3.5-A: The number of binary necklaces ‘N’, bracelets ‘B’, unlabeled necklaces ‘N/U’, and unlabeled
bracelets ‘B/U’. The second row gives the sequence number in [312].
3.5.2.5

Binary words with reversal and complement

The set S of n-bit binary words and the equivalence relation identifying two words x and y whenever
they are mutual complements or bit-wise reversals.
3 classes with 3-bit words:
0:
111 ...
1:
..1 .11 1.. 11.
2:
1.1 .1.
0:
1111 ....
1:
111. 1... .111 ...1
2:
..1. .1.. 1.11 11.1
3:
11.. ..11
5:
1.1. .1.1
6:
.11. 1..1

0:
11111 .....
1:
1111. 1.... .1111 ....1
2:
1.111 111.1 .1... ...1.
3:
111.. ...11 ..111 11...
4:
..1.. 11.11
5:
11.1. 1.1.. ..1.1 .1.11
6:
..11. .11.. 11..1 1..11
9:
.11.1 1.11. .1..1 1..1.
10:
.1.1. 1.1.1
14:
1...1 .111.

Figure 3.5-B: Equivalence classes of binary words where words are identified if either their reversals or
complements are equal.
For example, the equivalence classes with 3-, 4- and 5-bit words are shown in figure 3.5-B. The sequence
of numbers of equivalence classes for word-sizes n is (entry A005418 in [312])
n:
#:

1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11,
12,
13,
14,
15,
16, ...
1, 2, 3, 6, 10, 20, 36, 72, 136, 272, 528, 1056, 2080, 4160, 8256, 16512, ...

The equivalence classes can be computed with the program [FXT: sort/equivclass-bitstring-demo.cc].
We have chosen examples where the resulting equivalence classes can be verified by inspection. For
example, we could create the subsets of equivalent necklaces by simply rotating a given word and marking
the words visited so far. Such an approach, however, is not possible if the equivalence relation does not
have an obvious structure.

3.5.3

The number of equivalence relations for a set of n elements

We write B(n) for the number of possible partitionings (and thereby equivalence relations) of the set
{1, 2, . . . , n}. These are called Bell numbers. The sequence of Bell numbers is entry A000110 in [312],
it starts as (n ≥ 1):

152

1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975, 678570, 4213597, ...

The can be computed easily as indicated in the following table:
0:
1:
2:
3:
4:
5:
n:

[ 1]
[ 1, 2]
[ 2, 3, 5]
[ 5, 7, 10, 15]
[15, 20, 27, 37, 52]
[52, 67, 87, 114, 151, 203]
[B(n), ... ]

The ﬁrst element in each row is the last element of the previous row, the remaining elements are the sum
of their left and upper left neighbors. As GP code:
1
2
3
4
5
6
7
8

N=7; v=w=b=vector(N); v[1]=1;
{ for(n=1,N-1,
b[n] = v[1];
print(n-1, ": ", v); print row
w[1] = v[n];
for(k=2,n+1, w[k]=w[k-1]+v[k-1]);
v=w;
); }

An implementation in C++ is given in [FXT: comb/bell-number-demo.cc]. An alternative way to compute
the Bell numbers is shown in section 17.2 on page 358.

153

Chapter 4

Data structures
We give implementations of selected data structures like stack, ring buffer, queue, double-ended queue
(deque), bit-array, heap and priority queue.

4.1

Stack (LIFO)
push( 1)
push( 2)
push( 3)
push( 4)
push( 5)
push( 6)
push( 7)
pop== 7
pop== 6
push( 8)
pop== 8
pop== 5
push( 9)
pop== 9
pop== 4
push(10)
pop==10
pop== 3
push(11)
pop==11
pop== 2
push(12)
pop==12
pop== 1
push(13)
pop==13
pop== 0
(stack
push(14)
pop==14
pop== 0
(stack
push(15)

1 - - 1 2 - 1 2 3 1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 1 2 3 10
1 2 3 1 2 - 1 2 11 1 2 - 1 - - 1 12 - 1 - - - - - 13 - - - - - - - - was empty)
14 - - - - - - - - was empty)
15 - - -

5
5
5
5
5
5
5
9
-

6
6
6
8
-

7
-

-

#=1
#=2
#=3
#=4
#=5
#=6
#=7
#=6
#=5
#=6
#=5
#=4
#=5
#=4
#=3
#=4
#=3
#=2
#=3
#=2
#=1
#=2
#=1
#=0
#=1
#=0
#=0

-

-

-

-

#=1
#=0
#=0

-

-

-

-

#=1

Figure 4.1-A: Inserting and retrieving elements with a stack.
A stack (or LIFO, for last-in, first-out) is a data structure that supports the operations: push() to
save an entry, pop() to retrieve and remove the entry that was entered last, and peek() to retrieve
the element that was entered last without removing it. The method poke() modifies the last entry. An
implementation with the option to let the stack grow when necessary is [FXT: class stack in ds/stack.h]:
1
2
3
4
5
6

class stack
{
public:
Type *x_; // data
ulong s_; // size

154
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Chapter 4: Data structures
ulong
ulong

p_; // stack pointer (position of next write), top entry @ p-1
gq_; // grow gq elements if necessary, 0 for "never grow"

public:
stack(ulong n, ulong growq=0)
{
s_ = n;
x_ = new Type[s_];
p_ = 0; // stack is empty
gq_ = growq;
}
~stack()

{ delete [] x_; }

ulong num()

const

{ return p_; }

// Return number of entries.

Insertion and retrieval from the top of the stack are implemented as follows:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

ulong push(Type z)
// Add element z on top of stack.
// Return size of stack, zero on stack overflow.
// If gq_ is nonzero the stack grows if needed.
{
if ( p_ >= s_ )
{
if ( 0==gq_ ) return 0; // overflow
grow();
}
x_[p_] = z;
++p_;
return

s_;

}
ulong pop(Type &z)
// Retrieve top entry and remove it.
// Return number of entries before removing element.
// If empty return zero and leave z is undefined.
{
ulong ret = p_;
if ( 0!=p_ ) { --p_; z = x_[p_]; }
return ret;
}
ulong poke(Type z)
// Modify top entry.
// If empty return zero and do nothing.
{
if ( 0!=p_ ) x_[p_-1] = z;
return p_;
}
ulong peek(Type &z)
// Read top entry, without removing it.
// If empty return zero and leave z undefined.
{
if ( 0!=p_ ) z = x_[p_-1];
return p_;
}

The growth routine is implemented as
1
2
3
4
5
6
7
8

private:
void grow()
{
ulong ns = s_ + gq_; // new size
x_ = ReAlloc<Type>(x_, ns, s_);
s_ = ns;
}
};

here we use the function ReAlloc() that imports the C function realloc().
% man realloc

4.2: Ring buffer

155

#include <stdlib.h>
void *realloc(void *ptr, size_t size);
realloc() changes the size of the memory block pointed to by ptr to size
bytes.
The contents will be unchanged to the minimum of the old and new
sizes; newly allocated memory will be uninitialized. If ptr is NULL, the
call is equivalent to malloc(size); if size is equal to zero, the call is
equivalent to free(ptr). Unless ptr is NULL, it must have been returned by
an earlier call to malloc(), calloc() or realloc().

A program that shows the working of the stack is [FXT: ds/stack-demo.cc]. An example output where
the initial size is 4 and the growth-feature enabled (in increments of 4 elements) is shown in figure 4.1-A.

4.2

Ring buffer

A ring buffer is an array together with read and write operations that wrap around. That is, when the
last position of the array is reached, writing continues at the begin of the array, thereby erasing the oldest
entries. The read operation starts at the oldest entry in the array.
array x[]
A
A B
A B C
A B C D
E B C D
E F C D
E F G D
E F G H
I F G H
I J G H

insert(A)
insert(B)
insert(C)
insert(D)
insert(E)
insert(F)
insert(G)
insert(H)
insert(I)
insert(J)

x[] ordered
A
A B
A B C
A B C D
B C D E
C D E F
D E F G
E F G H
F G H I
G H I J

n
1
2
3
4
4
4
4
4
4
4

wpos
1
2
3
0
1
2
3
0
1
2

fpos
0
0
0
0
1
2
3
0
1
2

Figure 4.2-A: Writing to a ring buffer.
Figure 4.2-A shows the contents of a length-4 ring buffer after insertion of the symbols ‘A’, ‘B’, . . . , ‘J’.
The listing was created with the program [FXT: ds/ringbuffer-demo.cc]. The implementation used is
[FXT: class ringbuffer in ds/ringbuffer.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class ringbuffer
{
public:
Type *x_;
// data (ring buffer)
ulong s_;
// allocated size (# of elements)
ulong n_;
// current number of entries in buffer
ulong wpos_; // next position to write in buffer
ulong fpos_; // first position to read in buffer
public:
ringbuffer(ulong n)
{
s_ = n;
x_ = new Type[s_];
n_ = 0;
wpos_ = 0;
fpos_ = 0;
}
~ringbuffer()
ulong num()

{ delete [] x_; }
const

{ return n_; }

If an entry is inserted, it is written to index wpos:
1
2
3
4
5

void insert(const Type &z)
{
x_[wpos_] = z;
if ( ++wpos_>=s_ ) wpos_ = 0;
if ( n_ < s_ ) ++n_;

156
6
7
8
9
10
11
12
13
14
15
16
17
18
19

else

fpos_ =

wpos_;

}
ulong read(ulong k, Type &z) const
// Read entry k (that is, [(fpos_ + k)%s_]).
// Return 0 if k>=n, else return k+1.
{
if ( k>=n_ ) return 0;
ulong j = fpos_ + k;
if ( j>=s_ ) j -= s_;
z = x_[j];
return k + 1;
}
};

Ring buffers are, for example, useful for logging purposes, if only a certain number of lines can be saved.
To do so, enhance the ringbuffer class so that it uses an additional array of (fixed width) strings. The
message to log is copied into the array and the pointer set accordingly. A read returns the pointer to the
string.

4.3

Queue (FIFO)

A queue (or FIFO for first-in, first-out) is a data structure that supports the following operations: push()
saves an entry, pop() retrieves (and removes) the entry that was entered least recently, and peek()
retrieves the least recently entered element without removing it.
array x[]
push( 1)
1 - - push( 2)
1 2 - push( 3)
1 2 3 push( 4)
1 2 3 4
push( 5)
1 2 3 4 5 - push( 6)
1 2 3 4 5 6 push( 7)
1 2 3 4 5 6 7
pop== 1
- 2 3 4 5 6 7
pop== 2
- - 3 4 5 6 7
push( 8)
- - 3 4 5 6 7
pop== 3
- - - 4 5 6 7
pop== 4
- - - - 5 6 7
push( 9)
9 - - - 5 6 7
pop== 5
9 - - - - 6 7
pop== 6
9 - - - - - 7
push(10)
9 10 - - - - 7
pop== 7
9 10 - - - - pop== 8
9 10 - - - - push(11)
9 10 11 - - - pop== 9
- 10 11 - - - pop==10
- - 11 - - - push(12)
- - 11 12 - - pop==11
- - - 12 - - pop==12
- - - - - - push(13)
- - - - 13 - pop==13
- - - - - - pop== 0
- - - - - - (queue was empty)
push(14)
- - - - - 14 pop==14
- - - - - - pop== 0
- - - - - - (queue was empty)
push(15)
- - - - - - 15

8
8
8
8
8
8
8
8
-

n
1
2
3
4
5
6
7
6
5
6
5
4
5
4
3
4
3
2
3
2
1
2
1
0
1
0
0

rpos
0
0
0
0
0
0
0
1
2
2
3
4
4
5
6
6
7
0
0
1
2
2
3
4
4
5
5

wpos
1
2
3
0
5
6
7
7
7
0
0
0
1
1
1
2
2
2
3
3
3
4
4
4
5
5
5

-

1
0
0

5
6
6

6
6
6

-

1

6

7

Figure 4.3-A: Inserting and retrieving elements with a queue.
We describe a queue with an optional feature of growing when necessary. Figure 4.3-A shows the data
for a queue where the initial size is four and the growth-feature enabled (in steps of four elements). The
listing was created with the program [FXT: ds/queue-demo.cc].

4.3: Queue (FIFO)

157

The implementation is [FXT: class queue in ds/queue.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class queue
{
public:
Type *x_;
// pointer to data
ulong s_;
ulong n_;
ulong wpos_; // next position to write in buffer
ulong rpos_; // next position to read in buffer
ulong gq_; // grow gq elements if necessary, 0 for "never grow"
public:
explicit queue(ulong n, ulong growq=0)
{
s_ = n;
x_ = new Type[s_];
n_ = 0;
wpos_ = 0;
rpos_ = 0;
gq_ = growq;
}
~queue()

{ delete [] x_; }

ulong num()

const

{ return n_; }

The method push() writes to x[wpos], peek() and pop() read from x[rpos]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

ulong push(const Type &z)
// Zero is returned on failure
//
(i.e. space exhausted and 0==gq_)
{
if ( n_ >= s_ )
{
if ( 0==gq_ ) return 0; // growing disabled
grow();
}
x_[wpos_] = z;
++wpos_;
if ( wpos_>=s_ )

wpos_ = 0;

++n_;
return n_;
}
ulong peek(Type &z)
// if zero is returned the value of z is undefined.
{
z = x_[rpos_];
return n_;
}
ulong pop(Type &z)
// Return number of entries before pop
// i.e. zero is returned if queue was empty.
// If zero is returned the value of z is undefined.
{
ulong ret = n_;
if ( 0!=n_ )
{
z = x_[rpos_];
++rpos_;
if ( rpos_ >= s_ ) rpos_ = 0;
--n_;
}
return ret;
}

The growing feature is implemented as follows:
1

private:

158
2
3
4
5
6
7
8
9
10
11
12

void grow()
{
// move read-position to zero:
rotate_left(x_, s_, rpos_);
wpos_ = s_;
rpos_ = 0;
s_ = ns;
}

};

4.4

Deque (double-ended queue)

A deque (for double-ended queue) combines the data structures stack and queue: insertion and deletion
in time O(1) is possible both at the ﬁrst and the last position. An implementation with the option to let
the deque grow when necessary is [FXT: class deque in ds/deque.h]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class deque
{
public:
Type *x_;
// data (ring buffer)
ulong s_;
ulong n_;
ulong fpos_; // position of first element in buffer
// insert_first() will write to (fpos-1)%n
ulong lpos_; // position of last element in buffer plus one
// insert_last() will write to lpos, n==(lpos-fpos) (mod s)
// entries are at [fpos, ..., lpos-1] (range may be empty)
ulong

gq_; // grow gq elements if necessary, 0 for "never grow"

public:
explicit deque(ulong n, ulong growq=0)
{
s_ = n;
x_ = new Type[s_];
n_ = 0;
fpos_ = 0;
lpos_ = 0;
gq_ = growq;
}
~deque()

{ delete [] x_; }

ulong num()

const

{ return n_; }

The insertion at the front and end are implemented as
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

ulong insert_first(const Type &z)
// Return number of entries after insertion.
//
{
if ( n_ >= s_ )
{
if ( 0==gq_ ) return 0; // growing disabled
grow();
}
--fpos_;
if ( fpos_ == -1UL )
x_[fpos_] = z;
++n_;
return n_;

fpos_ = s_ - 1;

}
ulong insert_last(const Type &z)
// Return number of entries after insertion.
//

4.4: Deque (double-ended queue)
24
25
26
27
28
29
30
31
32
33
34
35
36

159

{
if ( n_ >= s_ )
{
if ( 0==gq_ )
grow();
}

return 0;

x_[lpos_] = z;
++lpos_;
if ( lpos_>=s_ )
++n_;
return n_;

lpos_ = 0;

// growing disabled

}

The extraction methods are
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

ulong extract_first(Type & z)
// Return number of elements before extract.
// Return 0 if extract on empty deque was attempted.
{
if ( 0==n_ ) return 0;
z = x_[fpos_];
++fpos_;
if ( fpos_ >= s_ ) fpos_ = 0;
--n_;
return n_ + 1;
}
ulong extract_last(Type & z)
// Return number of elements before extract.
// Return 0 if extract on empty deque was attempted.
{
--lpos_;
if ( lpos_ == -1UL ) lpos_ = s_ - 1;
z = x_[lpos_];
--n_;
return n_ + 1;
}

We can read at the front, end, or an arbitrary index, without changing any data:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
1
2
3
4
5
6
7
8

ulong read_first(Type & z) const
// Read (but don’t remove) first entry.
// Return number of elements (i.e. on error return zero).
{
z = x_[fpos_];
return n_;
}
ulong read_last(Type & z) const
// Read (but don’t remove) last entry.
// Return number of elements (i.e. on error return zero).
{
return read(n_-1, z); // ok for n_==0
}
ulong read(ulong k, Type & z) const
// Read entry k (that is, [(fpos_ + k)%s_]).
// Return 0 if k>=n_ else return k+1
{
if ( k>=n_ ) return 0;
ulong j = fpos_ + k;
if ( j>=s_ ) j -= s_;
z = x_[j];
return k + 1;
}
private:
void grow()
{
// Move read-position to zero:
rotate_left(x_, s_, fpos_);
fpos_ = 0;

160
9
10
11
12

lpos_ = n_;
s_ = ns;
}

};
insert_first( 1)
1
insert_last(51)
1 51
insert_first( 2)
2 1 51
insert_last(52)
2 1 51 52
insert_first( 3)
3 2 1 51
insert_last(53)
3 2 1 51
extract_first()= 3
2 1 51 52
extract_last()= 53
2 1 51 52
insert_first( 4)
4 2 1 51
insert_last(54)
4 2 1 51
extract_first()= 4
2 1 51 52
extract_last()= 54
2 1 51 52
extract_first()= 2
1 51 52
extract_last()= 52
1 51
extract_first()= 1
51
extract_last()= 51
insert_first( 5)
5
insert_last(55)
5 55
extract_first()= 5
55
extract_last()= 55
extract_first()= (deque is empty)
extract_last()= (deque is empty)
insert_first( 7)
7
insert_last(57)
7 57

52
52 53
53
52
52 54
54

Figure 4.4-A: Inserting and retrieving elements with a queue.
Its working is shown in figure 4.4-A which was created with the program [FXT: ds/deque-demo.cc].

4.5

Heap and priority queue

4.5.1

Indexing scheme for binary trees
1:[...1]
2:[..1.]
4:[.1..]

8:[1...]

3:[..11]
5:[.1.1]

6:[.11.]

7:[.111]

9:[1..1]

Figure 4.5-A: Indexing a binary tree: the left child of node k is node 2k, the right child is node 2k + 1.
A one-based index array with n elements can be identified with a binary tree as shown in figure 4.5-A.
Node 1 is the root node. The left child of node k is node 2k and the right child is node 2k + 1. The
parent of node k is node k/2 .
We require that consecutive array indices 1, 2, . . ., n are used. Therefore all nodes k where k ≤ n/2
have at least one child.

4.5.2

The binary heap

A binary heap is a binary tree of the form just described, where both children are less than or equal to
their parent. Figure 4.5-B shows an example of a heap with nine elements.
The following function determines whether a given array is a heap [FXT: ds/heap.h]:
1
2

ulong test_heap(const Type *x, ulong n)

4.5: Heap and priority queue

161

95
91
79
76

as array:

84
91

80

78

71

[ 95,

91, 84,

79, 91, 80, 78,

76, 71]

Figure 4.5-B: A heap with nine elements, the left or right child is never greater than the parent.
3
4
5
6
7
8
9
10
11
12
13

// Return 0 if x[] has heap property
// else index of node found to be greater than its parent.
{
const Type *p = x - 1; // make one-based
{
ulong t = (k>>1); // parent(k)
if ( p[t]<p[k] ) return k-1; // in {1, 2, ..., n}
}
return 0; // has heap property
}

Let L = 2k and R = 2k + 1 be the left and right children of node k, respectively. Now assume that the
subtrees whose roots are L and R already have the heap property, but node k is less than either L or R.
We can restore the heap property between k, L, and R by swapping element k downwards (with L or R,
as needed). The process is repeated if necessary until the bottom of the tree is reached:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

void heapify(Type *z, ulong n, ulong k)
// Data expected in z[1,2,...,n].
{
ulong m = k; // index of max of k, left(k), and right(k)
const ulong l = (k<<1); // left(k);
if ( (l <= n) && (z[l] > z[k]) ) m = l;

// left child (exists and) greater than k

const ulong r = (k<<1) + 1; // right(k);
if ( (r <= n) && (z[r] > z[m]) ) m = r;

// right child (ex. and) greater than max(k,l)

if ( m != k ) // need to swap
{
swap2(z[k], z[m]);
heapify(z, n, m);
}
}

To reorder an array into a heap, we restore the heap property from the bottom up:
1
2
3
4
5
6
7
8
9
10
11
12
13

void build_heap(Type *x, ulong n)
// Reorder data to a heap.
// Data expected in x[0,1,...,n-1].
{
Type *z = x - 1;
// make one-based
ulong j = (n>>1); // max index such that node has at least one child
while ( j > 0 )
{
heapify(z, n, j);
--j;
}
}

The routine has complexity O (n). Let the height of node k be the maximal number of swaps that can
happen with heapify(k). There are less than n/2 elements of height 1, n/4 of height 2, n/8 of height 3,

162


and so on. Let W (n) be the maximal number of swaps with n elements, we have
W (n) <

1 n/2 + 2 n/4 + 3 n/8 + . . . + log2 (n) 1 < 2 n

(4.5-1)

So the complexity is indeed linear.
A new element can be inserted into a heap in O(log n) time by appending it and moving it towards the
root as necessary:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

bool heap_insert(Type *x, ulong n, ulong s, Type t)
// With x[] a heap of current size n
// and max size s (i.e. space for s elements allocated),
// insert t and restore heap-property.
// Return true if successful, else (i.e. if space exhausted) false.
{
if ( n > s ) return false;
++n;
Type *x1 = x - 1; // make one-based
ulong j = n;
while ( j > 1 ) // move towards root as needed
{
ulong k = (j>>1); // k==parent(j)
if ( x1[k] >= t ) break;
x1[j] = x1[k];
j = k;
}
x1[j] = t;
return true;
}

Similarly, the maximal element can be removed in time O(log n):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Type heap_extract_max(Type *x, ulong n)
// Return maximal element of heap and restore heap structure.
// Return value is undefined for 0==n.
{
Type m = x[0];
if ( 0 != n )
{
Type *x1 = x - 1;
x1[1] = x1[n];
--n;
heapify(x1, n, 1);
}
return m;
}

4.5.3

Priority queue

A priority queue is a data structure that supports insertion of an element and extraction of its maximal
element, both in time O (log(n)). A priority queue can be used to schedule an event for a certain time
and return the next pending event.
We use a binary heap to implement a priority queue. Two modiﬁcations seem appropriate: Firstly, replace
extract_max() by extract_next(), leaving it as a compile time option whether to extract the minimal
or the maximal element. We need to change the comparison operators at a few strategic places so that
the heap is built either with its maximal or its minimal element ﬁrst [FXT: class priority queue in
ds/priorityqueue.h]:
1
2
3
4
5
6
7
8
9
10
11

#if 1
// next() is the one with the smallest key
// i.e. extract_next() is extract_min()
#define _CMP_ <
#define _CMPEQ_ <=
#else
// next() is the one with the biggest key
// i.e. extract_next() is extract_max()
#define _CMP_ >
#define _CMPEQ_ >=
#endif

4.5: Heap and priority queue
Secondly, augment the elements by an event description that can be freely deﬁned:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

template <typename Type1, typename Type2>
class priority_queue
{
public:
Type1 *t1_; // time:
t1[1..s] one-based array!
Type2 *e1_; // events: e1[1..s] one-based array!
ulong s_;
ulong n_;
// current number of events
ulong gq_;
// grow gq elements if necessary, 0 for "never grow"
public:
priority_queue(ulong n, ulong growq=0)
{
s_ = n;
t1_ = new Type1[s_] - 1;
e1_ = new Type2[s_] - 1;
n_ = 0;
gq_ = growq;
}
~priority_queue()
{
delete [] (t1_+1);
delete [] (e1_+1);
}
[--snip--]

The extraction and insertion operations are
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

bool extract_next(Type1 &t, Type2 &e)
{
if ( n_ == 0 ) return false;
t = t1_[1];
e = e1_[1];
t1_[1] = t1_[n_];
e1_[1] = e1_[n_];
--n_;
heapify(1);
return true;
}
bool insert(const Type1 &t, const Type2 &e)
// Insert event e at time t.
// Return true if successful, else false (space exhausted and growth disabled).
{
if ( n_ >= s_ )
{
if ( 0==gq_ ) return false; // growing disabled
grow();
}
++n_;
ulong j = n_;
while ( j > 1 )
{
ulong k = (j>>1); // k==parent(j)
if ( t1_[k] _CMPEQ_ t ) break;
t1_[j] = t1_[k]; e1_[j] = e1_[k];
j = k;
}
t1_[j] = t;
e1_[j] = e;
return true;
}
void reschedule_next(Type1 t)
{
t1_[1] = t;
heapify(1);
}

163

164


The member function reschedule_next() is more eﬃcient than the sequence extract_next();
insert();, as it calls heapify() only once. The heapify() function is tail-recursive, so we make it
iterative:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

private:
void heapify(ulong k)
{
ulong m = k;
hstart:
ulong l
ulong r
if ( (l
if ( (r

= (k<<1); // left(k);
= l + 1; // right(k);
<= n_) && (t1_[l] _CMP_ t1_[k]) )
<= n_) && (t1_[r] _CMP_ t1_[m]) )

m = l;
m = r;

if ( m != k )
{
swap2(t1_[k], t1_[m]); swap2(e1_[k], e1_[m]);
heapify(m);
k = m;
goto hstart; // tail recursion
}

//

}

The second argument of the constructor determines the number of elements added in case of growth, it
is disabled (equals zero) by default.
1
2
3
4
5
6
7
8
9

private:
void grow()
{
t1_ = ReAlloc<Type1>(t1_+1, ns, s_) - 1;
e1_ = ReAlloc<Type2>(e1_+1, ns, s_) - 1;
s_ = ns;
}
};

The ReAlloc() routine is described in section 4.1 on page 153.
Inserting into piority_queue:
# : event @
time
0:
A @
0.840188
1:
B @
0.394383
2:
C @
0.783099
3:
D @
0.79844
4:
E @
0.911647
5:
F @
0.197551
6:
G @
0.335223
7:
H @
0.76823
8:
I @
0.277775
9:
J @
0.55397

Extracting from piority_queue:
# : event @
time
9:
F @
0.197551
8:
I @
0.277775
7:
G @
0.335223
6:
B @
0.394383
5:
J @
0.55397
4:
H @
0.76823
3:
C @
0.783099
2:
D @
0.79844
1:
A @
0.840188
0:
E @
0.911647

Figure 4.5-C: Insertion of events labeled ‘A’, ‘B’, . . . , ‘J’ scheduled for random times into a priority
queue (left) and subsequent extraction (right).
The program [FXT: ds/priorityqueue-demo.cc] inserts events at random times 0 ≤ t < 1, then extracts
all of them. It gives the output shown in ﬁgure 4.5-C. A more typical usage would intermix the insertions
and extractions.

4.6

Bit-array

The use of bit-arrays should be obvious: an array of tag values (like ‘seen’ versus ‘unseen’) where all
standard data types would be a waste of space. Besides reading and writing individual bits one should
implement a convenient search for the next set (or cleared) bit.
The class [FXT: class bitarray in ds/bitarray.h] is used, for example, for lists of small primes [FXT:
mod/primes.cc], for in-place transposition routines [FXT: aux2/transpose.h] (see section 2.8 on page 122)
and several operations on permutations (see section 2.4 on page 109).
1

class bitarray

4.6: Bit-array
2
3
4
5
6
7
8
9
10
11
12

165

// Bit-array class mostly for use as memory saving array of Boolean values.
// Valid index is 0...nb_-1 (as usual in C arrays).
{
public:
ulong *f_;
// bit bucket
ulong n_;
// number of bits
ulong nfw_; // number of words where all bits are used, may be zero
ulong mp_;
// mask for partially used word if there is one, else zero
// (ones are at the positions of the _unused_ bits)
bool myfq_; // whether f[] was allocated by class
[--snip--]

The constructor allocates memory by default. If the second argument is nonzero, it must point to an
accessible memory range:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

bitarray(ulong nbits, ulong *f=0)
// nbits must be nonzero
{
ulong nw = ctor_core(nbits);
if ( f!=0 )
{
f_ = (ulong *)f;
myfq_ = false;
}
else
{
f_ = new ulong[nw];
myfq_ = true;
}
}

The public methods are
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// operations on bit n:
ulong test(ulong n) const
void set(ulong n)
void clear(ulong n)
void change(ulong n)
ulong test_set(ulong n)
ulong test_clear(ulong n)
ulong test_change(ulong n)

//
//
//
//
//
//
//

Test whether n-th
Set n-th bit
Clear n-th bit
Toggle n-th bit
Test whether n-th
Test whether n-th
Test whether n-th

// Operations on all bits:
void clear_all()
void set_all()
int all_set_q() const;
int all_clear_q() const;

//
//
//
//

Clear all bits
Set all bits
Return whether all bits are set
Return whether all bits are clear

bit set

bit is set and set it
bit is set and clear it
bit is set and toggle it

// Scanning the array:
// Note: the given index n is included in the search
ulong next_set_idx(ulong n) const
// Return index of next set or value beyond end
ulong next_clear_idx(ulong n) const // Return index of next clear or value beyond end

Combined operations like ‘test-and-set-bit’, ‘test-and-clear-bit’, ‘test-and-change-bit’ are often needed in
applications that use bit-arrays. This is why modern CPUs often have instructions implementing these
operations.
The class does not supply overloading of the array-index operator [ ] because the writing variant
would cause a performance penalty. One might want to add ‘sparse’-versions of the scan functions
(next_set_idx() and next_clear_idx()) for large bit-arrays with only few bits set or unset.
On the AMD64 architecture the corresponding CPU instructions are used [FXT: bits/bitasm-amd64.h]:
1
2
3
4
5
6
7
8
9
10

static inline ulong asm_bts(ulong *f, ulong i)
// Bit Test and Set
{
ulong ret;
asm ( "btsq %2, %1 n"
"sbbq %0, %0"
: "=r" (ret)
: "m" (*f), "r" (i) );
return ret;
}

166


If no specialized CPU instructions are available, the following two macros are used:
1
2
3

#define DIVMOD(n, d, bm)
ulong d = n / BITS_PER_LONG;
ulong bm = 1UL << (n % BITS_PER_LONG);

1
2
3
4

#define DIVMOD_TEST(n, d, bm)
ulong d = n / BITS_PER_LONG;
ulong bm = 1UL << (n % BITS_PER_LONG);
ulong t = bm & f_[d];

The macro BITS_USE_ASM determines whether the CPU instruction is available:
1
2
3
4
5
6
7
8
9
10

ulong test_set(ulong n) // Test whether n-th bit is set and set it.
{
#ifdef BITS_USE_ASM
return asm_bts(f_, n);
#else
DIVMOD_TEST(n, d, bm);
f_[d] |= bm;
return t;
#endif
}

Performance is still good in that case as the modulo operation and division by BITS PER LONG (a power
of 2) are replaced with cheap (bit-and and shift) operations. On the machine described in appendix B
on page 922 both versions give practically identical performance.
The way that out of bounds are handled can be defined at the beginning of the header file:
#define CHECK 0 // define to disable check of out of bounds access
//#define CHECK 1 // define to handle out of bounds access
//#define CHECK 2 // define to fail with out of bounds access

4.7

Left-right array

The left-right array (or LR-array) keeps track of a range of indices 0, . . . , n − 1. Every index can have
two states, free or set. The LR-array implements the following operations in time O (log n): marking the
k-th free index as set; marking the k-th set index as free; for the i-th (absolute) index, finding how many
indices of the same type (free or set) are left (or right) to it (including or excluding i).
The implementation is given as [FXT: class left right array in ds/left-right-array.h]:
1
2
3
4
5
6
7

class left_right_array
{
public:
ulong *fl_; // Free indices Left (including current element) in bsearch interval
bool *tg_;
// tags: tg[i]==true if and only if index i is free
ulong n_;
// total number of indices
ulong f_;
// number of free indices

The arrays used have n elements:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public:
left_right_array(ulong n)
{
n_ = n;
fl_ = new ulong[n_];
tg_ = new bool[n_];
free_all();
}
~left_right_array()
{
delete [] fl_;
delete [] tg_;
}
ulong num_free() const { return f_; }
ulong num_set() const { return n_ - f_; }

The initialization routine free_all() of the array fl[] uses a variation of the binary search algorithm
described in section 3.2 on page 141:

4.7: Left-right array
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

167

private:
void init_rec(ulong i0, ulong i1)
// Set elements of fl[0,...,n-2] according to empty array a[].
// The element fl[n-1] needs to be set to 1 afterwards.
// Work is O(n).
{
if ( (i1-i0)!=0 )
{
ulong t = (i1+i0)/2;
init_rec(i0, t);
init_rec(t+1, i1);
}
fl_[i1] = i1-i0+1;
}
public:
void free_all()
// Mark all indices as free.
{
f_ = n_;
for (ulong j=0; j<n_; ++j)
init_rec(0, n_-1);
fl_[n_-1] = 1;
}

tg_[j] = true;

The crucial observation is that the set of all intervals occurring with binary search is fixed if the size of
the searched array is fixed. For any interval [i0 , i1 ] the element fl[t] where t = (i0 + i1 )/2 contains
the number of free positions in [i0 , t]. The following method returns the k-th free index:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

ulong get_free_idx(ulong k) const
// Return the k-th ( 0 <= k < num_free() ) free index.
// Return ~0UL if k is out of bounds.
// Work is O(log(n)).
{
if ( k >= num_free() ) return ~0UL;
ulong i0 = 0, i1 = n_-1;
while ( 1 )
{
if ( (fl_[t] == k+1) && (tg_[t]) )

return t;

if ( fl_[t] > k ) // left:
{
i1 = t;
}
else
// right:
{
i0 = t+1; k-=fl_[t];
}
}
}

Usually one would have an extra array where one actually does write to the position returned above.
Then the data of the LR-array has to be modified accordingly. The following method does this:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ulong get_free_idx_chg(ulong k)
// Return the k-th ( 0 <= k < num_free() ) free index.
// Change the arrays and fl[] and tg[] reflecting
//
that index i will be set afterwards.
{
if ( k >= num_free() ) return ~0UL;
--f_;
ulong i0 = 0, i1 = n_-1;
while ( 1 )
{
if ( (fl_[t] == k+1) && (tg_[t]) )
{
--fl_[t];
tg_[t] = false;
return t;

168
22
23
24
25
26
27
28
29
30
31
32
33
34

}
if ( fl_[t] > k ) // left:
{
--fl_[t];
i1 = t;
}
else
// right:
{
i0 = t+1; k-=fl_[t];
}
}
}

fl[]= 1 2 3 1 5 1 2 1 1
a[]= * * * * * * * * *

(continued)

------- first: ------fl[]= 0 1 2 1 4 1 2 1 1
a[]= 1 * * * * * * * *

------- last: ------fl[]= 0 0 0 1 2 1 1 0 0
a[]= 1 3 5 * * * 6 4 2

------- last: ------fl[]= 0 1 2 1 4 1 2 1 0
a[]= 1 * * * * * * * 2

------- first: ------fl[]= 0 0 0 0 1 1 1 0 0
a[]= 1 3 5 7 * * 6 4 2

------- first: ------fl[]= 0 0 1 1 3 1 2 1 0
a[]= 1 3 * * * * * * 2

------- last: ------fl[]= 0 0 0 0 1 0 0 0 0
a[]= 1 3 5 7 * 8 6 4 2

------- last: ------fl[]= 0 0 1 1 3 1 2 0 0
a[]= 1 3 * * * * * 4 2

------- first: ------fl[]= 0 0 0 0 0 0 0 0 0
a[]= 1 3 5 7 9 8 6 4 2

------- first: ------fl[]= 0 0 0 1 2 1 2 0 0
a[]= 1 3 5 * * * * 4 2
Figure 4.7-A: Alternately setting the first and last free position in an LR-array. Asterisks denote free
positions, indices i where tg[i] is true.
For example, the following program sets alternately the first and last free position until no free position
is left [FXT: ds/left-right-array-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ulong n = 9;
ulong *A = new ulong[n];
left_right_array LR(n);
LR.free_all();
// PRINT
for (ulong e=0; e<n; ++e)
{
ulong s = 0; // first free
if ( 0!=(e&1) ) s = LR.num_free()-1;

// last free

ulong idx2 = LR.get_free_idx_chg(s);
A[idx2] = e+1;
// PRINT
}

Its output is shown in figure 4.7-A. For large n the method get_free_idx_chg() runs at a rate of (very
roughly) 2 million per second. The method to free the k-th set position is
1
2
3
4
5
6
7
8
9
10
11
12
13
14

ulong get_set_idx_chg(ulong k)
// Return the k-th ( 0 <= k < num_set() ) set index.
// Change the arrays and fl[] and tg[] reflecting
//
that index i will be freed afterwards.
{
if ( k >= num_set() ) return ~0UL;
++f_;
ulong i0 = 0,
while ( 1 )
{

i1 = n_-1;

4.7: Left-right array
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

169

// how many elements to the left are set:
ulong slt = t-i0+1 - fl_[t];
if ( (slt == k+1) && (tg_[t]==false) )
{
++fl_[t];
tg_[t] = true;
return t;
}
if ( slt > k ) // left:
{
++fl_[t];
i1 = t;
}
else
// right:
{
i0 = t+1; k-=slt;
}
}
}

The following method returns the number of free indices left of i (and excluding i):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

ulong num_FLE(ulong i) const
// Return number of Free indices Left of (absolute) index i (Excluding i).
{
if ( i >= n_ ) { return ~0UL; } // out of bounds
ulong i0 = 0, i1 = n_-1;
ulong ns = i; // number of set element left to i (including i)
while ( 1 )
{
if ( i0==i1 ) break;
if ( i<=t ) // left:
{
i1 = t;
}
else
// right:
{
ns -= fl_[t];
i0 = t+1;
}
}
return

i-ns;

}

Based on it are methods to determine the number of free/set indices to the left/right, including/excluding
the given index. We omit the out-of-bounds clauses in the following:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

ulong num_FLI(ulong i) const
// Return number of Free indices Left of (absolute) index i (Including i).
{ return num_FLE(i) + tg_[i]; }
ulong num_FRE(ulong i) const
// Return number of Free indices Right of (absolute) index i (Excluding i).
{ return num_free() - num_FLI(i); }
ulong num_FRI(ulong i) const
// Return number of Free indices Right of (absolute) index i (Including i).
{ return num_free() - num_FLE(i); }
ulong num_SLE(ulong i) const
// Return number of Set indices Left of (absolute) index i (Excluding i).
{ return i - num_FLE(i); }
ulong num_SLI(ulong i) const
// Return number of Set indices Left of (absolute) index i (Including i).
{ return i - num_FLE(i) + !tg_[i]; }
ulong num_SRE(ulong i) const
// Return number of Set indices Right of (absolute) index i (Excluding i).

170
23
24
25
26
27

{ return

num_set() - num_SLI(i); }

ulong num_SRI(ulong i) const
// Return number of Set indices Right of (absolute) index i (Including i).
{ return num_set() - i + num_FLE(i); }

These can be used for the fast conversion between permutations and inversion tables, see section 10.1.1.1
on page 235.

171

Part II

Combinatorial generation

172

Chapter 5: Conventions and considerations

Chapter 5

Conventions and considerations
We give algorithms for the generation of all combinatorial objects of certain types such as combinations,
compositions, subsets, permutations, integer partitions, set partitions, restricted growth strings and necklaces. Finally, we give some constructions for Hadamard and conference matrices. Several (more esoteric)
combinatorial objects that are found via searching in directed graphs are presented in chapter 20.
These routines are useful in situations where an exhaustive search over all configurations of a certain kind
is needed. Combinatorial algorithms are also fundamental to many programming problems and they can
simply be fun!

5.1

Representations and orders

For a set of n elements we will take either {0, 1, . . . , n − 1} or {1, 2, . . . , n}. Our convention for the set
notation is to start with the smallest element. Often there is more than one useful way to represent a
combinatorial object. For example the subset {1, 4, 6} of the set {0, 1, 2, 3, 4, 5, 6} can also be written
as a delta set [0100101]. Some sources use the term bit string. We often write dots instead of zeros
for readability: [.1..1.1]. Note that in the delta set we put the first element to the left side (array
notation), this is in contrast to the usual way of printing binary numbers, where the least significant bit
(bit number zero) is shown on the right side.
For most objects we will give an algorithm for generation in lexicographic (or simply lex ) order. In
lexicographic order a string X = [x0 , x1 , . . .] precedes the string Y = [y0 , y1 , . . .] if for the smallest index
k where the strings differ we have xk < yk . Further, the string X precedes X.W (the concatenation of X
with W ) for any nonempty string W . The co-lexicographic (or simply colex ) order is obtained by sorting
with respect to the reversed strings. The order sometimes depends on the representation that is used,
for an example see figure 8.1-A on page 202.
In a minimal-change order the amount of change between successive objects is the least possible. Such
an order is also called a (combinatorial) Gray code. There is in general more than one such order. Often
we can impose even stricter conditions, like that (with permutations) the changes are between adjacent
positions. The corresponding order is a strong minimal-change order. A very readable survey of Gray
codes is given in [343], see also [298].

5.2

Ranking, unranking, and counting

For a particular ordering of combinatorial objects (say, lexicographic order for permutations) we can ask
which position in the list a given object has. An algorithm for finding the position is called a ranking
algorithm. A method to determine the object, given its position, is called an unranking algorithm.
Given both ranking and unranking methods, one can compute the successor of a given object by computing
its rank r and unranking r + 1. While this method is usually slow the idea can be used to find more
efficient algorithms for computing the successor. In addition the idea often suggests interesting orderings
for combinatorial objects.

5.3: Characteristics of the algorithms

173

We sometimes give ranking or unranking methods for numbers in special forms such as factorial representations for permutations. Ranking and unranking methods are implicit in generation algorithms based
on mixed radix counting given in section 10.9 on page 258.
A simple but surprisingly powerful way to discover isomorphisms (one-to-one correspondences) between
combinatorial objects is counting them. If the sequences of numbers of two kinds of objects are identical,
chances are good of finding a conversion routine between the corresponding objects. For example, there
are 2n permutations of n elements such that no element lies more than one position to the right of
its original position. With this observation an algorithm for generating these permutations via binary
counting can be found, see section 11.2 on page 282.
The representation of combinatorial objects as restricted growth strings (as shown in section 15.2 on
page 325) follows from the same idea. The resulting generation methods can be very fast and flexible.
The number of objects of a given size can often be given by an explicit expression (for example, the
number of parentheses strings of n pairs is the Catalan number Cn = 2n /(n + 1), see section 15.4 on
n
page 331). The ordinary generating function (OGF) for a combinatorial object has a power series whose
coefficients count the objects: for the Catalan numbers we have the OGF
√
∞
1 − 1 − 4x
n
(5.2-1)
Cn x =
C(x) =
2x
n=0
Generating functions can often be given even though no explicit expression for the number of the objects
is known. The generating functions sometimes can be used to observe nontrivial identities, for example,
that the number of partitions into distinct parts equals the number of partitions into odd parts, given as
relation 16.4-23 on page 348. An exponential generating function (EGF) for a type of object where there
are En objects of size n has the power series of the form (see, for example, relation 11.1-7 on page 279)
∞

En
n=0

xn
n!

(5.2-2)

An excellent introduction to generating functions is given in [166], for in-depth information see [167,
vol.2, chap.21, p.1021], [143], and [319].

5.3

Characteristics of the algorithms

In almost all cases we produce the combinatorial objects one by one. Let n be the size of the object. The
successor (with respect to the specified order) is computed from the object itself and additional data of
a size less than a constant multiple of n.
Let B be the total number of combinatorial objects under consideration. Sometimes the cost of a successor
computation is O(n). Then the total cost for generating all objects is O(n · B).
If the successor computation takes a fixed number of operations (independent of the object size), then
we say the algorithm is O(1). If so, there can be no loop in the implementation, we say the algorithm is
loopless. Then the total cost for all objects is c · B for some constant c, independent of the object size.
A loopless algorithm can only exist if the amount of change between successive objects is bounded by a
constant that does not depend on the object size. Natural candidates for loopless algorithms are Gray
codes.
In many cases the cost of computing all objects is also c · B while the computation of the successor does
involve a loop. As an example consider incrementing in binary using arrays: in half of the cases just
the lowest bit changes, for half of the remaining cases just two bits change, and so on. The total cost
is B · (1 + 1 (1 + 1 (· · · ))) = 2 · B, independent of the number of bits used. So the total cost is as in
2
2
the loopless case while the successor computation can be expensive in some cases. Algorithms with this
characteristic are said to be constant amortized time (or CAT). Often CAT algorithms are faster than
loopless algorithms, typically if their structure is simpler.

174

Chapter 5: Conventions and considerations

5.4

Optimization techniques

Let x be an array of n elements. The loop
ulong k = 0;
while ( (k<n) && (x[k]!=0) )

++k;

// find first zero

can be replaced by
ulong k = 0;
while ( x[k]!=0 )

++k;

// find first zero

if a single sentinel element x[n]=0 is appended to the end of the array. The latter version will often be
faster as less branches occur.
The test for equality as in
ulong k = 0;
while ( k!=n )

{ /*...*/

++k; }

is more expensive than the test for equality with zero as in
ulong k = n;
while ( --k!=0 )

{ /*...*/ }

Therefore the latter version should be used when applicable.
To reduce the number of branches, replace the two tests
if ( (x<0) || (x>m) )

{ /*...*/ }

by the following single test where unsigned integers are used:
if ( x>m )

{ /*...*/ }

Use a do-while construct instead of a while-do loop whenever possible because the latter also tests the
loop condition at entry. Even if the do-while version causes some additional work, the gain from avoiding
a branch may outweigh it. Note that in the C language the for-loop also tests the condition at loop entry.
When computing the next object there may be special cases where the update is easy. If the percentage
of these ‘easy cases’ is not too small, an extra branch in the update routine should be created. The
performance gain is very visible in most cases (section 10.4 on page 245) and can be dramatic (section 10.5
on page 248).
Recursive routines can be quite elegant and versatile, see, for example, section 6.4 on page 182 and
section 13.2.1 on page 297. However, expect only about half the speed of a good iterative implementation
of the same algorithm. The notation for list recursions is given in section 14.1 on page 304.
Address generation can be simpler if arrays are used instead of pointers. This technique is useful for
many permutation generators, see chapter 10 on page 232. Change the pointer declarations to array
declarations in the corresponding class as follows:
//ulong *p_;
ulong p_[32];

// permutation data (pointer version)
// permutation data (array version)

Here we assume that nobody would attempt to compute all permutations of 31 or more elements (31! ≈
8.22 · 1033 , taking about 1.3 · 1018 years to finish). To use arrays uncomment (in the corresponding header
files) a line like
#define PERM_REV2_FIXARRAYS // use arrays instead of pointers (speedup)

This will also disable the statements to allocate and free memory with the pointers. Whether the use of
arrays tends to give a speedup is noted in the comment. The performance gain can be spectacular, see

5.5

Implementations, demo-programs, and timings

Most combinatorial generators are implemented as C++ classes. The first object in the given order is
created by the method first(). The method to compute the successor is usually next(). If a method

5.5: Implementations, demo-programs, and timings

175

for the computation of the predecessor is given, then it is called prev() and a method last() to compute
the last element in the list is given.
The current combinatorial object can be accessed through the method data(). To make all data of a
class accessible the data is declared public. This way the need for various get_something() methods
is avoided. To minimize the danger of accidental modiﬁcation of class data the variable names end with
an underscore. For example, the class for the generation of combinations in lexicographic order starts as
class combination_lex
{
public:
ulong *x_;
// combination: k elements 0<=x[j]<k in increasing order
ulong n_, k_; // Combination (n choose k)

The methods for the user of the class are public, the internal methods (which can leave the data in an
inconsistent state) are declared private.
Timings for the routines are given with most demo-programs. For example, the timings for the generation
of subsets in minimal-change order (as delta sets, implemented in [FXT: class subset gray delta in
comb/subset-gray-delta.h]) are given near the end of [FXT: comb/subset-gray-delta-demo.cc], together
with the parameters used:
Timing:
time ./bin 30
arg 1: 30 == n [Size of the set] default=5
arg 2: 0 == cq [Whether to start with full set] default=0
./bin 30 5.90s user 0.02s system 100% cpu 5.912 total
==> 2^30/5.90 == 181,990,139 per second
// with SUBSET_GRAY_DELTA_MAX_ARRAY_LEN defined:
time ./bin 30
arg 1: 30 == n [Size of the set] default=5
arg 2: 0 == cq [Whether to start with full set] default=0
==> 2^30/5.84 == 183,859,901 per second

For your own measurements simply uncomment the line
//#define TIMING // uncomment to disable printing

near the top of the demo-program. The rate of generation for a certain object is occasionally given as
123 M/s, meaning that 123 million objects are generated per second.
If a generator routine is used in an application, one must do the benchmarking with the application.
Choosing the optimal ordering and type of representation (for example, delta sets versus sets) for the
given task is crucial for good performance. Further optimization will very likely involve the surrounding
code rather than the generator alone.

176

Chapter 6: Combinations

Chapter 6

Combinations
We give algorithms to generate all subsets of the n-element set that contain k elements. For brevity we
sometimes refer to the n combinations of k out of n elements as “the combinations n ”.
k
k

6.1

Binomial coefficients

n k 0
0:
1
1:
1
2:
1
3:
1
4:
1
5:
1
6:
1
7:
1
8:
1
9:
1
10:
1
11:
1
12:
1
13:
1
14:
1
15:
1

1

2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1
3
6
10
15
21
28
36
45
55
66
78
91
105

3

4

5

6

7

8

11

12

13

14

15

1
4
1
10
5
1
20
15
6
1
35
35
21
7
1
56
70
56
28
8
1
84 126 126
84
36
9
1
120 210 252 210 120
45
10
1
165 330 462 462 330 165
55
11
1
220 495 792 924 792 495 220
66
12
286 715 1287 1716 1716 1287 715 286
78
364 1001 2002 3003 3432 3003 2002 1001 364
455 1365 3003 5005 6435 6435 5005 3003 1365

1
13
91
455

1
14
105

1
15

1

Figure 6.1-A: The binomial coefficients

9

n
k

10

for 0 ≤ n, k ≤ 15.

The number of ways to choose k elements from a set of n elements equals the binomial coefficient (‘n
choose k’, or ‘k out of n’):
n
k

=

n (n − 1) (n − 2) . . . (n − k + 1)
n!
=
=
k! (n − k)!
k (k − 1) (k − 2) . . . 1

k
j=1

(n − j + 1)
k!

=

nk
kk

(6.1-1)

The last equality uses the falling factorial notation ab := a (a − 1) (a − 2) . . . (a − b + 1). Equivalently, a
set of n elements has n subsets of exactly k elements. These subsets are called the k-subsets (where k
k
is fixed) or k-combinations of an n-set (a set with n elements).
To avoid overflow during the computation of the binomial coefficient, use the form
n
k

=

(n − k + 1)k
1k

=

n−k+1 n−k+2 n−k+3
n
·
·
···
1
2
3
k

An implementation is given in [FXT: aux0/binomial.h]:
1
2
3
4
5
6
7
8
9

inline
{
if
if
if

ulong binomial(ulong n, ulong k)
( k>n ) return 0;
( (k==0) || (k==n) ) return 1;
( 2*k > n ) k = n-k; // use symmetry

ulong b = n - k + 1;
ulong f = b;
for (ulong j=2; j<=k; ++j)

(6.1-2)

6.2: Lexicographic and co-lexicographic order
10
11
12
13
14
15
16

177

{
++f;
b *= f;
b /= j;
}
return

b;

}

The table of the first binomial coefficients is shown in figure 6.1-A. This table is called Pascal’s triangle,
it was generated with the program [FXT: comb/binomial-demo.cc]. Observe that
n
k

n−1
n−1
+
k−1
k

=

(6.1-3)

That is, each entry is the sum of its upper and left upper neighbor. The generating function for the
k-combinations of an n-set is
n
n

(1 + x)

=
k=0

6.2

n k
x
k

(6.1-4)

Lexicographic and co-lexicographic order
lexicographic
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

set
0, 1,
0, 1,
0, 1,
0, 1,
0, 2,
0, 2,
0, 2,
0, 3,
0, 3,
0, 4,
1, 2,
1, 2,
1, 2,
1, 3,
1, 3,
1, 4,
2, 3,
2, 3,
2, 4,
3, 4,

2
3
4
5
3
4
5
4
5
5
3
4
5
4
5
5
4
5
5
5

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

co-lexicographic

delta set
111...
11.1..
11..1.
11...1
1.11..
1.1.1.
1.1..1
1..11.
1..1.1
1...11
.111..
.11.1.
.11..1
.1.11.
.1.1.1
.1..11
..111.
..11.1
..1.11
...111

Figure 6.2-A: All combinations

6
3

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

set
0, 1,
0, 1,
0, 2,
1, 2,
0, 1,
0, 2,
1, 2,
0, 3,
1, 3,
2, 3,
0, 1,
0, 2,
1, 2,
0, 3,
1, 3,
2, 3,
0, 4,
1, 4,
2, 4,
3, 4,

2
3
3
3
4
4
4
4
4
4
5
5
5
5
5
5
5
5
5
5

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

delta set
111...
11.1..
1.11..
.111..
11..1.
1.1.1.
.11.1.
1..11.
.1.11.
..111.
11...1
1.1..1
.11..1
1..1.1
.1.1.1
..11.1
1...11
.1..11
..1.11
...111

set reversed
{ 2, 1, 0 }
{ 3, 1, 0 }
{ 3, 2, 0 }
{ 3, 2, 1 }
{ 4, 1, 0 }
{ 4, 2, 0 }
{ 4, 2, 1 }
{ 4, 3, 0 }
{ 4, 3, 1 }
{ 4, 3, 2 }
{ 5, 1, 0 }
{ 5, 2, 0 }
{ 5, 2, 1 }
{ 5, 3, 0 }
{ 5, 3, 1 }
{ 5, 3, 2 }
{ 5, 4, 0 }
{ 5, 4, 1 }
{ 5, 4, 2 }
{ 5, 4, 3 }

in lexicographic order (left) and co-lexicographic order (right).

The combinations of three elements out of six in lexicographic (or simply lex ) order are shown in figure 6.2A (left). The sequence is such that the sets are ordered lexicographically. Note that for the delta sets the
element zero is printed first whereas with binary words (section 1.24 on page 62) the least significant bit
(bit zero) is printed last. The sequence for co-lexicographic (or colex ) order is such that the sets, when
written reversed, are ordered lexicographically.

6.2.1

Lexicographic order

The following implementation generates the combinations in lexicographic order as sets [FXT: class
combination lex in comb/combination-lex.h]:
1
2
3
4

class combination_lex
{
public:
ulong *x_;

178
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


public:
combination_lex(ulong n, ulong k)
{
n_ = n; k_ = k;
x_ = new ulong[k_];
first();
}
~combination_lex()

{ delete [] x_; }

void first()
{
for (ulong k=0; k<k_; ++k)
}

x_[k] = k;

void last()
{
for (ulong i=0; i<k_; ++i)
}

x_[i] = n_ - k_ + i;

Computation of the successor and predecessor:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ulong next()
// Return smallest position that changed, return k with last combination
{
if ( x_[0] == n_ - k_ ) // current combination is the last
{ first(); return k_; }
ulong j = k_ - 1;
// easy case: highest element != highest possible value:
if ( x_[j] < (n_-1) ) { ++x_[j]; return j; }
// find highest falling edge:
while ( 1 == (x_[j] - x_[j-1]) )

{ --j; }

// move lowest element of highest block up:
ulong ret = j - 1;
ulong z = ++x_[j-1];
// ... and attach rest of block:
while ( j < k_ ) { x_[j] = ++z;
return

++j; }

ret;

}
ulong prev()
// Return smallest position that changed, return k with last combination
{
if ( x_[k_-1] == k_-1 ) // current combination is the first
{ last(); return k_; }
// find highest falling edge:
ulong j = k_ - 1;
while ( 1 == (x_[j] - x_[j-1]) )

{ --j; }

ulong ret = j;
--x_[j]; // move down edge element
// ... and move rest of block to high end:
while ( ++j < k_ ) x_[j] = n_ - k_ + j;
return

ret;

}

The listing in ﬁgure 6.2-A was created with the program [FXT: comb/combination-lex-demo.cc]. The
routine generates the combinations 32 at a rate of about 104 million per second. The combinations 32
20
12
are generated at a rate of 166 million per second.

6.2.2

Co-lexicographic order

The combinations of three elements out of six in co-lexicographic (or colex ) order are shown in ﬁgure 6.2-A (right). Algorithms to compute the successor and predecessor are implemented in [FXT: class
combination colex in comb/combination-colex.h]:

6.2: Lexicographic and co-lexicographic order
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

179

class combination_colex
{
public:
ulong *x_;
combination_colex(ulong n, ulong k)
{
n_ = n; k_ = k;
x_ = new ulong[k_+1];
x_[k_] = n_ + 2; // sentinel
first();
}
[--snip--]
ulong next()
// Return greatest position that changed, return k with last combination
{
if ( x_[0] == n_ - k_ ) // current combination is the last
{ first(); return k_; }
ulong j = 0;
// until lowest rising edge: attach block at low end
while ( 1 == (x_[j+1] - x_[j]) ) { x_[j] = j; ++j; }
++x_[j];
return

// can touch sentinel

// move edge element up
j;

}
ulong prev()
// Return greatest position that changed, return k with last combination
{
if ( x_[k_-1] == k_-1 ) // current combination is the first
{ last(); return k_; }
// find lowest falling edge:
ulong j = 0;
while ( j == x_[j] ) ++j; // can touch sentinel
--x_[j]; // move edge element down
ulong ret = j;
// attach rest of low block:
while ( 0!=j-- ) x_[j] = x_[j+1] - 1;
return
}
[--snip--]

ret;

The listing in ﬁgure 6.2-A was created with the program [FXT: comb/combination-colex-demo.cc]. The
combinations are generated 32 at a rate of about 140 million objects per second, the combinations 32
20
12
are generated at a rate of 190 million objects per second.
As a toy application of the combinations in co-lexicographic order we compute the products of k of
the n smallest primes. We maintain an array of k products shown at the right of ﬁgure 6.2-B. If the
return value of the method next() is j, then j + 1 elements have to be updated from right to left [FXT:
comb/kproducts-colex-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

combination_colex C(n, k);
const ulong *c = C.data();

// combinations as sets

ulong *tf = new ulong[n]; // table of Factors (primes)
// fill in small primes:
for (ulong j=0,f=2; j<n; ++j) { tf[j] = f; f=next_small_prime(f+1); }
ulong *tp = new ulong[k+1]; // table of Products
tp[k] = 1; // one appended (sentinel)
ulong j = k-1;
do
{
// update products from right:
ulong x = tp[j+1];
{ ulong i = j;

180


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

combination
{ 0, 1, 2 }
{ 0, 1, 3 }
{ 0, 2, 3 }
{ 1, 2, 3 }
{ 0, 1, 4 }
{ 0, 2, 4 }
{ 1, 2, 4 }
{ 0, 3, 4 }
{ 1, 3, 4 }
{ 2, 3, 4 }
{ 0, 1, 5 }
{ 0, 2, 5 }
{ 1, 2, 5 }
{ 0, 3, 5 }
{ 1, 3, 5 }
{ 2, 3, 5 }
{ 0, 4, 5 }
{ 1, 4, 5 }
{ 2, 4, 5 }
{ 3, 4, 5 }
{ 0, 1, 6 }
{ 0, 2, 6 }
{ 1, 2, 6 }
{ 0, 3, 6 }
{ 1, 3, 6 }
{ 2, 3, 6 }
{ 0, 4, 6 }
{ 1, 4, 6 }
{ 2, 4, 6 }
{ 3, 4, 6 }
{ 0, 5, 6 }
{ 1, 5, 6 }
{ 2, 5, 6 }
{ 3, 5, 6 }
{ 4, 5, 6 }

j
2
2
1
0
2
1
0
1
0
0
2
1
0
1
0
0
1
0
0
0
2
1
0
1
0
0
1
0
0
0
1
0
0
0
0

delta-set
111....
11.1...
1.11...
.111...
11..1..
1.1.1..
.11.1..
1..11..
.1.11..
..111..
11...1.
1.1..1.
.11..1.
1..1.1.
.1.1.1.
..11.1.
1...11.
.1..11.
..1.11.
...111.
11....1
1.1...1
.11...1
1..1..1
.1.1..1
..11..1
1...1.1
.1..1.1
..1.1.1
...11.1
1....11
.1...11
..1..11
...1.11
....111

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

products
30
15
42
21
70
35
105
35
66
33
110
55
165
55
154
77
231
77
385
77
78
39
130
65
195
65
182
91
273
91
455
91
286 143
429 143
715 143
1001 143
102
51
170
85
255
85
238 119
357 119
595 119
374 187
561 187
935 187
1309 187
442 221
663 221
1105 221
1547 221
2431 221

5
7
7
7
11
11
11
11
11
11
13
13
13
13
13
13
13
13
13
13
17
17
17
17
17
17
17
17
17
17
17
17
17
17
17

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 6.2-B: All products of k = 3 of the n = 7 smallest primes (2, 3, 5, . . . , 17). The products are the
leftmost elements of the array on the right side.
17
18
19
20
21
22
23
24
25
26
27
28
29
30

do
{
ulong f = tf[ c[i] ];
x *= f;
tp[i] = x;
}
while ( i-- );
} // here: final product is x == tp[0]
// visit the product x here
j = C.next();
}
while ( j < k );

The leftmost element of this array is the desired product. A sentinel element at the end of the array is
used to avoid an extra branch with the loop variable. With lexicographic order the update would go from
left to right.

6.3

Order by prefix shifts (cool-lex)

An algorithm for generating combinations by prefix shifts is given in [291]. The ordering is called cool-lex
5
in the paper. Figure 6.3-A shows some orders for k , figure 6.3-B shows the combinations 9 . The listings
3
were created with the program [FXT: comb/combination-pref-demo.cc] which uses the implementation
in [FXT: class combination pref in comb/combination-pref.h]:

6.3: Order by prefix shifts (cool-lex)
1:
2:
3:
4:
5:

1....
.1...
..1..
...1.
....1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

181

11...
.11..
1.1..
.1.1.
..11.
1..1.
.1..1
..1.1
...11
1...1


5
k

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

111..
.111.
1.11.
11.1.
.11.1
1.1.1
.1.11
..111
1..11
11..1

1:
2:
3:
4:
5:

1111.
.1111
1.111
11.11
111.1

, for k = 1, 2, 3, 4 in an ordering generated by prefix shifts.

........................................................1111111111111111111111111111
...................................111111111111111111111....................1111111.
....................111111111111111..............111111...............111111.....1..
..........1111111111.........11111..........11111....1...........11111....1.....1...
....111111.....1111......1111...1.......1111...1....1........1111...1....1.....1....
.111..111...111..1....111..1...1.....111..1...1....1......111..1...1....1.....1.....
111.11.1..11.1..1...11.1..1...1....11.1..1...1....1.....11.1..1...1....1.....1......
11.11.1..11.1..1...11.1..1...1....11.1..1...1....1.....11.1..1...1....1.....1......1
1.11.1..11.1..1...11.1..1...1....11.1..1...1....1.....11.1..1...1....1.....1......11
Figure 6.3-B: Combinations

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

9
3

via prefix shifts.

class combination_pref
{
public:
ulong *b_; // data as delta set
ulong s_, t_, n_; // combination (n choose k) where n=s+t, k=t.
private:
ulong x, y; // aux
public:
combination_pref(ulong n, ulong k)
// Must have: n>=2, k>=1 (i.e. s!=0 and t!=0)
{
s_ = n - k;
t_ = k;
n_ = s_ + t_;
b_ = new ulong[n_];
first();
}
[--snip--]
void first()
{
for (ulong j=0; j<t_; ++j)
x = 0; y = 0;
}

b_[j] = 0;
b_[j] = 1;

bool next()
{
if ( x==0 ) { x=1; b_[t_]=1; b_[0]=0; return true; }
else
{
if ( x>=n_-1 ) return false;
else
{
b_[x] = 0; ++x; b_[y] = 1; ++y; // X(s,t)
if ( b_[x]==0 )
{
b_[x] = 1; b_[0] = 0;
// Y(s,t)
if ( y>1 ) x = 1;
// Z(s,t)
y = 0;
}
return true;
}
}
}
[--snip--]

The combinations

32
20

and

32
12

are generated at a rate of about 200 M/s.

182

6.4


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

Gray code
{ 0, 1, 2 }
{ 0, 2, 3 }
{ 1, 2, 3 }
{ 0, 1, 3 }
{ 0, 3, 4 }
{ 1, 3, 4 }
{ 2, 3, 4 }
{ 0, 2, 4 }
{ 1, 2, 4 }
{ 0, 1, 4 }
{ 0, 4, 5 }
{ 1, 4, 5 }
{ 2, 4, 5 }
{ 3, 4, 5 }
{ 0, 3, 5 }
{ 1, 3, 5 }
{ 2, 3, 5 }
{ 0, 2, 5 }
{ 1, 2, 5 }
{ 0, 1, 5 }

111...
1.11..
.111..
11.1..
1..11.
.1.11.
..111.
1.1.1.
.11.1.
11..1.
1...11
.1..11
..1.11
...111
1..1.1
.1.1.1
..11.1
1.1..1
.11..1
11...1


6
3

complemented Gray code
1:
{ 3, 4, 5 }
...111
2:
{ 1, 4, 5 }
.1..11
3:
{ 0, 4, 5 }
1...11
4:
{ 2, 4, 5 }
..1.11
5:
{ 1, 2, 5 }
.11..1
6:
{ 0, 2, 5 }
1.1..1
7:
{ 0, 1, 5 }
11...1
8:
{ 1, 3, 5 }
.1.1.1
9:
{ 0, 3, 5 }
1..1.1
10:
{ 2, 3, 5 }
..11.1
11:
{ 1, 2, 3 }
.111..
12:
{ 0, 2, 3 }
1.11..
13:
{ 0, 1, 3 }
11.1..
14:
{ 0, 1, 2 }
111...
15:
{ 1, 2, 4 }
.11.1.
16:
{ 0, 2, 4 }
1.1.1.
17:
{ 0, 1, 4 }
11..1.
18:
{ 1, 3, 4 }
.1.11.
19:
{ 0, 3, 4 }
1..11.
20:
{ 2, 3, 4 }
..111.

in Gray order (left) and complemented Gray order (right).

The combinations of three elements out of six in a minimal-change order (a Gray code) are shown in
ﬁgure 6.4-A (left). With each transition exactly one element changes its position. We use a recursion for
the list C(n, k) of combinations n (notation as in relation 14.1-1 on page 304):
k
C(n, k)

=

[C(n − 1, k)
]
[0 . C(n − 1, k)
]
=
[(n) . C R (n − 1, k − 1)]
[1 . C R (n − 1, k − 1)]

(6.4-1)

The ﬁrst equality is for the set representation, the second for the delta-set representation. An implementation is given in [FXT: comb/combination-gray-rec-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

ulong *x;

// elements in combination at x[1] ... x[k]

void comb_gray(ulong n, ulong k, bool z)
{
if ( k==n )
{
for (ulong j=1; j<=k; ++j) x[j] = j;
visit();
return;
}
if ( z ) // forward:
{
comb_gray(n-1, k, z);
if ( k>0 ) { x[k] = n;
}
else
// backward:
{
if ( k>0 ) { x[k] = n;
comb_gray(n-1, k, z);
}

comb_gray(n-1, k-1, !z); }

comb_gray(n-1, k-1, !z); }

}

The recursion can be partly unfolded as follows
C(n, k)

=

[C(n − 2, k)
]
[0 0 . C(n − 2, k)
]
[(n − 1) . C R (n − 2, k − 1)] = [0 1 . C R (n − 2, k − 1)]
[(n) . C R (n − 1, k − 1)
]
[1 . C R (n − 1, k − 1) ]

(6.4-2)

6.5: The Eades-McKay strong minimal-change order

183

A recursion for the complemented order is
C (n, k)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

=

[(n) . C (n − 1, k − 1)]
[1 . C (n − 1, k − 1)]
=
R
R
[C (n − 1, k)
]
[0 . C (n − 1, k) ]

(6.4-3)

void comb_gray_compl(ulong n, ulong k, bool z)
{
[--snip--]
{
if ( k>0 ) { x[k] = n; comb_gray_compl(n-1, k-1, z); }
comb_gray_compl(n-1, k, !z);
}
else
// backward:
{
comb_gray_compl(n-1, k, !z);
if ( k>0 ) { x[k] = n; comb_gray_compl(n-1, k-1, z); }
}
}

A very eﬃcient (revolving door ) algorithm to generate the sets for the Gray code is given in
[269]. An implementation following [215, alg.R, sect.7.2.1.3] is [FXT: class combination revdoor in
comb/combination-revdoor.h]. Usage of the class is shown in [FXT: comb/combination-revdoor-demo.cc].
The routine generates the combinations 32 at a rate of about 115 M/s, the combinations 32 are gen20
12
erated at a rate of 181 M/s. An implementation geared for good performance for small values of k is
given in [223], a C++ adaptation is [FXT: comb/combination-lam-demo.cc]. The combinations 32 are
12
generated at a rate of 190 M/s and the combinations 64 at a rate of 250 M/s. The routine is limited to
7
values k ≥ 2.

6.5

The Eades-McKay strong minimal-change order

In any Gray code order for combinations just one element is moved between successive combinations.
When an element is moved across any other, there is more than one change on the set representation. If
i elements are crossed, then i + 1 entries in the set change:
set
{ 0, 1, 2, 3 }
{ 1, 2, 3, 4 }

delta set
1111..
.1111.

A strong minimal-change order is a Gray code where only one entry in the set representation is changed
per step. That is, only zeros in the delta set representation are crossed, the moves are called homogeneous.
One such order is the Eades-McKay sequence described in [134]. The Eades-McKay sequence for the
combinations 7 is shown in ﬁgure 6.5-A (left).
3

6.5.1

Recursive generation

The Eades-McKay order can be generated with the program [FXT: comb/combination-emk-rec-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ulong *rv;

// elements in combination at rv[1] ... rv[k]

void
comb_emk(ulong n, ulong k, bool z)
{
if ( k==n )
{
visit();
return;
}
if ( z
{
if
if
if
}
else

)

rv[j] = j;

// forward:

( (n>=2) && (k>=2) )
( (n>=2) && (k>=1) )
( (n>=1) )
// backward:

{ rv[k] = n; rv[k-1] = n-1; comb_emk(n-2, k-2, z); }
{ rv[k] = n; comb_emk(n-2, k-1, !z); }
{ comb_emk(n-1, k, z); }

184

Eades-McKay
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

4,
3,
2,
1,
0,
0,
0,
1,
1,
0,
2,
2,
1,
0,
3,
3,
2,
1,
0,
0,
0,
1,
1,
0,
2,
2,
1,
0,
0,
0,
1,
1,
0,
0,
0,

5,
5,
5,
5,
5,
1,
2,
2,
3,
3,
3,
4,
4,
4,
4,
4,
4,
4,
4,
1,
2,
2,
3,
3,
3,
3,
3,
3,
1,
2,
2,
2,
2,
1,
1,

6
6
6
6
6
6
6
6
6
6
6
6
6
6
6
5
5
5
5
5
5
5
5
5
5
4
4
4
4
4
4
3
3
3
2

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

complemented Eades-McKay
....111
...1.11
..1..11
.1...11
1....11
11....1
1.1...1
.11...1
.1.1..1
1..1..1
..11..1
..1.1.1
.1..1.1
1...1.1
...11.1
...111.
..1.11.
.1..11.
1...11.
11...1.
1.1..1.
.11..1.
.1.1.1.
1..1.1.
..11.1.
..111..
.1.11..
1..11..
11..1..
1.1.1..
.11.1..
.111...
1.11...
11.1...
111....

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

4,
3,
2,
1,
0,
0,
1,
2,
3,
2,
1,
0,
0,
1,
0,
0,
0,
1,
2,
1,
0,
0,
1,
2,
3,
2,
1,
0,
0,
1,
0,
0,
0,
1,
0,

5,
5,
5,
5,
5,
4,
4,
4,
4,
3,
3,
3,
2,
2,
1,
1,
2,
2,
3,
3,
3,
4,
4,
4,
4,
3,
3,
3,
2,
2,
1,
1,
2,
2,
1,

6
6
6
6
6
6
6
6
6
6
6
6
6
6
6
5
5
5
5
5
5
5
5
5
5
4
4
4
4
4
4
3
3
3
2

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

....111
...1.11
..1..11
.1...11
1....11
1...1.1
.1..1.1
..1.1.1
...11.1
..11..1
.1.1..1
1..1..1
1.1...1
.11...1
11....1
11...1.
1.1..1.
.11..1.
..11.1.
.1.1.1.
1..1.1.
1...11.
.1..11.
..1.11.
...111.
..111..
.1.11..
1..11..
1.1.1..
.11.1..
11..1..
11.1...
1.11...
.111...
111....

Figure 6.5-A: Combinations in Eades-McKay order (left) and complemented Eades-Mckay order (right).
20
21
22
23
24
25

{
if ( (n>=1) )
if ( (n>=2) && (k>=1) )
if ( (n>=2) && (k>=2) )

{ comb_emk(n-1, k, z); }
{ rv[k] = n; comb_emk(n-2, k-1, !z); }
{ rv[k] = n; rv[k-1] = n-1; comb_emk(n-2, k-2, z); }

}
}

The combinations 32 are generated at a rate of about 44 million per second, the combinations
20
a rate of 34 million per second.
The underlying recursion for the list E(n, k) of combinations
page 304)

E(n, k)

=

n
k

32
12

at

is (notation as in relation 14.1-1 on

[(n) . (n − 1) . E(n − 2, k − 2)]
[1 1 . E(n − 2, k − 2) ]
[(n) . E R (n − 2, k − 1)
] = [1 0 . E R (n − 2, k − 1)]
[E(n − 1, k)
]
[0 . E(n − 1, k)
]

(6.5-1)

Again, the ﬁrst equality is for the set representation, the second for the delta-set representation. Counting
the elements on both sides gives the relation
n
k

=

n−2
n−2
n−1
+
+
k−2
k−1
k

(6.5-2)

which is an easy consequence of relation 6.1-3 on page 177. A recursion for the complemented sequence

6.5: The Eades-McKay strong minimal-change order

185

(with respect to the delta sets) is

E (n, k)

[(n) . E (n − 1, k − 1)
]
[1 . E (n − 1, k − 1) ]
= [(n − 1) . E R (n − 2, k − 1)] = [0 1 . E R (n − 2, k − 1)]
[E (n − 2, k)
]
[0 0 . E (n − 2, k)
]

(6.5-3)

Counting on both sides gives
n
k

=

n−2
n−2
n−1
+
+
k
k−1
k−1

(6.5-4)

The condition for the recursion end has to be modiﬁed:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

void
comb_emk_compl(ulong n, ulong k, bool z)
{
if ( (k==0) || (k==n) )
{
for (ulong j=1; j<=k; ++j) rv[j] = j;
++ct;
visit();
return;
}
if ( z
{
if
if
if
}
else
{
if
if
if
}

)

// forward:

( (n>=1) && (k>=1) )
( (n>=2) && (k>=1) )
( (n>=2) )

{ rv[k] = n; comb_emk_compl(n-1, k-1, z); }
{ rv[k] = n-1; comb_emk_compl(n-2, k-1, !z); }
{ comb_emk_compl(n-2, k-0, z); }

// 1
// 01
// 00

{ comb_emk_compl(n-2, k-0, z); }
{ rv[k] = n-1; comb_emk_compl(n-2, k-1, !z); }
{ rv[k] = n; comb_emk_compl(n-1, k-1, z); }

// 00
// 01
// 1

// backward:
( (n>=2) )
( (n>=2) && (k>=1) )
( (n>=1) && (k>=1) )

}

The complemented sequence is not a strong Gray code.

6.5.2

Iterative generation via modulo moves

An iterative algorithm for the Eades-McKay sequence is given in [FXT: class combination emk in
comb/combination-emk.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class combination_emk
{
public:
ulong *x_; // combination: k elements 0<=x[j]<k in increasing order
ulong *s_; // aux: start of range for moves
ulong *a_; // aux: actual start position of moves
public:
combination_emk(ulong n, ulong k)
{
n_ = n;
k_ = k;
x_ = new ulong[k_+1]; // incl. high sentinel
s_ = new ulong[k_+1]; // incl. high sentinel
a_ = new ulong[k_];
x_[k_] = n_;
first();
}
[--snip--]
void first()
{
for (ulong j=0; j<k_; ++j)
}

x_[j] = j;
s_[j] = j;
a_[j] = x_[j];

186


The computation of the successor uses modulo steps:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

ulong next()
// Return position where track changed, return k with last combination
{
ulong j = k_;
while ( j-- ) // loop over tracks
{
const ulong sj = s_[j];
const ulong m = x_[j+1] - sj - 1;
if ( 0!=m ) // unless range empty
{
ulong u = x_[j] - sj;
// modulo moves:
if ( 0==(j&1) )
{
++u;
if ( u>m ) u = 0;
}
else
{
--u;
if ( u>m ) u = m;
}
u += sj;
if ( u != a_[j] ) // next position != start position
{
x_[j] = u;
s_[j+1] = u+1;
return j;
}
}
a_[j] = x_[j];
}
return

k_;

// current combination is last

}
};

The combinations 32 are generated at a rate of about 60 million per second, the combinations
20
a rate of 85 million per second [FXT: comb/combination-emk-demo.cc].

6.5.3

32
12

at

Alternative order via modulo moves

A slight modification of the successor computation gives an ordering where the first and last combination
differ by a single transposition (though not a homogeneous one), see figure 6.5-B. The generator is given
in [FXT: class combination mod in comb/combination-mod.h]:
1
2
3
4
5
6
7
8
9
10

class combination_mod
{
[--snip--]
ulong next()
{
[--snip--]
// modulo moves:
// if ( 0==(j&1) ) // gives EMK
if ( 0!=(j&1) ) // mod
[--snip--]

The rate of generation is identical with the EMK order [FXT: comb/combination-mod-demo.cc].

6.6
6.6.1

Two-close orderings via endo/enup moves
The endo and enup orderings for numbers

The endo order of the set {0, 1, 2, . . . , m} is obtained by writing all odd numbers of the set in increasing
order followed by all even numbers in decreasing order: {1, 3, 5, . . . , 6, 4, 2, 0}. The term endo stands

6.6: Two-close orderings via endo/enup moves
mod
111....
11....1
11...1.
11..1..
11.1...
1.11...
1.1...1
1.1..1.
1.1.1..
1..11..
1..1..1
1..1.1.
1...11.
1...1.1
1....11
....111
...1.11
...11.1
...111.
..1.11.
..1.1.1
..1..11
..11..1
..11.1.
..111..
.1.11..
.1.1..1
.1.1.1.
.1..11.
.1..1.1
.1...11
.11...1
.11..1.
.11.1..
.111...

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

EMK
111....
11.1...
11..1..
11...1.
11....1
1....11
1...1.1
1...11.
1..1.1.
1..1..1
1..11..
1.1.1..
1.1..1.
1.1...1
1.11...
.111...
.11.1..
.11..1.
.11...1
.1...11
.1..1.1
.1..11.
.1.1.1.
.1.1..1
.1.11..
..111..
..11.1.
..11..1
..1..11
..1.1.1
..1.11.
...111.
...11.1
...1.11
....111

Figure 6.5-B: All combinations
m
1:
2:
3:
4:
5:
6:
7:
8:
9:

187

endo sequence
1 0
1 2 0
1 3 2 0
1 3 4 2 0
1 3 5 4 2 0
1 3 5 6 4 2 0
1 3 5 7 6 4 2 0
1 3 5 7 8 6 4 2 0
1 3 5 7 9 8 6 4 2 0

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
7
3

(left) and
m
1:
2:
3:
4:
5:
6:
7:
8:
9:

7
4

mod
1111...
111.1..
111..1.
111...1
11...11
11..1.1
11..11.
11.1.1.
11.1..1
11.11..
1.111..
1.11.1.
1.11..1
1.1..11
1.1.1.1
1.1.11.
1..111.
1..11.1
1..1.11
1...111
...1111
..1.111
..11.11
..111.1
..1111.
.1.111.
.1.11.1
.1.1.11
.1..111
.11..11
.11.1.1
.11.11.
.111.1.
.111..1
.1111..

EMK
1111...
111...1
111..1.
111.1..
11.11..
11.1..1
11.1.1.
11..11.
11..1.1
11...11
1...111
1..1.11
1..11.1
1..111.
1.1.11.
1.1.1.1
1.1..11
1.11..1
1.11.1.
1.111..
.1111..
.111..1
.111.1.
.11.11.
.11.1.1
.11..11
.1..111
.1.1.11
.1.11.1
.1.111.
..1111.
..111.1
..11.11
..1.111
...1111

(right) in mod order and EMK order.

enup sequence
0 1
0 2 1
0 2 3 1
0 2 4 3 1
0 2 4 5 3 1
0 2 4 6 5 3 1
0 2 4 6 7 5 3 1
0 2 4 6 8 7 5 3 1
0 2 4 6 8 9 7 5 3 1

Figure 6.6-A: The endo (left) and enup (right) orderings with maximal value m.
for ‘Even Numbers DOwn, odd numbers up’. A routine for generating the successor in endo order with
maximal value m is [FXT: comb/endo-enup.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

inline ulong next_endo(ulong x, ulong m)
// Return next number in endo order
{
if ( x & 1 ) // x odd
{
x += 2;
if ( x>m ) x = m - (m&1); // == max even <= m
}
else // x even
{
x = ( x==0 ? 1 : x-2 );
}
return x;
}

The sequences for the ﬁrst few m are shown in ﬁgure 6.6-A. The routine computes one for the input zero.
An ordering starting with the even numbers in increasing order will be called enup (for ‘Even Numbers
UP, odd numbers down’). The computation of the successor can be implemented as
1
2

static inline ulong next_enup(ulong x, ulong m)
{

188
3
4
5
6
7
8
9
10
11
12
13

if ( x & 1 ) // x odd
{
x = ( x==1 ? 0 : x-2 );
}
else // x even
{
x += 2;
if ( x>m ) x = m - !(m&1);
}
return x;

// max odd <=m

}

The orderings are reversals of each other, so we deﬁne:
1
2

static inline ulong prev_endo(ulong x, ulong m)
static inline ulong prev_enup(ulong x, ulong m)

{ return next_enup(x, m); }
{ return next_endo(x, m); }

A function that returns the x-th number in enup order with maximal digit m is
1
2
3
4
5
6

static inline ulong enup_num(ulong x, ulong m)
{
ulong r = 2*x;
if ( r>m ) r = 2*m+1 - r;
return r;
}

The function will only work if x ≤ m. For example, with m = 5:
x:
0 1 2 3 4 5
r:
0 2 4 5 3 1
1
2
3
4
5
6

static inline ulong enup_idx(ulong x, ulong m)
{
const ulong b = x & 1;
x >>= 1;
return ( b ? m-x : x );
}

The function to map into endo order is
1
2
3
4
5
6
7
8

static inline ulong endo_num(ulong x, ulong m)
{
// return enup_num(m-x, m);
x = m - x;
ulong r = 2*x;
if ( r>m ) r = 2*m+1 - r;
return r;
}

For example,
x:
0 1 2 3 4 5
r:
1 3 5 4 2 0
Its inverse is
1
2
3
4
5
6

static inline ulong endo_idx(ulong x, ulong m)
{
const ulong b = x & 1;
x >>= 1;
return ( b ? x : m-x );
}

6.6.2

The endo and enup orderings for combinations

Two strong minimal-change orderings for combinations can be obtained via moves in enup and endo
order. Figure 6.6-B shows an ordering where the moves to the right are on even positions (enup order,
left). If the moves to the right are on odd positions (endo order), then Chase’s sequence is obtained
(right). Both have the property of being two-close: an element in the delta set moves by at most two
positions (and the move is homogeneous, no other element is crossed). An implementation of an iterative
algorithm for the computation of the combinations in enup order is [FXT: class combination enup in
comb/combination-enup.h].
1
2

class combination_enup
{

6.6: Two-close orderings via endo/enup moves

189

enup moves
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
4,
4,
4,
5,
3,
3,
3,
3,
3,
3,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,

1,
1,
1,
1,
1,
1,
2,
2,
2,
2,
2,
4,
4,
4,
6,
5,
5,
3,
3,
3,
3,
3,
3,
3,
3,
4,
4,
4,
6,
5,
5,
5,
5,
6,
6,
6,
5,
5,
4,
4,
4,
4,
4,
4,
6,
5,
5,
3,
3,
3,
3,
2,
2,
2,
2,
2,

2
4
6
7
5
3
3
4
6
7
5
5
6
7
7
7
6
6
7
5
4
4
6
7
5
5
6
7
7
7
6
6
7
7
7
7
7
6
6
7
5
5
6
7
7
7
6
6
7
5
4
4
6
7
5
3

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

Figure 6.6-B: Combinations

endo moves
111.....
11..1...
11....1.
11.....1
11...1..
11.1....
1.11....
1.1.1...
1.1...1.
1.1....1
1.1..1..
1...11..
1...1.1.
1...1..1
1.....11
1....1.1
1....11.
1..1..1.
1..1...1
1..1.1..
1..11...
..111...
..11..1.
..11...1
..11.1..
..1.11..
..1.1.1.
..1.1..1
..1...11
..1..1.1
..1..11.
....111.
....11.1
....1.11
.....111
...1..11
...1.1.1
...1.11.
...11.1.
...11..1
...111..
.1..11..
.1..1.1.
.1..1..1
.1....11
.1...1.1
.1...11.
.1.1..1.
.1.1...1
.1.1.1..
.1.11...
.11.1...
.11...1.
.11....1
.11..1..
.111....
8
3

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
3,
3,
3,
3,
3,
3,
5,
4,
4,
4,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,

1,
1,
1,
1,
1,
1,
3,
3,
3,
3,
5,
5,
6,
4,
4,
4,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
3,
3,
3,
3,
5,
5,
6,
4,
4,
4,
4,
4,
4,
5,
5,
6,
6,
6,
5,
5,
5,
5,
6,
4,
4,
4,
3,
3,
3,
3,

2
3
5
7
6
4
4
5
7
6
6
7
7
7
6
5
5
7
6
4
3
3
5
7
6
4
4
5
7
6
6
7
7
7
6
5
5
7
6
6
7
7
7
7
7
6
6
7
7
7
6
5
5
7
6
4

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

111.....
11.1....
11...1..
11.....1
11....1.
11..1...
1..11...
1..1.1..
1..1...1
1..1..1.
1....11.
1....1.1
1.....11
1...1..1
1...1.1.
1...11..
1.1..1..
1.1....1
1.1...1.
1.1.1...
1.11....
.111....
.11..1..
.11....1
.11...1.
.11.1...
.1.11...
.1.1.1..
.1.1...1
.1.1..1.
.1...11.
.1...1.1
.1....11
.1..1..1
.1..1.1.
.1..11..
...111..
...11..1
...11.1.
...1.11.
...1.1.1
...1..11
.....111
....1.11
....11.1
....111.
..1..11.
..1..1.1
..1...11
..1.1..1
..1.1.1.
..1.11..
..11.1..
..11...1
..11..1.
..111...

via enup moves (left) and via endo moves (Chase’s sequence, right).

190
3
4
5
6
7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21


public:
ulong
ulong
ulong
ulong

*x_; // combination: k elements 0<=x[j]<k in increasing order
*s_; // aux: start of range for enup moves
*a_; // aux: actual start position of enup moves
n_, k_; // Combination (n choose k)

public:
combination_enup(ulong n, ulong k)
{
n_ = n;
k_ = k;
x_ = new ulong[k_+1]; // incl. padding x_[k]
s_ = new ulong[k_+1]; // incl. padding x_[k]
a_ = new ulong[k_];
x_[k_] = n_;
first();
}
[--snip--]
void first()
{
}

x_[j] = j;
s_[j] = j;
a_[j] = x_[j];

The ‘padding’ elements x[k] and s[k] allow omitting a branch, similar to sentinel elements. The successor
of the current combination is computed by ﬁnding the range of possible movements (variable m) and, unless
the range is empty, move until we are back at the start position:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

ulong next()
// Return position where track changed, return k with last combination
{
ulong j = k_;
while ( j-- ) // loop over tracks
{
const ulong sj = s_[j];
const ulong m = x_[j+1] - sj - 1;
if ( 0!=m ) // unless range empty
{
ulong u = x_[j] - sj;
// move right on even positions:
if ( 0==(sj&1) ) u = next_enup(u, m);
else
u = next_endo(u, m);
u += sj;
if ( u != a_[j] ) // next pos != start position
{
x_[j] = u;
s_[j+1] = u+1;
return j;
}
}
a_[j] = x_[j];
}
return

k_;

// current combination is last

}
};

The combinations 32 are generated at a rate of 45 million objects per second, the combinations 32 at
20
12
a rate of 55 million per second. The only change in the implementation for computing the endo ordering
is (at the obvious place in the code) [FXT: comb/combination-endo.h]:
1
2
3

// move right on odd positions:
if ( 0==(sj&1) ) u = next_endo(u, m);
else
u = next_enup(u, m);

The ordering with endo moves is called Chase’s sequence. Figure 6.6-B was created with the programs

6.7: Recursive generation of certain orderings

191

[FXT: comb/combination-enup-demo.cc] and [FXT: comb/combination-endo-demo.cc].
The underlying recursion for the list U (n, k) of combinations

U (n, k)

n
k

in enup order is

[(n) . (n − 1) . U (n − 2, k − 2)]
[1 1 . U (n − 2, k − 2)]
] = [1 0 . U (n − 2, k − 1)]
= [(n) . U (n − 2, k − 1)
[U R (n − 1, k)
]
[0 . U R (n − 1, k)
]

(6.6-1)

The recursion is very similar to relation 6.5-1 on page 184. The crucial part of the recursive routine is
[FXT: comb/combination-enup-rec-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

void
comb_enup(ulong n, ulong k, bool z)
{
if ( k==n ) { visit(); return; }
if ( z
{
if
if
if
}
else
{
if
if
if
}

)

// forward:

( (n>=2) && (k>=2) )
( (n>=2) && (k>=1) )
( (n>=1) )

{ rv[k] = n; rv[k-1] = n-1; comb_enup(n-2, k-2, z); }
{ rv[k] = n; comb_enup(n-2, k-1, z); }
{ comb_enup(n-1, k, !z); }

// backward:
( (n>=1) )
( (n>=2) && (k>=1) )
( (n>=2) && (k>=2) )

{ comb_enup(n-1, k, !z); }
{ rv[k] = n; comb_enup(n-2, k-1, z); }
{ rv[k] = n; rv[k-1] = n-1; comb_enup(n-2, k-2, z); }

}

A recursion for the complemented sequence (with respect to the delta sets) is
R

U (n, k)

=

R

[(n) . U (n − 1, k − 1) ]
[1 . U (n − 1, k − 1)]
[(n − 1) . U (n − 2, k − 1)] = [0 1 . U (n − 2, k − 1)]
[U (n − 2, k)
]
[0 0 . U (n − 2, k)
]

(6.6-2)

The condition for the recursion end has to be modiﬁed:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

void
comb_enup_compl(ulong n, ulong k, bool z)
{
if ( (k==0) || (k==n) ) { visit(); return; }
if ( z
{
if
if
if
}
else
{
if
if
if
}

)

// forward:

( (n>=1) && (k>=1) )
( (n>=2) && (k>=1) )
( (n>=2) )

{ rv[k] = n; comb_enup_compl(n-1, k-1, !z); }
{ rv[k] = n-1; comb_enup_compl(n-2, k-1, z); }
{ comb_enup_compl(n-2, k-0, z); }

// 1
// 01
// 00

{ comb_enup_compl(n-2, k-0, z); }
{ rv[k] = n-1; comb_enup_compl(n-2, k-1, z); }
{ rv[k] = n; comb_enup_compl(n-1, k-1, !z); }

// 00
// 01
// 1

// backward:
( (n>=2) )
( (n>=2) && (k>=1) )
( (n>=1) && (k>=1) )

}

An algorithm for Chase’s sequence that generates delta sets is described in [215, alg.C, sect.7.2.1.3], an
implementation is given in [FXT: class combination chase in comb/combination-chase.h]. The routine
generates about 80 million combinations per second for both 32 and 32 [FXT: comb/combination20
12
chase-demo.cc].

6.7

Recursive generation of certain orderings

We give a simple recursive routine to generate the orders shown in ﬁgure 6.7-A. The combinations are
generated as sets [FXT: class comb rec in comb/combination-rec.h]:
1
2

class comb_rec
{

192

lexicographic
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

Gray code

compl. enup

111....
11.1...
11..1..
11...1.
11....1
1.11...
1.1.1..
1.1..1.
1.1...1
1..11..
1..1.1.
1..1..1
1...11.
1...1.1
1....11
.111...
.11.1..
.11..1.
.11...1
.1.11..
.1.1.1.
.1.1..1
.1..11.
.1..1.1
.1...11
..111..
..11.1.
..11..1
..1.11.
..1.1.1
..1..11
...111.
...11.1
...1.11
....111

1....11
1...11.
1...1.1
1..11..
1..1.1.
1..1..1
1.11...
1.1.1..
1.1..1.
1.1...1
111....
11.1...
11..1..
11...1.
11....1
.1...11
.1..11.
.1..1.1
.1.11..
.1.1.1.
.1.1..1
.111...
.11.1..
.11..1.
.11...1
..1..11
..1.11.
..1.1.1
..111..
..11.1.
..11..1
...1.11
...111.
...11.1
....111

1....11
1...1.1
1...11.
1..11..
1..1.1.
1..1..1
1.1...1
1.1..1.
1.1.1..
1.11...
111....
11.1...
11..1..
11...1.
11....1
.11...1
.11..1.
.11.1..
.111...
.1.11..
.1.1.1.
.1.1..1
.1..1.1
.1..11.
.1...11
..1..11
..1.1.1
..1.11.
..111..
..11.1.
..11..1
...11.1
...111.
...1.11
....111

compl. Eades-McKay
111....
11.1...
11..1..
11...1.
11....1
1.1...1
1.1..1.
1.1.1..
1.11...
1..11..
1..1.1.
1..1..1
1...1.1
1...11.
1....11
.1...11
.1..1.1
.1..11.
.1.11..
.1.1.1.
.1.1..1
.11...1
.11..1.
.11.1..
.111...
..111..
..11.1.
..11..1
..1.1.1
..1.11.
..1..11
...1.11
...11.1
...111.
....111

Figure 6.7-A: All combinations 7 in lexicographic, minimal-change, complemented enup, and comple3
mented Eades-McKay order (from left to right).
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public:
ulong n_, k_; // (n choose k)
ulong *rv_;
// == Record of Visits in graph
ulong rq_;
// condition that determines the order:
// 0 ==> lexicographic order
// 1 ==> Gray code
// 2 ==> complemented enup order
// 3 ==> complemented Eades-McKay sequence
ulong nq_;
// whether to reverse order
[--snip--]
void (*visit_)(const comb_rec &); // function to call with each combination
[--snip--]
void generate(void (*visit)(const comb_rec &), ulong rq, ulong nq=0)
{
visit_ = visit;
rq_ = rq;
nq_ = nq;
ct_ = 0;
rct_ = 0;
next_rec(0);
}

The recursion function is given in [FXT: comb/combination-rec.cc]:
1
2
3
4
5
6
7
8
9

void comb_rec::next_rec(ulong d)
{
ulong r = k_ - d; // number of elements remaining
if ( 0==r ) visit_(*this);
else
{
ulong rv1 = rv_[d-1]; // left neighbor
bool q;
switch ( rq_ )

6.7: Recursive generation of certain orderings
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

{
case 0: q
case 1: q
case 2: q
case 3: q
default: q
}
q ^= nq_;

=
=
=
=
=

1; break;
!(d&1); break;
rv1&1; break;
(d^rv1)&1; break;
1;

// reversed order if

193

//
//
//
//

0
1
2
3

==>
==>
==>
==>

lexicographic order
Gray code
complemented enup order
complemented Eades-McKay sequence

nq == true

if ( q ) // forward:
for (ulong x=rv1+1; x<=n_-r; ++x) { rv_[d] = x; next_rec(d+1); }
else
// backward:
for (ulong x=n_-r; (long)x>=(long)rv1+1; --x) { rv_[d] = x; next_rec(d+1); }
}
}

Figure 6.7-A was created with the program [FXT: comb/combination-rec-demo.cc]. The routine generates
the combinations 32 at a rate of about 35 million objects per second. The combinations 32 are
20
12
generated at a rate of 64 million objects per second.

194

Chapter 7: Compositions

Chapter 7

Compositions
The compositions of n into at most k parts are the ordered tuples (x0 , x1 , . . . , xk−1 ) where x0 + x1 +
. . . + xk−1 = n and 0 ≤ xi ≤ n. Order matters: one 4-composition of 7 is (0, 1, 5, 1), diﬀerent ones are
(5, 0, 1, 1) and (0, 5, 1, 1). The compositions of n into at most k parts are also called ‘k-compositions of
n’. To obtain the compositions of n into exactly k parts (where k ≤ n) generate the compositions of n − k
into k parts and add one to each position.

7.1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

composition
[ 3 . . . .
[ 2 1 . . .
[ 1 2 . . .
[ . 3 . . .
[ 2 . 1 . .
[ 1 1 1 . .
[ . 2 1 . .
[ 1 . 2 . .
[ . 1 2 . .
[ . . 3 . .
[ 2 . . 1 .
[ 1 1 . 1 .
[ . 2 . 1 .
[ 1 . 1 1 .
[ . 1 1 1 .
[ . . 2 1 .
[ 1 . . 2 .
[ . 1 . 2 .
[ . . 1 2 .
[ . . . 3 .
[ 2 . . . 1
[ 1 1 . . 1
[ . 2 . . 1
[ 1 . 1 . 1
[ . 1 1 . 1
[ . . 2 . 1
[ 1 . . 1 1
[ . 1 . 1 1
[ . . 1 1 1
[ . . . 2 1
[ 1 . . . 2
[ . 1 . . 2
[ . . 1 . 2
[ . . . 1 2
[ . . . . 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

chg
4
1
1
1
2
1
1
2
1
2
3
1
1
2
1
2
3
1
2
3
4
1
1
2
1
2
3
1
2
3
4
1
2
3
4

combination
111....
11.1...
1.11...
.111...
11..1..
1.1.1..
.11.1..
1..11..
.1.11..
..111..
11...1.
1.1..1.
.11..1.
1..1.1.
.1.1.1.
..11.1.
1...11.
.1..11.
..1.11.
...111.
11....1
1.1...1
.11...1
1..1..1
.1.1..1
..11..1
1...1.1
.1..1.1
..1.1.1
...11.1
1....11
.1...11
..1..11
...1.11
....111

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

composition
[ 7 . . ]
[ 6 1 . ]
[ 5 2 . ]
[ 4 3 . ]
[ 3 4 . ]
[ 2 5 . ]
[ 1 6 . ]
[ . 7 . ]
[ 6 . 1 ]
[ 5 1 1 ]
[ 4 2 1 ]
[ 3 3 1 ]
[ 2 4 1 ]
[ 1 5 1 ]
[ . 6 1 ]
[ 5 . 2 ]
[ 4 1 2 ]
[ 3 2 2 ]
[ 2 3 2 ]
[ 1 4 2 ]
[ . 5 2 ]
[ 4 . 3 ]
[ 3 1 3 ]
[ 2 2 3 ]
[ 1 3 3 ]
[ . 4 3 ]
[ 3 . 4 ]
[ 2 1 4 ]
[ 1 2 4 ]
[ . 3 4 ]
[ 2 . 5 ]
[ 1 1 5 ]
[ . 2 5 ]
[ 1 . 6 ]
[ . 1 6 ]
[ . . 7 ]

chg
2
1
1
1
1
1
1
1
2
1
1
1
1
1
1
2
1
1
1
1
1
2
1
1
1
1
2
1
1
1
2
1
1
2
1
2

combination
1111111..
111111.1.
11111.11.
1111.111.
111.1111.
11.11111.
1.111111.
.1111111.
111111..1
11111.1.1
1111.11.1
111.111.1
11.1111.1
1.11111.1
.111111.1
11111..11
1111.1.11
111.11.11
11.111.11
1.1111.11
.11111.11
1111..111
111.1.111
11.11.111
1.111.111
.1111.111
111..1111
11.1.1111
1.11.1111
.111.1111
11..11111
1.1.11111
.11.11111
1..111111
.1.111111
..1111111

Figure 7.1-A: The compositions of 3 into 5 parts in co-lexicographic order, positions of the rightmost
change, and delta sets of the corresponding combinations (left); and the corresponding data for compositions of 7 into 3 parts (right). Dots denote zeros.

7.1: Co-lexicographic order

195

The compositions in co-lexicographic (colex) order are shown in figure 7.1-A. The generator is implemented as [FXT: class composition colex in comb/composition-colex.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class composition_colex
{
public:
ulong n_, k_; // composition of n into k parts
ulong *x_;
// data (k elements)
[--snip--]
void first()
{
x_[0] = n_; // all in first position
for (ulong k=1; k<k_; ++k) x_[k] = 0;
}
void last()
{
for (ulong k=0; k<k_; ++k) x_[k] = 0;
x_[k_-1] = n_; // all in last position
}
[--snip--]

The methods to compute the successor and predecessor are:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

ulong next()
// Return position of rightmost change, return k with last composition.
{
ulong j = 0;
while ( 0==x_[j] ) ++j; // find first nonzero
if ( j==k_-1 )

return k_;

ulong v = x_[j];
x_[j] = 0;
x_[0] = v - 1;
++j;
++x_[j];
return

// current composition is last

// value of first nonzero
// set to zero
// value-1 to first position
// increment next position

j;

}
ulong prev()
{
const ulong v = x_[0];
// value at first position
if ( n_==v )

return k_; // current composition is first

x_[0] = 0;
ulong j = 1;
while ( 0==x_[j] )
--x_[j];
x_[j-1] = 1 + v;
return

// set first position to zero
++j;

// find next nonzero
// decrement value
// set previous position

j;

}

With each transition at most 3 entries are changed. The compositions of 10 into 30 parts (sparse case)
are generated at a rate of about 110 million per second, the compositions of 30 into 10 parts (dense
case) at about 200 million per second [FXT: comb/composition-colex-demo.cc]. With the dense case
(corresponding to the right of figure 7.1-A) the computation is faster as the position to change is found
earlier.
Optimized implementation
An implementation that is efficient also for the sparse case (that is, k much greater than n) is [FXT: class
composition colex2 in comb/composition-colex2.h]. One additional variable p0 records the position of
the first nonzero entry. The method to compute the successor is:
1
2
3

class composition_colex2
{
[--snip--]

196
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

ulong next()
{
ulong j = p0_; // position of first nonzero
if ( j==k_-1 )
ulong v = x_[j];
x_[j] = 0;
--v;
x_[0] = v;
++p0_;
if ( 0!=v )
++j;
++x_[j];
return

return k_;


// value of first nonzero
// set to zero

// first nonzero one more right except ...
p0_ = 0;
// ... if value v was not one

j;

}
};

About 270 million compositions are generated per second, independent of either n and k [FXT:
comb/composition-colex2-demo.cc]. With the line
#define COMP_COLEX2_MAX_ARRAY_LEN

128

just before the class definition an array is used instead of a pointer. The fixed array length limits the
value of k so by default the line is commented out. Using an array gives a significant speedup, the rate
is about 365 million per second (about 6 CPU cycles per update).

7.2

Co-lexicographic order for compositions into exactly k parts

The compositions of n into exactly k parts (where k ≥ n) can be obtained from the compositions of
n − k into at most k parts as shown in figure 7.2-A. The listing was created with the program [FXT:
comb/composition-ex-colex-demo.cc]. The compositions can be generated in co-lexicographic order using
[FXT: class composition ex colex in comb/composition-ex-colex.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class composition_ex_colex
{
public:
ulong n_, k_; // composition of n into exactly k parts
ulong *x_;
// data (k elements)
ulong nk1_;
// ==n-k+1
public:
composition_ex_colex(ulong n, ulong k)
// Must have n>=k
{
n_ = n;
k_ = k;
nk1_ = n - k + 1; // must be >= 1
if ( (long)nk1_ < 1 ) nk1_ = 1; // avoid hang with invalid pair n,k
x_ = new ulong[k_ + 1];
x_[k] = 0; // not one
first();
}
[--snip--]

The variable nk1_ is the maximal entry in the compositions:
1
2
3
4
5
6
7
8
9
10
11

void first()
{
x_[0] = nk1_; // all in first position
for (ulong k=1; k<k_; ++k) x_[k] = 1;
}
void last()
{
for (ulong k=0; k<k_; ++k) x_[k] = 1;
x_[k_-1] = nk1_; // all in last position
}

7.2: Co-lexicographic order for compositions into exactly k parts

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

exact comp. chg
[ 4 1 1 1 1 ] 4
[ 3 2 1 1 1 ] 1
[ 2 3 1 1 1 ] 1
[ 1 4 1 1 1 ] 1
[ 3 1 2 1 1 ] 2
[ 2 2 2 1 1 ] 1
[ 1 3 2 1 1 ] 1
[ 2 1 3 1 1 ] 2
[ 1 2 3 1 1 ] 1
[ 1 1 4 1 1 ] 2
[ 3 1 1 2 1 ] 3
[ 2 2 1 2 1 ] 1
[ 1 3 1 2 1 ] 1
[ 2 1 2 2 1 ] 2
[ 1 2 2 2 1 ] 1
[ 1 1 3 2 1 ] 2
[ 2 1 1 3 1 ] 3
[ 1 2 1 3 1 ] 1
[ 1 1 2 3 1 ] 2
[ 1 1 1 4 1 ] 3
[ 3 1 1 1 2 ] 4
[ 2 2 1 1 2 ] 1
[ 1 3 1 1 2 ] 1
[ 2 1 2 1 2 ] 2
[ 1 2 2 1 2 ] 1
[ 1 1 3 1 2 ] 2
[ 2 1 1 2 2 ] 3
[ 1 2 1 2 2 ] 1
[ 1 1 2 2 2 ] 2
[ 1 1 1 3 2 ] 3
[ 2 1 1 1 3 ] 4
[ 1 2 1 1 3 ] 1
[ 1 1 2 1 3 ] 2
[ 1 1 1 2 3 ] 3
[ 1 1 1 1 4 ] 4

197

composition
[ 3 . . . . ]
[ 2 1 . . . ]
[ 1 2 . . . ]
[ . 3 . . . ]
[ 2 . 1 . . ]
[ 1 1 1 . . ]
[ . 2 1 . . ]
[ 1 . 2 . . ]
[ . 1 2 . . ]
[ . . 3 . . ]
[ 2 . . 1 . ]
[ 1 1 . 1 . ]
[ . 2 . 1 . ]
[ 1 . 1 1 . ]
[ . 1 1 1 . ]
[ . . 2 1 . ]
[ 1 . . 2 . ]
[ . 1 . 2 . ]
[ . . 1 2 . ]
[ . . . 3 . ]
[ 2 . . . 1 ]
[ 1 1 . . 1 ]
[ . 2 . . 1 ]
[ 1 . 1 . 1 ]
[ . 1 1 . 1 ]
[ . . 2 . 1 ]
[ 1 . . 1 1 ]
[ . 1 . 1 1 ]
[ . . 1 1 1 ]
[ . . . 2 1 ]
[ 1 . . . 2 ]
[ . 1 . . 2 ]
[ . . 1 . 2 ]
[ . . . 1 2 ]
[ . . . . 3 ]

Figure 7.2-A: The compositions of n = 8 into exactly k = 5 parts (left) are obtained from the compositions of n − k = 3 into at most k = 5 parts (right). Co-lexicographic order. Dots denote zeros.
The methods for computing the successor and predecessor are adaptations from the routines from the
compositions into at most k parts:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

ulong next()
{
ulong j = 0;
while ( 1==x_[j] ) ++j; // find first greater than one
if ( j==k_ )

return k_;

ulong v = x_[j];
x_[j] = 1;
x_[0] = v - 1;
++j;
++x_[j];
return


// value of first greater one
// set to 1

j;

}
ulong prev()
{
const ulong v = x_[0];
// value at first position
if ( nk1_==v )

return k_; // current composition is first

x_[0] = 1;
ulong j = 1;
while ( 1==x_[j] )
--x_[j];

// set first position to 1
++j;

// find next greater than one
// decrement value

198
29
30
31
32
33

x_[j-1] = 1 + v;
return

// set previous position

j;

}
};

The routines are as fast as the generation into at most k parts with the corresponding parameters: the
compositions of 40 into 10 parts are generated at a rate of about 200 million per second.

7.3

Compositions and combinations
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

combination
[ 0 1 2 ]
[ 0 2 3 ]
[ 1 2 3 ]
[ 0 1 3 ]
[ 0 3 4 ]
[ 1 3 4 ]
[ 2 3 4 ]
[ 0 2 4 ]
[ 1 2 4 ]
[ 0 1 4 ]
[ 0 4 5 ]
[ 1 4 5 ]
[ 2 4 5 ]
[ 3 4 5 ]
[ 0 3 5 ]
[ 1 3 5 ]
[ 2 3 5 ]
[ 0 2 5 ]
[ 1 2 5 ]
[ 0 1 5 ]

delta set
111...
1.11..
.111..
11.1..
1..11.
.1.11.
..111.
1.1.1.
.11.1.
11..1.
1...11
.1..11
..1.11
...111
1..1.1
.1.1.1
..11.1
1.1..1
.11..1
11...1

composition
[ 3 . . . ]
[ 1 2 . . ]
[ . 3 . . ]
[ 2 1 . . ]
[ 1 . 2 . ]
[ . 1 2 . ]
[ . . 3 . ]
[ 1 1 1 . ]
[ . 2 1 . ]
[ 2 . 1 . ]
[ 1 . . 2 ]
[ . 1 . 2 ]
[ . . 1 2 ]
[ . . . 3 ]
[ 1 . 1 1 ]
[ . 1 1 1 ]
[ . . 2 1 ]
[ 1 1 . 1 ]
[ . 2 . 1 ]
[ 2 . . 1 ]

Figure 7.3-A: Combinations 6 choose 3 (left) and the corresponding compositions of 3 into 4 parts
(right). The sequence of combinations is a Gray code but the sequence of compositions is not.
Figure 7.3-A shows the correspondence between compositions and combinations. The listing was generated using the program [FXT: comb/comb2comp-demo.cc]. Entries in the left column are combinations
of 3 parts out of 6. The middle column is the representation of the combinations as delta sets. It also is
a binary representation of a composition: A run of r consecutive ones corresponds to an entry r in the
composition at the right.
N
Now write P (n, k) for the compositions of n into (at most) k parts and B(N, K) for the combination K :
A composition of n into at most k parts corresponds to a combination of K = n parts from N = n + k − 1
elements, symbolically:

P (n, k) ↔

B(N, K) = B(n + k − 1, n)

(7.3-1a)

A combination of K elements out of N corresponds to a composition of n into at most k parts where
n = K and k = N − K + 1:
B(N, K) ↔ P (n, k) = P (K, N − K + 1)

(7.3-1b)

We give routines for the conversion between combinations and compositions. The following routine
converts a composition into the corresponding combination [FXT: comb/comp2comb.h]:
1
2
3
4
5
6
7
8
9
10

inline void comp2comb(const ulong *p, ulong k, ulong *b)
// Convert composition P(*, k) in p[] to combination in b[]
{
for (ulong j=0,i=0,z=0; j<k; ++j)
{
ulong pj = p[j];
for (ulong w=0; w<pj; ++w)
b[i++] = z++;
++z;
}
}

7.4: Minimal-change orders

199

The conversion of a combination into the corresponding composition can be implemented as
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

inline void comb2comp(const ulong *b, ulong N, ulong K, ulong *p)
// Convert combination B(N, K) in b[] to composition P(*,k) in p[]
// Must have: K>0
{
ulong k = N-K+1;
for (ulong z=0; z<k; ++z) p[z] = 0;
--k;
ulong c1 = N;
while ( K-- )
{
ulong c0 = b[K];
ulong d = c1 - c0;
k -= (d-1);
++p[k];
c1 = c0;
}
}

7.4
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

Minimal-change orders
composition
[ . . . 3 . ]
[ . 1 . 2 . ]
[ 1 . . 2 . ]
[ . . 1 2 . ]
[ . . 2 1 . ]
[ . 1 1 1 . ]
[ 1 . 1 1 . ]
[ 2 . . 1 . ]
[ 1 1 . 1 . ]
[ . 2 . 1 . ]
[ . 3 . . . ]
[ 1 2 . . . ]
[ 2 1 . . . ]
[ 3 . . . . ]
[ 2 . 1 . . ]
[ 1 1 1 . . ]
[ . 2 1 . . ]
[ . 1 2 . . ]
[ 1 . 2 . . ]
[ . . 3 . . ]
[ . . 2 . 1 ]
[ . 1 1 . 1 ]
[ 1 . 1 . 1 ]
[ 2 . . . 1 ]
[ 1 1 . . 1 ]
[ . 2 . . 1 ]
[ . 1 . 1 1 ]
[ 1 . . 1 1 ]
[ . . 1 1 1 ]
[ . . . 2 1 ]
[ . . . 1 2 ]
[ . 1 . . 2 ]
[ 1 . . . 2 ]
[ . . 1 . 2 ]
[ . . . . 3 ]

combination
...111. [ 3 4
.1..11. [ 1 4
1...11. [ 0 4
..1.11. [ 2 4
..11.1. [ 2 3
.1.1.1. [ 1 3
1..1.1. [ 0 3
11...1. [ 0 1
1.1..1. [ 0 2
.11..1. [ 1 2
.111... [ 1 2
1.11... [ 0 2
11.1... [ 0 1
111.... [ 0 1
11..1.. [ 0 1
1.1.1.. [ 0 2
.11.1.. [ 1 2
.1.11.. [ 1 3
1..11.. [ 0 3
..111.. [ 2 3
..11..1 [ 2 3
.1.1..1 [ 1 3
1..1..1 [ 0 3
11....1 [ 0 1
1.1...1 [ 0 2
.11...1 [ 1 2
.1..1.1 [ 1 4
1...1.1 [ 0 4
..1.1.1 [ 2 4
...11.1 [ 3 4
...1.11 [ 3 5
.1...11 [ 1 5
1....11 [ 0 5
..1..11 [ 2 5
....111 [ 4 5

5
5
5
5
5
5
5
5
5
5
3
3
3
2
4
4
4
4
4
4
6
6
6
6
6
6
6
6
6
6
6
6
6
6
6

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

composition
[ 3 . . . .
[ 2 1 . . .
[ 1 2 . . .
[ . 3 . . .
[ . 2 1 . .
[ 1 1 1 . .
[ 2 . 1 . .
[ 1 . 2 . .
[ . 1 2 . .
[ . . 3 . .
[ . . 2 1 .
[ 1 . 1 1 .
[ . 1 1 1 .
[ . 2 . 1 .
[ 1 1 . 1 .
[ 2 . . 1 .
[ 1 . . 2 .
[ . 1 . 2 .
[ . . 1 2 .
[ . . . 3 .
[ . . . 2 1
[ 1 . . 1 1
[ . 1 . 1 1
[ . . 1 1 1
[ . . 2 . 1
[ 1 . 1 . 1
[ . 1 1 . 1
[ . 2 . . 1
[ 1 1 . . 1
[ 2 . . . 1
[ 1 . . . 2
[ . 1 . . 2
[ . . 1 . 2
[ . . . 1 2
[ . . . . 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

combination
111.... [ 0 1
11.1... [ 0 1
1.11... [ 0 2
.111... [ 1 2
.11.1.. [ 1 2
1.1.1.. [ 0 2
11..1.. [ 0 1
1..11.. [ 0 3
.1.11.. [ 1 3
..111.. [ 2 3
..11.1. [ 2 3
1..1.1. [ 0 3
.1.1.1. [ 1 3
.11..1. [ 1 2
1.1..1. [ 0 2
11...1. [ 0 1
1...11. [ 0 4
.1..11. [ 1 4
..1.11. [ 2 4
...111. [ 3 4
...11.1 [ 3 4
1...1.1 [ 0 4
.1..1.1 [ 1 4
..1.1.1 [ 2 4
..11..1 [ 2 3
1..1..1 [ 0 3
.1.1..1 [ 1 3
.11...1 [ 1 2
1.1...1 [ 0 2
11....1 [ 0 1
1....11 [ 0 5
.1...11 [ 1 5
..1..11 [ 2 5
...1.11 [ 3 5
....111 [ 4 5

2
3
3
3
4
4
4
4
4
4
5
5
5
5
5
5
5
5
5
5
6
6
6
6
6
6
6
6
6
6
6
6
6
6
6

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 7.4-A: Compositions of 3 into 5 parts and the corresponding combinations as delta sets and sets
in two minimal-change orders: order with enup moves (left) and order with modulo moves (right). The
ordering by enup moves is a two-close Gray code. Dots denote zeros.
A minimal-change order (Gray code) for compositions is such that with each transition one entry is
increased by 1 and another is decreased by 1. A recursion for the compositions P (n, k) of n into k parts

200

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:


[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
4

combination
5 6 ] 1....11
4 6 ] 1...1.1
4 5 ] 1...11.
3 4 ] 1..11..
3 5 ] 1..1.1.
3 6 ] 1..1..1
2 6 ] 1.1...1
2 5 ] 1.1..1.
2 4 ] 1.1.1..
2 3 ] 1.11...
1 2 ] 111....
1 3 ] 11.1...
1 4 ] 11..1..
1 5 ] 11...1.
1 6 ] 11....1
2 6 ] .11...1
2 5 ] .11..1.
2 4 ] .11.1..
2 3 ] .111...
3 4 ] .1.11..
3 5 ] .1.1.1.
3 6 ] .1.1..1
4 6 ] .1..1.1
4 5 ] .1..11.
5 6 ] .1...11
5 6 ] ..1..11
4 6 ] ..1.1.1
4 5 ] ..1.11.
3 4 ] ..111..
3 5 ] ..11.1.
3 6 ] ..11..1
4 6 ] ...11.1
4 5 ] ...111.
5 6 ] ...1.11
5 6 ] ....111

composition
[ 1 . . . 2 ]
[ 1 . . 1 1 ]
[ 1 . . 2 . ]
[ 1 . 2 . . ]
[ 1 . 1 1 . ]
[ 1 . 1 . 1 ]
[ 1 1 . . 1 ]
[ 1 1 . 1 . ]
[ 1 1 1 . . ]
[ 1 2 . . . ]
[ 3 . . . . ]
[ 2 1 . . . ]
[ 2 . 1 . . ]
[ 2 . . 1 . ]
[ 2 . . . 1 ]
[ . 2 . . 1 ]
[ . 2 . 1 . ]
[ . 2 1 . . ]
[ . 3 . . . ]
[ . 1 2 . . ]
[ . 1 1 1 . ]
[ . 1 1 . 1 ]
[ . 1 . 1 1 ]
[ . 1 . 2 . ]
[ . 1 . . 2 ]
[ . . 1 . 2 ]
[ . . 1 1 1 ]
[ . . 1 2 . ]
[ . . 3 . . ]
[ . . 2 1 . ]
[ . . 2 . 1 ]
[ . . . 2 1 ]
[ . . . 3 . ]
[ . . . 1 2 ]
[ . . . . 3 ]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
4

combination
1 2 ] 111....
1 3 ] 11.1...
1 4 ] 11..1..
1 5 ] 11...1.
1 6 ] 11....1
2 6 ] 1.1...1
2 5 ] 1.1..1.
2 4 ] 1.1.1..
2 3 ] 1.11...
3 4 ] 1..11..
3 5 ] 1..1.1.
3 6 ] 1..1..1
4 6 ] 1...1.1
4 5 ] 1...11.
5 6 ] 1....11
5 6 ] .1...11
4 6 ] .1..1.1
4 5 ] .1..11.
3 4 ] .1.11..
3 5 ] .1.1.1.
3 6 ] .1.1..1
2 6 ] .11...1
2 5 ] .11..1.
2 4 ] .11.1..
2 3 ] .111...
3 4 ] ..111..
3 5 ] ..11.1.
3 6 ] ..11..1
4 6 ] ..1.1.1
4 5 ] ..1.11.
5 6 ] ..1..11
5 6 ] ...1.11
4 6 ] ...11.1
4 5 ] ...111.
5 6 ] ....111

composition
[ 3 . . . . ]
[ 2 1 . . . ]
[ 2 . 1 . . ]
[ 2 . . 1 . ]
[ 2 . . . 1 ]
[ 1 1 . . 1 ]
[ 1 1 . 1 . ]
[ 1 1 1 . . ]
[ 1 2 . . . ]
[ 1 . 2 . . ]
[ 1 . 1 1 . ]
[ 1 . 1 . 1 ]
[ 1 . . 1 1 ]
[ 1 . . 2 . ]
[ 1 . . . 2 ]
[ . 1 . . 2 ]
[ . 1 . 1 1 ]
[ . 1 . 2 . ]
[ . 1 2 . . ]
[ . 1 1 1 . ]
[ . 1 1 . 1 ]
[ . 2 . . 1 ]
[ . 2 . 1 . ]
[ . 2 1 . . ]
[ . 3 . . . ]
[ . . 3 . . ]
[ . . 2 1 . ]
[ . . 2 . 1 ]
[ . . 1 1 1 ]
[ . . 1 2 . ]
[ . . 1 . 2 ]
[ . . . 1 2 ]
[ . . . 2 1 ]
[ . . . 3 . ]
[ . . . . 3 ]

Figure 7.4-B: The (reversed) complemented enup ordering (left) and Eades-McKay sequence (right) for
combinations correspond to compositions where only two adjacent entries change with each transition,
but by more than 1 in general.
in lexicographic order is (notation as in relation 14.1-1 on page 304)

P (n, k)

=

[0 . P (n − 0, k − 1)]
[1 . P (n − 1, k − 1)]
[2 . P (n − 2, k − 1)]
[3 . P (n − 3, k − 1)]
[4 . P (n − 4, k − 1)]
.
.
[
.
]
[n . P (0, k − 1)

(7.4-1)

]

A Gray code is obtained by changing the direction if the element is even:

P (n, k)

=

[0 . P R (n − 0, k − 1)]
[1 . P (n − 1, k − 1) ]
[2 . P R (n − 2, k − 1)]
[3 . P (n − 3, k − 1) ]
[4 . P R (n − 4, k − 1)]
.
.
.
]
[

(7.4-2)

The ordering is shown in ﬁgure 7.4-A (left), the corresponding combinations are in the (reversed) enup

7.4: Minimal-change orders

201

order from section 6.6.2 on page 188. Now we change directions at the odd elements:

P (n, k)

=

[0 . P (n − 0, k − 1) ]
[1 . P R (n − 1, k − 1)]
[2 . P (n − 2, k − 1) ]
[3 . P R (n − 3, k − 1)]
[4 . P (n − 4, k − 1) ]
.
.
[
.
]

(7.4-3)

We get an ordering (right of figure 7.4-A) corresponding to the combinations are in the (reversed)
Eades-McKay order from section 6.5 on page 183. The listings were created with the program [FXT:
comb/composition-gray-rec-demo.cc].
Gray codes for combinations correspond to Gray codes for combinations where no element in the delta
set crosses another. The standard Gray code for combinations does not lead to a Gray code for compositions as shown in figure 7.3-A on page 198. If the directions in the recursions are always changed, the
compositions correspond to combinations that have the complemented delta sets of the standard Gray
code in reversed order.
Orderings where the changes involve just one pair of adjacent entries (shown in figure 7.4-B) correspond to
the complemented strong Gray codes for combinations. The amount of change is greater than 1 in general.
The listings were created with the program [FXT: comb/combination-rec-demo.cc], see section 6.7 on page
191.

202

Chapter 8: Subsets

Chapter 8

Subsets
We give algorithms to generate all subsets of a set of n elements. There are 2n subsets, including the
empty set. We further give methods to generate all subsets with k elements where k lies in a given range:
kmin ≤ k ≤ kmax . The subsets with exactly k elements are treated in chapter 6 on page 176.

8.1

Lexicographic order
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

1....
11...
111..
1111.
11111
111.1
11.1.
11.11
11..1
1.1..
1.11.
1.111
1.1.1
1..1.
1..11
1...1
.1...
.11..
.111.
.1111
.11.1
.1.1.
.1.11
.1..1
..1..
..11.
..111
..1.1
...1.
...11
....1

{0}
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{0,
{1}
{1,
{1,
{1,
{1,
{1,
{1,
{1,
{2}
{2,
{2,
{2,
{3}
{3,
{4}

1}
1,
1,
1,
1,
1,
1,
1,
2}
2,
2,
2,
3}
3,
4}
2}
2,
2,
2,
3}
3,
4}

2}
2,
2,
2,
3}
3,
4}

3}
3, 4}
4}
4}

3}
3, 4}
4}
4}

3}
3, 4}
4}
4}

3}
3, 4}
4}
4}

1....
.1...
11...
..1..
1.1..
.11..
111..
...1.
1..1.
.1.1.
11.1.
..11.
1.11.
.111.
1111.
....1
1...1
.1..1
11..1
..1.1
1.1.1
.11.1
111.1
...11
1..11
.1.11
11.11
..111
1.111
.1111
11111

{0}
{1}
{0,
{2}
{0,
{1,
{0,
{3}
{0,
{1,
{0,
{2,
{0,
{1,
{0,
{4}
{0,
{1,
{0,
{2,
{0,
{1,
{0,
{3,
{0,
{1,
{0,
{2,
{0,
{1,
{0,

1}
2}
2}
1, 2}
3}
3}
1,
3}
2,
2,
1,
4}
4}
1,
4}
2,
2,
1,
4}
3,
3,
1,
3,
2,
2,
1,

3}
3}
3}
2, 3}

4}
4}
4}
2, 4}
4}
4}
3,
4}
3,
3,
2,

4}
4}
4}
3, 4}

Figure 8.1-A: Nonempty subsets of a 5-element set in lexicographic order for the sets (left) and in
lexicographic order for the delta sets (right).
The (nonempty) subsets of a set of five elements in lexicographic order are shown in figure 8.1-A. Note
that the lexicographic order with sets is different from the lexicographic order with delta sets.

8.1.1

Generation as delta sets

The listing on the right side of figure 8.1-A is with respect to the delta sets. It was created with the
program [FXT: comb/subset-deltalex-demo.cc] which uses the generator [FXT: class subset deltalex

8.1: Lexicographic order

203

in comb/subset-deltalex.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class subset_deltalex
{
public:
ulong *d_; // subset as delta set
ulong n_;
// subsets of the n-set {0,1,2,...,n-1}
public:
subset_deltalex(ulong n)
{
n_ = n;
d_ = new ulong[n+1];
d_[n] = 0; // sentinel
first();
}
~subset_deltalex()
void first()

{ delete [] d_; }

{ for (ulong k=0; k<n_; ++k)

d_[k] = 0; }

The algorithm for the computation of the successor is binary counting:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

bool next()
{
ulong k = 0;
while ( d_[k]==1 )
if ( k==n_ )

{ d_[k]=0;

return false;

++k; }

// current subset is last

d_[k] = 1;
return true;
}
const ulong * data()

const { return d_; }

};

About 176 million subsets per second are generated and 192 M/s if an array is used. A bit-level algorithm
to compute the subsets in lexicographic order is given in section 1.26 on page 70.

8.1.2

Generation as sets

The lexicographic order with respect to the set representation is shown at the left side of ﬁgure 8.1-A.
The routines in [FXT: class subset lex in comb/subset-lex.h] compute the nonempty sets:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class subset_lex
{
public:
ulong *x_; // subset of {0,1,2,...,n-1}
ulong n_;
// number of elements in set
ulong k_;
// index of last element in subset
// Number of elements in subset == k+1
public:
subset_lex(ulong n)
{
n_ = n;
x_ = new ulong[n_];
first();
}
~subset_lex()

{ delete [] x_; }

ulong first()
{
k_ = 0;
x_[0] = 0;
return k_ + 1;
}
ulong last()
{
k_ = 0;
x_[0] = n_ - 1;
return k_ + 1;
}

204
32

Chapter 8: Subsets
[--snip--]

The method next() computes the successor:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

ulong next()
// Generate next subset
// Return number of elements in subset
// Return zero if current == last
{
if ( x_[k_] == n_-1 ) // last element is max ?
{
if ( k_==0 ) { first(); return 0; }
--k_;
x_[k_]++;

// remove last element
// increase last element

}
else // add next element from set:
{
++k_;
x_[k_] = x_[k_-1] + 1;
}
return

k_ + 1;

}

Computation of the predecessor:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

ulong prev()
// Generate previous subset
// Return number of elements in subset
// Return zero if current == first
{
if ( k_ == 0 ) // only one element ?
{
if ( x_[0]==0 ) { last(); return 0; }
x_[0]--; // decr first element
x_[++k_] = n_ - 1;
// add element
}
else
{
if ( x_[k_] == x_[k_-1]+1 ) --k_; // remove last element
else
{
x_[k_]--; // decr last element
x_[++k_] = n_ - 1;
// add element
}
}
return

k_ + 1;

}

const { return x_; }

};

About 270 million subsets per second are generated with next() and about 155 million with prev()
[FXT: comb/subset-lex-demo.cc]. A generalization of this order with mixed radix numbers is described
in section 9.3 on page 224. A bit-level algorithm is given in section 1.26 on page 70.

8.2


8.2.1

Generation as delta sets

The subsets of a set with 5 elements in minimal-change order are shown in ﬁgure 8.2-A. The implementation [FXT: class subset gray delta in comb/subset-gray-delta.h] uses the Gray code of binary words
and updates the position corresponding to the bit that changes in the Gray code:
1
2
3
4
5
6
7

class subset_gray_delta
// Subsets of the set {0,1,2,...,n-1} in minimal-change (Gray code) order.
{
public:
ulong *x_; // current subset as delta-set
ulong n_;
// number of elements in set <= BITS_PER_LONG
ulong j_;
// position of last change

8.2: Minimal-change order
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

.....
1....
11...
.1...
.11..
111..
1.1..
..1..
..11.
1.11.
1111.
.111.
.1.1.
11.1.
1..1.
...1.
...11
1..11
11.11
.1.11
.1111
11111
1.111
..111
..1.1
1.1.1
111.1
.11.1
.1..1
11..1
1...1
....1

{}
{0}
{0,
{1}
{1,
{0,
{0,
{2}
{2,
{0,
{0,
{1,
{1,
{0,
{0,
{3}
{3,
{0,
{0,
{1,
{1,
{0,
{0,
{2,
{2,
{0,
{0,
{1,
{1,
{0,
{0,
{4}

205
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

1}
2}
1, 2}
2}
3}
2,
1,
2,
3}
1,
3}
4}
3,
1,
3,
2,
1,
2,
3,
4}
2,
1,
2,
4}
1,
4}

3}
2, 3}
3}
3}

4}
3,
4}
3,
2,
3,
4}

4}
4}
3, 4}
4}

4}
2, 4}
4}
4}

11111
.1111
..111
1.111
1..11
...11
.1.11
11.11
11..1
.1..1
....1
1...1
1.1.1
..1.1
.11.1
111.1
111..
.11..
..1..
1.1..
1....
.....
.1...
11...
11.1.
.1.1.
...1.
1..1.
1.11.
..11.
.111.
1111.

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

0, 1, 2, 3, 4 }
1, 2, 3, 4 }
2, 3, 4 }
0, 2, 3, 4 }
0, 3, 4 }
3, 4 }
1, 3, 4 }
0, 1, 3, 4 }
0, 1, 4 }
1, 4 }
4 }
0, 4 }
0, 2, 4 }
2, 4 }
1, 2, 4 }
0, 1, 2, 4 }
0, 1, 2 }
1, 2 }
2 }
0, 2 }
0 }
}
1 }
0, 1 }
0, 1, 3 }
1, 3 }
3 }
0, 3 }
0, 2, 3 }
2, 3 }
1, 2, 3 }
0, 1, 2, 3 }

Figure 8.2-A: The subsets of the set {0, 1, 2, 3, 4} in minimal-change order (left) and complemented
minimal-change order (right). The changes are on the same places for both orders.
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ulong ct_; // gray_code(ct_) corresponds to the current subset
ulong mct_; // max value of ct.
public:
subset_gray_delta(ulong n)
{
n_ = (n ? n : 1); // not zero
x_ = new ulong[n_];
mct_ = (1UL<<n) - 1;
first(0);
}
~subset_gray_delta()

{ delete [] x_; }

In the initializer one can choose whether the ﬁrst set is the empty or the full set (left and right of
ﬁgure 8.2-A):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void first(ulong v=0)
{
ct_ = 0;
j_ = n_ - 1;
}

x_[j] = v;

const ulong * data() const { return x_; }
ulong pos() const { return j_; }
ulong current() const { return ct_; }
ulong next()
// Return position of change, return n with last subset
{
if ( ct_ == mct_ ) { return n_; }

206
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

Chapter 8: Subsets
++ct_;
j_ = lowest_one_idx( ct_ );
x_[j_] ^= 1;
return

j_;

}
ulong prev()
// Return position of change, return n with first subset
{
if ( ct_ == 0 ) { return n_; }
j_ = lowest_one_idx( ct_ );
x_[j_] ^= 1;
--ct_;
return

j_;

}
};

About 180 million subsets are generated per second [FXT: comb/subset-gray-delta-demo.cc].

8.2.2

Generation as sets

A generator for the subsets of {1, 2, . . . , n} in set representation is [FXT: class subset gray in
comb/subset-gray.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class subset_gray
// Subsets of the set {1,2,...,n} in minimal-change (Gray code) order.
{
public:
ulong *x_; // data k-subset of {1,2,...,n} in x[1,...,k]
ulong n_;
// subsets of n-set
ulong k_;
// number of elements in subset
public:
subset_gray(ulong n)
{
n_ = n;
x_ = new ulong[n_+1];
x_[0] = 0;
first();
}
~subset_gray()

{ delete [] x_; }

ulong first() { k_ = 0; return k_; }
ulong last() { x_[1] = 1; k_ = 1; return k_; }
const ulong * data() const { return x_+1; }
const ulong num() const { return k_; }

The algorithm to compute the successor is described in section 1.16.3 on page 43, see also [192]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

private:
ulong next_even()
{
if ( x_[k_]==n_ ) // remove n (from end):
{
--k_;
}
else // append n:
{
++k_;
x_[k_] = n_;
}
return k_;
}
ulong next_odd()
{
if ( x_[k_]-1==x_[k_-1] ) // remove x[k]-1 (from position k-1):
{
x_[k_-1] = x_[k_];
--k_;

8.3: Ordering with De Bruijn sequences
22
23
24
25
26
27
28
29
30
31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

207

}
else // insert x[k]-1 as second last element:
{
x_[k_+1] = x_[k_];
--x_[k_];
++k_;
}
return k_;
}
public:
ulong next()
{
if ( 0==(k_&1 ) ) return next_even();
else
return next_odd();
}
ulong prev()
{
if ( 0==(k_&1 ) ) // k even
{
if ( 0==k_ ) return last();
return next_odd();
}
else return next_even();
}
};

About 241 million subsets per second are generated with next() and about 167 M/s with prev() [FXT:
comb/subset-gray-demo.cc]. With arrays instead of pointers the rates are about 266 M/s and 179 M/s.

8.2.3

Computing just the positions of change

The following routine computes only the locations of the changes, it is given in [52]. It can also be
obtained as a specialization (for radix 2) of the loopless algorithm for computing a Gray code ordering
of mixed radix numbers given section 9.2 on page 220 [FXT: class ruler func in comb/ruler-func.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class ruler_func
// Ruler function sequence: 0 1 0 2 0 1 0 3 0 1 0 2 0 1 0 4 0 1 0 2 0 1 ...
{
public:
ulong *f_; // focus pointer
ulong n_;
public:
ruler_func(ulong n)
{
n_ = n;
f_ = new ulong[n+2];
first();
}
~ruler_func()
void first()

{ delete [] f_; }
{ for (ulong k=0; k<n_+2; ++k)

ulong next()
{
const ulong j = f_[0];
// if ( j==n_ ) { first(); return n_; }
f_[0] = 0;
const ulong nj = j+1;
f_[j] = f_[nj];
f_[nj] = nj;
return j;
}

f_[k] = k; }

// leave to user

};

The rate of generation is about 244 M/s and 293 M/s if an array is used [FXT: comb/ruler-func-demo.cc].

208

Chapter 8: Subsets

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

{0,
{ ,
{ ,
{ ,
{0,
{0,
{ ,
{ ,
{0,
{ ,
{0,
{ ,
{ ,
{0,
{0,
{0,
{ ,
{0,
{ ,
{0,
{0,
{ ,
{0,
{0,
{0,
{0,
{0,
{ ,
{ ,
{ ,
{ ,
{ ,

,
1,
,
,
,
1,
1,
,
,
1,
,
1,
,
,
1,
1,
1,
,
1,
,
1,
1,
,
1,
1,
1,
1,
1,
,
,
,
,

,
,
2,
,
,
,
2,
2,
,
,
2,
,
2,
,
,
2,
2,
2,
,
2,
,
2,
2,
,
2,
2,
2,
2,
2,
,
,
,

,
,
,
3,
,
,
,
3,
3,
,
,
3,
,
3,
,
,
3,
3,
3,
,
3,
,
3,
3,
,
3,
3,
3,
3,
3,
,
,

}
}
}
}
4}
}
}
}
4}
4}
}
}
4}
}
4}
}
}
4}
4}
4}
}
4}
}
4}
4}
}
4}
4}
4}
4}
4}
}

#=1
#=1
#=1
#=1
#=2
#=2
#=2
#=2
#=3
#=2
#=2
#=2
#=2
#=2
#=3
#=3
#=3
#=4
#=3
#=3
#=3
#=3
#=3
#=4
#=4
#=4
#=5
#=4
#=3
#=2
#=1
#=0

{0}
{1}
{2}
{3}
{0,
{0,
{1,
{2,
{0,
{1,
{0,
{1,
{2,
{0,
{0,
{0,
{1,
{0,
{1,
{0,
{0,
{1,
{0,
{0,
{0,
{0,
{0,
{1,
{2,
{3,
{4}
{}

4}
1}
2}
3}
3,
4}
2}
3}
4}
3}
1,
1,
2,
2,
3,
2,
1,
2,
2,
1,
1,
1,
1,
2,
3,
4}

4}

4}
2}
3}
3,
4}
4}
3}
4}
3}
3,
2,
2,
2,
3,
4}

4}

4}
4}
3}
3, 4}
4}

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

{ ,
{0,
{0,
{0,
{ ,
{ ,
{0,
{0,
{ ,
{0,
{ ,
{0,
{0,
{ ,
{ ,
{ ,
{0,
{ ,
{0,
{ ,
{ ,
{0,
{ ,
{ ,
{ ,
{ ,
{ ,
{0,
{0,
{0,
{0,
{0,

,
1,
,
,
,
1,
1,
,
,
1,
,
1,
,
,
1,
1,
1,
,
1,
,
1,
1,
,
1,
1,
1,
1,
1,
,
,
,
,

2,
2,
,
2,
2,
2,
,
,
2,
2,
,
2,
,
2,
2,
,
,
,
2,
,
2,
,
,
2,
,
,
,
,
,
2,
2,
2,

,
,
,
3,
,
,
,
3,
3,
,
,
3,
,
3,
,
,
3,
3,
3,
,
3,
,
3,
3,
,
3,
3,
3,
3,
3,
,
,

4}
4}
4}
4}
}
4}
4}
4}
}
}
4}
4}
}
4}
}
4}
4}
}
}
}
4}
}
4}
}
}
4}
}
}
}
}
}
4}

#=2
#=4
#=2
#=4
#=1
#=3
#=3
#=3
#=2
#=3
#=1
#=5
#=1
#=3
#=2
#=2
#=4
#=1
#=4
#=0
#=4
#=2
#=2
#=3
#=1
#=3
#=2
#=3
#=2
#=3
#=2
#=3

{2,
{0,
{0,
{0,
{2}
{1,
{0,
{0,
{2,
{0,
{4}
{0,
{0}
{2,
{1,
{1,
{0,
{3}
{0,
{}
{1,
{0,
{3,
{1,
{1}
{1,
{1,
{0,
{0,
{0,
{0,
{0,

4}
1, 2, 4}
4}
2, 3, 4}
2,
1,
3,
3}
1,

4}
4}
4}
2}

1, 2, 3, 4}
3, 4}
2}
4}
1, 3, 4}
1, 2, 3}
2, 3, 4}
1}
4}
2, 3}
3,
3}
1,
3}
2,
2}
2,

4}
3}
3}
4}

Figure 8.3-A: Subsets of a 5-element set in an order corresponding to a De Bruijn sequence (left), and
alternative ordering obtained by complementing the elements at even indices (right).

8.3

Ordering with De Bruijn sequences

A curious ordering for all subsets of a given set can be generated using a binary De Bruijn sequence that
is a cyclic sequence of zeros and ones that contains each n-bit word once. In figure 8.3-A the empty places
of the subsets are included to make the nice feature apparent [FXT: comb/subset-debruijn-demo.cc]. The
ordering has the single track property: each column in this (delta set) representation is a circular shift
of the first column. Each subset is made from its predecessor by shifting it to the right and inserting the
current element from the sequence. The underlying De Bruijn sequence is
1 0 0 0 1 1 0 0 1 0 1 0 0 1 1 1 0 1 0 1 1 0 1 1 1 1 1 0 0 0 0 0

The implementation [FXT: class subset debruijn in comb/subset-debruijn.h] uses [FXT: class
binary debruijn in comb/binary-debruijn.h], described in section 18.2 on page 377.
Successive subsets differ in many elements if the sequency (see section 1.17 on page 46) is large. Using the
‘sequency-complemented’ subsets (see end of section 1.17), we obtain an ordering where more elements
change with small sequencies, as shown at the right of figure 8.3-A. This ordering corresponds to the
complement-shift sequence of section 20.2.3 on page 397.

8.4

Shifts-order for subsets

Figure 8.4-A shows an ordering (shifts-order ) of the nonempty subsets of a 6-bit binary word where
all linear shifts of a word appear in succession. The generation is done by a simple recursion [FXT:
comb/shift-subsets-demo.cc]:
1
2
3
4
5
6

ulong n;
ulong N;

// number of bits
// 2**n

void A(ulong x)
{
if ( x>=N )

return;

8.4: Shifts-order for subsets
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

.....1
....1.
...1..
..1...
.1....
1.....
1....1
.1...1
1...1.
1...11
..1..1
.1..1.
1..1..
1..1.1
.1..11
1..11.

1
1
1
1
1
1
2
2
2
3
2
2
2
3
3
3

209

17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

1..111
...1.1
..1.1.
.1.1..
1.1...
1.1..1
.1.1.1
1.1.1.
1.1.11
..1.11
.1.11.
1.11..
1.11.1
.1.111
1.111.
1.1111

4
2
2
2
2
3
3
3
4
3
3
3
4
4
4
5

33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:

....11
...11.
..11..
.11...
11....
11...1
.11..1
11..1.
11..11
..11.1
.11.1.
11.1..
11.1.1
.11.11
11.11.
11.111

2
2
2
2
2
3
3
3
4
3
3
3
4
4
4
5

49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

...111
..111.
.111..
111...
111..1
.111.1
111.1.
111.11
..1111
.1111.
1111..
1111.1
.11111
11111.
111111

3
3
3
3
4
4
4
5
4
4
4
5
5
5
6

Figure 8.4-A: Nonempty subsets of a 6-bit binary word where all linear shifts of a word appear in
succession (shifts-order). All shifts are left shifts.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

.....1
....1.
...1..
..1...
.1....
1.....
1....1
1...11
1...1.
.1...1
.1..11
1..11.
1..111
1..1.1
1..1..
.1..1.

1
1
1
1
1
1
2
3
2
2
3
3
4
3
2
2

17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

..1..1
..1.11
.1.11.
1.11..
1.11.1
1.1111
1.111.
.1.111
.1.1.1
1.1.1.
1.1.11
1.1..1
1.1...
.1.1..
..1.1.
...1.1

2
3
3
3
4
5
4
4
3
3
4
3
2
2
2
2

33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:

...111
..111.
.111..
111...
111..1
111.11
111.1.
.111.1
.11111
11111.
111111
1111.1
1111..
.1111.
..1111
..11.1

3
3
3
3
4
5
4
4
5
5
6
5
4
4
4
3

49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

.11.1.
11.1..
11.1.1
11.111
11.11.
.11.11
.11..1
11..1.
11..11
11...1
11....
.11...
..11..
...11.
....11

3
3
4
5
4
4
3
3
4
3
2
2
2
2
2

Figure 8.4-B: Nonempty subsets of a 6-bit binary word where all linear shifts of a word appear in
succession and transitions that are not shifts switch just one bit (minimal-change shifts-order).
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

.......1
......1.
.....1..
....1...
...1....
..1.....
.1......
1.......
1......1
.1.....1
1.....1.
..1....1
.1....1.
1....1..
1....1.1
...1...1

1
1
1
1
1
1
1
1
2
2
2
2
2
2
3
2

17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

..1...1.
.1...1..
1...1...
1...1..1
.1...1.1
1...1.1.
....1..1
...1..1.
..1..1..
.1..1...
1..1....
1..1...1
.1..1..1
1..1..1.
..1..1.1
.1..1.1.

2
2
2
3
3
3
2
2
2
2
2
3
3
3
3
3

33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:

1..1.1..
1..1.1.1
.....1.1
....1.1.
...1.1..
..1.1...
.1.1....
1.1.....
1.1....1
.1.1...1
1.1...1.
..1.1..1
.1.1..1.
1.1..1..
1.1..1.1
...1.1.1

3
4
2
2
2
2
2
2
3
3
3
3
3
3
4
3

49:
50:
51:
52:
53:
54:

..1.1.1.
.1.1.1..
1.1.1...
1.1.1..1
.1.1.1.1
1.1.1.1.

3
3
3
4
4
4

Figure 8.4-C: Nonzero Fibonacci words in an order where all shifts appear in succession.
7
8
9
10

visit(x);
A(2*x);
A(2*x+1);
}

The function visit() prints the binary expansion of its argument. The initial call is A(1).
The transitions that are not shifts change just one bit if the following pair of functions is used for the
recursion (minimal-change shifts-order shown in ﬁgure 8.4-B):
1
2
3
4
5
6

void F(ulong x)
{
if ( x>=N )
visit(x);
F(2*x);
G(2*x+1);

return;

210
7
8
9
10
11
12
13
14
15

Chapter 8: Subsets

}
void G(ulong x)
{
if ( x>=N )
F(2*x+1);
G(2*x);
visit(x);
}

return;

The initial call is F(1), the reversed order can be generated via G(1).
A simple variation can be used to generate the Fibonacci words in a shifts-order shown in figure 8.4-C.
With transitions that are not shifts more than one bit is changed in general. The function used is [FXT:
comb/shift-subsets-demo.cc]:
1
2
3
4
5
6
7

void B(ulong x)
{
if ( x>=N )
visit(x);
B(2*x);
B(4*x+1);
}

return;

A bit-level algorithm for combinations in shifts-order is given in section 1.24.3 on page 64.

8.5

k-subsets where k lies in a given range

We give algorithms for generating all k-subsets of the n-set where k lies in the range kmin ≤ k ≤ kmax .
If kmin = 0 and kmax = n, we generate all subsets. If kmin = kmax = k, we get the k-combinations of n.

8.5.1

Recursive algorithm

A generator for all k-subsets where k lies in a prescribed range is [FXT: class ksubset rec in
comb/ksubset-rec.h]. The used algorithm can generate the subsets in 16 different orders. Figure 8.5A shows the lexicographic orders, figure 8.5-B shows three Gray codes. The constructor has just one
argument, the number of elements of the set whose subsets are generated:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class ksubset_rec
// k-subsets where kmin<=k<=kmax in various orders.
// Recursive CAT algorithm.
{
public:
long n_; // subsets of a n-element set
long kmin_, kmax_; // k-subsets where kmin<=k<=kma
long *rv_; // record of visits in graph (list of elements in subset)
ulong ct_;
// count subsets
ulong rct_; // count recursions (==work)
ulong rq_;
// condition that determines the order
ulong pq_;
// condition that determines the (printing) order
ulong nq_;
// whether to reverse order
// function to call with each combination:
void (*visit_)(const ksubset_rec &, long);
public:
ksubset_rec(ulong n)
{
n_ = n;
rv_ = new long[n_+1];
++rv_;
rv_[-1] = -1UL;
}
~ksubset_rec()
{
--rv_;
delete [] rv_;
}

One has to supply the interval for k (variables kmin and kmax) and a function that will be called with
each subset. The argument rq determines which of the sixteen different orderings is chosen, the order

8.5: k-subsets where k lies in a given range

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

order #0:
11....
......
111...
..P...
11.1..
..MP..
11..1.
...MP.
11...1
....MP
1.1...
.MP..M
1.11..
...P..
1.1.1.
...MP.
1.1..1
....MP
1..1..
..MP.M
1..11.
....P.
1..1.1
....MP
1...1.
...MPM
1...11
.....P
1....1
....M.
.11...
MPP..M
.111..
...P..
.11.1.
...MP.
.11..1
....MP
.1.1..
..MP.M
.1.11.
....P.
.1.1.1
....MP
.1..1.
...MPM
.1..11
.....P
.1...1
....M.
..11..
.MPP.M
..111.
....P.
..11.1
....MP
..1.1.
...MPM
..1.11
.....P
..1..1
....M.
...11.
..MPPM
...111
.....P
...1.1
....M.
....11
...MP.

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
2,
2,
2,
2,
3,
3,
3,
4,

1 }
1, 2
1, 3
1, 4
1, 5
2 }
2, 3
2, 4
2, 5
3 }
3, 4
3, 5
4 }
4, 5
5 }
2 }
2, 3
2, 4
2, 5
3 }
3, 4
3, 5
4 }
4, 5
5 }
3 }
3, 4
3, 5
4 }
4, 5
5 }
4 }
4, 5
5 }
5 }

211

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

order #8:
111...
......
11.1..
..MP..
11..1.
...MP.
11...1
....MP
11....
.....M
1.11..
.MPP..
1.1.1.
...MP.
1.1..1
....MP
1.1...
.....M
1..11.
..MPP.
1..1.1
....MP
1..1..
.....M
1...11
...MPP
1...1.
.....M
1....1
....MP
.111..
MPPP.M
.11.1.
...MP.
.11..1
....MP
.11...
.....M
.1.11.
..MPP.
.1.1.1
....MP
.1.1..
.....M
.1..11
...MPP
.1..1.
.....M
.1...1
....MP
..111.
.MPPPM
..11.1
....MP
..11..
.....M
..1.11
...MPP
..1.1.
.....M
..1..1
....MP
...111
..MPP.
...11.
.....M
...1.1
....MP
....11
...MP.

{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{

0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
2,
2,
2,
2,
3,
3,
3,
4,

1, 2
1, 3
1, 4
1, 5
1 }
2, 3
2, 4
2, 5
2 }
3, 4
3, 5
3 }
4, 5
4 }
5 }
2, 3
2, 4
2, 5
2 }
3, 4
3, 5
3 }
4, 5
4 }
5 }
3, 4
3, 5
3 }
4, 5
4 }
5 }
4, 5
4 }
5 }
5 }

}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

Figure 8.5-A: The k-subsets (where 2 ≤ k ≤ 3) of a 6-element set. Lexicographic order for sets (left)
and reversed lexicographic order for delta sets (right).
can be reversed with nonzero nq.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

void generate(void (*visit)(const ksubset_rec &, long),
long kmin, long kmax, ulong rq, ulong nq=0)
{
ct_ = 0;
rct_ = 0;
kmin_ = kmin;
kmax_ = kmax;
if ( kmin_ > kmax_ ) swap2(kmin_, kmax_);
if ( kmax_ > n_ ) kmax_ = n_;
if ( kmin_ > n_ ) kmin_ = n_;
visit_ = visit;
rq_ = rq % 4;
pq_ = (rq>>2) % 4;
nq_ = nq;
next_rec(0);
}
private:
void next_rec(long d);
};

The recursive routine itself is given in [FXT: comb/ksubset-rec.cc]:
1
2
3
4

void
ksubset_rec::next_rec(long d)
{
if ( d>kmax_ ) return;

212

Chapter 8: Subsets

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

order
1....1
1...11
1...1.
1..1..
1..11.
1..1.1
1.1..1
1.1.1.
1.11..
1.1...
11....
111...
11.1..
11..1.
11...1
.11..1
.11.1.
.111..
.11...
.1.1..
.1.11.
.1.1.1
.1..11
.1..1.
.1...1
..1..1
..1.11
..1.1.
..11..
..111.
..11.1
...111
...11.
...1.1
....11

#6:
......
....P.
.....M
...PM.
....P.
....MP
..PM..
....PM
...PM.
...M..
.PM...
..P...
..MP..
...MP.
....MP
M.P...
....PM
...PM.
...M..
..MP..
....P.
....MP
...MP.
.....M
....MP
.MP...
....P.
.....M
...PM.
....P.
....MP
..M.P.
.....M
....MP
...MP.

order #7:
11....
......
111...
..P...
11.1..
..MP..
11..1.
...MP.
11...1
....MP
1.1..1
.MP...
1.1.1.
....PM
1.11..
...PM.
1.1...
...M..
1..1..
..MP..
1..11.
....P.
1..1.1
....MP
1...11
...MP.
1...1.
.....M
1....1
....MP
.1...1
MP....
.1..11
....P.
.1..1.
.....M
.1.1..
...PM.
.1.11.
....P.
.1.1.1
....MP
.11..1
..PM..
.11.1.
....PM
.111..
...PM.
.11...
...M..
..11..
.M.P..
..111.
....P.
..11.1
....MP
..1.11
...MP.
..1.1.
.....M
..1..1
....MP
...1.1
..MP..
...111
....P.
...11.
.....M
....11
...M.P

order #10:
1....1
......
1...1.
....PM
1...11
.....P
1..11.
...P.M
1..1.1
....MP
1..1..
.....M
1.1...
..PM..
1.1..1
.....P
1.1.1.
....PM
1.11..
...PM.
111...
.P.M..
11.1..
..MP..
11..1.
...MP.
11...1
....MP
11....
.....M
.11...
M.P...
.11..1
.....P
.11.1.
....PM
.111..
...PM.
.1.11.
..M.P.
.1.1.1
....MP
.1.1..
.....M
.1..1.
...MP.
.1..11
.....P
.1...1
....M.
..1..1
.MP...
..1.1.
....PM
..1.11
.....P
..111.
...P.M
..11.1
....MP
..11..
.....M
...11.
..M.P.
...111
.....P
...1.1
....M.
....11
...MP.

Figure 8.5-B: Three minimal-change orders of the k-subsets (where 2 ≤ k ≤ 3) of a 6-element set.

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

order #7:
......
......
1.....
P.....
11....
.P....
111...
..P...
1111..
...P..
11111.
....P.
111111
.....P
1111.1
....M.
111.11
...MP.
111.1.
.....M
111..1
....MP
11.1.1
..MP..
11.111
....P.
11.11.
.....M
11.1..
....M.
11..1.
...MP.
11..11
.....P
11...1
....M.
1.1..1
.MP...
1.1.1.
....PM
1.1.11
.....P
1.11.1
...PM.
1.1111
....P.
1.111.
.....M
1.11..
....M.
1.1...
...M..
1..1..
..MP..
1..11.
....P.
1..111
.....P
1..1.1
....M.
1...11
...MP.
1...1.
.....M

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
2
2
3
3
3
3
4
4

2
2
2
2
2
2
2
2
3
3
3
3
4
4
5
5
4
4
3
3
3
3

3
3
3
3
4
4
5
5
4
4

4
4 5
5
5
5

5
5
5
4 5
4

4
4 5
5
5

32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

1....1
.1...1
.1..11
.1..1.
.1.1..
.1.11.
.1.111
.1.1.1
.11..1
.11.1.
.11.11
.111.1
.11111
.1111.
.111..
.11...
.1....
..1...
..11..
..111.
..1111
..11.1
..1.11
..1.1.
..1..1
...1.1
...111
...11.
...1..
....1.
....11
.....1

....MP
MP....
....P.
.....M
...PM.
....P.
.....P
....M.
..PM..
....PM
.....P
...PM.
....P.
.....M
....M.
...M..
..M...
.MP...
...P..
....P.
.....P
....M.
...MP.
.....M
....MP
..MP..
....P.
.....M
....M.
...MP.
.....P
....M.

0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
2
2
3
3
3
3
4
4
5

5
5
4
4
3
3
3
3
2
2
2
2
2
2
2
2
3
3
3
3
4
4
5
5
4
4

5
4
4
5
5
4
4
3
3
3
3

5
5
5
4 5
4

4
4 5
5
5
5

5

Figure 8.5-C: With kmin = 0 and order number seven at each transition either one element is added or
removed, or one element moves to an adjacent position.

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

++rct_;
long rv1
bool q;
switch (
{
case 0:
case 1:
case 2:
case 3:
}

213

// measure computational work
= rv_[d-1]; // left neighbor
rq_ % 4 )
q
q
q
q

if ( nq_ )

=
=
=
=

1; break;
!(d&1); break;
rv1&1; break;
(d^rv1)&1; break;
q = !q;

long x0 = rv1 + 1;
long rx = n_ - (kmin_ - d);
long x1 = min2( n_-1, rx );
#define PCOND(x) if ( (pq_==x) && (d>=kmin_) ) { visit_(*this, d); ++ct_; }
PCOND(0);
if ( q ) // forward:
{
PCOND(1);
for (long x=x0; x<=x1; ++x) { rv_[d] = x; next_rec(d+1); }
PCOND(2);
}
else // backward:
{
PCOND(2);
for (long x=x1; x>=x0; --x) { rv_[d] = x; next_rec(d+1); }
PCOND(1);
}
PCOND(3);
#undef PCOND
}

About 50 million subsets per second are generated [FXT: comb/ksubset-rec-demo.cc].

8.5.2

Iterative algorithm for a minimal-change order
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

delta set
...11
..11.
..111
..1.1
.11..
.11.1
.1111
.111.
.1.1.
.1.11
.1..1
11...
11..1
11.11
11.1.
1111.
111.1
111..
1.1..
1.1.1
1.111
1.11.
1..1.
1..11
1...1

diff
.....
..P.M
....P
...M.
.P..M
....P
...P.
....M
..M..
....P
...M.
P...M
....P
...P.
....M
..P..
...MP
....M
.M...
....P
...P.
....M
..M..
....P
...M.

set
{ 4,
{ 3,
{ 3,
{ 3,
{ 2,
{ 2,
{ 2,
{ 2,
{ 2,
{ 2,
{ 2,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,
{ 1,

5 }
4 }
4, 5 }
5 }
3 }
3, 5 }
3, 4, 5
3, 4 }
4 }
4, 5 }
5 }
2 }
2, 5 }
2, 4, 5
2, 4 }
2, 3, 4
2, 3, 5
2, 3 }
3 }
3, 5 }
3, 4, 5
3, 4 }
4 }
4, 5 }
5 }

}

}
}
}

}

Figure 8.5-D: The (25) k-subsets where 2 ≤ k ≤ 4 of a 5-element set in a minimal-change order.
A generator for subsets in Gray code order is [FXT: class ksubset gray in comb/ksubset-gray.h]:

214
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

Chapter 8: Subsets

class ksubset_gray
{
public:
ulong n_;
// k-subsets of {1, 2, ..., n}
ulong kmin_, kmax_; // kmin <= k <= kmax
ulong k_;
// k elements in current set
ulong *S_; // set in S[1,2,...,k] with elements in {1,2,...,n}
ulong j_;
// aux
public:
ksubset_gray(ulong n, ulong kmin, ulong kmax)
{
n_ = (n>0 ? n : 1);
// Must have 1<=kmin<=kmax<=n
kmin_ = kmin;
kmax_ = kmax;
if ( kmax_ < kmin_ ) swap2(kmin_, kmax_);
if ( kmin_==0 ) kmin_ = 1;
S_ = new ulong[kmax_+1];
S_[0] = 0; // sentinel: != 1
first();
}
~ksubset_gray() { delete [] S_; }
const ulong *data() const { return S_+1; }
ulong num() const { return k_; }
ulong last()
{
S_[1] = 1; k_ = kmin_;
if ( kmin_==1 ) { j_ = 1; }
else
{
for (ulong i=2; i<=kmin_; ++i)
j_ = 2;
}
return k_;
}
ulong first()
{
k_ = kmin_;
for (ulong i=1; i<=kmin_; ++i)
j_ = 1;
return k_;
}
bool is_first()

const

{ S_[i] = n_ - kmin_ + i; }

{ S_[i] = n_ - kmin_ + i; }

{ return ( S_[1] == n_ - kmin_ + 1 );

}

bool is_last() const
{
if ( S_[1] != 1 )
return 0;
if ( kmin_<=1 ) return (k_==1);
return (S_[2]==n_-kmin_+2);
}
[--snip--]

The routines for computing the next or previous subset are adapted from a routine to compute the
successor given in [192]. It is split into two auxiliary functions:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

private:
void prev_even()
{
ulong &n=n_, &kmin=kmin_, &kmax=kmax_, &j=j_;
if ( S_[j-1] == S_[j]-1 ) // can touch sentinel S[0]
{
S_[j-1] = S_[j];
if ( j > kmin )
{
if ( S_[kmin] == n ) { j = j-2; } else { j = j-1; }
}
else
{
S_[j] = n - kmin + j;
if ( S_[j-1]==S_[j]-1 ) { j = j-2; }

16
17
18
19
20
21
22
23
24
25
26
27
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

}
}
else
{
S_[j] = S_[j]
if ( j < kmax
{
S_[j+1] =
if ( j >=
}
}

215

- 1;
)
S_[j] + 1;
kmin-1 ) { j = j+1; }

else

{ j = j+2; }

}
void prev_odd()
{
ulong &n=n_, &kmin=kmin_, &kmax=kmax_, &j=j_;
if ( S_[j] == n ) { j = j-1; }
else
{
if ( j < kmax )
{
S_[j+1] = n;
j = j+1;
}
else
{
S_[j] = S_[j]+1;
if ( S_[kmin]==n ) { j = j-1; }
}
}
}
[--snip--]

The next() and prev() functions use these routines. Note that calls cannot not be mixed.
1
2
3
4
5
6
7
8

ulong prev()
{
if ( is_first() ) { last(); return 0; }
if ( j_&1 ) prev_odd();
else
prev_even();
if ( j_<kmin_ ) { k_ = kmin_; } else { k_ = j_; };
return k_;
}

1
2
3
4
5
6
7
8
9

ulong next()
{
if ( is_last() ) { first(); return 0; }
if ( j_&1 ) prev_even();
else
prev_odd();
if ( j_<kmin_ ) { k_ = kmin_; } else { k_ = j_; };
return k_;
}
[--snip--]

Usage of the class is shown in the program [FXT: comb/ksubset-gray-demo.cc], the k-subsets where
2 ≤ k ≤ 4 in the order generated by the algorithm are shown in ﬁgure 8.5-D. About 150 million subsets
per second can be generated with the routine next() and 130 million with prev().

8.5.3

A two-close order with homogenous moves

Orderings of the k-subsets with k in a given range that are two-close are shown in ﬁgure 8.5-E: one
element is inserted or removed or moves by at most two positions. The moves by two positions only
cross a zero, the changes are homogenous. The list was produced with the program [FXT: comb/ksubsettwoclose-demo.cc] which uses [FXT: class ksubset twoclose in comb/ksubset-twoclose.h]:
1
2
3
4
5
6
7
8
9

class ksubset_twoclose
// k-subsets (kmin<=k<=kmax) in a two-close order.
// Recursive algorithm.
{
public:
ulong *rv_; // record of visits in graph (delta set)
ulong n_;
// subsets of the n-element set
// function to call with each combination:

216

Chapter 8: Subsets

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

delta set
.1111
..111
1.111
11.11
.1.11
...11
1..11
11..1
.1..1
1...1
..1.1
1.1.1
.11.1
111.1
1111.
.111.
..11.
1.11.
11.1.
.1.1.
1..1.
11...
1.1..
.11..
111..

diff
.....
.M...
P....
.PM..
M....
.M...
P....
.P.M.
M....
PM...
M.P..
P....
MP...
P....
...PM
M....
.M...
P....
.PM..
M....
PM...
.P.M.
.MP..
MP...
P....

set
{ 1,
{ 2,
{ 0,
{ 0,
{ 1,
{ 3,
{ 0,
{ 0,
{ 1,
{ 0,
{ 2,
{ 0,
{ 1,
{ 0,
{ 0,
{ 1,
{ 2,
{ 0,
{ 0,
{ 1,
{ 0,
{ 0,
{ 0,
{ 1,
{ 0,

2, 3, 4
3, 4 }
2, 3, 4
1, 3, 4
3, 4 }
4 }
3, 4 }
1, 4 }
4 }
4 }
4 }
2, 4 }
2, 4 }
1, 2, 4
1, 2, 3
2, 3 }
3 }
2, 3 }
1, 3 }
3 }
3 }
1 }
2 }
2 }
1, 2 }

}
}
}

}
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

delta set
....11
...1.1
.1...1
.....1
1....1
..1..1
..11..
.1.1..
...1..
1..1..
11....
.1....
1.....
..1...
1.1...
.11...
.1..1.
....1.
1...1.
..1.1.
...11.

diff
......
...PM.
.P.M..
.M....
P.....
M.P...
...P.M
.PM...
.M....
P.....
.P.M..
M.....
PM....
M.P...
P.....
MP....
..M.P.
.M....
P.....
M.P...
..MP..

set
{ 4, 5
{ 3, 5
{ 1, 5
{ 5 }
{ 0, 5
{ 2, 5
{ 2, 3
{ 1, 3
{ 3 }
{ 0, 3
{ 0, 1
{ 1 }
{ 0 }
{ 2 }
{ 0, 2
{ 1, 2
{ 1, 4
{ 4 }
{ 0, 4
{ 2, 4
{ 3, 4

}
}
}
}
}
}
}
}
}

}
}
}
}
}
}

Figure 8.5-E: The k-subsets where 2 ≤ k ≤ 4 of 5 elements (left) and the sets where 1 ≤ k ≤ 2 of 6
elements (right) in two-close orders.
10
11
12
13
14
15
16
17
18
19

void (*visit_)(const ksubset_twoclose &);
[--snip--]
void generate(void (*visit)(const ksubset_twoclose &),
ulong kmin, ulong kmax)
{
visit_ = visit;
ulong kmax0 = n_ - kmin;
next_rec(n_, kmax, kmax0, 0);
}

The recursion is:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

private:
void next_rec(ulong d, ulong n1, ulong n0, bool q)
// d: remaining depth in recursion
// n1: remaining ones to fill in
// n0: remaining zeros to fill in
// q: direction in recursion
{
if ( 0==d ) { visit_(*this); return; }
--d;
if ( q
{
if
if
}
else
{
if
if
}

)
( n0 )
( n1 )

{ rv_[d]=0;
{ rv_[d]=1;

next_rec(d, n1-0, n0-1, d&1); }
next_rec(d, n1-1, n0-0, q); }

( n1 )
( n0 )

{ rv_[d]=1;
{ rv_[d]=0;

next_rec(d, n1-1, n0-0, q); }
next_rec(d, n1-0, n0-1, d&1); }

}
};

About 75 million subsets per second can be generated. For kmin = kmax =: k we obtain the enup order
for combinations described in section 6.6.2 on page 188.

217

Chapter 9

Mixed radix numbers
The mixed radix representation A = [a0 , a1 , a2 , . . . , an−1 ] of a number x with respect to a radix vector
M = [m0 , m1 , m2 , . . . , mn−1 ] is given by
n−1

x

=

k−1

ak
k=0

mj

(9.0-1)

j=0

n−1

where 0 ≤ aj < mj (and 0 ≤ x < j=0 mj , so that n digits suffice). For M = [r, r, r, . . . , r] the relation
reduces to the radix-r representation:
n−1

x

ak r k

=

(9.0-2)

k=0

All 3-digit radix-4 numbers are shown in various orders in figure 9.0-A. Note that the least significant
digit (a0 ) is at the left side of each number (array representation).

9.1

Counting (lexicographic) order

An implementation for mixed radix counting is [FXT: class mixedradix lex in comb/mixedradix-lex.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class mixedradix_lex
{
public:
ulong *a_; // digits
ulong *m1_; // radix (minus one) for each digit
ulong n_;
// Number of digits
ulong j_;
public:
mixedradix_lex(const ulong *m, ulong n, ulong mm=0)
{
n_ = n;
a_ = new ulong[n_+1];
m1_ = new ulong[n_+1];
a_[n_] = 1;
// sentinel: !=0, and !=m1[n]
m1_[n_] = 0; // sentinel
mixedradix_init(n_, mm, m, m1_);
first();
}
[--snip--]

The initialization routine mixedradix_init() is given in [FXT: comb/mixedradix-init.cc]:
1
2
3
4
5
6
7
8
9

void
mixedradix_init(ulong n, ulong mm, const ulong *m, ulong *m1)
// Auxiliary function used to initialize vector of nines in mixed radix classes.
{
if ( m ) // all radices given
{
for (ulong k=0; k<n; ++k) m1[k] = m[k] - 1;
}
else

218

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

Chapter 9: Mixed radix numbers

counting
[ . . . ]
[ 1 . . ]
[ 2 . . ]
[ 3 . . ]
[ . 1 . ]
[ 1 1 . ]
[ 2 1 . ]
[ 3 1 . ]
[ . 2 . ]
[ 1 2 . ]
[ 2 2 . ]
[ 3 2 . ]
[ . 3 . ]
[ 1 3 . ]
[ 2 3 . ]
[ 3 3 . ]
[ . . 1 ]
[ 1 . 1 ]
[ 2 . 1 ]
[ 3 . 1 ]
[ . 1 1 ]
[ 1 1 1 ]
[ 2 1 1 ]
[ 3 1 1 ]
[ . 2 1 ]
[ 1 2 1 ]
[ 2 2 1 ]
[ 3 2 1 ]
[ . 3 1 ]
[ 1 3 1 ]
[ 2 3 1 ]
[ 3 3 1 ]
[ . . 2 ]
[ 1 . 2 ]
[ 2 . 2 ]
[ 3 . 2 ]
[ . 1 2 ]
[ 1 1 2 ]
[ 2 1 2 ]
[ 3 1 2 ]
[ . 2 2 ]
[ 1 2 2 ]
[ 2 2 2 ]
[ 3 2 2 ]
[ . 3 2 ]
[ 1 3 2 ]
[ 2 3 2 ]
[ 3 3 2 ]
[ . . 3 ]
[ 1 . 3 ]
[ 2 . 3 ]
[ 3 . 3 ]
[ . 1 3 ]
[ 1 1 3 ]
[ 2 1 3 ]
[ 3 1 3 ]
[ . 2 3 ]
[ 1 2 3 ]
[ 2 2 3 ]
[ 3 2 3 ]
[ . 3 3 ]
[ 1 3 3 ]
[ 2 3 3 ]
[ 3 3 3 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

Gray
. . .
1 . .
2 . .
3 . .
3 1 .
2 1 .
1 1 .
. 1 .
. 2 .
1 2 .
2 2 .
3 2 .
3 3 .
2 3 .
1 3 .
. 3 .
. 3 1
1 3 1
2 3 1
3 3 1
3 2 1
2 2 1
1 2 1
. 2 1
. 1 1
1 1 1
2 1 1
3 1 1
3 . 1
2 . 1
1 . 1
. . 1
. . 2
1 . 2
2 . 2
3 . 2
3 1 2
2 1 2
1 1 2
. 1 2
. 2 2
1 2 2
2 2 2
3 2 2
3 3 2
2 3 2
1 3 2
. 3 2
. 3 3
1 3 3
2 3 3
3 3 3
3 2 3
2 2 3
1 2 3
. 2 3
. 1 3
1 1 3
2 1 3
3 1 3
3 . 3
2 . 3
1 . 3
. . 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

modular Gray
[ . . . ]
[ 1 . . ]
[ 2 . . ]
[ 3 . . ]
[ 3 1 . ]
[ . 1 . ]
[ 1 1 . ]
[ 2 1 . ]
[ 2 2 . ]
[ 3 2 . ]
[ . 2 . ]
[ 1 2 . ]
[ 1 3 . ]
[ 2 3 . ]
[ 3 3 . ]
[ . 3 . ]
[ . 3 1 ]
[ 1 3 1 ]
[ 2 3 1 ]
[ 3 3 1 ]
[ 3 . 1 ]
[ . . 1 ]
[ 1 . 1 ]
[ 2 . 1 ]
[ 2 1 1 ]
[ 3 1 1 ]
[ . 1 1 ]
[ 1 1 1 ]
[ 1 2 1 ]
[ 2 2 1 ]
[ 3 2 1 ]
[ . 2 1 ]
[ . 2 2 ]
[ 1 2 2 ]
[ 2 2 2 ]
[ 3 2 2 ]
[ 3 3 2 ]
[ . 3 2 ]
[ 1 3 2 ]
[ 2 3 2 ]
[ 2 . 2 ]
[ 3 . 2 ]
[ . . 2 ]
[ 1 . 2 ]
[ 1 1 2 ]
[ 2 1 2 ]
[ 3 1 2 ]
[ . 1 2 ]
[ . 1 3 ]
[ 1 1 3 ]
[ 2 1 3 ]
[ 3 1 3 ]
[ 3 2 3 ]
[ . 2 3 ]
[ 1 2 3 ]
[ 2 2 3 ]
[ 2 3 3 ]
[ 3 3 3 ]
[ . 3 3 ]
[ 1 3 3 ]
[ 1 . 3 ]
[ 2 . 3 ]
[ 3 . 3 ]
[ . . 3 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

gslex
1 . .
2 . .
3 . .
1 1 .
2 1 .
3 1 .
. 1 .
1 2 .
2 2 .
3 2 .
. 2 .
1 3 .
2 3 .
3 3 .
. 3 .
1 . 1
2 . 1
3 . 1
1 1 1
2 1 1
3 1 1
. 1 1
1 2 1
2 2 1
3 2 1
. 2 1
1 3 1
2 3 1
3 3 1
. 3 1
. . 1
1 . 2
2 . 2
3 . 2
1 1 2
2 1 2
3 1 2
. 1 2
1 2 2
2 2 2
3 2 2
. 2 2
1 3 2
2 3 2
3 3 2
. 3 2
. . 2
1 . 3
2 . 3
3 . 3
1 1 3
2 1 3
3 1 3
. 1 3
1 2 3
2 2 3
3 2 3
. 2 3
1 3 3
2 3 3
3 3 3
. 3 3
. . 3
. . .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

endo
. . .
1 . .
3 . .
2 . .
. 1 .
1 1 .
3 1 .
2 1 .
. 3 .
1 3 .
3 3 .
2 3 .
. 2 .
1 2 .
3 2 .
2 2 .
. . 1
1 . 1
3 . 1
2 . 1
. 1 1
1 1 1
3 1 1
2 1 1
. 3 1
1 3 1
3 3 1
2 3 1
. 2 1
1 2 1
3 2 1
2 2 1
. . 3
1 . 3
3 . 3
2 . 3
. 1 3
1 1 3
3 1 3
2 1 3
. 3 3
1 3 3
3 3 3
2 3 3
. 2 3
1 2 3
3 2 3
2 2 3
. . 2
1 . 2
3 . 2
2 . 2
. 1 2
1 1 2
3 1 2
2 1 2
. 3 2
1 3 2
3 3 2
2 3 2
. 2 2
1 2 2
3 2 2
2 2 2

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

endo Gray
[ . . . ]
[ 1 . . ]
[ 3 . . ]
[ 2 . . ]
[ 2 1 . ]
[ 3 1 . ]
[ 1 1 . ]
[ . 1 . ]
[ . 3 . ]
[ 1 3 . ]
[ 3 3 . ]
[ 2 3 . ]
[ 2 2 . ]
[ 3 2 . ]
[ 1 2 . ]
[ . 2 . ]
[ . 2 1 ]
[ 1 2 1 ]
[ 3 2 1 ]
[ 2 2 1 ]
[ 2 3 1 ]
[ 3 3 1 ]
[ 1 3 1 ]
[ . 3 1 ]
[ . 1 1 ]
[ 1 1 1 ]
[ 3 1 1 ]
[ 2 1 1 ]
[ 2 . 1 ]
[ 3 . 1 ]
[ 1 . 1 ]
[ . . 1 ]
[ . . 3 ]
[ 1 . 3 ]
[ 3 . 3 ]
[ 2 . 3 ]
[ 2 1 3 ]
[ 3 1 3 ]
[ 1 1 3 ]
[ . 1 3 ]
[ . 3 3 ]
[ 1 3 3 ]
[ 3 3 3 ]
[ 2 3 3 ]
[ 2 2 3 ]
[ 3 2 3 ]
[ 1 2 3 ]
[ . 2 3 ]
[ . 2 2 ]
[ 1 2 2 ]
[ 3 2 2 ]
[ 2 2 2 ]
[ 2 3 2 ]
[ 3 3 2 ]
[ 1 3 2 ]
[ . 3 2 ]
[ . 1 2 ]
[ 1 1 2 ]
[ 3 1 2 ]
[ 2 1 2 ]
[ 2 . 2 ]
[ 3 . 2 ]
[ 1 . 2 ]
[ . . 2 ]

Figure 9.0-A: All 3-digit, radix-4 numbers in various orders (dots denote zeros): counting-, Gray-,
modular Gray-, gslex-, endo-, and endo Gray order. The least signiﬁcant digit is on the left of each word
(array notation).

9.1: Counting (lexicographic) order

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

2
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1

3
.
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2

4
.
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
3

219

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

4
.
1
2
3
.
1
2
3
.
1
2
3
.
1
2
3
.
1
2
3
.
1
2
3

3
.
.
.
.
1
1
1
1
2
2
2
2
.
.
.
.
1
1
1
1
2
2
2
2

2
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 9.1-A: Mixed radix numbers in counting (lexicographic) order, dots denote zeros. The radix
vectors are M = [2, 3, 4] (rising factorial base, left) and M = [4, 3, 2] (falling factorial base, right). The
least significant digit is on the left of each word (array notation).
10
11
12
13
14
15
16
17
18
19
20
21

{
if ( mm>1 ) // use mm as radix for all digits:
for (ulong k=0; k<n; ++k) m1[k] = mm - 1;
else
{
if ( mm==0 ) // falling factorial base
for (ulong k=0; k<n; ++k) m1[k] = n - k;
else // rising factorial base
for (ulong k=0; k<n; ++k) m1[k] = k + 1;
}
}
}

Instead of the vector of radices M = [m0 , m1 , m2 , . . . , mn−1 ] the vector of ‘nines’ (M = [m0 − 1, m1 −
1, m2 − 1, . . . , mn−1 − 1], variable m1_) is used. This modification leads to slightly faster generation. The
first n-digit in lexicographic order number is all-zero, the last is all-nines:
1
2
3
4
5
6
7
8
9
10
11
12
13

[--snip--]
void first()
{
for (ulong k=0; k<n_; ++k)
j_ = n_;
}
void last()
{
j_ = n_;
}
[--snip--]

a_[k] = 0;

a_[k] = m1_[k];

A number is incremented by setting all nines (digits aj that are equal to mj − 1) at the lower end to zero
and incrementing the next digit:
1
2
3
4
5
6
7
8

bool next() // increment
{
ulong j = 0;
while ( a_[j]==m1_[j] )
j_ = j;
if ( j==n_ )

{ a_[j]=0;

return false;

++j; }

// can touch sentinels

// current is last

220
9
10
11
12

++a_[j];
return true;
}
[--snip--]

A number is decremented by setting all zero digits at the lower end to nine and decrementing the next
digit:
1
2
3
4
5
6
7
8
9
10
11
12

bool prev() // decrement
{
ulong j = 0;
while ( a_[j]==0 ) { a_[j]=m1_[j];
j_ = j;
if ( j==n_ )

return false;

++j; }


// current is first

--a_[j];
return true;
}
[--snip--]

Figure 9.1-A shows the 3-digit mixed radix numbers for bases M = [2, 3, 4] (left) and M = [4, 3, 2] (right).
The listings were created with the program [FXT: comb/mixedradix-lex-demo.cc].
The rate of generation for the routine next() is about 166 M/s (with radix-2 numbers, M =
[2, 2, 2, . . . , 2]), 257 M/s (radix-3), and about 370 M/s (radix-8). The slowest generation occurs for
radix-2, as the number of carries is maximal. The number C of carries with incrementing is on average
C

=

1
m0

1+

1
m1

1+

1
m2

1+

1
( ... )
m3

n

=
k=0

1
k
j=0

mj

(9.1-1)

The number of digits changed on average equals C + 1. For M = [r, r, r, . . . , r] (and n = ∞) we have
1
C = r−1 . For the worst case (r = 2) we have C = 1, so two digits are changed on average.

9.2

Minimal-change (Gray code) order

9.2.1

Constant amortized time (CAT) algorithm

Figure 9.2-A shows the 3-digit mixed radix numbers for radix vectors M = [2, 3, 4] (left) and M = [4, 3, 2]
(right) in Gray code order. A generator for the Gray code order is [FXT: class mixedradix gray in
comb/mixedradix-gray.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class mixedradix_gray
{
public:
ulong *a_; // mixed radix digits
ulong *m1_; // radices (minus one)
ulong *i_; // direction
ulong n_;
// n_ digits
ulong j_;
int dm_;
// direction of last move
public:
mixedradix_gray(const ulong *m, ulong n, ulong mm=0)
{
n_ = n;
a_[n] = -1UL; // sentinel
i_ = new ulong[n_+1];
i_[n_] = 0;
// sentinel
m1_ = new ulong[n_+1];
first();
}
[--snip--]

9.2: Minimal-change (Gray code) order

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

2
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.

3
.
.
1
1
2
2
2
2
1
1
.
.
.
.
1
1
2
2
2
2
1
1
.
.

4
.
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
0
1
3
2
4
5
11
10
8
9
7
6
12
13
15
14
16
17
23
22
20
21
19
18

221

j

d

0
1
0
1
0
2
0
1
0
1
0
2
0
1
0
1
0
2
0
1
0
1
0

1
1
-1
1
1
1
-1
-1
1
-1
-1
1
1
1
-1
1
1
1
-1
-1
1
-1
-1

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

4
.
1
2
3
3
2
1
.
.
1
2
3
3
2
1
.
.
1
2
3
3
2
1
.

3
.
.
.
.
1
1
1
1
2
2
2
2
2
2
2
2
1
1
1
1
.
.
.
.

2
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
0
1
2
3
7
6
5
4
8
9
10
11
23
22
21
20
16
17
18
19
15
14
13
12

j

d

0
0
0
1
0
0
0
1
0
0
0
2
0
0
0
1
0
0
0
1
0
0
0

1
1
1
1
-1
-1
-1
1
1
1
1
1
-1
-1
-1
-1
1
1
1
-1
-1
-1
-1

Figure 9.2-A: Mixed radix numbers in Gray code order, dots denote zeros. The radix vectors are
M = [2, 3, 4] (left) and M = [4, 3, 2] (right). Columns ‘x’ give the values, columns ‘j’ and ‘d’ give the
position of last change and its direction, respectively.
The array i_[] contains the ‘directions’ for each digit: it contains +1 or -1 if the computation of the
successor will increase or decrease the corresponding digit. It has to be ﬁlled when the ﬁrst or last number
is computed:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

void first()
{
j_ = n_;
dm_ = 0;
}

a_[k] = 0;
i_[k] = +1;

void last()
{
// find position of last even radix:
ulong z = 0;
for (ulong i=0; i<n_; ++i) if ( m1_[i]&1 )
while ( z<n_ ) // last even .. end:
{
a_[z] = m1_[z];
i_[z] = +1;
++z;
}

z = i;

j_ = 0;
dm_ = -1;
}
[--snip--]

A sentinel element (i_[n]=0) is used to optimize the computations of the successor and predecessor.
The method works in constant amortized time:
1
2
3
4
5
6
7
8
9
10

bool next()
{
ulong j = 0;
ulong ij;
while ( (ij=i_[j]) ) // can touch sentinel i[n]==0
{
ulong dj = a_[j] + ij;
if ( dj>m1_[j] ) // =^= if ( (dj>m1_[j]) || ((long)dj<0) )
{
i_[j] = -ij; // flip direction

222
11
12
13
14
15
16
17
18
19
20
21
22
23
24

}
else
{

// can update
a_[j] = dj; // update digit
dm_ = ij;
// save for dir()
j_ = j;
// save for pos()
return true;

}
++j;
}
return false;
}
[--snip--]

Note the if-clause: it is an optimized expression equivalent to the one given as comment. The following
methods are often useful:
1
2

ulong pos() const { return j_; }
int dir() const { return dm_; }

// direction of last change

The routine for the computation of the predecessor is obtained by changing the plus sign in the statement
ulong dj = a_[j] + ij; to a minus sign. The rate of generation is about 128 M/s for radix 2, 243 M/s
for radix 4, and 304 M/s for radix 8 [FXT: comb/mixedradix-gray-demo.cc].

9.2.2

Loopless algorithm

A loopless algorithm for the computation of the successor, taken from [215, alg.H, sect.7.2.1.1], is given
in [FXT: comb/mixedradix-gray2.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class mixedradix_gray2
{
public:
ulong *m1_; // radix minus one (’nines’)
ulong *f_; // focus pointer
ulong *d_; // direction
ulong n_;
// number of digits
ulong j_;
int dm_;
[--snip--]
void first()
{
for (ulong k=0; k<n_; ++k) a_[k] = 0;
for (ulong k=0; k<n_; ++k) d_[k] = 1;
for (ulong k=0; k<=n_; ++k) f_[k] = k;
dm_ = 0;
j_ = n_;
}
bool next()
{
const ulong j = f_[0];
f_[0] = 0;
if ( j>=n_ )

{ first();

return false; }

const ulong dj = d_[j];
const ulong aj = a_[j] + dj;
a_[j] = aj;
dm_ = (int)dj;
j_ = j;

// save for dir()
// save for pos()

if ( aj+dj > m1_[j] ) // was last move?
{
d_[j] = -dj;
// change direction
f_[j] = f_[j+1]; // lookup next position
f_[j+1] = j + 1;
}
return true;
}

9.2: Minimal-change (Gray code) order

223

The rate of generation is about 120 M/s for radix 2, 194 M/s for radix 4, and 264 M/s for radix 8 [FXT:
comb/mixedradix-gray2-demo.cc].

9.2.3

Modular Gray code order
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

2
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.

3
.
.
1
1
2
2
2
2
.
.
1
1
1
1
2
2
.
.
.
.
1
1
2
2

4
.
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

j
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

0
1
0
1
0
2
0
1
0
1
0
2
0
1
0
1
0
2
0
1
0
1
0

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

4
.
1
2
3
3
.
1
2
2
3
.
1
1
2
3
.
.
1
2
3
3
.
1
2

3
.
.
.
.
1
1
1
1
2
2
2
2
2
2
2
2
.
.
.
.
1
1
1
1

2
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

j
0
0
0
1
0
0
0
1
0
0
0
2
0
0
0
1
0
0
0
1
0
0
0

Figure 9.2-B: Mixed radix numbers in modular Gray code order, dots denote zeros. The radix vectors
are M = [2, 3, 4] (left) and M = [4, 3, 2] (right). The columns ‘j’ give the position of last change.
Figure 9.2-B shows the modular Gray code order for 3-digit mixed radix numbers with radix vectors M =
[2, 3, 4] (left) and M = [4, 3, 2] (right). The transitions are either k → k+1 or, if k is maximal, k → 0. The
mixed radix modular Gray code can be generated as follows [FXT: class mixedradix modular gray2
in comb/mixedradix-modular-gray2.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class mixedradix_modular_gray2
{
public:
ulong *m1_; // radix minus one (’nines’)
ulong *x_; // count changes of digit
ulong n_;
// number of digits
ulong j_;
public:
mixedradix_modular_gray2(ulong n, ulong mm, const ulong *m=0)
{
n_ = n;
a_ = new ulong[n_];
m1_ = new ulong[n_+1]; // incl. sentinel at m1[n]
// incl. sentinel at x[n] (!= m1[n])
first();
}
[--snip--]

The computation of the successor works in constant amortized time
1
2
3
4
5
6

bool next()
{
ulong j = 0;
while ( x_[j] == m1_[j] )
{
x_[j] = 0;


224
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

++j;
}
++x_[j];
if ( j==n_ )
j_ = j;

{ first();

return false; }

// current is last

// save position of change

// increment:
ulong aj = a_[j] + 1;
if ( aj>m1_[j] ) aj = 0;
a_[j] = aj;
return true;
}
[--snip--]

The rate of generation is about 151 M/s for radix 2, 254 M/s for radix 4, and 267 M/s for radix 8 [FXT:
comb/mixedradix-modular-gray2-demo.cc].
The loopless implementation [FXT: class mixedradix modular gray in comb/mixedradix-modulargray.h] was taken from [215, ex.77, sect.7.2.1.1]. The rate of generation is about 169 M/s with radix 2,
197 M/s with radix 4, and 256 M/s with radix 8 [FXT: comb/mixedradix-modular-gray-demo.cc].

9.3

gslex order
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

2
1
1
.
1
.
1
1
.
1
.
.
1
1
.
1
.
.
1
1
.
1
.
.
.

3
.
1
1
2
2
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2
.
.

4
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
3
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
1
3
2
5
4
7
9
8
11
10
6
13
15
14
17
16
12
19
21
20
23
22
18
0

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

4
1
2
3
1
2
3
.
1
2
3
.
1
2
3
1
2
3
.
1
2
3
.
.
.

3
.
.
.
1
1
1
1
2
2
2
2
.
.
.
1
1
1
1
2
2
2
2
.
.

2
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
1
2
3
5
6
7
4
9
10
11
8
13
14
15
17
18
19
16
21
22
23
20
12
0

Figure 9.3-A: Mixed radix numbers in gslex (generalized subset lex) order, dots denote zeros. The
radix vectors are M = [2, 3, 4] (left) and M = [4, 3, 2] (right). Successive words diﬀer in at most three
positions. Columns ‘x’ give the values.
The algorithm for the generation of subsets in lexicographic order in set representation given in section 8.1.2 on page 203 can be generalized for mixed radix numbers. Figure 9.3-A shows the 3-digit mixed
radix numbers for base M = [2, 3, 4] (left) and M = [4, 3, 2] (right). Note that zero is the last word in this
order. For lack of a better name we call the order gslex (for generalized subset-lex ) order. A generator
for the gslex order is [FXT: class mixedradix gslex in comb/mixedradix-gslex.h]:
1
2
3
4
5
6

class mixedradix_gslex
{
public:
ulong n_;
// n-digit numbers
ulong *m1_; // m1[k] == radix-1 at position k

9.3: gslex order
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

225

public:
mixedradix_gslex(ulong n, ulong mm, const ulong *m=0)
{
n_ = n;
a_ = new ulong[n_ + 1];
a_[n_] = 1; // sentinel
m1_ = new ulong[n_];
first();
}
[--snip--]
void first()
{
for (ulong k=0; k<n_; ++k) a_[k] = 0;
a_[0] = 1;
}
void last()
{
}

a_[k] = 0;

The method next() computes the successor:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

bool next()
{
ulong e = 0;
while ( 0==a_[e] )
if ( e==n_ )

++e;

{ first();

return false; }

// current is last

ulong ae = a_[e];
if ( ae != m1_[e] ) // easy case: simple increment
{
a_[0] = 1;
a_[e] = ae + 1;
}
else
{
a_[e] = 0;
if ( a_[e+1]==0 ) // can touch sentinel
{
a_[0] = 1;
++a_[e+1];
}
}
return true;
}

The predecessor is computed by the method prev():
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

bool prev()
{
ulong e = 0;
while ( 0==a_[e] )
if ( 0!=e
{
--e;
a_[e]
}
else
{
ulong
--a0;
a_[0]

)

++e;


// easy case: prepend nine

= m1_[e];

a0 = a_[0];
= a0;

if ( 0==a0 )
{
do { ++e; } while ( 0==a_[e] ); // can touch sentinel
if ( e==n_ ) { last(); return false; } // current is first
ulong ae = a_[e];
--ae;
a_[e] = ae;
if ( 0==ae )
{
--e;

226
27
28
29
30
31
32

a_[e] = m1_[e];
}
}
}
return true;
}

The routine works in constant amortized time and is fast in practice. The worst performance occurs
when all digits are radix 2, then about 123 million objects are created per second. With radix 4 the rate
is about 198 M/s, with radix 16 about 273 M/s [FXT: comb/mixedradix-gslex-demo.cc].
Alternative gslex order

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

2
.
1
1
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.

3
.
.
1
1
1
1
2
2
2
2
.
.
.
1
1
1
1
2
2
2
2
.
.
.

4
.
.
.
1
2
3
.
1
2
3
1
2
3
.
1
2
3
.
1
2
3
1
2
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
0
1
3
9
15
21
5
11
17
23
7
13
19
2
8
14
20
4
10
16
22
6
12
18

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

4
.
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
3
.
.
.
.
.

3
.
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2
.
1
1
2
2
.

2
.
.
.
1
.
1
1
.
.
1
.
1
1
.
.
1
.
1
1
.
1
.
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
0
1
5
17
9
21
13
2
6
18
10
22
14
3
7
19
11
23
15
4
16
8
20
12

Figure 9.3-B: Mixed radix numbers in alternative gslex order, dots denote zeros. The radix vectors are
M = [2, 3, 4] (left) and M = [4, 3, 2] (right). Successive words diﬀer in at most three positions. Columns
‘x’ give the values.
A variant of the gslex order is shown in ﬁgure 9.3-B. The ordering can be obtained from the gslex order by
reversing the list, reversing the words, and replacing all nonzero digits di by ri − di where ri is the radix
at position i. The implementation is given in [FXT: class mixedradix gslex alt in comb/mixedradixgslex-alt.h], the rate of generation is about the same as with gslex order [FXT: comb/mixedradix-gslexalt-demo.cc].

9.4

endo order

The computation of the successor in mixed radix endo order (see section 6.6.1 on page 186) is very
similar to the counting order described in section 9.1 on page 217. The implementation [FXT: class
mixedradix endo in comb/mixedradix-endo.h] uses an additional array le_[] of the last nonzero elements
in endo order. Its entries are 2 for m > 1, else 1:
1
2
3
4
5
6
7
8
9
10

class mixedradix_endo
{
public:
ulong *a_; // digits, sentinel a[n]
ulong *m1_; // radix (minus one) for each digit
ulong *le_; // last positive digit in endo order, sentinel le[n]
ulong n_;
// Number of digits
ulong j_;
mixedradix_endo(const ulong *m, ulong n, ulong mm=0)

9.4: endo order

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

227
M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

5
.
1
3
4
2
.
1
3
4
2
.
1
3
4
2

6
.
.
.
.
.
1
1
1
1
1
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
0
1
3
4
2
5
6
8
9
7
15
16
18
19
17

15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

.
1
3
4
2
.
1
3
4
2
.
1
3
4
2

5
5
5
5
5
4
4
4
4
4
2
2
2
2
2

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
25
26
28
29
27
20
21
23
24
22
10
11
13
14
12

Figure 9.4-A: Mixed radix numbers in endo order, dots denote zeros. The radix vector is M = [5, 6].
Columns ‘x’ give the values.
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

{
n_ = n;
a_[n_] = 1; // sentinel:
m1_ = new ulong[n_];

!= 0

le_ = new ulong[n_+1];
le_[n_] = 0; // sentinel:

!= a[n]
le_[k] = 2 - (m1_[k]==1);

first();
}
[--snip--]

The ﬁrst word is all zero, the last can be read from the array le_[]:
1
2
3
4
5
6
7
8
9
10
11
12

void first()
{
j_ = n_;
}
void last()
{
j_ = n_;
}
[--snip--]

a_[k] = 0;

a_[k] = le_[k];

In the computation of the successor the function next_endo() is used instead of a simple increment:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

bool next()
{
bool ret = false;
ulong j = 0;
while ( a_[j]==le_[j] ) { a_[j]=0; ++j; } // can touch sentinel
if ( j<n_ ) // only if no overflow
{
a_[j] = next_endo(a_[j], m1_[j]); // increment
ret = true;
}
j_ = j;
return ret;
}
bool prev()
{
bool ret = false;
ulong j = 0;
while ( a_[j]==0 )

{ a_[j]=le_[j]; ++j; }

228


23
24
25
26
27
28
29
30
31
32

if ( j<n_ ) // only if no overflow
{
a_[j] = prev_endo(a_[j], m1_[j]);
ret = true;
}

// decrement

j_ = j;
return ret;
}
[--snip--]

The function next() generates between about 115 million (radix 2) and 180 million (radix 16) numbers
per second. The listing in ﬁgure 9.4-A was created with the program [FXT: comb/mixedradix-endodemo.cc].

9.5

Gray code for endo order

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

M=[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

5
.
1
3
4
2
2
4
3
1
.
.
1
3
4
2

6
.
.
.
.
.
1
1
1
1
1
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
0
1
3
4
2
7
9
8
6
5
15
16
18
19
17

j
0
0
0
0
1
0
0
0
0
1
0
0
0
0

d
1
1
1
1
1
-1
-1
-1
-1
1
1
1
1
1

15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

2
4
3
1
.
.
1
3
4
2
2
4
3
1
.

5
5
5
5
5
4
4
4
4
4
2
2
2
2
2

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x
27
29
28
26
25
20
21
23
24
22
12
14
13
11
10

j
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0

d
1
-1
-1
-1
-1
1
1
1
1
1
1
-1
-1
-1
-1

Figure 9.5-A: Mixed radix numbers in endo Gray code, dots denote zeros. The radix vector is M = [4, 5].
Columns ‘x’ give the values, columns ‘j’ and ‘d’ give the position of last change and its direction,
respectively.
A Gray code for mixed radix numbers in endo order is a modiﬁcation of the CAT algorithm for the Gray
code described in section 9.2 on page 220 [FXT: class mixedradix endo gray in comb/mixedradixendo-gray.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class mixedradix_endo_gray
{
public:
ulong *a_; // mixed radix digits
ulong *m1_; // radices (minus one)
ulong *i_; // direction
ulong *le_; // last positive digit in endo order
ulong n_;
// n_ digits
ulong j_;
int dm_;
[--snip--]
void first()
{
j_ = n_;
dm_ = 0;
}

a_[k] = 0;
i_[k] = +1;

In the computation of the last number the digits from the last even radix to the end have to be set to
the last digit in endo order:
1
2
3
4

void last()
{

a_[k] = 0;
i_[k] = -1UL;

9.6: Fixed sum of digits
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// find position of last even radix:
ulong z = 0;
for (ulong i=0; i<n_; ++i) if ( m1_[i]&1 )
while ( z<n_ ) // last even .. end:
{
a_[z] = le_[z];
i_[z] = +1;
++z;
}

229

z = i;

j_ = 0;
dm_ = -1;
}
[--snip--]

The successor is computed as follows:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

bool next()
{
ulong j = 0;
ulong ij;
while ( (ij=i_[j]) ) // can touch sentinel i[n]==0
{
ulong dj;
bool ovq; // overflow?
if ( ij == 1 )
{
dj = next_endo(a_[j], m1_[j]);
ovq = (dj==0);
}
else
{
ovq = (a_[j]==0);
dj = prev_endo(a_[j], m1_[j]);
}
if ( ovq ) i_[j] = -ij;
else
{
a_[j] = dj;
dm_ = ij;
j_ = j;
return true;
}
++j;
}
return false;
}
[--snip--]

For the routine for computation of the predecessor change the test if ( ij == 1 ) to if ( ij != 1 ).
About 65 million (radix 2) and 110 million (radix 16) numbers per second are generated. The listing in
figure 9.5-A was created with the program [FXT: comb/mixedradix-endo-gray-demo.cc].

9.6

Fixed sum of digits

Mixed radix numbers with sum of digits 4 in lexicographic order are shown in figure 9.6-A. The numbers
in falling factorial base correspond to length-6 permutations with 5 inversions (left, see section 10.1.1),
the radix-4 numbers correspond to compositions of 4 into 4 parts of size at most 3 (middle, see section
7.1 on page 194), and the binary numbers correspond to combinations 7 (right, see section 6.2 on page
4
177). The numbers also correspond to the k-subsets (combinations) of multisets, see section 13.1 on page
295. The listings were created with the program [FXT: comb/mixedradix-sod-lex-demo.cc].
The successor is computed by determining the position j of the leftmost nonzero digit whose right neighbor
can be incremented. After the increment the digits at positions up to j are set to the (lexicographically)
first string such that the sum of digits is preserved. Sentinels are used with the scans [FXT: class
mixedradix sod lex in comb/mixedradix-sod-lex.h]:
1

class mixedradix_sod_lex

230


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
4 . . .
3 1 . .
2 2 . .
1 3 . .
. 4 . .
3 . 1 .
2 1 1 .
1 2 1 .
. 3 1 .
2 . 2 .
1 1 2 .
. 2 2 .
1 . 3 .
. 1 3 .
3 . . 1
2 1 . 1
1 2 . 1
. 3 . 1
2 . 1 1
1 1 1 1
. 2 1 1
1 . 2 1
. 1 2 1
. . 3 1
2 . . 2
1 1 . 2
. 2 . 2
1 . 1 2
. 1 1 2
. . 2 2
3 . . .
2 1 . .
1 2 . .
. 3 . .
2 . 1 .
1 1 1 .
. 2 1 .
1 . 2 .
. 1 2 .
. . 3 .
2 . . 1
1 1 . 1
. 2 . 1
1 . 1 1
. 1 1 1
. . 2 1
1 . . 2
. 1 . 2
. . 1 2

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

radix-4
3 1 . .
2 2 . .
1 3 . .
3 . 1 .
2 1 1 .
1 2 1 .
. 3 1 .
2 . 2 .
1 1 2 .
. 2 2 .
1 . 3 .
. 1 3 .
3 . . 1
2 1 . 1
1 2 . 1
. 3 . 1
2 . 1 1
1 1 1 1
. 2 1 1
1 . 2 1
. 1 2 1
. . 3 1
2 . . 2
1 1 . 2
. 2 . 2
1 . 1 2
. 1 1 2
. . 2 2
1 . . 3
. 1 . 3
. . 1 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

1
1
1
1
.
1
1
1
.
1
1
.
1
.
.
1
1
1
.
1
1
.
1
.
.
1
1
.
1
.
.
1
.
.
.

radix-2
1 1 1 .
1 1 . 1
1 . 1 1
. 1 1 1
1 1 1 1
1 1 . .
1 . 1 .
. 1 1 .
1 1 1 .
1 . . 1
. 1 . 1
1 1 . 1
. . 1 1
1 . 1 1
. 1 1 1
1 1 . .
1 . 1 .
. 1 1 .
1 1 1 .
1 . . 1
. 1 . 1
1 1 . 1
. . 1 1
1 . 1 1
. 1 1 1
1 . . .
. 1 . .
1 1 . .
. . 1 .
1 . 1 .
. 1 1 .
. . . 1
1 . . 1
. 1 . 1
. . 1 1

.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 9.6-A: Mixed radix numbers with sum of digits 4 in lexicographic order: 5-digit falling factorial
base (left), 4-digit radix 4 (middle), and 7-digit binary (right).
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
public:
ulong
ulong
ulong
ulong
ulong
ulong

*a_;
*m1_;
n_;
s_;
j_;
sm_;

//
//
//
//
//
//

digits
nines (radix minus one) for each digit
Number of digits
Sum of digits
rightmost position of last change
max possible sum of digits (arg s with first())

public:
mixedradix_sod_lex(ulong n, ulong mm, const ulong *m=0)
{
n_ = n;
a_[n_] = 1;
// sentinel !=0
m1_[n_] = 2; // sentinel >a[n]
a_[n_+1] = 0;
// sentinel ==0
m1_[n_+1] = 1; // sentinel >0
ulong s = 0;
for (ulong i=0; i<n_; ++i)

s += m1_[i];

9.6: Fixed sum of digits
24
25
26
27
28

231

sm_ = s;
j_ = n_ - 1;
}
[--snip--]

The sum of digits is supplied with the method first():
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

bool first(ulong k)
{
s_ = k;
if ( s_ > sm_ )

return false;

// too big

ulong i = 0;
ulong s = s_;
while ( s )
{
const ulong m1 = m1_[i];
if ( s >= m1 ) { a_[i] = m1; s -= m1; }
else
{ a_[i] = s; break; }
++i;
}
while ( ++i<n_ )

{ a_[i] = 0; }

j_ = n_ - 1;
return true;
}
bool next()
{
ulong j = 0;
ulong s = 0;
while ( (a_[j]==0) || (a_[j+1]==m1_[j+1]) ) // can read sentinels
{
s += a_[j];
a_[j]=0;
++j;
}
j_ = j+1; // record rightmost position of change
if ( j_ >= n_ )

return false;

// current is last

s += (a_[j] - 1);
a_[j] = 0;
++a_[j+1]; // increment next digit
ulong i = 0;
do // set prefix to lex-first string
{
const ulong m1 = m1_[i];
if ( s >= m1 ) { a_[i] = m1; s -= m1; }
else
{ a_[i] = s; s = 0; }
++i;
}
while ( s );
return true;
}
[--snip--]
};

232

Chapter 10: Permutations

Chapter 10

Permutations
We present algorithms for the generation of all permutations in various orders such as lexicographic and
minimal-change order. Several methods to convert permutations to and from mixed radix numbers with
factorial base are described. Algorithms for application, inversion, and composition of permutations and
for the generation of random permutations are given in chapter 2.

10.1

Factorial representations of permutations

The factorial number system corresponds to the mixed radix bases M = [2, 3, 4, . . .] (rising factorial base)
or M = [. . . , 4, 3, 2] (falling factorial base). A factorial number with (n − 1)-digits can have n! different
values. We develop different methods to convert factorial numbers to permutations and vice versa.

10.1.1

The Lehmer code (inversion table)

Each permutation of n elements can be converted to a unique (n − 1)-digit factorial number A =
[a0 , a1 , . . . , an−2 ] in the falling factorial base: for each index k (except the last) count the number of
elements with indices to the right of k that are less than the current element [FXT: comb/fact2perm.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13

void perm2ffact(const ulong *x, ulong n, ulong *fc)
// Convert permutation in x[0,...,n-1] into
//
the (n-1) digit falling factorial representation in fc[0,...,n-2].
// We have: fc[0]<n, fc[1]<n-1, ..., fc[n-2]<2 (falling radices)
{
for (ulong k=0; k<n-1; ++k)
{
ulong xk = x[k];
ulong i = 0;
for (ulong j=k+1; j<n; ++j) if ( x[j]<xk ) ++i;
fc[k] = i;
}
}

The routine works because all elements of the permutation are distinct. The factorial representation
computed is called the Lehmer code of the permutation. For example, the permutation P = [3, 0, 1, 4, 2]
has the inversion table I = [3, 0, 0, 1]: three elements less than the first element (3) lie to the right of it,
no elements less than the second (0) or third (1) elements lies right to them, and one element less than
4 lies right of it.
An alternative term for the Lehmer code is inversion table: an inversion of a permutation
[x0 , x1 , . . . , xn−1 ]

(10.1-1)

is a pair of indices k and j where k < j and xj < xk . Now fix k and call such an inversion (where an
element xj right of k is less than xk ) a right inversion at k. The inversion table [i0 , i1 , . . . , in−2 ] of a
permutation is computed by setting ik to the number of right inversions at k. This is exactly what the
given routine does.
A routine that computes the permutation for a given Lehmer code is

10.1: Factorial representations of permutations
1
2
3
4
5
6
7
8
9
10
11
12
13

233

void ffact2perm(const ulong *fc, ulong n, ulong *x)
// Inverse of perm2ffact():
// Convert the (n-1) digit falling factorial representation in fc[0,...,n-2].
// into permutation in x[0,...,n-1]
// Must have: fc[0]<n, fc[1]<n-1, ..., fc[n-2]<2 (falling radices)
{
{
ulong i = fc[k];
if ( i ) rotate_right1(x+k, i+1);
}
}

A routine to compute the inverse permutation from the Lehmer code is
1
2
3
4
5
6
7
8
9
10
11
12

void ffact2invperm(const ulong *fc, ulong n, ulong *x)
// Convert the (n-1) digit falling factorial representation in fc[0,...,n-2]
// into permutation in x[0,...,n-1] such that
// the permutation is the inverse of the one computed via ffact2perm().
{
for (ulong k=n-2; (long)k>=0; --k)
{
ulong i = fc[k];
if ( i ) rotate_left1(x+k, i+1);
}
}

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . .
1 . .
2 . .
3 . .
. 1 .
1 1 .
2 1 .
3 1 .
. 2 .
1 2 .
2 2 .
3 2 .
. . 1
1 . 1
2 . 1
3 . 1
. 1 1
1 1 1
2 1 1
3 1 1
. 2 1
1 2 1
2 2 1
3 2 1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 . 1 3 ]
[ 3 . 1 2 ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 3 1 2 . ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ 2 3 1 . ]
[ 3 2 1 . ]

rev.compl.perm.
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ . 2 1 3 ]
[ . 3 1 2 ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ 1 2 . 3 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 2 . 3 1 ]
[ 2 1 3 . ]
[ 2 . 1 3 ]
[ 3 . 1 2 ]
[ 3 . 2 1 ]
[ 3 1 2 . ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact
. . .
. . 1
. . 2
. . 3
. 1 .
. 1 1
. 1 2
. 1 3
. 2 .
. 2 1
. 2 2
. 2 3
1 . .
1 . 1
1 . 2
1 . 3
1 1 .
1 1 1
1 1 2
1 1 3
1 2 .
1 2 1
1 2 2
1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 10.1-A: Numbers in falling factorial base and permutations so that the number is the Lehmer
code of it (left columns). Dots denote zeros. The rising factorial representation of the reversed and
complemented permutation equals the reversed Lehmer code (right columns).
A similar method can compute a representation in the rising factorial base. We count the number of
elements to the left of k that are greater than the element at k (the number of left inversions at k):
1
2
3
4
5
6
7
8
9

void perm2rfact(const ulong *x, ulong n, ulong *fc)
// Convert permutation in x[0,...,n-1] into
//
the (n-1) digit rising factorial representation in fc[0,...,n-2].
// We have: fc[0]<2, fc[1]<3, ..., fc[n-2]<n (rising radices)
{
{
ulong xk = x[k];
ulong i = 0;

234


0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact
. . .
1 . .
. 1 .
1 1 .
. 2 .
1 2 .
. . 1
1 . 1
. 1 1
1 1 1
. 2 1
1 2 1
. . 2
1 . 2
. 1 2
1 1 2
. 2 2
1 2 2
. . 3
1 . 3
. 1 3
1 1 3
. 2 3
1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 1 3 . 2 ]
[ 3 1 . 2 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ . 3 2 1 ]
[ 3 . 2 1 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 1 3 2 . ]
[ 3 1 2 . ]
[ 2 3 1 . ]
[ 3 2 1 . ]

rev.compl.perm.
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 2 1 3 ]
[ . 2 3 1 ]
[ . 3 1 2 ]
[ . 3 2 1 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ 2 . 1 3 ]
[ 2 . 3 1 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 . 1 2 ]
[ 3 . 2 1 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ 3 2 . 1 ]
[ 3 2 1 . ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . .
. . 1
. 1 .
. 1 1
. 2 .
. 2 1
1 . .
1 . 1
1 1 .
1 1 1
1 2 .
1 2 1
2 . .
2 . 1
2 1 .
2 1 1
2 2 .
2 2 1
3 . .
3 . 1
3 1 .
3 1 1
3 2 .
3 2 1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 10.1-B: Numbers in rising factorial base and permutations so that the number is the Lehmer
code of it (left columns). The reversed and complemented permutations and their falling factorial representations are shown in the right columns. They appear in lexicographic order.
10
11
12
13

for (ulong j=0; j<k; ++j)
fc[k-1] = i;

if ( x[j]>xk )

++i;

}
}

1
2
3
4
5
6
7
8
9
10

void rfact2perm(const ulong *fc, ulong n, ulong *x)
{
ulong *y = x+n;
for (ulong k=n-1; k!=0; --k, --y)
{
ulong i = fc[k-1];
if ( i ) { ++i; rotate_left1(y-i, i); }
}
}

A routine for the inverse permutation is
1
2
3
4
5
6
7
8
9
10
11
12
13

void rfact2invperm(const ulong *fc, ulong n, ulong *x)
// Convert the (n-1) digit rising factorial representation in fc[0,...,n-2].
// into permutation in x[0,...,n-1] such that
// the permutation is the inverse of the one computed via rfact2perm().
{
ulong *y = x + 2;
for (ulong k=0; k<n-1; ++k, ++y)
{
ulong i = fc[k];
if ( i ) { ++i; rotate_right1(y-i, i); }
}
}

The permutations corresponding to the Lehmer codes (in counting order) are shown in ﬁgure 10.1-A
(left columns) which was created with the program [FXT: comb/fact2perm-demo.cc]. The permutation
whose rising factorial representation is the digit-reversed Lehmer code is computed by reversing and
complementing (replacing each element x by n − 1 − x) the original permutation:
Lehmer code
[3,0,0,1]

permutation
[3,0,1,4,2]

rev.perm
compl.rev.perm
[2,4,1,0,3] [2,0,3,4,1]

rising fact
[1,0,0,3]

235

The permutations obtained from counting in the rising factorial base are shown in ﬁgure 10.1-B.
10.1.1.1

Computation with large arrays

With the left-right array described in section 4.7 on page 166 the conversion to and from the Lehmer
code can be done in O (n log n) operations [FXT: comb/big-fact2perm.cc]:
1
2
3
4
5
6
7
8
9
10
11

void perm2ffact(const ulong *x, ulong n, ulong *fc, left_right_array &LR)
{
LR.set_all();
{
// i := number of Set positions Left of x[k], Excluding x[k].
ulong i = LR.num_SLE( x[k] );
LR.get_set_idx_chg( i );
fc[k] = i;
}
}

The LR-array passed as an extra argument has to be of size n. Conversion of an array of, say, 10 million
entries is a matter of seconds if this routine is used [FXT: comb/big-fact2perm-demo.cc].
1
2
3
4
5
6
7
8
9
10
11

void ffact2perm(const ulong *fc, ulong n, ulong *x, left_right_array &LR)
{
LR.free_all();
{
ulong i = LR.get_free_idx_chg( fc[k] );
x[k] = i;
}
ulong i = LR.get_free_idx_chg( 0 );
x[n-1] = i;
}

The routines for rising factorials are
1
2
3
4
5
6
7
8
9
10
11

void perm2rfact(const ulong *x, ulong n, ulong *fc, left_right_array &LR)
{
LR.set_all();
for (ulong k=0, r=n-1; k<n-1; ++k, --r) // r == n-1-k;
{
// i := number of Set positions Left of x[r], Excluding x[r].
ulong i = LR.num_SLE( x[r] );
LR.get_set_idx_chg( i );
fc[r-1] = r - i;
}
}

and
1
2
3
4
5
6
7
8
9
10
11

void rfact2perm(const ulong *fc, ulong n, ulong *x, left_right_array &LR)
{
LR.free_all();
{
ulong i = LR.get_free_idx_chg( fc[n-2-k] );
x[n-1-k] = n-1-i;
}
x[0] = n-1-i;
}

The conversion of the routines that compute permutations from factorial numbers into routines that
compute the inverse permutations is especially easy, just change the code as follows:
x[a] = b;

=-->

x[b] = a;

We obtain the routines
1
2
3
4
5
6
7

void ffact2invperm(const ulong *fc, ulong n, ulong *x, left_right_array &LR)
{
LR.free_all();
{
ulong i = LR.get_free_idx_chg( fc[k] );
x[i] = k;

236
8
9
10
11

}
x[i] = n-1;

}

and
1
2
3
4
5
6
7
8
9
10
11

void rfact2invperm(const ulong *fc, ulong n, ulong *x, left_right_array &LR)
{
LR.free_all();
{
ulong i = LR.get_free_idx_chg( fc[n-2-k] );
x[n-1-i] = n-1-k;
}
x[n-1-i] = 0;
}

10.1.1.2

The number of inversions

The number of inversions of a permutation can be computed as follows [FXT: perm/permq.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13

ulong
count_inversions(const ulong *f, ulong n)
// Return number of inversions in f[],
// i.e. number of pairs k,j where k<j and f[k]>f[j]
{
ulong ct = 0;
{
ulong fk = f[k];
for (ulong j=0; j<k; ++j) ct += ( fk<f[j] );
}
return ct;
}

The algorithm is O(n2 ). For large arrays we can use the fact that the number of inversions equals the
sum of digits of the Lehmer code, the algorithm is O (n log n):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ulong
count_inversions(const ulong *f, ulong n, left_right_array *tLR)
{
left_right_array *LR = tLR;
if ( tLR==0 ) LR = new left_right_array(n);
ulong ct = 0;
LR->set_all();
{
ulong i = LR->num_SLE( f[k] );
LR->get_set_idx_chg( i );
ct += i;
}
if ( tLR==0 )
return ct;

delete LR;

}

10.1.2

A representation via reversals ‡

Replacing the rotations in the computation of a permutation from its Lehmer code by reversals gives
a diﬀerent one-to-one relation between factorial numbers and permutations. The routine for the falling
factorial base is [FXT: comb/fact2perm-rev.cc]:
1
2
3
4
5
6
7
8
9

void perm2ffact_rev(const ulong *x, ulong n, ulong *fc)
{
ALLOCA(ulong, ti, n); // inverse permutation
for (ulong k=0; k<n; ++k) ti[x[k]] = k;
{
ulong j; // find element k
for (j=k; j<n; ++j) if ( ti[j]==k ) break;
j -= k;


237

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . .
1 . .
2 . .
3 . .
. 1 .
1 1 .
2 1 .
3 1 .
. 2 .
1 2 .
2 2 .
3 2 .
. . 1
1 . 1
2 . 1
3 . 1
. 1 1
1 1 1
2 1 1
3 1 1
. 2 1
1 2 1
2 2 1
3 2 1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 1 . 3 ]
[ 3 2 1 . ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 . 1 3 ]
[ 3 1 2 . ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ 2 3 . 1 ]
[ 3 . 1 2 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 2 1 3 . ]
[ 3 2 . 1 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ 2 . 3 1 ]
[ 3 1 . 2 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 2 3 1 . ]
[ 3 . 2 1 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv.perm.
. 1 2 3 ]
1 . 2 3 ]
2 1 . 3 ]
3 2 1 . ]
. 2 1 3 ]
2 . 1 3 ]
1 2 . 3 ]
3 1 2 . ]
. 3 2 1 ]
3 . 2 1 ]
2 3 . 1 ]
1 2 3 . ]
. 1 3 2 ]
1 . 3 2 ]
3 1 . 2 ]
2 3 1 . ]
. 3 1 2 ]
3 . 1 2 ]
1 3 . 2 ]
2 1 3 . ]
. 2 3 1 ]
2 . 3 1 ]
3 2 . 1 ]
1 3 2 . ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . .
1 . .
2 . .
3 . .
. 1 .
2 1 .
1 1 .
3 1 .
. 2 .
3 2 1
2 2 .
1 1 1
. . 1
1 . 1
3 1 1
2 2 1
. 2 1
3 2 .
1 2 1
2 . 1
. 1 1
2 1 1
3 . 1
1 2 .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact
. . .
1 . .
. 1 .
1 1 .
. 2 .
1 2 .
. . 1
1 . 1
. 1 1
1 1 1
. 2 1
1 2 1
. . 2
1 . 2
. 1 2
1 1 2
. 2 2
1 2 2
. . 3
1 . 3
. 1 3
1 1 3
. 2 3
1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 2 1 . 3 ]
[ 1 2 . 3 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 1 3 . 2 ]
[ . 3 2 1 ]
[ 3 . 2 1 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]
[ 2 3 1 . ]
[ 3 1 2 . ]
[ 1 3 2 . ]
[ 1 2 3 . ]
[ 2 1 3 . ]

inv.perm.
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 2 . 1 3 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 2 . 3 1 ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 2 1 . ]
[ 3 2 . 1 ]
[ 3 1 2 . ]
[ 3 . 2 1 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact
. . .
1 . .
. 1 .
1 2 .
. 2 .
1 1 .
. . 1
1 . 1
. 1 2
. 2 3
1 2 3
1 1 2
. . 2
1 1 3
. 1 1
1 2 1
. 2 2
1 . 3
. . 3
1 2 2
. 1 3
1 . 2
1 1 1
. 2 1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 10.1-C: Numbers in falling (top) and rising (bottom) factorial base and permutations so that
the number is the alternative (reversal) code of it (left columns). The inverse permutations and their
factorial representations are shown in the right columns. Dots denote zeros.

238
10
11
12
13

fc[k] = j;
reverse(ti+k, j+1);
}

}

The routine is the inverse of
1
2
3
4
5
6
7
8
9
10

void ffact2perm_rev(const ulong *fc, ulong n, ulong *x)
{
{
ulong i = fc[k];
// Lehmer: rotate_right1(x+k, i+1);
if ( i ) reverse(x+k, i+1);
}
}

Figure 10.1-C shows the permutations of 4 elements and their factorial representations. It was created
with the program [FXT: comb/fact2perm-rev-demo.cc]. The routines for the rising factorial base are
1
2
3
4
5
6
7
8
9
10
11
12
13

void perm2rfact_rev(const ulong *x, ulong n, ulong *fc)
{
for (ulong k=0; k<n; ++k) ti[x[k]] = k;
for (ulong k=n-1; k!=0; --k)
{
ulong j; // find element k
for (j=0; j<=k; ++j) if ( ti[j]==k ) break;
j = k - j;
fc[k-1] = j;
reverse(ti+k-j, j+1);
}
}

and
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void rfact2perm_rev(const ulong *fc, ulong n, ulong *x)
{
ulong *y = x+n;
for (ulong k=n-1; k!=0; --k, --y)
{
ulong i = fc[k-1];
if ( i )
{
++i;
// Lehmer: rotate_left1(y-i, i);
reverse(y-i, i);
}
}
}

10.1.3

A representation via rotations ‡

To compute permutations from the Lehmer code we used rotations by one position of length determined
by the digits. If we ﬁx the length and let the amount of rotation be the value of the digits, we obtain
two more methods to compute permutations from factorial numbers [FXT: comb/fact2perm-rot.cc]:
1
2
3
4
5
6
7
8
9

void ffact2perm_rot(const ulong *fc, ulong n, ulong *x)
{
for (ulong k=0, len=n; k<n-1; ++k, --len)
{
ulong i = fc[k];
rotate_left(x+k, len, i);
}
}

1
2
3
4
5
6

void rfact2perm_rot(const ulong *fc, ulong n, ulong *x)
{
for (ulong k=n-2, len=n; len>1; --k, --len)
{
ulong i = fc[k];

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

ffact
. . .
1 . .
2 . .
3 . .
. 1 .
1 1 .
2 1 .
3 1 .
. 2 .
1 2 .
2 2 .
3 2 .
. . 1
1 . 1
2 . 1
3 . 1
. 1 1
1 1 1
2 1 1
3 1 1
. 2 1
1 2 1
2 2 1
3 2 1

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

permutation
[ . 1 2 3 ]
[ 1 2 3 . ]
[ 2 3 . 1 ]
[ 3 . 1 2 ]
[ . 2 3 1 ]
[ 1 3 . 2 ]
[ 2 . 1 3 ]
[ 3 1 2 . ]
[ . 3 1 2 ]
[ 1 . 2 3 ]
[ 2 1 3 . ]
[ 3 2 . 1 ]
[ . 1 3 2 ]
[ 1 2 . 3 ]
[ 2 3 1 . ]
[ 3 . 2 1 ]
[ . 2 1 3 ]
[ 1 3 2 . ]
[ 2 . 3 1 ]
[ 3 1 . 2 ]
[ . 3 2 1 ]
[ 1 . 3 2 ]
[ 2 1 . 3 ]
[ 3 2 1 . ]

inv.
[ . 1
[ 3 .
[ 2 3
[ 1 2
[ . 3
[ 2 .
[ 1 2
[ 3 1
[ . 2
[ 1 .
[ 3 1
[ 2 3
[ . 1
[ 2 .
[ 3 2
[ 1 3
[ . 2
[ 3 .
[ 1 3
[ 2 1
[ . 3
[ 1 .
[ 2 1
[ 3 2

perm.
2 3 ]
1 2 ]
. 1 ]
3 . ]
1 2 ]
3 1 ]
. 3 ]
2 . ]
3 1 ]
2 3 ]
. 2 ]
1 . ]
3 2 ]
1 3 ]
. 1 ]
2 . ]
1 3 ]
2 1 ]
. 2 ]
3 . ]
2 1 ]
3 2 ]
. 3 ]
1 . ]

239

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact
. . .
1 . .
. 1 .
1 1 .
. 2 .
1 2 .
. . 1
1 . 1
. 1 1
1 1 1
. 2 1
1 2 1
. . 2
1 . 2
. 1 2
1 1 2
. 2 2
1 2 2
. . 3
1 . 3
. 1 3
1 1 3
. 2 3
1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

permutation
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 2 3 1 ]
[ . 2 1 3 ]
[ . 3 1 2 ]
[ . 3 2 1 ]
[ 1 2 3 . ]
[ 1 2 . 3 ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 2 . 1 3 ]
[ 2 . 3 1 ]
[ 2 1 3 . ]
[ 2 1 . 3 ]
[ 3 . 1 2 ]
[ 3 . 2 1 ]
[ 3 1 2 . ]
[ 3 1 . 2 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]

inv.
[ . 1
[ . 1
[ . 3
[ . 2
[ . 2
[ . 3
[ 3 .
[ 2 .
[ 2 .
[ 3 .
[ 1 .
[ 1 .
[ 2 3
[ 3 2
[ 1 2
[ 1 3
[ 3 1
[ 2 1
[ 1 2
[ 1 3
[ 3 1
[ 2 1
[ 2 3
[ 3 2

perm.
2 3 ]
3 2 ]
1 2 ]
1 3 ]
3 1 ]
2 1 ]
1 2 ]
1 3 ]
3 1 ]
2 1 ]
2 3 ]
3 2 ]
. 1 ]
. 1 ]
. 3 ]
. 2 ]
. 2 ]
. 3 ]
3 . ]
2 . ]
2 . ]
3 . ]
1 . ]
1 . ]

Figure 10.1-D: Falling (left) and rising (right) factorial numbers and permutations via rotation code.
7
8
9

rotate_left(x+n-len, len, i);
}
}

Figure 10.1-D shows the permutations of 4 elements corresponding to the falling and rising factorial
numbers in lexicographic order [FXT: comb/fact2perm-rot-demo.cc]. The second half of the inverse
permutations is the reversed permutations in the ﬁrst half in reversed order. The columns of the inverse
permutations with the falling factorials are cyclic shifts of each other, see section 10.12 on page 271 for
more orderings with this property.
The routines to compute the factorial representation of a given permutation are
1
2
3
4
5
6
7
8
9
10
11

void perm2ffact_rot(const ulong *x, ulong n, ulong *fc)
{
ALLOCA(ulong, t, n);
for (ulong k=0; k<n; ++k) t[x[k]] = k; // inverse permutation
{
ulong s = 0; while ( t[k+s] != k ) ++s;
if ( s!=0 ) rotate_left(t+k, n-k, s);
fc[k] = s;
}
}

and
void perm2rfact_rot(const ulong *x, ulong n, ulong *fc)
{
for (ulong k=0; k<n; ++k) t[x[k]] = k; // inverse permutation
{
ulong s = 0; while ( t[k+s] != k ) ++s;
if ( s!=0 ) rotate_left(t+k, n-k, s);
fc[n-2-k] = s;
}
}

10.1.4

A representation via swaps

The following routines compute factorial representations via swaps, the method is adapted from [258].
The complexity of the direct implementation is O(n) [FXT: comb/fact2perm-swp.cc]:

240


[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact.
. . . ]
1 . . ]
2 . . ]
3 . . ]
. 1 . ]
1 1 . ]
2 1 . ]
3 1 . ]
. 2 . ]
1 2 . ]
2 2 . ]
3 2 . ]
. . 1 ]
1 . 1 ]
2 . 1 ]
3 . 1 ]
. 1 1 ]
1 1 1 ]
2 1 1 ]
3 1 1 ]
. 2 1 ]
1 2 1 ]
2 2 1 ]
3 2 1 ]

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 1 . 3 ]
[ 3 1 2 . ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 . 1 3 ]
[ 3 2 1 . ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ 2 3 . 1 ]
[ 3 . 2 1 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 2 1 3 . ]
[ 3 1 . 2 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ 2 . 3 1 ]
[ 3 2 . 1 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 2 3 1 . ]
[ 3 . 1 2 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv.perm.
. 1 2 3 ]
1 . 2 3 ]
2 1 . 3 ]
3 1 2 . ]
. 2 1 3 ]
2 . 1 3 ]
1 2 . 3 ]
3 2 1 . ]
. 3 2 1 ]
3 . 2 1 ]
2 3 . 1 ]
1 3 2 . ]
. 1 3 2 ]
1 . 3 2 ]
3 1 . 2 ]
2 1 3 . ]
. 3 1 2 ]
3 . 1 2 ]
1 3 . 2 ]
2 3 1 . ]
. 2 3 1 ]
2 . 3 1 ]
3 2 . 1 ]
1 2 3 . ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact.
. . . ]
. . 1 ]
. . 2 ]
. . 3 ]
. 1 . ]
. 1 1 ]
. 1 2 ]
. 1 3 ]
. 2 . ]
. 2 1 ]
. 2 2 ]
. 2 3 ]
1 . . ]
1 . 1 ]
1 . 2 ]
1 . 3 ]
1 1 . ]
1 1 1 ]
1 1 2 ]
1 1 3 ]
1 2 . ]
1 2 1 ]
1 2 2 ]
1 2 3 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact
. . .
1 . .
. 1 .
1 1 .
. 2 .
1 2 .
. . 1
1 . 1
. 1 1
1 1 1
. 2 1
1 2 1
. . 2
1 . 2
. 1 2
1 1 2
. 2 2
1 2 2
. . 3
1 . 3
. 1 3
1 1 3
. 2 3
1 2 3

permutation
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 2 1 3 ]
[ . 3 1 2 ]
[ . 3 2 1 ]
[ . 2 3 1 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 2 . 1 3 ]
[ 3 . 1 2 ]
[ 3 . 2 1 ]
[ 2 . 3 1 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ 1 2 . 3 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ 3 1 2 . ]
[ 2 1 3 . ]
[ 3 2 1 . ]
[ 2 3 1 . ]
[ 1 3 2 . ]
[ 1 2 3 . ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv.perm.
. 1 2 3 ]
. 1 3 2 ]
. 2 1 3 ]
. 2 3 1 ]
. 3 2 1 ]
. 3 1 2 ]
1 . 2 3 ]
1 . 3 2 ]
1 2 . 3 ]
1 2 3 . ]
1 3 2 . ]
1 3 . 2 ]
2 1 . 3 ]
2 1 3 . ]
2 . 1 3 ]
2 . 3 1 ]
2 3 . 1 ]
2 3 1 . ]
3 1 2 . ]
3 1 . 2 ]
3 2 1 . ]
3 2 . 1 ]
3 . 2 1 ]
3 . 1 2 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . .
. . 1
. 1 .
. 1 1
. 2 .
. 2 1
1 . .
1 . 1
1 1 .
1 1 1
1 2 .
1 2 1
2 . .
2 . 1
2 1 .
2 1 1
2 2 .
2 2 1
3 . .
3 . 1
3 1 .
3 1 1
3 2 .
3 2 1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 10.1-E: Numbers in falling (top) and rising (bottom) factorial base and permutations so that the
number is the alternative (swaps) code of it (left columns). The inverse permutations and their factorial
representations are shown in the right columns. Dots denote zeros.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

241

void perm2ffact_swp(const ulong *x, ulong n, ulong *fc)
{
for (ulong k=0; k<n; ++k) t[k] = x[k];
for (ulong k=0; k<n; ++k) ti[t[k]] = k;
{
ulong tk = t[k]; // >= k
fc[k] = tk - k;
ulong j = ti[k]; // location of element k, j>=k
ti[tk] = j;
t[j] = tk;
}
}
void perm2rfact_swp(const ulong *x, ulong n, ulong *fc)
{
for (ulong k=0; k<n; ++k) t[k] = x[k];
for (ulong k=0; k<n; ++k) ti[t[k]] = k;
{
ulong j = ti[k]; // location of element k, j>=k
fc[n-2-k] = j - k;
ulong tk = t[k]; // >=k
ti[tk] = j;
t[j] = tk;
}
}

Their inverses also have linear complexity, and no additional memory is needed. The routine for falling
base is
1
2
3
4
5
6
7
8
9

void ffact2perm_swp(const ulong *fc, ulong n, ulong *x)
{
{
ulong i = fc[k];
swap2( x[k], x[k+i] );
}
}

The routine for the rising base is
1
2
3
4
5
6
7
8
9

void rfact2perm_swp(const ulong *fc, ulong n, ulong *x)
{
for (ulong k=0,j=n-2; k<n-1; ++k,--j)
{
ulong i = fc[k];
swap2( x[j], x[j+i] );
}
}

The permutations corresponding to the alternative codes for the falling base are shown in ﬁgure 10.1-E
(left columns, top). The inverse permutation has the rising factorial representation that is digit-reversed
(right columns). The permutations corresponding to the alternative codes for rising base are shown at the
bottom of ﬁgure 10.1-E The listings were created with the program [FXT: comb/fact2perm-swp-demo.cc].
The inverse permutations can be computed by applying the swaps (which are self-inverse) in reversed
order, the routines are
1
2
3
4
5
6
7
8

void ffact2invperm_swp(const ulong *fc, ulong n, ulong *x)
// Generate inverse permutation wrt. ffact2perm_swp().
{
if ( n<=1 ) return;
ulong k = n-2;
do
{

242
9
10
11
12
13

ulong i = fc[k];
swap2( x[k], x[k+i] );
}
while ( k-- );

}

and
1
2
3
4
5
6
7
8
9
10
11
12
13
14

void rfact2invperm_swp(const ulong *fc, ulong n, ulong *x)
// Generate inverse permutation wrt. rfact2perm_swp().
{
if ( n<=1 ) return;
ulong k = n-2, j=0;
do
{
ulong i = fc[k];
swap2( x[j], x[j+i] );
++j;
}
while ( k-- );
}

The routines can serve as a means to find interesting orders for permutations. Indeed, the permutation
generator shown in section 10.4 on page 245 was found this way. A recursive algorithm for the (inverse)
permutations shown at the lower right of figure 10.1-E is given in section 11.4.1 on page 285.

10.2
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

Lexicographic order
permutation
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 2 1 3 ]
[ . 2 3 1 ]
[ . 3 1 2 ]
[ . 3 2 1 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ 2 . 1 3 ]
[ 2 . 3 1 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 . 1 2 ]
[ 3 . 2 1 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ 3 2 . 1 ]
[ 3 2 1 . ]

inv.
[ . 1
[ . 1
[ . 2
[ . 3
[ . 2
[ . 3
[ 1 .
[ 1 .
[ 2 .
[ 3 .
[ 2 .
[ 3 .
[ 1 2
[ 1 3
[ 2 1
[ 3 1
[ 2 3
[ 3 2
[ 1 2
[ 1 3
[ 2 1
[ 3 1
[ 2 3
[ 3 2

perm.
2 3 ]
3 2 ]
1 3 ]
1 2 ]
3 1 ]
2 1 ]
2 3 ]
3 2 ]
1 3 ]
1 2 ]
3 1 ]
2 1 ]
. 3 ]
. 2 ]
. 3 ]
. 2 ]
. 1 ]
. 1 ]
3 . ]
2 . ]
3 . ]
2 . ]
1 . ]
1 . ]

compl.
[ 3
[ 3
[ 3
[ 3
[ 3
[ 3
[ 2
[ 2
[ 1
[ .
[ 1
[ .
[ 2
[ 2
[ 1
[ .
[ 1
[ .
[ 2
[ 2
[ 1
[ .
[ 1
[ .

inv. perm.
2 1 . ]
2 . 1 ]
1 2 . ]
. 2 1 ]
1 . 2 ]
. 1 2 ]
3 1 . ]
3 . 1 ]
3 2 . ]
3 2 1 ]
3 . 2 ]
3 1 2 ]
1 3 . ]
. 3 1 ]
2 3 . ]
2 3 1 ]
. 3 2 ]
1 3 2 ]
1 . 3 ]
. 1 3 ]
2 . 3 ]
2 1 3 ]
. 2 3 ]
1 2 3 ]

reversed
[ 3 2 1
[ 2 3 1
[ 3 1 2
[ 1 3 2
[ 2 1 3
[ 1 2 3
[ 3 2 .
[ 2 3 .
[ 3 . 2
[ . 3 2
[ 2 . 3
[ . 2 3
[ 3 1 .
[ 1 3 .
[ 3 . 1
[ . 3 1
[ 1 . 3
[ . 1 3
[ 2 1 .
[ 1 2 .
[ 2 . 1
[ . 2 1
[ 1 . 2
[ . 1 2

perm.
. ]
. ]
. ]
. ]
. ]
. ]
1 ]
1 ]
1 ]
1 ]
1 ]
1 ]
2 ]
2 ]
2 ]
2 ]
2 ]
2 ]
3 ]
3 ]
3 ]
3 ]
3 ]
3 ]

Figure 10.2-A: All permutations of 4 elements in lexicographic order, their inverses, the complements
of the inverses, and the reversed permutations. Dots denote zeros.
The permutations in lexicographic order appear as if (read as numbers and) sorted numerically in ascending order, see figure 10.2-A. The first half of the inverse permutations are the reversed inverse
permutations in the second half: the position of zero in the first half of the inverse permutations lies in
the first half of each permutation, so their reversal gives the second half. Write I for the operator that
inverts a permutation, C for the complement, and R for reversal. Then we have
C

=

I RI

(10.2-1)

and thereby the first half of the permutations are the complements of the permutations in the second
half. An implementation of an iterative algorithm is [FXT: class perm lex in comb/perm-lex.h].

10.3: Co-lexicographic order
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class perm_lex
{
public:
ulong *p_;
ulong n_;

243

// permutation in 0, 1, ..., n-1, sentinel at [-1]
// number of elements to permute

public:
perm_lex(ulong n)
{
n_ = n;
p_ = new ulong[n_+1];
p_[0] = 0; // sentinel
++p_;
first();
}
~perm_lex() { --p_;
void first()

delete [] p_; }

{ for (ulong i=0; i<n_; i++)

const ulong *data()
[--snip--]

const

p_[i] = i; }

{ return p; }

The method next() computes the next permutation with each call. The routine perm_lex::next() is
based on code by Glenn Rhoads
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

bool next()
{
// find rightmost pair with p_[i] < p_[i+1]:
const ulong n1 = n_ - 1;
ulong i = n1;
do { --i; } while ( p_[i] > p_[i+1] );
if ( (long)i<0 ) return false; // last sequence is falling seq.
// find rightmost element p[j] less than p[i]:
ulong j = n1;
while ( p_[i] > p_[j] ) { --j; }
swap2(p_[i], p_[j]);
// Here the elements p[i+1], ..., p[n-1] are a falling sequence.
// Reverse order to the right:
ulong r = n1;
ulong s = i + 1;
while ( r > s ) { swap2(p_[r], p_[s]); --r; ++s; }
return true;
}

Using the class is no black magic [FXT: comb/perm-lex-demo.cc]:
ulong n = 4;
perm_lex P(n);
do
{
// visit permutation
}
while ( P.next() );

The routine generates about 130 million permutations per second. A faster algorithm is obtained by
modifying the update operation for the co-lexicographic order (section 10.3) on the right end of the
permutations [FXT: comb/perm-lex2.h]. The rate of generation is about 180 M/s when arrays are used
and about 305 M/s with pointers [FXT: comb/perm-lex2-demo.cc].
The routine for computing the successor can easily be adapted for permutations of a multiset, see section
13.2.2 on page 298.

10.3


Figure 10.3-A shows the permutations of 4 elements in co-lexicographic (colex) order. An algorithm for
the generation is implemented in [FXT: class perm colex in comb/perm-colex.h]:

244


0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ 3 2 1 . ]
[ 2 3 1 . ]
[ 3 1 2 . ]
[ 1 3 2 . ]
[ 2 1 3 . ]
[ 1 2 3 . ]
[ 3 2 . 1 ]
[ 2 3 . 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ 2 . 3 1 ]
[ . 2 3 1 ]
[ 3 1 . 2 ]
[ 1 3 . 2 ]
[ 3 . 1 2 ]
[ . 3 1 2 ]
[ 1 . 3 2 ]
[ . 1 3 2 ]
[ 2 1 . 3 ]
[ 1 2 . 3 ]
[ 2 . 1 3 ]
[ . 2 1 3 ]
[ 1 . 2 3 ]
[ . 1 2 3 ]

rfact
[ . . .
[ 1 . .
[ . 1 .
[ 1 1 .
[ . 2 .
[ 1 2 .
[ . . 1
[ 1 . 1
[ . 1 1
[ 1 1 1
[ . 2 1
[ 1 2 1
[ . . 2
[ 1 . 2
[ . 1 2
[ 1 1 2
[ . 2 2
[ 1 2 2
[ . . 3
[ 1 . 3
[ . 1 3
[ 1 1 3
[ . 2 3
[ 1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

inv.
[ 3 2
[ 3 2
[ 3 1
[ 3 .
[ 3 1
[ 3 .
[ 2 3
[ 2 3
[ 1 3
[ . 3
[ 1 3
[ . 3
[ 2 1
[ 2 .
[ 1 2
[ . 2
[ 1 .
[ . 1
[ 2 1
[ 2 .
[ 1 2
[ . 2
[ 1 .
[ . 1

perm.
1 . ]
. 1 ]
2 . ]
2 1 ]
. 2 ]
1 2 ]
1 . ]
. 1 ]
2 . ]
2 1 ]
. 2 ]
1 2 ]
3 . ]
3 1 ]
3 . ]
3 1 ]
3 2 ]
3 2 ]
. 3 ]
1 3 ]
. 3 ]
1 3 ]
2 3 ]
2 3 ]

Figure 10.3-A: The permutations of 4 elements in co-lexicographic order. Dots denote zeros.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class perm_colex
{
public:
ulong *d_; // mixed radix digits with radix = [2, 3, 4, ...]
ulong *x_; // permutation
ulong n_;
// permutations of n elements
public:
perm_colex(ulong n)
// Must have n>=2
{
n_ = n;
d_ = new ulong[n_];
d_[n-1] = 0; // sentinel
x_ = new ulong[n_];
first();
}
[--snip--]
void first()
{
for (ulong k=0; k<n_; ++k) x_[k] = n_-1-k;
for (ulong k=0; k<n_-1; ++k) d_[k] = 0;
}

The update process uses rising factorial numbers. Let j be the position where the digit is incremented
and d the value before the increment. The update
permutation
[ 0 3 4 5 2 1 ]
[ 5 4 2 0 3 1 ]

rfact
v-- increment at j=3
[ 1 2 3 1 1 ] <--= digit before increment is d=1
[ . . . 2 1 ]

is done in three steps:
[ 0 3 4 5 2 1 ]
[ 0 2 4 5 3 1 ]
[ 5 4 2 0 3 1 ]

[ 1 2 3 1 1 ]
[ 1 2 3 2 1 ]
[ . . . 2 1 ]

<--= swap positions d=1 and j+1=4
<--= reverse range 0...j

The corresponding method is
1
2
3

bool next()
{
if ( d_[0]==0 ) // easy case

10.4: An order from reversing prefixes
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

245

{
d_[0] = 1;
swap2(x_[0], x_[1]);
return true;
}
else
{
d_[0] = 0;
ulong j = 1;
ulong m1 = 2; // nine in rising factorial base
while ( d_[j]==m1 )
{
d_[j] = 0;
++m1;
++j;
}
if ( j==n_-1 )

return false;

// current permutation is last

d_[j] = dj + 1;
swap2( x_[dj], x_[j+1] );

// swap positions dj and j+1

{ // reverse range [0...j]:
ulong a = 0, b = j;
do
{
swap2(x_[a], x_[b]);
++a;
--b;
}
while ( a < b );
}
return true;
}
}
}

About 220 million permutations per second can be generated [FXT: comb/perm-colex-demo.cc]. With
arrays instead of pointers the rate is 330 million per second.

10.4

An order from reversing prefixes

A surprisingly simple algorithm for the generation of all permutations uses mixed radix counting with
the radices [2, 3, 4, . . .] (column digits in figure 10.4-A). Whenever the first j digits change with an
increment, the permutation is updated by reversing the first j + 1 elements (the method is given in [364]).
As with lex order the first half of the permutations are the complements of the permutations in the second
half, now rewrite relation 10.2-1 on page 242 as
R

= ICI

(10.4-1)

to see that the first half of the inverse permutations are the reversed inverse permutations in the second
half. This can (for n even) also be observed from the positions of the largest element in the inverse
permutations. A generator is [FXT: class perm rev in comb/perm-rev.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

class perm_rev
{
public:
ulong *d_;
ulong *p_;
ulong n_;

// mixed radix digits with radix = [2, 3, 4, ..., n-1, (sentinel=-1)]
// permutation

public:
perm_rev(ulong n)
{
n_ = n;
p_ = new ulong[n_];
d_ = new ulong[n_];
d_[n-1] = -1UL; // sentinel

246


0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 . 1 3 ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 . 1 2 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 3 1 . 2 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 3 1 2 . ]
[ 1 3 2 . ]
[ 2 3 1 . ]
[ 3 2 1 . ]

rfact
[ . . .
[ 1 . .
[ . 1 .
[ 1 1 .
[ . 2 .
[ 1 2 .
[ . . 1
[ 1 . 1
[ . 1 1
[ 1 1 1
[ . 2 1
[ 1 2 1
[ . . 2
[ 1 . 2
[ . 1 2
[ 1 1 2
[ . 2 2
[ 1 2 2
[ . . 3
[ 1 . 3
[ . 1 3
[ 1 1 3
[ . 2 3
[ 1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

inv. perm.
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 1 2 . 3 ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 2 1 . 3 ]
[ 1 2 3 . ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 2 1 3 . ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ . 3 2 1 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ 3 . 2 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]

Figure 10.4-A: All permutations of 4 elements in an order where the ﬁrst j + 1 elements are reversed
when the ﬁrst j digits change in the mixed radix counting sequence with radices [2, 3, 4, . . .].
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

first();
}
~perm_rev()
{
delete [] p_;
delete [] d_;
}
void first()
{
for (ulong k=0; k<n_-1; ++k) d_[k] = 0;
for (ulong k=0; k<n_; ++k) p_[k] = k;
}
void last()
{
for (ulong k=0; k<n_-1; ++k) d_[k] = k+1;
for (ulong k=0; k<n_; ++k) p_[k] = n_-1-k;
}

The update routines are quite concise:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

bool next()
{
// increment mixed radix number:
ulong j = 0;
while ( d_[j]==j+1 ) { d_[j]=0; ++j; }
// j==n-1 for last permutation
if ( j!=n_-1 ) // only if no overflow
{
++d_[j];
reverse(p_, j+2); // update permutation
return true;
}
else return false;
}
bool prev()
{
// decrement mixed radix number:
ulong j = 0;
while ( d_[j]==0 ) { d_[j]=j+1; ++j; }

10.4: An order from reversing preﬁxes
22
23
24
25
26
27
28
29
30
31
32

247

if ( j!=n_-1 ) // only if no overflow
{
--d_[j];
return true;
}
else return false;
}
};

Note that the routines work for arbitrary (distinct) entries of the array p_[].
An upper bound for the average number of elements that are moved in the transitions when generating
all N = n! permutations is e ≈ 2.7182818 so the algorithm is CAT. The implementation generates more
than 140 million permutations per second [FXT: comb/perm-rev-demo.cc]. Usage of the class is simple:
ulong n = 4; // Number of elements to permute
perm_rev P(n);
P.first();
do
{
// Use permutation here
}
while ( P.next() );

We note that the inverse permutations have the single-track property, see section 10.12 on page 271.

10.4.1

Method for unranking

Conversion of a rising factorial number into the corresponding permutation proceeds as exempliﬁed for
the 16-th permutation (15 = 1 · 1 + 1 · 2 + 2 · 6, so d=[1,1,2]):
1:
13:
15:
16:

p=[
p=[
p=[
p=[

0,
2,
0,
2,

1,
3,
2,
0,

2,
0,
3,
3,

3
1
1
1

]
]
]
]

d=[
d=[
d=[
d=[

0,
0,
0,
1,

0,
0,
1,
1,

0
2
2
2

]
]
]
]

//
//
//
//

start
right rotate all elements twice
right rotate first three elements
right rotate first two elements

The idea can be implemented as
1
2
3
4
5
6
7
8
9

void goto_rfact(const ulong *d)
// Goto permutation corresponding to d[] (i.e. unrank d[]).
// d[] must be a valid (rising) factorial mixed radix string:
// d[]==[d(0), d(1), d(2), ..., d(n-2)] (n-1 elements) where 0<=d(j)<=j+1
{
for (ulong k=0; k<n_; ++k) p_[k] = k;
for (ulong k=0; k<n_-1; ++k) d_[k] = d[k];
for (long j=n_-2; j>=0; --j) rotate_right(p_, j+2, d_[j]);
}

Compare to the method of section 10.1.3 on page 238.

10.4.2

Optimizing the update routine

We optimize the update routine by observing that 5 out of 6 updates are the swaps
(0,1)

(0,2)

(0,1)

(0,2)

(0,1)

We use a counter ct_ and modify the methods first() and next() accordingly [FXT: class perm rev2
in comb/perm-rev2.h]:
1
2
3
4
5
6
7
8
9
10
11

class perm_rev2
{
perm_rev2(ulong n)
{
n_ = n;
const ulong s = ( n_<3 ? 3 : n_ );
p_ = new ulong[s+1];
d_ = new ulong[s];
first();
}

248
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

[--snip--]
ulong next()
// Return index of last element with reversal.
// Return n with last permutation.
{
if ( ct_!=0 ) // easy case(s)
{
--ct_;
const ulong e = 1 + (ct_ & 1);
swap2(p_[0], p_[e]);
return e;
}
else
{
ct_ = 5; // reset counter
ulong j = 2; // note: start with 2
while ( d_[j]==j+1 ) { d_[j]=0; ++j; }
++d_[j];
return j + 1;
}
}


[--snip--]

The speedup is remarkable, about 275 million permutations per second are generated (about 8.5 cycles
per update) [FXT: comb/perm-rev2-demo.cc]. If arrays are used instead of pointers, the rate drops to
about 200 M/s.

10.5

Minimal-change order (Heap’s algorithm)
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 . 1 3 ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ 1 3 . 2 ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 1 . 3 2 ]
[ . 1 3 2 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]
[ 2 3 1 . ]
[ 1 3 2 . ]
[ 3 1 2 . ]
[ 2 1 3 . ]
[ 1 2 3 . ]

swap
(0, 0)
(1, 0)
(2, 0)
(1, 0)
(2, 0)
(1, 0)
(3, 0)
(1, 0)
(2, 0)
(1, 0)
(2, 0)
(1, 0)
(3, 1)
(1, 0)
(2, 0)
(1, 0)
(2, 0)
(1, 0)
(3, 2)
(1, 0)
(2, 0)
(1, 0)
(2, 0)
(1, 0)

digits
[ . . .
[ 1 . .
[ . 1 .
[ 1 1 .
[ . 2 .
[ 1 2 .
[ . . 1
[ 1 . 1
[ . 1 1
[ 1 1 1
[ . 2 1
[ 1 2 1
[ . . 2
[ 1 . 2
[ . 1 2
[ 1 1 2
[ . 2 2
[ 1 2 2
[ . . 3
[ 1 . 3
[ . 1 3
[ 1 1 3
[ . 2 3
[ 1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

rfact(perm)
[ . . . ]
[ 1 . . ]
[ 1 1 . ]
[ . 1 . ]
[ . 2 . ]
[ 1 2 . ]
[ 1 2 1 ]
[ . 2 1 ]
[ . 1 1 ]
[ 1 1 1 ]
[ 1 . 1 ]
[ . . 1 ]
[ . . 2 ]
[ 1 . 2 ]
[ 1 1 2 ]
[ . 1 2 ]
[ . 2 2 ]
[ 1 2 2 ]
[ 1 2 3 ]
[ . 2 3 ]
[ . 1 3 ]
[ 1 1 3 ]
[ 1 . 3 ]
[ . . 3 ]

inv. perm.
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 1 2 . 3 ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ 2 . 3 1 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ 1 . 3 2 ]
[ . 1 3 2 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ . 3 2 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 2 1 . ]
[ 3 2 . 1 ]
[ 3 . 2 1 ]
[ 3 1 2 . ]
[ 3 1 . 2 ]
[ 3 . 1 2 ]

Figure 10.5-A: The permutations of 4 elements in a minimal-change order. Dots denote zeros.
Figure 10.5-A shows the permutations of 4 elements in a minimal-change order : just 2 elements are
swapped with each update. The column labeled digits shows the mixed radix numbers with rising
factorial base in counting order. Let j be the position of the rightmost change of the mixed radix string
R. Then the swap is (j + 1, x) where x = 0 if j is odd, and x = Rj − 1 if j is even. The sequence of
values j + 1 starts
1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 4, 1, 2, 1, ...

The n-th value (starting with n = 1) is the largest z such that z! divides n (entry A055881 in [312]).

10.5: Minimal-change order (Heap’s algorithm)

249

The list rising factorial representations of the permutations is a Gray code only for permutations of up
to four elements. (column labeled rfact(perm) in figure 10.5-A).
An implementation of the algorithm (given in [178]) is [FXT: class perm heap in comb/perm-heap.h]:
1
2
3
4
5
6
7
8

class perm_heap
{
public:
ulong *d_;
ulong *p_;
ulong n_;
ulong sw1_,
[--snip--]

// mixed radix digits with radix = [2, 3, 4, ..., n-1, (sentinel=-1)]
// permutation
sw2_;
// indices of swapped elements

The computation of the successor is simple:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

bool next()
{
ulong j = 0;
while ( d_[j]==j+1 ) { d_[j]=0; ++j; }


// j==n-1 for last permutation:
if ( j==n_-1 ) return false;
ulong k = j+1;
ulong x = ( k&1 ? d_[j] : 0 );
swap2(p_[k], p_[x]); // omit statement to just compute swaps
sw1_ = k; sw2_ = x;
++d_[j];
return true;
}
[--snip--]

About 133 million permutations are generated per second. Often one will only use the indices of the
swapped elements to update the visited configurations:
1

void get_swap(ulong &s1, ulong &s2)

const

{ s1=sw1_; s2=sw2_; }

Then the statement swap2(p_[k], p_[x]); in the update routine can be omitted which leads to a rate
of 215 M/s. Figure 10.5-A shows the permutations of 4 elements. It was created with the program [FXT:
comb/perm-heap-demo.cc].

10.5.1

Optimized implementation

The algorithm can be optimized by treating 5 out of 6 cases separately, those where the first or second
digit in the mixed radix number changes [FXT: class perm heap2 in comb/perm-heap2.h]:
1
2
3
4
5
6
7
8
9

class perm_heap2
{
public:
ulong *d_; // mixed radix digits with radix = [2, 3, 4, 5, ..., n-1, (sentinel=-1)]
ulong *p_; // permutation
ulong n_;
ulong sw1_, sw2_;
// indices of swapped elements
ulong ct_; // count 5,4,3,2,1,(0); nonzero ==> easy cases
[--snip--]

The counter is set to 5 in the method first(). The update routine is
1
2
3
4
5
6
7
8
9
10
11
12
13

ulong next()
// Return index of last element with reversal.
// Return n with last permutation.
{
if ( ct_!=0 ) // easy cases
{
--ct_;
sw1_ = 1 + (ct_ & 1); // == 1,2,1,2,1
sw2_ = 0;
swap2(p_[sw1_], p_[sw2_]);
return sw1_;
}
else

250
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

{
ct_ = 5;

// reset counter

ulong j = 2;
while ( d_[j]==j+1 ) { d_[j]=0; ++j; }


// j==n-1 for last permutation:
if ( j==n_-1 ) return n_;
ulong k = j+1;
ulong x = ( k&1 ? d_[j] : 0 );
swap2(p_[k], p_[x]);
sw1_ = k; sw2_ = x;
++d_[j];
return k;
}
}

Usage of the class is shown in [FXT: comb/perm-heap2-demo.cc]:
1

do { /* visit permutation */ }

while ( P.next()!=n );

The rate of generation is about 280 M/s (7.85 cycles per update), and 460 M/s (4.78 cycles per update)
with fixed arrays.
If only the swaps are of interest, we can simply omit all statements involving the permutation array p_[].
The implementation is [FXT: class perm heap2 swaps in comb/perm-heap2-swaps.h], usage of the class
is shown in [FXT: comb/perm-heap2-swaps-demo.cc].
Heap’s algorithm and the optimization idea was taken from the excellent survey [305] which gives several
permutation algorithms and implementations in pseudocode.

10.6

Lipski’s Minimal-change orders

Several algorithms similar to Heap’s method are given in Lipski’s paper [235].

10.6.1

Variants of Heap’s algorithm

Four orderings for the permutations of five elements are shown in figure 10.6-A. The leftmost order
is Heap’s order. The implementation is given in [FXT: class perm gray lipski in comb/perm-graylipski.h], the variable r determines the order that is generated:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class perm_gray_lipski
{
[--snip--]
ulong r_;
// order (0<=r<4):
[--snip--]
bool next()
{
ulong j = 0;
while ( d_[j]==j+1 ) { d_[j]=0; ++j; }
if ( j<n_-1 ) // only if no overflow
{
const ulong d = d_[j];
ulong x;
switch ( r_ )
{
case 0: x = (j&1 ? 0 :
case 1: x = (j&1 ? 0 :
case 2: x = (j&1 ? j-1
default: x = (j&1 ? j-1
}
const ulong k = j+1;
swap2(p_[k], p_[x]);
sw1_ = k; sw2_ = x;

d); break;
j-d); break;
: d); break;
: j-d); break;

//
//
//
//

Lipski(9) == Heap
Lipski(16)
Lipski(10)
not in Lipski’s paper

10.6: Lipski’s Minimal-change orders
x=(j&1 ?
1: [ . 1 2
2: [ 1 . 2
3: [ 2 . 1
4: [ . 2 1
5: [ 1 2 .
6: [ 2 1 .
7: [ 3 1 .
8: [ 1 3 .
9: [ . 3 1
10: [ 3 . 1
11: [ 1 . 3
12: [ . 1 3
13: [ . 2 3
14: [ 2 . 3
15: [ 3 . 2
16: [ . 3 2
17: [ 2 3 .
18: [ 3 2 .
19: [ 3 2 1
20: [ 2 3 1
21: [ 1 3 2
22: [ 3 1 2
23: [ 2 1 3
24: [ 1 2 3
25: [ 4 2 3
26: [ 2 4 3
27: [ 3 4 2
28: [ 4 3 2
29: [ 2 3 4
30: [ 3 2 4
31: [ . 2 4
32: [ 2 . 4
33: [ 4 . 2
34: [ . 4 2
35: [ 2 4 .
36: [ 4 2 .
37: [ 4 3 .
38: [ 3 4 .
39: [ . 4 3
40: [ 4 . 3
41: [ 3 . 4
42: [ . 3 4
43: [ . 3 2
44: [ 3 . 2
45: [ 2 . 3
46: [ . 2 3
47: [ 3 2 .
48: [ 2 3 .
49: [ 1 3 .
50: [ 3 1 .
51: [ . 1 3
52: [ 1 . 3
53: [ 3 . 1
54: [ . 3 1
55: [ 4 3 1
56: [ 3 4 1
57: [ 1 4 3
58: [ 4 1 3
59: [ 3 1 4
60: [ 1 3 4
[--snip--]
108: [ 3 4 2
109: [ 3 1 2
110: [ 1 3 2
111: [ 2 3 1
112: [ 3 2 1
113: [ 1 2 3
114: [ 2 1 3
115: [ 2 1 4
116: [ 1 2 4
117: [ 4 2 1
118: [ 2 4 1
119: [ 1 4 2
120: [ 4 1 2

0
3
3
3
3
3
3
2
2
2
2
2
2
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
3
3
3
3
3
3
2
2
2
2
2
2
4
4
4
4
4
4
4
4
4
4
4
4
.
.
.
.
.
.

:
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
2
2
2
2
2
2

d);
]
] (1)
] (2)
] (1)
] (2)
] (1)
] (3)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,1)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,2)
] (1)
] (2)
] (1)
] (2)
] (1)
] (4)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,1)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,2)
] (1)
] (2)
] (1)
] (2)
] (1)
] (4)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3)
] (1)
] (2)
] (1)
] (2)
] (1)

1
4
4
4
4
4
4
3
3
3
3
3
3

.
.
.
.
.
.
.
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]

(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3,2)
(1)
(2)
(1)
(2)
(1)

x=(j&1
[ . 1
[ 1 .
[ 2 .
[ . 2
[ 1 2
[ 2 1
[ 2 1
[ 1 2
[ 3 2
[ 2 3
[ 1 3
[ 3 1
[ 3 .
[ . 3
[ 2 3
[ 3 2
[ . 2
[ 2 .
[ 1 .
[ . 1
[ 3 1
[ 1 3
[ . 3
[ 3 .
[ 4 .
[ . 4
[ 1 4
[ 4 1
[ . 1
[ 1 .
[ 1 .
[ . 1
[ 2 1
[ 1 2
[ . 2
[ 2 .
[ 2 4
[ 4 2
[ 1 2
[ 2 1
[ 4 1
[ 1 4
[ . 4
[ 4 .
[ 2 .
[ . 2
[ 4 2
[ 2 4
[ 3 4
[ 4 3
[ . 3
[ 3 .
[ 4 .
[ . 4
[ . 4
[ 4 .
[ 1 .
[ . 1
[ 4 1
[ 1 4
[
[
[
[
[
[
[
[
[
[
[
[
[

4
4
1
3
4
1
3
2
1
4
2
1
4

2
1
4
4
3
3
1
1
2
2
4
4
1

251
?
2
2
1
1
.
.
3
3
1
1
2
2
2
2
.
.
3
3
3
3
.
.
1
1
1
1
.
.
4
4
2
2
.
.
1
1
1
1
4
4
2
2
2
2
4
4
.
.
.
.
4
4
3
3
1
1
4
4
.
.

0
3
3
3
3
3
3
.
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
2
2
2
2
2
2
2
2
4
4
4
4
4
4
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1
3
3
3
3
3
3

:
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
2
2
2
2
2
2
2
2
2
2
2
2

j-d);
]
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,2)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,1)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3)
] (1)
] (2)
] (1)
] (2)
] (1)
] (4)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,2)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,1)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3)
] (1)
] (2)
] (1)
] (2)
] (1)
] (4)
] (1)
] (2)
] (1)
] (2)
] (1)
] (3,2)
] (1)
] (2)
] (1)
] (2)
] (1)

3
3
3
1
1
4
4
4
4
1
1
2
2

1
2
2
2
2
2
2
3
3
3
3
3
3

.
.
.
.
.
.
.
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]

(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3)
(1)
(2)
(1)
(2)
(1)

x=(j&1
[ . 1
[ 1 .
[ 2 .
[ . 2
[ 1 2
[ 2 1
[ 3 1
[ 1 3
[ . 3
[ 3 .
[ 1 .
[ . 1
[ . 2
[ 2 .
[ 3 .
[ . 3
[ 2 3
[ 3 2
[ 3 2
[ 2 3
[ 1 3
[ 3 1
[ 2 1
[ 1 2
[ 1 2
[ 2 1
[ 4 1
[ 1 4
[ 2 4
[ 4 2
[ . 2
[ 2 .
[ 1 .
[ . 1
[ 2 1
[ 1 2
[ 1 4
[ 4 1
[ . 1
[ 1 .
[ 4 .
[ . 4
[ . 4
[ 4 .
[ 2 .
[ . 2
[ 4 2
[ 2 4
[ 2 4
[ 4 2
[ 3 2
[ 2 3
[ 4 3
[ 3 4
[ 1 4
[ 4 1
[ 2 1
[ 1 2
[ 4 2
[ 2 4
[
[
[
[
[
[
[
[
[
[
[
[
[

3
3
1
4
3
1
4
4
1
.
4
1
.

.
1
3
3
4
4
1
1
4
4
.
.
1

?
2
2
1
1
.
.
.
.
1
1
3
3
3
3
2
2
.
.
1
1
2
2
3
3
4
4
2
2
1
1
1
1
2
2
.
.
.
.
4
4
1
1
2
2
4
4
.
.
3
3
4
4
2
2
2
2
4
4
1
1

j-1
3 4
3 4
3 4
3 4
3 4
3 4
2 4
2 4
2 4
2 4
2 4
2 4
1 4
1 4
1 4
1 4
1 4
1 4
. 4
. 4
. 4
. 4
. 4
. 4
. 3
. 3
. 3
. 3
. 3
. 3
4 3
4 3
4 3
4 3
4 3
4 3
2 3
2 3
2 3
2 3
2 3
2 3
1 3
1 3
1 3
1 3
1 3
1 3
1 .
1 .
1 .
1 .
1 .
1 .
3 .
3 .
3 .
3 .
3 .
3 .

:
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

d);

4
4
4
1
1
3
3
.
.
1
1
4
4

1
.
.
.
.
.
.
3
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]

(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3,2)
(1)
(2)
(1)
(2)
(1)

2
2
2
2
2
2
2
2
2
2
2
2
2

(1)
(2)
(1)
(2)
(1)
(3)
(1)
(2)
(1)
(2)
(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3,2)
(1)
(2)
(1)
(2)
(1)
(4,2)
(1)
(2)
(1)
(2)
(1)
(3)
(1)
(2)
(1)
(2)
(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3,2)
(1)
(2)
(1)
(2)
(1)
(4,2)
(1)
(2)
(1)
(2)
(1)
(3)
(1)
(2)
(1)
(2)
(1)

x=(j&1
[ . 1
[ 1 .
[ 2 .
[ . 2
[ 1 2
[ 2 1
[ 2 1
[ 1 2
[ 3 2
[ 2 3
[ 1 3
[ 3 1
[ 3 .
[ . 3
[ 2 3
[ 3 2
[ . 2
[ 2 .
[ 1 .
[ . 1
[ 3 1
[ 1 3
[ . 3
[ 3 .
[ 3 .
[ . 3
[ 4 3
[ 3 4
[ . 4
[ 4 .
[ 4 .
[ . 4
[ 2 4
[ 4 2
[ . 2
[ 2 .
[ 2 3
[ 3 2
[ 4 2
[ 2 4
[ 3 4
[ 4 3
[ . 3
[ 3 .
[ 2 .
[ . 2
[ 3 2
[ 2 3
[ 2 3
[ 3 2
[ 1 2
[ 2 1
[ 3 1
[ 1 3
[ 1 3
[ 3 1
[ 4 1
[ 1 4
[ 3 4
[ 4 3
[
[
[
[
[
[
[
[
[
[
[
[
[

.
.
1
3
.
1
3
4
1
.
4
1
.

4
1
.
.
3
3
1
1
4
4
.
.
1

?
2
2
1
1
.
.
3
3
1
1
2
2
2
2
.
.
3
3
3
3
.
.
1
1
4
4
.
.
3
3
2
2
.
.
4
4
4
4
3
3
2
2
2
2
3
3
.
.
1
1
3
3
2
2
4
4
3
3
1
1

j-1
3 4
3 4
3 4
3 4
3 4
3 4
. 4
. 4
. 4
. 4
. 4
. 4
1 4
1 4
1 4
1 4
1 4
1 4
2 4
2 4
2 4
2 4
2 4
2 4
2 1
2 1
2 1
2 1
2 1
2 1
3 1
3 1
3 1
3 1
3 1
3 1
. 1
. 1
. 1
. 1
. 1
. 1
4 1
4 1
4 1
4 1
4 1
4 1
4 .
4 .
4 .
4 .
4 .
4 .
2 .
2 .
2 .
2 .
2 .
2 .

:
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

j-d);

3
3
3
1
1
.
.
.
.
1
1
4
4

1
4
4
4
4
4
4
3
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]

(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3)
(1)
(2)
(1)
(2)
(1)

2
2
2
2
2
2
2
2
2
2
2
2
2

(1)
(2)
(1)
(2)
(1)
(3,2)
(1)
(2)
(1)
(2)
(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3)
(1)
(2)
(1)
(2)
(1)
(4,2)
(1)
(2)
(1)
(2)
(1)
(3,2)
(1)
(2)
(1)
(2)
(1)
(3,1)
(1)
(2)
(1)
(2)
(1)
(3)
(1)
(2)
(1)
(2)
(1)
(4,2)
(1)
(2)
(1)
(2)
(1)
(3,2)
(1)
(2)
(1)
(2)
(1)

Figure 10.6-A: First half and last few permutations of ﬁve elements generated by variants of Heap’s
method. Next to the permutations the swaps are shown as (x, y), a swap (x, 0) is given as (x).

252
27
28
29
30
31
32
33
34


d_[j] = d + 1;
return true;
}
else

return

false;


}
[--snip--]
};

The top lines in figure 10.6-A repeat the statements in the switch-block. For three or less elements all
orderings coincide, with n = 4 elements the orderings for r = 0 and r = 2, and the orderings for r = 1
and r = 3 coincide. About 110 million permutations per second are generated [FXT: comb/perm-graylipski-demo.cc]. Optimizations similar to those for Heaps method should be obvious.

10.6.2

Variants of Wells’ algorithm

x=( (j&1) ||
1:
[ .
2:
[ 1
3:
[ 1
4:
[ 2
5:
[ 2
6:
[ .
7:
[ .
8:
[ 2
9:
[ 2
10:
[ 3
11:
[ 3
12:
[ .
13:
[ .
14:
[ 3
15:
[ 3
16:
[ 1
17:
[ 1
18:
[ .
19:
[ 2
20:
[ 1
21:
[ 1
22:
[ 3
23:
[ 3
24:
[ 2

(d<=1) ?
1 2 3 ]
. 2 3 ]
2 . 3 ]
1 . 3 ]
. 1 3 ]
2 1 3 ]
2 3 1 ]
. 3 1 ]
3 . 1 ]
2 . 1 ]
. 2 1 ]
3 2 1 ]
3 1 2 ]
. 1 2 ]
1 . 2 ]
3 . 2 ]
. 3 2 ]
1 3 2 ]
1 3 . ]
2 3 . ]
3 2 . ]
1 2 . ]
2 1 . ]
3 1 . ]

j : j-d );
(1,
(2,
(1,
(2,
(1,
(3,
(1,
(2,
(1,
(2,
(1,
(3,
(1,
(2,
(1,
(2,
(1,
(3,
(1,
(2,
(1,
(2,
(1,

0)
1)
0)
1)
0)
2)
0)
1)
0)
1)
0)
2)
0)
1)
0)
1)
0)
0)
0)
1)
0)
1)
0)

x=( (j&1)
1:
[
2:
[
3:
[
4:
[
5:
[
6:
[
7:
[
8:
[
9:
[
10:
[
11:
[
12:
[
13:
[
14:
[
15:
[
16:
[
17:
[
18:
[
19:
[
20:
[
21:
[
22:
[
23:
[
24:
[

|| (d==0) ? 0 : d-1 );
. 1 2 3 ]
1 . 2 3 ] (1, 0)
2 . 1 3 ] (2, 0)
. 2 1 3 ] (1, 0)
1 2 . 3 ] (2, 0)
2 1 . 3 ] (1, 0)
3 1 . 2 ] (3, 0)
1 3 . 2 ] (1, 0)
. 3 1 2 ] (2, 0)
3 . 1 2 ] (1, 0)
1 . 3 2 ] (2, 0)
. 1 3 2 ] (1, 0)
2 1 3 . ] (3, 0)
1 2 3 . ] (1, 0)
3 2 1 . ] (2, 0)
2 3 1 . ] (1, 0)
1 3 2 . ] (2, 0)
3 1 2 . ] (1, 0)
3 . 2 1 ] (3, 1)
. 3 2 1 ] (1, 0)
2 3 . 1 ] (2, 0)
3 2 . 1 ] (1, 0)
. 2 3 1 ] (2, 0)
2 . 3 1 ] (1, 0)

Figure 10.6-B: Wells’ order for the permutations of four elements (left) and an order where most swaps
are with the first position (right). Dots denote the element zero.
A Gray code for permutations given by Wells [350] is shown in the left of figure 10.6-B. The following
implementation includes two variants of the algorithm. We just give the crucial assignments in the
computation of the successor [FXT: class perm gray wells in comb/perm-gray-wells.h]:
1
2
3
4
5
6
7
8
9
10
11

bool next()
{
[--snip--]
switch (
{
case 1:
case 2:
default:
}
[--snip--]
}

r_ )
x = ( (j&1) || (d==0) ? 0 : d-1 );
x = ( (j&1) || (d==0) ? j : d-1 );
x = ( (j&1) || (d<=1) ? j : j-d );

break;
break;
break;

// Lipski(14)
// Lipski(15)
// Wells’ order == Lipski(8)

Both expressions (d==0) can be changed to (d<=1) without changing the algorithm. About 105 million
permutations per second are generated [FXT: comb/perm-gray-wells-demo.cc].

10.7: Strong minimal-change order (Trotter’s algorithm)

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 2 1 . 3 ]
[ 2 . 1 3 ]
[ . 2 1 3 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 2 1 . ]
[ 3 2 . 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ 1 3 2 . ]
[ 1 3 . 2 ]
[ 1 . 3 2 ]
[ . 1 3 2 ]

swap
(3, 2)
(0, 1)
(1, 2)
(2, 3)
(0, 1)
(3, 2)
(2, 1)
(1, 0)
(2, 3)
(0, 1)
(1, 2)
(2, 3)
(0, 1)
(3, 2)
(2, 1)
(1, 0)
(3, 2)
(0, 1)
(1, 2)
(2, 3)
(1, 0)
(3, 2)
(2, 1)
(1, 0)

inverse
[ . 1 2
[ 1 . 2
[ 2 . 1
[ 3 . 1
[ 3 1 .
[ 2 1 .
[ 1 2 .
[ . 2 1
[ . 3 1
[ 1 3 .
[ 2 3 .
[ 3 2 .
[ 3 2 1
[ 2 3 1
[ 1 3 2
[ . 3 2
[ . 2 3
[ 1 2 3
[ 2 1 3
[ 3 1 2
[ 3 . 2
[ 2 . 3
[ 1 . 3
[ . 1 3

253

p.
3 ]
3 ]
3 ]
2 ]
2 ]
3 ]
3 ]
3 ]
2 ]
2 ]
1 ]
1 ]
. ]
. ]
. ]
1 ]
1 ]
. ]
. ]
. ]
1 ]
1 ]
2 ]
2 ]

direction
+ + + +
+ + + +
+ + + +
+ + + +
- + + +
- + + +
- + + +
- + + +
+ + + +
+ + + +
+ + + +
+ + + +
- - + +
- - + +
- - + +
- - + +
+ - + +
+ - + +
+ - + +
+ - + +
- - + +
- - + +
- - + +
- - + +

Figure 10.7-A: The permutations of 4 elements in a strong minimal-change order (smallest element
moves most often). Dots denote zeros.

-----------------P=[3]
--> [2, 3]
--> [3, 2]

2]
[3, 2, 1]
[3, 1, 2]
[1, 3, 2]

P=[2,
-->
-->
-->
-->

1, 3]
[2, 1,
[2, 1,
[2, 0,
[0, 2,

3,
0,
1,
1,

0]
3]
3]
3]

P=[2,
-->
-->
-->
-->

3, 1]
[0, 2,
[2, 0,
[2, 3,
[2, 3,

3,
3,
0,
1,

1]
1]
1]
0]

P=[3,
-->
-->
-->
-->

2, 1]
[3, 2,
[3, 2,
[3, 0,
[0, 3,

1,
0,
2,
2,

0]
1]
1]
1]

P=[3,
-->
-->
-->
-->

1, 2]
[0, 3,
[3, 0,
[3, 1,
[3, 1,

1,
1,
0,
2,

3, 2]
[1, 3,
[1, 3,
[1, 0,
[0, 1,

2,
0,
3,
3,

perm(4)==
[0, 1, 2,
[1, 0, 2,
[1, 2, 0,
[1, 2, 3,
[2, 1, 3,
[2, 1, 0,
[2, 0, 1,
[0, 2, 1,
[0, 2, 3,
[2, 0, 3,
[2, 3, 0,
[2, 3, 1,
[3, 2, 1,
[3, 2, 0,
[3, 0, 2,
[0, 3, 2,
[0, 3, 1,
[3, 0, 1,
[3, 1, 0,
[3, 1, 2,
[1, 3, 2,
[1, 3, 0,
[1, 0, 3,
[0, 1, 3,

2]
2]
2]
0]

P=[1,
-->
-->
-->
-->

-----------------P=[2, 3]
--> [1, 2, 3]
--> [2, 1, 3]
--> [2, 3, 1]
P=[3,
-->
-->
-->

-----------------P=[1, 2, 3]
--> [0, 1, 2, 3]
--> [1, 0, 2, 3]
--> [1, 2, 0, 3]
--> [1, 2, 3, 0]

0]
2]
2]
2]

Figure 10.7-B: Trotter’s construction as an interleaving process.

3]
3]
3]
0]
0]
3]
3]
3]
1]
1]
1]
0]
0]
1]
1]
1]
2]
2]
2]
0]
0]
2]
2]
2]

254


10.7

Strong minimal-change order (Trotter’s algorithm)

Figure 10.7-A shows the permutations of 4 elements in a strong minimal-change order : just two elements
are swapped with each update and these are adjacent. In the sequence of the inverse permutations the
swapped pair always consists of elements x and x + 1. Also the first and last permutation differ by
an adjacent transposition (of the last two elements). The ordering can be obtained by an interleaving
process shown in figure 10.7-B. The first half of the permutations in this order are the reversals of the
second half: the relative order of the two smallest elements is changed only with the transition just after
the first half and reversal changes the order of these two elements. Mutually reversed permutations lie
n!/2 positions apart.
A computer program to generate all permutations in the shown order was given 1962 by H. F. Trotter [334],
see also [193] and [137]. We compute both the permutation and its inverse [FXT: class perm trotter
in comb/perm-trotter.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class perm_trotter
{
public:
ulong n_;
ulong *x_;
// permutation of {0, 1, ..., n-1}
ulong *xi_;
// inverse permutation
ulong *d_;
// auxiliary: directions
ulong sw1_, sw2_; // indices of elements swapped most recently
public:
perm_trotter(ulong n)
{
n_ = n;
xi_ = new ulong[n_];
d_ = new ulong[n_];
ulong sen = 0; // sentinel value minimal
x_[0] = x_[n_+1] = sen;
++x_;
first();
}
[--snip--]

Sentinel elements are put at the lower and the higher end of the array for the permutation. For each
element we store a direction-flag = ±1 in an array d_[]. Initially all are set to +1:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void fl_swaps()
// Auxiliary routine for first() and last().
// Set sw1, sw2 to swaps between first and last permutation.
{
sw1_ = ( n_==0 ? 0 : n_ - 1 );
sw2_ = ( n_<2 ? 0 : n_ - 2 );
}
void first()
{
for (ulong i=0; i<n_; i++)
fl_swaps();
}
[--snip--]

xi_[i] = i;
x_[i] = i;
d_[i] = 1;

To compute the successor, find the smallest element e1 whose neighbor e2 (left or right neighbor, according to the direction) is greater than e1. Swap the elements e1 and e2, and change the direction of all
elements that could not be moved. The locations of the elements, i1 and i2, are found with the inverse
permutation, which has to be updated accordingly:
1
2
3
4
5
6

bool next()
{
for (ulong e1=0; e1<n_; ++e1)
{
// e1 is the element we try to move
ulong i1 = xi_[e1];
// position of element e1

10.7: Strong minimal-change order (Trotter’s algorithm)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ulong d = d_[e1];
ulong i2 = i1 + d;
ulong e2 = x_[i2];

255

// direction to move e1
// position to swap with
// element to swap with

if ( e1 < e2 ) // can we swap?
{
xi_[e1] = i2;
xi_[e2] = i1;
x_[i1] = e2;
x_[i2] = e1;
sw1_ = i1; sw2_ = i2;
while ( e1-- ) d_[e1] = -d_[e1];
return true;
}
}
first();
return false;
}

The locations of the swap are retrieved by the method
1
2

void get_swap(ulong &s1, ulong &s2)
{ s1=sw1_; s2=sw2_; }

const

The last permutation is computed as follows:
1
2
3
4
5
6
7
8
9
10

void last()
{
for (ulong i=0; i<n_; i++) xi_[i] = i;
for (ulong i=0; i<n_; i++) x_[i] = i;
for (ulong i=0; i<n_; i++) d_[i] = -1UL;
fl_swaps();
d_[sw1_] = +1; d_[sw2_] = +1;
swap2(x_[sw1_], x_[sw2_]);
swap2(xi_[sw1_], xi_[sw2_]);
}

The routine for the predecessor is almost identical to the method next():
1
2
3
4
5
6
7
8

bool prev()
{
[--snip--]
ulong d = -d_[e1];
[--snip--]
last();
return false;
}

// direction to move e1 (NOTE: negated)

The routines next() and prev() generate about 145 million permutations per second. Figure 10.7-A
was created with the program [FXT: comb/perm-trotter-demo.cc]:
ulong n = 4;
perm_trotter P(n);
do
{
// visit permutation
}
while ( P.next() );

10.7.1

Optimized update routines

The element zero is moved most often, so we can treat that case separately [FXT: comb/perm-trotter.h]:
1
2
3
4
5
6
7

#define TROTTER_OPT // much faster computations
[--snip--]
#ifdef TROTTER_OPT
ulong ctm_; // counter to detect easy case
ulong xi0_; // position of element zero
ulong d0_;
// direction of element zero
#endif // TROTTER_OPT

The counter ctm_ is initially set to n_. The update method becomes
1
2

bool next()
{

256
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#ifdef TROTTER_OPT
if ( --ctm_ ) // easy
{
ulong i1 = xi0_;
ulong d = d0_;
ulong i2 = i1 + d;
ulong e2 = x_[i2];
xi_[0] = i2;
xi0_ = i2;
xi_[e2] = i1;
x_[i1] = e2;
x_[i2] = 0;
sw1_ = i1; sw2_ =
return true;
}
d0_ = -d0_;
ctm_ = n_;

case: move element 0
// position of element 0
// direction to move 0
// position to swap with
// element to swap with

i2;

#ifdef TROTTER_OPT
for (ulong e1=1; e1<n_; ++e1) // note: start at e1=1
#else
// TROTTER_OPT
for (ulong e1=0; e1<n_; ++e1)
[--snip--] // loop body as before

The very same modification can be applied to the method prev(), only the minus sign has to be added:
ulong d = -d_[0];

// direction to move e1 (NOTE: negated)

Now both methods generate about 190 million permutations per second.

10.7.2
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

Variant where largest element moves most often
permutation
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ . 2 3 1 ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]
[ 2 3 1 . ]
[ 2 1 3 . ]
[ 2 1 . 3 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ 1 3 2 . ]
[ 3 1 2 . ]
[ 3 1 . 2 ]
[ 1 3 . 2 ]
[ 1 . 3 2 ]
[ 1 . 2 3 ]

swap
(0, 1)
(3, 2)
(2, 1)
(1, 0)
(3, 2)
(0, 1)
(1, 2)
(2, 3)
(1, 0)
(3, 2)
(2, 1)
(1, 0)
(3, 2)
(0, 1)
(1, 2)
(2, 3)
(0, 1)
(3, 2)
(2, 1)
(1, 0)
(2, 3)
(0, 1)
(1, 2)
(2, 3)

inverse
[ . 1 2
[ . 1 3
[ . 2 3
[ 1 2 3
[ 1 3 2
[ . 3 2
[ . 3 1
[ . 2 1
[ 1 2 .
[ 1 3 .
[ 2 3 .
[ 2 3 1
[ 3 2 1
[ 3 2 .
[ 3 1 .
[ 2 1 .
[ 2 . 1
[ 3 . 1
[ 3 . 2
[ 3 1 2
[ 2 1 3
[ 2 . 3
[ 1 . 3
[ 1 . 2

p.
3 ]
2 ]
1 ]
. ]
. ]
1 ]
2 ]
3 ]
3 ]
2 ]
1 ]
. ]
. ]
1 ]
2 ]
3 ]
3 ]
2 ]
1 ]
. ]
. ]
1 ]
2 ]
3 ]

direction
- - - - - - - - - - - - - - - +
- - - +
- - - +
- - - +
- - - - - - - - - - - - - - + +
- - + +
- - + +
- - + +
- - + - - + - - + - - + - - + +
- - + +
- - + +
- - + +

Figure 10.7-C: The permutations of 4 elements in a strong minimal-change order (largest element moves
most often). Dots denote zeros.
A variant of the ordering where the largest element moves most often is shown in figure 10.7-C. Only
a few modifications have to be made [FXT: class perm trotter lg in comb/perm-trotter-lg.h]. The
sentinel needs to be greater than all elements of the permutations, the directions start with −1, and in
the update routine we look for the largest element whose neighbor is less than itself. Both next() and
prev() generate about 146 million permutations per second [FXT: comb/perm-trotter-lg-demo.cc].

10.8: Star-transposition order

10.8

257

Star-transposition order
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 . 1 3 ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 3 . 1 2 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ 2 3 1 . ]
[ 3 2 1 . ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 3 1 2 . ]

swap
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,

1)
2)
1)
2)
1)
3)
2)
1)
2)
1)
2)
3)
1)
2)
1)
2)
1)
3)
2)
1)
2)
1)
2)

inverse
[ . 1 2
[ 1 . 2
[ 1 2 .
[ . 2 1
[ 2 . 1
[ 2 1 .
[ 2 1 3
[ . 1 3
[ 1 . 3
[ 1 2 3
[ . 2 3
[ 2 . 3
[ 2 3 .
[ 2 3 1
[ . 3 1
[ 1 3 .
[ 1 3 2
[ . 3 2
[ 3 . 2
[ 3 2 .
[ 3 2 1
[ 3 . 1
[ 3 1 .
[ 3 1 2

p.
3 ]
3 ]
3 ]
3 ]
3 ]
3 ]
. ]
2 ]
2 ]
. ]
1 ]
1 ]
1 ]
. ]
2 ]
2 ]
. ]
1 ]
1 ]
1 ]
. ]
2 ]
2 ]
. ]

Figure 10.8-A: The permutations of 4 elements in star-transposition order. Dots denote zeros.
Figure 10.8-A shows an ordering where successive permutations differ by a swap of the element at the
first position with some other element (star transposition). In the list of the inverse permutations the
zero is always moved, also the reversed permutations of the first half lie in the second half. An algorithm
for the generation of such an ordering, attributed to Gideon Ehrlich, is given in [215, alg.E, sect.7.2.1.2].
An implementation is given in [FXT: class perm star in comb/perm-star.h].
The listing shown in figure 10.8-A was created with [FXT: comb/perm-star-demo.cc]. About 190
million permutations per second are generated. If only the swaps are of interest, use [FXT: class
perm star swaps in comb/perm-star-swaps.h], see [FXT: comb/perm-star-swaps-demo.cc] for its usage.
S1
S2
S3
S4
S5
==

= 0 --> 0,1 == S2
= 01 --> 01,20,12 == S3
= 012012 --> 012012,301301,230230,123123 == S4
= (S3-0),(S3-1),(S3-2),(S3-3) modulo 4
= (S4-0),(S4-1),(S4-2),(S4-3),(S4-4) modulo 5
012012301301230230123123,401401240240124124012012,340340134134013013401401,
234234023023402402340340,123123412412341341234234

Figure 10.8-B: Construction of the first column of the list of permutations, also sequence of positions
of element zero in the inverse permutations.
The sequence of positions swapped with the first position, entry A123400 in [312], starts as
1,2,1,2,1,3,2,1,2,1,2,3,1,2,1,2,1,3,2,1,2,1,2,4,3,1,3,1,3,2,1,3,1,3,1,2,3,1,3,1,3,2,1, ...

The sequence of positions of the element zero is entry A159880, it starts as
0,1,2,0,1,2,3,0,1,3,0,1,2,3,0,2,3,0,1,2,3,1,2,3,4,0,1,4,0,1,2,4,0,2,4,0,1,2,4,1,2,4,0, ...

It can be constructed as shown in figure 10.8-B. The sequence can be generated via the permutations
described in section 10.4 on page 245. Thus we can compute the inverse permutations as shown in figure
10.8-C. The listing was created with the program [FXT: comb/perm-star-inv-demo.cc]:
1
2
3

ulong n = 4;
perm_rev2 P(n); P.first();
const ulong *r = P.data();

258


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

inv. star-p.
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 1 2 . 3 ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 1 2 3 . ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ . 3 2 1 ]
[ 3 . 2 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]

swap
(0,
(1,
(2,
(0,
(1,
(2,
(3,
(0,
(1,
(3,
(0,
(1,
(2,
(3,
(0,
(2,
(3,
(0,
(1,
(2,
(3,
(1,
(2,

1)
2)
0)
1)
2)
3)
0)
1)
3)
0)
1)
2)
3)
0)
2)
3)
0)
1)
2)
3)
1)
2)
3)

perm-rev
[ . 1 2 3
[ 1 . 2 3
[ 2 . 1 3
[ . 2 1 3
[ 1 2 . 3
[ 2 1 . 3
[ 3 . 1 2
[ . 3 1 2
[ 1 3 . 2
[ 3 1 . 2
[ . 1 3 2
[ 1 . 3 2
[ 2 3 . 1
[ 3 2 . 1
[ . 2 3 1
[ 2 . 3 1
[ 3 . 2 1
[ . 3 2 1
[ 1 2 3 .
[ 2 1 3 .
[ 3 1 2 .
[ 1 3 2 .
[ 2 3 1 .
[ 3 2 1 .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 10.8-C: The inverse permutations of 4 elements with star-transposition order (left). The swaps
are determined by the first element of the permutations generated via reversals (right).
4
5
6
7
8
9
10
11
12
13
14
15

ulong *x = new ulong[n];
ulong i0 = 0; // position of element zero
do
{
++ct;
ulong i1 = r[0];
swap2(x[i0], x[i1]);
// visit permutation in x[]
i0 = i1;
}
while ( P.next()!=n );

The rate of generation is about 155 million per second.

10.9

Minimal-change orders from factorial numbers

10.9.1

Permutations with falling factorial numbers

The Gray code for the mixed radix numbers with falling factorial base allows the computation of the
permutations in Trotter’s minimal-change order (see section 10.7 on page 254) in an elegant way. See
figure 10.9-A which was created with the program [FXT: comb/perm-gray-ffact2-demo.cc]. The algorithm
is implemented in [FXT: class perm gray ffact2 in comb/perm-gray-ffact2.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13

class perm_gray_ffact2
{
public:
mixedradix_gray2 *mrg_; // loopless routine
ulong n_;
ulong *x_; // current permutation (of {0, 1, ..., n-1})
ulong *ix_; // inverse permutation
public:
perm_gray_ffact2(ulong n)
{
n_ = n;

10.9: Minimal-change orders from factorial numbers

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 2 1 . 3 ]
[ 2 . 1 3 ]
[ . 2 1 3 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 2 1 . ]
[ 3 2 . 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ 1 3 2 . ]
[ 1 3 . 2 ]
[ 1 . 3 2 ]
[ . 1 3 2 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . .
1 . .
2 . .
3 . .
3 1 .
2 1 .
1 1 .
. 1 .
. 2 .
1 2 .
2 2 .
3 2 .
3 2 1
2 2 1
1 2 1
. 2 1
. 1 1
1 1 1
2 1 1
3 1 1
3 . 1
2 . 1
1 . 1
. . 1

259
pos

dir

0
0
0
1
0
0
0
1
0
0
0
2
0
0
0
1
0
0
0
1
0
0
0

+1
+1
+1
+1
-1
-1
-1
+1
+1
+1
+1
+1
-1
-1
-1
-1
+1
+1
+1
-1
-1
-1
-1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

inverse
[ . 1 2
[ 1 . 2
[ 2 . 1
[ 3 . 1
[ 3 1 .
[ 2 1 .
[ 1 2 .
[ . 2 1
[ . 3 1
[ 1 3 .
[ 2 3 .
[ 3 2 .
[ 3 2 1
[ 2 3 1
[ 1 3 2
[ . 3 2
[ . 2 3
[ 1 2 3
[ 2 1 3
[ 3 1 2
[ 3 . 2
[ 2 . 3
[ 1 . 3
[ . 1 3

perm.
3 ]
3 ]
3 ]
2 ]
2 ]
3 ]
3 ]
3 ]
2 ]
2 ]
1 ]
1 ]
. ]
. ]
. ]
1 ]
1 ]
. ]
. ]
. ]
1 ]
1 ]
2 ]
2 ]

Figure 10.9-A: Permutations in minimal-change order (left) and Gray code for mixed radix numbers
with falling factorial base. The two columns labeled ‘pos’ and ‘dir’ give the place of change with the
mixed radix numbers and its direction. Whenever digit p (=‘pos’) changes by d = ±1 (=‘dir’) in the
mixed radix sequence, then element p of the permutation is swapped with its right (d = +1) or left
(d = −1) neighbor.
14
15
16
17
18
19
20
21
22
23
24
25
26
27

x_ = new ulong[n_];
ix_ = new ulong[n_];
mrg_ = new mixedradix_gray2(n_-1, 0);
first();

// falling factorial base

}
[--snip--]
void first()
{
mrg_->first();
sw1_=n_-1; sw2_=n_-2;
}

x_[k] = ix_[k] = k;

The crucial part is the computation of the successor:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

bool next()
{
// Compute next mixed radix number in Gray code order:
if ( false == mrg_->next() ) { first(); return false; }
const ulong j = mrg_->pos(); // position of changed digit
const int d = mrg_->dir();
// direction of change
// swap:
const ulong x1 = j;
//
const ulong i1 = ix_[x1]; //
const ulong i2 = i1 + d;
//
const ulong x2 = x_[i2];
//
x_[i1] = x2;
x_[i2] = x1;
ix_[x1] = i2; ix_[x2] = i1;
sw1_=i1; sw2_=i2;
return true;

element j
position of j
neighbor
position of neighbor
// swap2(x_[i1], x_[i2]);
// swap2(ix_[x1], ix_[x2]);

}

The class uses the loopless algorithm for the computation of the mixed radix Gray code, so it is loopless
itself. An alternative (CAT) algorithm is implemented in [FXT: class perm gray ffact in comb/permgray-ﬀact.h], we give just the routine for the successor:

260
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


private:
void swap(ulong j, ulong im) // used with next() and prev()
{
const ulong x1 = j;
// element j
const ulong i1 = ix_[x1]; // position of j
const ulong i2 = i1 + im; // neighbor
// position of neighbor
x_[i1] = x2;
x_[i2] = x1;
// swap2(x_[i1], x_[i2]);
ix_[x1] = i2; ix_[x2] = i1; // swap2(ix_[x1], ix_[x2]);
sw1_=i1; sw2_=i2;
}
public:
bool next()
{
ulong j = 0;
ulong m1 = n_ - 1; // nine in falling factorial base
ulong ij;
while ( (ij=i_[j]) )
{
ulong im = i_[j];
ulong dj = d_[j] + im;
if ( dj>m1 ) // =^= if ( (dj>m1) || ((long)dj<0) )
{
i_[j] = -ij;
}
else
{
d_[j] = dj;
swap(j, im);
return true;
}
--m1;
++j;
}
return false;
}

To compute the predecessor (method prev()), we only need to modify one statement as follows:
ulong im = i_[j];
ulong im = -i_[j];

// next()
// prev()

The loopless routine computes about 80 million permutations per second, the CAT version about 160
million per second [FXT: comb/perm-gray-ffact-demo.cc]. Both are slower than the implementation given
in section 10.7.1 on page 255.

10.9.2

Permutations with rising factorial numbers

Figure 10.9-B shows a Gray code for permutations based on the Gray code for numbers in rising factorial
base. The ordering coincides with Heap’s algorithm (see section 10.5 on page 248) for up to four elements.
A recursive construction for the order is shown in figure 10.9-C. The figure was created with the program
[FXT: comb/perm-gray-rfact-demo.cc]. A constant amortized time (CAT) algorithm for generating the
permutations is [FXT: class perm gray rfact in comb/perm-gray-rfact.h]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class perm_gray_rfact
{
public:
mixedradix_gray *M_; // loopless routine
ulong n_;
public:
perm_gray_rfact(ulong n)
{
n_ = n;
x_ = new ulong[n_];
M_ = new mixedradix_gray(n_-1, 1);

// rising factorial base


0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 . 1 3 ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ 1 3 . 2 ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 1 . 3 2 ]
[ . 1 3 2 ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]
[ 2 3 1 . ]
[ 1 3 2 . ]
[ 3 1 2 . ]
[ 2 1 3 . ]
[ 1 2 3 . ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

rfact
. . .
1 . .
1 1 .
. 1 .
. 2 .
1 2 .
1 2 1
. 2 1
. 1 1
1 1 1
1 . 1
. . 1
. . 2
1 . 2
1 1 2
. 1 2
. 2 2
1 2 2
1 2 3
. 2 3
. 1 3
1 1 3
1 . 3
. . 3

261

pos
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

dir

0
1
0
1
0
2
0
1
0
1
0
2
0
1
0
1
0
2
0
1
0
1
0

+1
+1
-1
+1
+1
+1
-1
-1
+1
-1
-1
+1
+1
+1
-1
+1
+1
+1
-1
-1
+1
-1
-1

inverse
[ . 1 2
[ 1 . 2
[ 1 2 .
[ . 2 1
[ 2 . 1
[ 2 1 .
[ 2 1 3
[ 2 . 3
[ . 2 3
[ 1 2 3
[ 1 . 3
[ . 1 3
[ . 3 1
[ 1 3 .
[ 1 3 2
[ . 3 2
[ 2 3 .
[ 2 3 1
[ 3 2 1
[ 3 2 .
[ 3 . 2
[ 3 1 2
[ 3 1 .
[ 3 . 1

perm.
3 ]
3 ]
3 ]
3 ]
3 ]
3 ]
. ]
1 ]
1 ]
. ]
2 ]
2 ]
2 ]
2 ]
. ]
1 ]
1 ]
. ]
. ]
1 ]
1 ]
. ]
2 ]
2 ]

Figure 10.9-B: Permutations in minimal-change order (left) and Gray code for mixed radix numbers
with rising factorial base. For even n the ﬁrst and last permutations are cyclic shifts of each other.

append 3:
012 3
102 3
201 3
021 3
120 3
210 3

perm(2)=
01
10
append 2:
01 2
10 2
reverse and swap (2,1)
20 1
02 1
reverse and swap (1,0)
12 0
21 0
==> perm(3)
012
102
201
021
120
210

reverse and swap (3,2):
310 2
130 2
031 2
301 2
103 2
013 2
023 1
203 1
302 1
032 1
230 1
320 1
321 0
231 0
132 0
312 0
213 0
123 0

Figure 10.9-C: Recursive construction of the permutations.

==> perm(4):
0123
1023
2013
0213
1203
2103
3102
1302
0312
3012
1032
0132
0231
2031
3021
0321
2301
3201
3210
2310
1320
3120
2130
1230

262
17
18
19
20
21
22
23
24
25

first();
}
[--snip--]
void first()
{
M_->first();
sw1_=n_-1; sw2_=n_-2;
}

x_[k] = ix_[k] = k;

Let j ≥ 0 be the position of the digit changed with incrementing the mixed radix number, and d = ±1
the increment or decrement of that digit. The compute the next permutation, swap the element x1 at
position j + 1 with the element x2 where x2 is lying to the left of x1 and it is the greatest element less
than x1 for d > 0, and the smallest element greater than x1 for d < 0:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

bool next()
{
if ( false == M_->next() ) { first(); return false; }
ulong j = M_->pos(); // position of changed digit
if ( j<=1 ) // easy cases: swap == (0,j+1)
{
const ulong i2 = j+1; // i1 == 0
const ulong x1 = x_[0], x2 = x_[i2];
x_[0] = x2;
x_[i2] = x1; // swap2(x_[i1], x_[i2]);
ix_[x1] = i2; ix_[x2] = 0; // swap2(ix_[x1], ix_[x2]);
sw1_=0; sw2_=i2;
return true;
}
else
{
ulong i1 = j+1, i2 = i1;
ulong x1 = x_[i1], x2;
int d = M_->dir();
if ( d>0 )
{
x2 = 0;
for (ulong t=0; t<i1; ++t) // search maximal smaller element left
{
ulong xt = x_[t];
if ( (xt < x1) && (xt >= x2) ) { i2=t; x2=xt; }
}
}
else
{
x2 = n_;
for (ulong t=0; t<i1; ++t) // search minimal greater element
{
ulong xt = x_[t];
if ( (xt > x1) && (xt <= x2) ) { i2=t; x2=xt; }
}
}
x_[i1] = x2;
ix_[x1] = i2;

x_[i2] = x1;
ix_[x2] = i1;

// swap2(x_[i1], x_[i2]);
// swap2(ix_[x1], ix_[x2]);

sw1_=i2; sw2_=i1;
return true;
}
}

There is a slightly more eﬃcient algorithm to compute the successor using the inverse permutations:
1
2
3
4
5
6
7
8
9
10
11
12
13

bool next()
{
[--snip--] /* easy cases as before */
else
{
ulong i1 = j+1, i2 = i1;
ulong x1 = x_[i1], x2;
int d = M_->dir();
if ( d>0 ) // in the inverse permutation search first smaller element left:
{
for (x2=x1-1; ; --x2) if ( (i2=ix_[x2]) < i1 ) break;
}
else // in the inverse permutation search first smaller element right:

14
15
16
17
18
19

263

{
for (x2=x1+1; ; ++x2)
}
[--snip--] /* swaps as before */
}
}

if ( (i2=ix_[x2]) < i1 )

break;

The method is chosen by defining SUCC_BY_INV in the file [FXT: comb/perm-gray-rfact.h]. About 80
million permutations per second are generated, about 71 million with the first method.

10.9.3

Permutations with permuted factorial numbers

permutation
0:
[ . 1 2 3 4
1:
[ 1 . 2 3 4
2:
[ 2 . 1 3 4
3:
[ . 2 1 3 4
4:
[ 1 2 . 3 4
5:
[ 2 1 . 3 4
6:
[ 2 1 . 4 3
7:
[ 1 2 . 4 3
[--snip--]
91:
[ 3 4 2 1 .
92:
[ 2 4 3 1 .
93:
[ 4 2 3 1 .
94:
[ 3 2 4 1 .
95:
[ 2 3 4 1 .
96:
[ 2 3 4 . 1
97:
[ 3 2 4 . 1
[--snip--]
106:
[ 3 1 4 . 2
107:
[ 1 3 4 . 2
108:
[ 1 2 4 . 3
109:
[ 2 1 4 . 3
110:
[ 4 1 2 . 3
111:
[ 1 4 2 . 3
112:
[ 2 4 1 . 3
113:
[ 4 2 1 . 3
114:
[ 3 2 1 . 4
115:
[ 2 3 1 . 4
116:
[ 1 3 2 . 4
117:
[ 3 1 2 . 4
118:
[ 2 1 3 . 4
119:
[ 1 2 3 . 4

swap
1)
2)
1)
2)
1)
4)
1)

[
[
[
[
[
[
[
[

xfact
. . .
1 . .
1 1 .
. 1 .
. 2 .
1 2 .
1 2 1
. 2 1

.
.
.
.
.
.
.
.

]
]
]
]
]
]
]
]

0
1
0
1
0
2
0

(0,
(0,
(0,
(0,
(0,
(3,
(0,

1)
2)
1)
2)
1)
4)
1)

[
[
[
[
[
[
[

.
.
1
1
.
.
1

2
1
1
.
.
.
.

4
4
4
4
4
3
3

3
3
3
3
3
3
3

]
]
]
]
]
]
]

(0,
(0,
(1,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,

2)
1)
4)
1)
2)
1)
2)
1)
4)
1)
2)
1)
2)
1)

[
[
[
[
[
[
[
[
[
[
[
[
[
[

1
.
.
1
1
.
.
1
1
.
.
1
1
.

.
.
.
.
1
1
2
2
2
2
1
1
.
.

2
2
1
1
1
1
1
1
.
.
.
.
.
.

3
3
3
3
3
3
3
3
3
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]

]
]
]
]
]
]
]
]

(0,
(0,
(0,
(0,
(0,
(3,
(0,

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

pos dir
+1
+1
-1
+1
+1
+1
-1

[
[
[
[
[
[
[
[

inv.perm.
. 1 2 3 4
1 . 2 3 4
1 2 . 3 4
. 2 1 3 4
2 . 1 3 4
2 1 . 3 4
2 1 . 4 3
2 . 1 4 3

]
]
]
]
]
]
]
]

0
1
0
1
0
2
0

-1
-1
+1
-1
-1
-1
+1

[
[
[
[
[
[
[

4
4
4
4
4
3
3

3
3
3
3
3
4
4

2
.
1
1
.
.
1

.
2
2
.
1
1
.

1
1
.
2
2
2
2

]
]
]
]
]
]
]

1
0
2
0
1
0
1
0
2
0
1
0
1
0

-1
-1
-1
+1
+1
-1
+1
+1
-1
-1
-1
+1
-1
-1

[
[
[
[
[
[
[
[
[
[
[
[
[
[

3
3
3
3
3
3
3
3
3
3
3
3
3
3

1
.
.
1
1
.
2
2
2
2
.
1
1
.

4
4
1
.
2
2
.
1
1
.
2
2
.
1

.
1
4
4
4
4
4
4
.
1
1
.
2
2

2
2
2
2
.
1
1
.
4
4
4
4
4
4

]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 10.9-D: Permutations with mixed radix numbers with radix vector [2, 3, 5, 4].
The rising and falling factorial numbers are special cases of factorial numbers with permuted digits. We
give a method to compute the Gray code for permutations from the Gray code for permuted (falling)
factorial numbers. A permutation of the radices determines how often a digit at any position is changed:
the leftmost changes most often, the rightmost least often. The permutations corresponding to the mixed
radix numbers with radix vector [2, 3, 5, 4], the falling factorial last two radices swapped, is shown in
figure 10.9-D [FXT: comb/perm-gray-rot1-demo.cc]. The desired property of this ordering is that the
last permutation is as close to a cyclic shift by one position of the first as possible. With even n the Gray
code with the falling factorial base the last permutation is a shift by one. With odd n no such Gray code
exists: the total number of transpositions with any Gray code is odd for all n > 1, but the cyclic rotation
by one corresponds to an even number of transpositions. The best we can get is that the first e elements
where e ≤ n is the greatest possible even number. For example,
n=6:
n=7:

first
[ 0 1 2 3 4 5 ]
[ 0 1 2 3 4 5 6 ]

last
[ 1 2 3 4 5 0 ]
[ 1 2 3 4 5 0 6 ]

We use this ordering to show the general method [FXT: class perm gray rot1 in comb/perm-grayrot1.h]:
1

class perm_gray_rot1

264
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


{
public:
mixedradix_gray *M_; // Gray code for factorial numbers
ulong n_;
public:
perm_gray_rot1(ulong n)
// Must have: n>=1
{
n_ = (n ? n : 1); // at least one
x_ = new ulong[n_];

// rising factorial base

// apply permutation of radix vector with mixed radix number:
if ( (n_ >= 3) && (n & 1) ) // odd n>=3
{
ulong *m1 = M_->m1_;
swap2(m1[n_-2], m1[n_-3]); // swap last two factorial nines
}
first();
}
[--snip--]

The permutation applied here can be replaced by any permutation, the following update routines will
still work:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

bool next()
{
if ( false == M_->next() ) { first(); return false; }
const ulong j = M_->pos(); // position of changed digit
const ulong i1 = M_->m1_[j]; // valid for any permutation of factorial radices
ulong i2 = i1, x2;
const int d = M_->dir();


if ( d>0 ) // in the inverse permutation search first smaller element left:
{
for (x2=x1-1; ; --x2) if ( (i2=ix_[x2]) < i1 ) break;
}
else // in the inverse permutation search first smaller element right:
{
for (x2=x1+1; ; ++x2) if ( (i2=ix_[x2]) < i1 ) break;
}
x_[i1] = x2;
ix_[x1] = i2;
sw1_=i2;

x_[i2] = x1;
ix_[x2] = i1;

// swap2(x_[i1], x_[i2]);
// swap2(ix_[x1], ix_[x2]);

sw2_=i1;

return true;
}
[--snip--]

Note that instead of taking j + 1 as the position of the element to move, we take the value of the nine
at the position j. The special ordering shown here can be used to construct a Gray code with the single
track property, see section 10.12.2 on page 274.

10.10

Derangement order

In a derangement order for permutations two successive permutations have no element at the same
position, as shown in ﬁgure 10.10-A. The listing was created with the program [FXT: comb/permderange-demo.cc]. There is no derangement order for n = 3. An implementation of the underlying
algorithm (given in [298, p.611]) is [FXT: class perm derange in comb/perm-derange.h]:

10.10: Derangement order

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 3 . 1 2 ]
[ 1 2 3 . ]
[ 2 3 . 1 ]
[ 1 . 2 3 ]
[ 3 1 . 2 ]
[ . 2 3 1 ]
[ 2 3 1 . ]
[ 1 2 . 3 ]
[ 3 1 2 . ]
[ 2 . 3 1 ]
[ . 3 1 2 ]
[ 2 1 . 3 ]
[ 3 2 1 . ]
[ 1 . 3 2 ]
[ . 3 2 1 ]
[ 2 . 1 3 ]
[ 3 2 . 1 ]
[ . 1 3 2 ]
[ 1 3 2 . ]
[ . 2 1 3 ]
[ 3 . 2 1 ]
[ 2 1 3 . ]
[ 1 3 . 2 ]

265
inverse
[ . 1 2
[ 1 2 3
[ 3 . 1
[ 2 3 .
[ 1 . 2
[ 2 1 3
[ . 3 1
[ 3 2 .
[ 2 . 1
[ 3 1 2
[ 1 3 .
[ . 2 3
[ 2 1 .
[ 3 2 1
[ 1 . 3
[ . 3 2
[ 1 2 .
[ 2 3 1
[ . 1 3
[ 3 . 2
[ . 2 1
[ 1 3 2
[ 3 1 .
[ 2 . 3

perm.
3 ]
. ]
2 ]
1 ]
3 ]
. ]
2 ]
1 ]
3 ]
. ]
2 ]
1 ]
3 ]
. ]
2 ]
1 ]
3 ]
. ]
2 ]
1 ]
3 ]
. ]
2 ]
1 ]

Figure 10.10-A: The permutations of 4 elements in derangement order.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class perm_derange
{
public:
ulong n_;
// number of elements
ulong *x_; // current permutation
ulong ctm_; // counter modulo n
perm_trotter* T_;
public:
perm_derange(ulong n)
// Must have: n>=4
// n=2: trivial, n=3: no solution exists,
{
n_ = n;
x_ = new ulong[n_];
T_ = new perm_trotter(n_-1);
first();
}
[--snip--]

n>=4: ok

The routine to update the permutation is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

bool next()
{
++ctm_;
if ( ctm_>=n_ ) // every n steps: need next perm_trotter
{
ctm_ = 0;
if ( ! T_->next() ) return false; // current permutation is last
const ulong *t = T_->data();
for (ulong k=0; k<n_-1; ++k) x_[k] = t[k];
x_[n_-1] = n_-1; // last element
}
else // rotate
{
if ( ctm_==n_-1 ) rotate_left1(x_, n_);
else // last two elements swapped
{
rotate_right1(x_, n_);
if ( ctm_==n_-2 ) rotate_right1(x_, n_);
}
}
return true;
}

266


The routines rotate_right1() and rotate_last() rotate the array x_[] by one position [FXT:
perm/rotate.h]. These cyclic shifts are the performance bottleneck, one update of a length-n permutation is O(n). Still, about 35 million permutations per second are generated for n = 12.
Gray codes have the minimal number of changes between successive permutations while derangement
orders have the maximum. An algorithm for generating all permutations of n objects with k transitions
(where 2 ≤ k ≤ n and k = 3) is given in [297].
Derangement order for even n ‡

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 2 3 . ]
[ 2 3 . 1 ]
[ 3 . 1 2 ]
[ 1 2 . 3 ]
[ 2 . 3 1 ]
[ . 3 1 2 ]
[ 3 1 2 . ]
[ 2 . 1 3 ]
[ . 1 3 2 ]
[ 1 3 2 . ]
[ 3 2 . 1 ]
[ 1 . 2 3 ]
[ . 2 3 1 ]
[ 2 3 1 . ]
[ 3 1 . 2 ]
[ . 2 1 3 ]
[ 2 1 3 . ]
[ 1 3 . 2 ]
[ 3 . 2 1 ]
[ 2 1 . 3 ]
[ 1 . 3 2 ]
[ . 3 2 1 ]
[ 3 2 1 . ]

inv. perm.
[ . 1 2 3 ]
[ 3 . 1 2 ]
[ 2 3 . 1 ]
[ 1 2 3 . ]
[ 2 . 1 3 ]
[ 1 3 . 2 ]
[ . 2 3 1 ]
[ 3 1 2 . ]
[ 1 2 . 3 ]
[ . 1 3 2 ]
[ 3 . 2 1 ]
[ 2 3 1 . ]
[ 1 . 2 3 ]
[ . 3 1 2 ]
[ 3 2 . 1 ]
[ 2 1 3 . ]
[ . 2 1 3 ]
[ 3 1 . 2 ]
[ 2 . 3 1 ]
[ 1 3 2 . ]
[ 2 1 . 3 ]
[ 1 . 3 2 ]
[ . 3 2 1 ]
[ 3 2 1 . ]

0:
1:
2:
3:
4:
5:

permutation
[ . 1 2 ]
[ 1 2 . ]
[ 2 . 1 ]
[ 1 . 2 ]
[ . 2 1 ]
[ 2 1 . ]

inv.
[ .
[ 2
[ 1
[ 1
[ .
[ 2

perm.
1 2 ]
. 1 ]
2 . ]
. 2 ]
2 1 ]
1 . ]

<<
<<

Figure 10.10-B: Permutations generated via cyclic shifts. The order is a derangement order for even n
(left), but not for odd n (right). Dots denote zeros.
An algorithm for the generation of permutations via cyclic shifts suggested in [225] generates a derangement order if the number n of elements is even, see ﬁgure 10.10-B. An implementation of the algorithm,
following [215, alg.C, sect.7.2.1.2], is [FXT: class perm rot in comb/perm-rot.h]. For odd n the number
of times that the successor is not a derangement of the predecessor equals ((n + 1)/2)! − 1. The program
[FXT: comb/perm-rot-demo.cc] generates the permutations and counts those transitions.
An alternative ordering with the same number of transitions that are not derangements is obtained via
mixed radix counting in falling factorial base and the routine [FXT: comb/perm-rot-unrank-demo.cc]
1
2
3
4
5
6
7

void ffact2perm_rot(const ulong *fc, ulong n, ulong *x)
// Convert falling factorial number fc[0, ..., n-2] into
// permutation of x[0, ..., n-1].
{
for (ulong k=n-1, j=2; k!=0; --k, ++j) rotate_right(x+k-1, j, fc[k-1]);
}

Figure 10.10-C shows the generated ordering for n = 4 and n = 3. The observation that the permutations
in second ordering are the complemented reversals of the ﬁrst leads to the unranking routine
1
2
3
4
5
6
7
8
9

class perm_rot
{
ulong *a_;
ulong n_;
[--snip--]

// permutation of n elements

void goto_ffact(const ulong *d)
// Goto permutation corresponding to d[] (i.e. unrank d[]).
// d[] must be a valid (falling) factorial mixed radix string.

10.11: Orders where the smallest element always moves right

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . .
1 . .
2 . .
3 . .
. 1 .
1 1 .
2 1 .
3 1 .
. 2 .
1 2 .
2 2 .
3 2 .
. . 1
1 . 1
2 . 1
3 . 1
. 1 1
1 1 1
2 1 1
3 1 1
. 2 1
1 2 1
2 2 1
3 2 1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

permutation
[ . 1 2 3 ]
[ 3 . 1 2 ]
[ 2 3 . 1 ]
[ 1 2 3 . ]
[ . 3 1 2 ]
[ 2 . 3 1 ]
[ 1 2 . 3 ]
[ 3 1 2 . ]
[ . 2 3 1 ]
[ 1 . 2 3 ]
[ 3 1 . 2 ]
[ 2 3 1 . ]
[ . 1 3 2 ]
[ 2 . 1 3 ]
[ 3 2 . 1 ]
[ 1 3 2 . ]
[ . 2 1 3 ]
[ 3 . 2 1 ]
[ 1 3 . 2 ]
[ 2 1 3 . ]
[ . 3 2 1 ]
[ 1 . 3 2 ]
[ 2 1 . 3 ]
[ 3 2 1 . ]

inv. perm.
[ . 1 2 3 ]
[ 1 2 3 . ]
[ 2 3 . 1 ]
[ 3 . 1 2 ]
[ . 2 3 1 ]
[ 1 3 . 2 ]
[ 2 . 1 3 ]
[ 3 1 2 . ]
[ . 3 1 2 ]
[ 1 . 2 3 ]
[ 2 1 3 . ]
[ 3 2 . 1 ]
[ . 1 3 2 ]
[ 1 2 . 3 ]
[ 2 3 1 . ]
[ 3 . 2 1 ]
[ . 2 1 3 ]
[ 1 3 2 . ]
[ 2 . 3 1 ]
[ 3 1 . 2 ]
[ . 3 2 1 ]
[ 1 . 3 2 ]
[ 2 1 . 3 ]
[ 3 2 1 . ]

0:
1:
2:
3:
4:
5:

267
ffact
[ . .
[ 1 .
[ 2 .
[ . 1
[ 1 1
[ 2 1

]
]
]
]
]
]

[
[
[
[
[
[

perm.
. 1 2
2 . 1
1 2 .
. 2 1
1 . 2
2 1 .

]
]
]
]
]
]

inv. perm.
[ . 1 2 ]
[ 1 2 . ]
[ 2 . 1 ] <<
[ . 2 1 ] <<
[ 1 . 2 ]
[ 2 1 . ]

Figure 10.10-C: Alternative ordering for permutations generated via cyclic shifts. The order is a
derangement order for even n (left), but not for odd n (right).
10
11
12
13
14
15
16
17

{
for (ulong k=0; k<n_; ++k) a_[k] = k;
for (ulong k=n_-1, j=2; k!=0; --k, ++j)
reverse(a_, n_);
make_complement(a_, a_, n_);

rotate_right(a_+k-1, j, d[k-1]);

}
[--snip--]
}

Compare to the unranking for permutations by prefix reversals shown in section 10.4.1 on page 247.

10.11

Orders where the smallest element always moves right

10.11.1

A variant of Trotter’s construction

An ordering for the permutations where the first element always moves right is produced by the interleaving process shown in figure 10.11-A. The process is similar to the one for Trotter’s order shown in figure
10.7-B on page 253, but the directions are not changed. This ordering essentially appears in [259, p.7].
The second half of the permutations is the reversed list of the reversed permutations in the first half. The
permutations are shown in figure 10.11-B, they are the inverses of the permutations corresponding to the
falling factorial numbers, see figure 10.1-A on page 233. An implementation is [FXT: class perm mv0
in comb/perm-mv0.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class perm_mv0
{
public:
ulong *d_;
ulong *x_;
ulong ect_;
ulong n_;

//
//
//
//

mixed radix digits with radix = [n-1, n-2, n-3, ..., 2]
permutation
counter for easy case
permutations of n elements

public:
perm_mv0(ulong n)
// Must have n>=2
{
n_ = n;
d_ = new ulong[n_];
d_[n-1] = 1; // sentinel (must be nonzero)
x_ = new ulong[n_];

268


-----------------P=[1, 2, 3]
--> [0, 1, 2, 3]
--> [1, 0, 2, 3]
--> [1, 2, 0, 3]
--> [1, 2, 3, 0]

-----------------P=[3]
--> [2, 3]
--> [3, 2]

P=[2,
-->
-->
-->
-->

3, 1]
[0, 2,
[2, 0,
[2, 3,
[2, 3,

3,
3,
0,
1,

1]
1]
1]
0]

P=[1,
-->
-->
-->
-->

3, 2]
[0, 1,
[1, 0,
[1, 3,
[1, 3,

3,
3,
0,
2,

2]
2]
2]
0]

1, 2]
[0, 3,
[3, 0,
[3, 1,
[3, 1,

1,
1,
0,
2,

2, 1]
[0, 3,
[3, 0,
[3, 2,
[3, 2,

2,
2,
0,
1,

3]
3]
3]
0]
3]
3]
3]
0]
1]
1]
1]
0]
2]
2]
2]
0]
2]
2]
2]
0]
1]
1]
1]
0]

2]
2]
2]
0]

P=[3,
-->
-->
-->
-->

2]
[1, 3, 2]
[3, 1, 2]
[3, 2, 1]

3]
3]
3]
0]

P=[3,
-->
-->
-->
-->

P=[3,
-->
-->
-->

1,
1,
0,
3,

P=[2,
-->
-->
-->
-->

-----------------P=[2, 3]
--> [1, 2, 3]
--> [2, 1, 3]
--> [2, 3, 1]

1, 3]
[0, 2,
[2, 0,
[2, 1,
[2, 1,

perm(4)==
[0, 1, 2,
[1, 0, 2,
[1, 2, 0,
[1, 2, 3,
[0, 2, 1,
[2, 0, 1,
[2, 1, 0,
[2, 1, 3,
[0, 2, 3,
[2, 0, 3,
[2, 3, 0,
[2, 3, 1,
[0, 1, 3,
[1, 0, 3,
[1, 3, 0,
[1, 3, 2,
[0, 3, 1,
[3, 0, 1,
[3, 1, 0,
[3, 1, 2,
[0, 3, 2,
[3, 0, 2,
[3, 2, 0,
[3, 2, 1,

1]
1]
1]
0]

Figure 10.11-A: Interleaving process to generate all permutations by right moves.

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ . 3 2 1 ]
[ 3 . 2 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]

ffact
[ . . .
[ 1 . .
[ 2 . .
[ 3 . .
[ . 1 .
[ 1 1 .
[ 2 1 .
[ 3 1 .
[ . 2 .
[ 1 2 .
[ 2 2 .
[ 3 2 .
[ . . 1
[ 1 . 1
[ 2 . 1
[ 3 . 1
[ . 1 1
[ 1 1 1
[ 2 1 1
[ 3 1 1
[ . 2 1
[ 1 2 1
[ 2 2 1
[ 3 2 1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

inv. perm.
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 . 1 3 ]
[ 3 . 1 2 ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 3 1 2 . ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ 2 3 1 . ]
[ 3 2 1 . ]

Figure 10.11-B: All permutations of 4 elements and falling factorial numbers used to update the permutations. Dots denote zeros.

10.11: Orders where the smallest element always moves right
17
18
19
20
21
22
23
24
25
26
27

269

first();
}
[--snip--]
void first()
{
for (ulong k=0; k<n_; ++k) x_[k] = k;
for (ulong k=0; k<n_-1; ++k) d_[k] = 0;
ect_ = 0;
}
[--snip--]

The update process uses the falling factorial numbers. Let j be the position where the digit is incremented
and d the value before the increment. The update
permutation
[ 4 2 3 5 1 0 ]
[ 0 1 4 3 2 5 ]

ffact
v-- increment at j=2
[ 5 4 1 1 . ] <--= digit before increment is d=1
[ . . 2 1 . ]

is done in three steps:
[
[
[
[

4
4
*
0

2
3
*
1

3
2
4
4

5
5
3
3

1
1
2
2

0
0
5
5

]
]
]
]

[
[
[
[

5
5
*
.

4
4
*
.

1
2
2
2

1
1
1
1

.
.
.
.

]
]
]
]

move element at position d=1 to the right
move all but j=2 elements to end
insert identical permutation at start

We treat the ﬁrst digit separately as it changes most often (easy case):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

bool next()
{
if ( ++ect_ < n_ ) // easy case
{
swap2(x_[ect_], x_[ect_-1]);
return true;
}
else
{
ect_ = 0;
ulong j = 1;
ulong m1 = n_ - 2;
// nine in falling factorial base
while ( d_[j]==m1 ) // find digit to increment
{
d_[j] = 0;
--m1;
++j;
}
if ( j==n_-1 )

return false;


d_[j] = dj + 1;
// element at d[j] moves one position to the right:
swap2( x_[dj], x_[dj+1] );
{ // move n-j
ulong s =
do
{
--s;
--d;
x_[d]
}
while ( s
}

elements to end:
n_-j, d = n_;

= x_[s];
);

// fill in 0,1,2,..,j-1 at start:
for (ulong k=0; k<j; ++k) x_[k] = k;
return true;
}
}
}

The routine generates about 210 million permutations per second [FXT: comb/perm-mv0-demo.cc].

270


10.11.2

Ives’ algorithm
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

permutation
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ . 2 3 1 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ . 3 1 2 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ . 2 1 3 ]
[ 2 . 1 3 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ . 3 2 1 ]
[ 3 . 2 1 ]
[ 3 2 . 1 ]
[ 3 2 1 . ]

inv. perm.
[ . 1 2 3 ]
[ 1 . 2 3 ]
[ 2 . 1 3 ]
[ 3 . 1 2 ]
[ . 3 1 2 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ . 2 3 1 ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 3 1 2 . ]
[ . 2 1 3 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ . 1 3 2 ]
[ 1 . 3 2 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ . 3 2 1 ]
[ 1 3 2 . ]
[ 2 3 1 . ]
[ 3 2 1 . ]

<< only update with more
<< than one transposition

Figure 10.11-C: All permutations of 4 elements in an order by Ives.
An ordering where most of the moves are a move by one position to the right of the smallest element is
shown in figure 10.11-C. With n elements only one in n (n − 1) moves is more than a transposition (only
the update from 12 to 13 in figure 10.11-C). The second half of the list of permutations is the reversed
list of the reversed permutations in the first half. The algorithm, given by Ives [189], is implemented in
[FXT: class perm ives in comb/perm-ives.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class perm_ives
{
public:
ulong *p_;
ulong *ip_;
ulong n_;

// permutation

public:
perm_ives(ulong n)
// Must have: n >= 2
{
n_ = n;
p_ = new ulong[n_];
ip_ = new ulong[n_];
first();
}
[--snip--]

The computation of the successor is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

bool next()
{
ulong e1 = 0, u = n_ - 1;
do
{
const ulong i1 = ip_[e1];
const ulong i2 = (i1==u ? e1 : i1+1 );
const ulong e2 = p_[i2];
p_[i1] = e2; p_[i2] = e1;
ip_[e1] = i2; ip_[e2] = i1;
if ( (p_[e1]!=e1) || (p_[u]!=u) )
++e1;
--u;
}

return true;

10.12: Single track orders
17
18
19
20
21

271

while ( u > e1 );
return false;
}
[--snip--]

The rate of generation is about 180 M/s [FXT: comb/perm-ives-demo.cc]. Using arrays instead of pointers
increases the rate to about 190 M/s.
As the easy case with the update (when just the first element is moved) occurs so often it is natural
to create an extra branch for it. If the define for PERM_IVES_OPT is made before the class definition, a
counter is created:
1
2
3
4
5
6
7
8

class perm_ives
{
[--snip--]
#ifdef PERM_IVES_OPT
ulong ctm_;
// aux: counter for easy case
ulong ctm0_; // aux: start value of ctm == n*(n-1)-1
#endif
[--snip--]

If the counter is nonzero, the following update can be used:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

bool next()
{
if ( ctm_-- ) // easy case
{
const ulong i1 = ip_[0]; // e1 == 0
const ulong i2 = (i1==n_-1 ? 0 : i1+1);
const ulong e2 = p_[i2];
p_[i1] = e2; p_[i2] = 0;
ip_[0] = i2; ip_[e2] = i1;
return true;
}
ctm_ = ctm0_;
[--snip--]
}

// rest as before

If arrays are used, a minimal speedup is achieved (rate 192 M/s), if pointers are used, the effect is a
notable slowdown (rate 163 M/s).
The greatest speedup comes from a modification of a condition in the loop:
if ( (p_[e1]ê1) | (p_[u]û) ) return true;
// same as:
if ( (p_[e1]!=e1) || (p_[u]!=u) )

return true;

The rate is increased to almost 194 M/s. This optimization is activated by defining PERM_IVES_OPT2.

10.12

Single track orders

Figure 10.12-A shows a single track order for the permutations of four elements. Each column in the list
of permutations is a cyclic shift of the first column. A recursive construction for the ordering is shown in
figure 10.12-B. Figure 10.12-A was created with the program [FXT: comb/perm-st-demo.cc] which uses
[FXT: class perm st in comb/perm-st.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class perm_st
{
public:
ulong *d_;
ulong *p_;
ulong *pi_;
ulong n_;

//
//
//
//

mixed radix digits with radix = [2, 3, 4, ..., n-1, (sentinel=-1)]
permutation
inverse permutation
permutations of n elements

public:
perm_st(ulong n)
{
n_ = n;
d_ = new ulong[n_];
p_ = new ulong[n_];
pi_ = new ulong[n_];

272

permutation
[ . 2 3 1 ]
[ . 3 2 1 ]
[ . 3 1 2 ]
[ . 2 1 3 ]
[ . 1 2 3 ]
[ . 1 3 2 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ 3 . 1 2 ]
[ 2 . 1 3 ]
[ 3 1 . 2 ]
[ 2 1 . 3 ]
[ 1 2 . 3 ]
[ 1 3 . 2 ]
[ 2 3 . 1 ]
[ 3 2 . 1 ]
[ 2 3 1 . ]
[ 3 2 1 . ]
[ 3 1 2 . ]
[ 2 1 3 . ]
[ 1 2 3 . ]
[ 1 3 2 . ]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1

.
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2

.
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

inv. perm.
[ . 3 1 2 ]
[ . 3 2 1 ]
[ . 2 3 1 ]
[ . 2 1 3 ]
[ . 1 2 3 ]
[ . 1 3 2 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ 1 2 3 . ]
[ 1 2 . 3 ]
[ 2 1 3 . ]
[ 2 1 . 3 ]
[ 2 . 1 3 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 2 . 1 ]
[ 3 2 1 . ]
[ 3 1 2 . ]
[ 3 1 . 2 ]
[ 3 . 1 2 ]
[ 3 . 2 1 ]

Figure 10.12-A: Permutations of 4 elements in single track order. Dots denote zeros.
23
32

<--=

11 23 32
112332
321123
233211

permutations of 2 elements
<--= concatenate rows and prepend new element
<--= shift
<--= shift
<--= shift

0
2
4

000000 112332 321123 233211


000000
233211
321123
112332

<--=
<--=
<--=
<--=

112332
000000
233211
321123

321123
112332
000000
233211

233211
321123
112332
000000

shift 0
shift 6
shift 12
shift 18

Figure 10.12-B: Construction of the single track order for permutations of 4 elements.
16
17
18
19

d_[n-1] = -1UL;
first();

// sentinel

}
[--snip--]

The ﬁrst permutation is in enup order (see section 6.6.1 on page 186):
1
2
3
4
5
6
7
8
9
10
11
12
13
14

const ulong *data() const { return p_; }
const ulong *invdata() const { return pi_; }
void first()
{
for (ulong k=0; k<n_-1; ++k) d_[k] = 0;
for (ulong k=0, e=0; k<n_; ++k)
{
p_[k] = e;
pi_[e] = k;
e = next_enup(e, n_-1);
}
}
[--snip--]

273

The swap with the inverse permutations are determined by the rightmost position j changing with mixed
radix counting with rising factorial base. We write −1 for the last element, −2 for the second last, and
so on:
j
0:
1:
2:
3:
4:
5:
j:

swaps
(-2,-1)
(-3,-2)
(-4,-3) (-2,-1)
(-5,-4) (-3,-2)
(-6,-5) (-4,-3) (-2,-1)
(-7,-6) (-5,-4) (-3,-2)
(-j-2, -j-1) ... (-2-(j%1), -1-(j%1))

The computation of the successor is CAT:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

bool next()
{
ulong j = 0;
while ( d_[j]==j+1 ) { d_[j]=0;
if ( j==n_-1 )
++d_[j];

++j; }

return false; // current permutation is last

for (ulong e1=n_-2-j, e2=e1+1; e2<n_; e1+=2, e2+=2)
{
const ulong i1 = pi_[e1]; // position of element e1
const ulong i2 = pi_[e2]; // position of element e2
pi_[e1] = i2;
pi_[e2] = i1;
p_[i1] = e2;
p_[i2] = e1;
}
return true;
}

All swaps with the inverse permutations are of adjacent pairs. The reversals of the ﬁrst half of all
permutations lie in the second half, the reversal of the k-th permutation lies at position n! − 1 − k

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 2 3 1 ]
[ . 3 2 1 ]
[ . 3 1 2 ]
[ . 2 1 3 ]
[ 1 3 . 2 ]
[ 1 2 . 3 ]
[ 2 1 . 3 ]
[ 3 1 . 2 ]
[ 3 2 . 1 ]
[ 2 3 . 1 ]
[ 3 2 1 . ]
[ 2 3 1 . ]
[ 1 3 2 . ]
[ 1 2 3 . ]
[ 2 1 3 . ]
[ 3 1 2 . ]
[ 2 . 3 1 ]
[ 3 . 2 1 ]
[ 3 . 1 2 ]
[ 2 . 1 3 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1

.
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2
.
.
1
1
2
2

.
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

inv. perm.
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 3 1 2 ]
[ . 3 2 1 ]
[ . 2 3 1 ]
[ . 2 1 3 ]
[ 2 . 3 1 ]
[ 2 . 1 3 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ 2 3 1 . ]
[ 2 3 . 1 ]
[ 3 2 1 . ]
[ 3 2 . 1 ]
[ 3 . 2 1 ]
[ 3 . 1 2 ]
[ 3 1 . 2 ]
[ 3 1 2 . ]
[ 1 3 . 2 ]
[ 1 3 2 . ]
[ 1 2 3 . ]
[ 1 2 . 3 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]

Figure 10.12-C: Permutations of 4 elements in single track order starting with the identical permutation.
The single track property is independent of the ﬁrst permutation, we start with the identical permutation:
1
2
3

void first_id() // start with identical permutation
{
for (ulong k=0; k<n_-1; ++k) d_[k] = 0;

274
4
5


p_[k] = pi_[k] = k;

}

The generated ordering is shown in figure 10.12-C. The reversal of the k-th permutation lies at position
(n!)/2 + k. About 123 million permutations per second are generated.

10.12.1

Construction of all single track orders
112233
231312
323121

<--= permutations of 3 elements in lex order (columns)

000000 112233 231312 323121


000000
323121
231312
112233

<--=
<--=
<--=
<--=

112233
000000
323121
231312

231312
112233
000000
323121

323121
231312
112233
000000

shift 0
shift 6
shift 12
shift 18

Figure 10.12-D: Construction of a single track order for permutations of 4 elements from an arbitrary
ordering of the permutations of 3 elements.
single track ordering
...... 112233 231312 323121
323121 ...... 112233 231312
231312 323121 ...... 112233
112233 231312 323121 ......

modified single track
21.113 332.22 .212.1
1.333. 21.113 332.22
.212.1 1.333. 21.113
332.22 .212.1 1.333.

^^^^^^
000000

ordering
1.333.
.212.1
332.22
21.113

^^^^^^
210321 <--= cyclic shifts

Figure 10.12-E: In each of the first (n − 1)! permutations in a single track ordering (first block left) an
arbitrary rotation can be applied (first block right), leading to a different single track ordering.
A construction for a single track order of n + 1 elements from an arbitrary ordering of n elements is shown
in figure 10.12-D (for n = 3 and lexicographic order). Thereby we obtain as many single track orders
for the permutations of n elements as there are orders of the permutations of n − 1 elements, namely
((n − 1)!)!. One can apply cyclic shifts in each block as shown in figure 10.12-E. The shifts in the first
(n − 1)! positions (first blocks in the figure) determine the shifts for the remaining permutations, and
there are n different cyclic shifts in each position. Indeed all single track orderings are of this form, so
their number is
Ns (n)

=

((n − 1)!)! n(n−1)!

(10.12-1)

The number of single track orders that start with the identical permutation, and where the k-th run of
(n − 1)! elements starts with k (and so all shifts between consecutive tracks are left shifts by (n − 1)!
positions) is
Ns (n)/n!

10.12.2

=

((n − 1)! − 1)! n(n−1)!−1

(10.12-2)

A single track Gray code

A Gray code with the single track property can be constructed by using a Gray code for the permutations
of n − 1 elements if the first and last permutation are cyclic shifts by one position of each other. Such
Gray codes exist for even lengths only. Figure 10.12-F shows a single track Gray code for n = 5. For
even n we use a Gray code where all but the last element are cyclically shifted between the first and last
permutation. Such a Gray code is given in section 10.9.3 on page 263. The resulting single track order
has just n−1 extra transpositions for all permutations of n elements, see figure 10.12-G. The listings were
created with the program [FXT: comb/perm-st-gray-demo.cc] which uses [FXT: class perm st gray in
comb/perm-st-gray.h]:
1
2

class perm_st_gray
{

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

.
1
2
.
1
2
3
1
.
3
1
.
.
2
3
.
2
3
3
2
1
3
2
1

1
.
.
2
2
1
1
3
3
.
.
1
2
.
.
3
3
2
2
3
3
1
1
2

2
2
1
1
.
.
.
.
1
1
3
3
3
3
2
2
.
.
1
1
2
2
3
3

3
3
3
3
3
3
2
2
2
2
2
2
1
1
1
1
1
1
.
.
.
.
.
.

4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

275

1
.
.
2
2
1
1
3
3
.
.
1
2
.
.
3
3
2
2
3
3
1
1
2

2
2
1
1
.
.
.
.
1
1
3
3
3
3
2
2
.
.
1
1
2
2
3
3

3
3
3
3
3
3
2
2
2
2
2
2
1
1
1
1
1
1
.
.
.
.
.
.

4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4

.
1
2
.
1
2
3
1
.
3
1
.
.
2
3
.
2
3
3
2
1
3
2
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

2
2
1
1
.
.
.
.
1
1
3
3
3
3
2
2
.
.
1
1
2
2
3
3

3
3
3
3
3
3
2
2
2
2
2
2
1
1
1
1
1
1
.
.
.
.
.
.

4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4

.
1
2
.
1
2
3
1
.
3
1
.
.
2
3
.
2
3
3
2
1
3
2
1

1
.
.
2
2
1
1
3
3
.
.
1
2
.
.
3
3
2
2
3
3
1
1
2

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

3
3
3
3
3
3
2
2
2
2
2
2
1
1
1
1
1
1
.
.
.
.
.
.

4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4

.
1
2
.
1
2
3
1
.
3
1
.
.
2
3
.
2
3
3
2
1
3
2
1

1
.
.
2
2
1
1
3
3
.
.
1
2
.
.
3
3
2
2
3
3
1
1
2

2
2
1
1
.
.
.
.
1
1
3
3
3
3
2
2
.
.
1
1
2
2
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4
4

.
1
2
.
1
2
3
1
.
3
1
.
.
2
3
.
2
3
3
2
1
3
2
1

1
.
.
2
2
1
1
3
3
.
.
1
2
.
.
3
3
2
2
3
3
1
1
2

2
2
1
1
.
.
.
.
1
1
3
3
3
3
2
2
.
.
1
1
2
2
3
3

3
3
3
3
3
3
2
2
2
2
2
2
1
1
1
1
1
1
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 10.12-F: A cyclic Gray code for the permutations of 5 elements with the single track property.

1:
[
2:
[
3:
[
4:
[
5:
[
[--one
116:
[
117:
[
118:
[
119:
[
120:
[
121:
[
[--one
240:
[
241:
[
[--one
360:
[
361:
[
[--one
480:
[
481:
[
[--one
600:
[
601:
[
[--one
720:
[
1:
[

0 1 2 3 4 5 ]
1 0 2 3 4 5 ]
2 0 1 3 4 5 ]
0 2 1 3 4 5 ]
1 2 0 3 4 5 ]
transposition
2 3 1 0 4 5 ]
1 3 2 0 4 5 ]
3 1 2 0 4 5 ]
2 1 3 0 4 5 ]
1 2 3 0 4 5 ]
1 2 3 4 5 0 ]
transposition
2 3 0 4 5 1 ]
2 3 4 5 0 1 ]
transposition
3 0 4 5 1 2 ]
3 4 5 0 1 2 ]
transposition
0 4 5 1 2 3 ]
4 5 0 1 2 3 ]
transposition
4 5 1 2 3 0 ]
5 0 1 2 3 4 ]
transposition
5 1 2 3 0 4 ]
0 1 2 3 4 5 ]

only--]

<< (0, 4, 5)
only--]
<< (0, 4, 5)
only--]
<< (0, 4, 5)
only--]
<< (0, 4, 5)
only--]
<< (0, 4, 5)
only--]
<< (0, 4, 5)

Figure 10.12-G: The single track ordering for even n with the least number of transpositions contains
n − 1 extra transpositions. The transitions involving more than 2 elements are 3-cycles.

276
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


public:
perm_gray_rot1 *G;
ulong
ulong
ulong
ulong

*x_;
*ix_;
n_;
sct_;

//
//
//
//

// underlying permutations

permutation
inverse permutation
number of elements
count cyclic shifts

public:
perm_st_gray(ulong n)
// Must have n>=2
{
n_ = (n>=2 ? n : 2);
G = new perm_gray_rot1(n-1);
x_ = new ulong[n_];
first();
}
[--snip--]
void first()
{
G->first();
for (ulong j=0; j<n_; ++j) ix_[j] = x_[j] = j;
sct_ = n_;
}

We deﬁne two auxiliary routines for swapping elements by their value and by their positions:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

private:
void swap_elements(ulong x1, ulong x2)
{
const ulong i1 = ix_[x1], i2 = ix_[x2];
x_[i1] = x2;
x_[i2] = x1;
// swap2(x_[i1], x_[i2]);
}
void swap_positions(ulong i1, ulong i2)
{
const ulong x1 = x_[i1], x2 = x_[i2];
x_[i1] = x2;
x_[i2] = x1;
// swap2(x_[i1], x_[i2]);
}

The update routine consists of two cases. The frequent case is the update via the underlying permutation:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public:
bool next()
{
bool q = G->next();
if ( q ) // normal update (in underlying permutation of n-1 elements)
{
ulong i1, i2; // positions of swaps
G->get_swap(i1, i2);
// rotate positions according to sct:
i1 += sct_; if ( i1>=n_ ) i1-=n_;
i2 += sct_; if ( i2>=n_ ) i2-=n_;
swap_positions(i1, i2);
return true;
}

The infrequent case happens when the last underlying permutation is encountered:
1
2
3
4
5
6
7
8
9
10
11
12

else // goto next cyclic shift (once in (n-1)! updates, n-1 times in total)
{
G->first(); // restart underlying permutations
--sct_;
// adjust cyclic shift
swap_elements(0, n_-1);
if ( 0==(n_&1) )
if ( n_>=4 )

// n even
swap_elements(n_-2, n_-1);

return ( 0!=sct_ );
}
}

// one extra transposition

277

Chapter 11

Permutations with special properties
11.1

The number of certain permutations

We give expressions for the number of permutations with special properties, such as involutions, derangements, permutations with prescribed cycle types, and permutations with distance restrictions.

11.1.1
n:
1:
2:
3:
4:
5:
6:
7:
8:
9:

Permutations with m cycles: Stirling cycle numbers
total
1
2
6
24
120
720
5040
40320
362880

m=

1
2
3
1
1
1
2
3
1
6
11
6
24
50
35
120
274
225
720
1764
1624
5040 13068 13132
40320 109584 118124

4

5

6

7

8

9

1
10
85
735
6769
67284

1
15
175
1960
22449

1
21
322
4536

1
28
546

1
36

1

Figure 11.1-A: Stirling numbers of the first kind s(n, m) (Stirling cycle numbers).
The number of permutations of n elements into m cycles is given by the (unsigned) Stirling numbers of
the first kind (or Stirling cycle numbers) s(n, m). The first few are shown in figure 11.1-A which was
created with the program [FXT: comb/stirling1-demo.cc]. We have s(1, 1) = 1 and
s(n, m)

= s(n − 1, m − 1) + (n − 1) s(n − 1, m)

(11.1-1)

See entry A008275 in [312] and [1, p.824]. Many identities involving the Stirling numbers are given
in [166, pp.243-253]. We note just a few, writing S(n, k) for the Stirling set numbers (see section 17.2 on
page 358):
n

n

xn

S(n, k) xk =

=
k=0

S(n, k) (−1)n−k xk

(11.1-2a)

k=0

where xk = x (x − 1) (x − 2) · · · (x − k + 1) and xk = x (x + 1) (x + 2) · · · (x + k − 1). Also
n

xk

s(n, k) (−1)n−k xk

(11.1-2b)

s(n, k) xk

=

(11.1-2c)

k=0
n

xk

=
k=0

278
With D :=

Chapter 11: Permutations with special properties
d
dz

d
and ϑ = z dz , we have the operator identities [166, p.296]
n

ϑn

S(n, k) z k Dk

(11.1-3a)

s(n, k) (−1)n−k ϑk

=

(11.1-3b)

k=0
n

z n Dn

=
k=0

11.1.2

Permutations with prescribed cycle type

A permutation of n elements is of type C = [c1 , c2 , c3 , . . . , cn ] if it has c1 fixed points, c2 cycles of
length 2, c3 cycles of length 3, and so on. The number Zn,C of permutations of n elements with type C
equals [62, p.80]
n

Zn,C

= n! / (c1 ! c2 ! c3 ! . . . cn ! 1c1 2c2 3c3 . . . ncn ) = n! /

(ck ! k ck )

(11.1-4)

k=1

We necessarily have n = 1 c1 + 2 c2 + . . . + n cn , that is, the cj correspond to an integer partition of n.
The exponential generating function exp(L(z)) where
∞

L(z)

=
k=1

tk z k
k

(11.1-5a)

gives detailed information about all cycle types:
∞

exp(L(z))

=

Zn,C
n=0

C

tck
k

zn
n!

(11.1-5b)

That is, the exponent of tk indicates how many cycles of length k are present in the given cycle type:
? n=8;R=O(z^(n+1));
? L=sum(k=1,n,eval(Str("t"k))*z^k/k)+R
t1*z + 1/2*t2*z^2 + 1/3*t3*z^3 + 1/4*t4*z^4 + [...] + 1/8*t8*z^8 + O(z^9)
? serlaplace(exp(L))
1
+ t1 *z
+ (t1^2 + t2) *z^2
+ (t1^3 + 3*t2*t1 + 2*t3) *z^3
+ (t1^4 + 6*t2*t1^2 + 8*t3*t1 + 3*t2^2 + 6*t4) *z^4
+ (t1^5 + 10*t2*t1^3 + 20*t3*t1^2 + 15*t1*t2^2 + 30*t1*t4 + 20*t3*t2 + 24*t5) *z^5
+ (t1^6 + 15*t2*t1^4 + 40*t3*t1^3 + [...] + 15*t2^3 + 90*t4*t2 + 40*t3^2 + 120*t6) *z^6
+ (t1^7 + 21*t2*t1^5 + 70*t3*t1^4 + [...] + 504*t5*t2 + 420*t4*t3 + 720*t7) *z^7
+ (t1^8 + 28*t2*t1^6 + 112*t3*t1^5 + [...] + 2688*t5*t3 + 1260*t4^2 + 5040*c8) *z^8
+ O(z^9)

Relation 11.1-5a is obtained by replacing tk by (k − 1)! tk in relation 17.2-7a on page 359 (for the EGF
for set partitions of given type), which takes the order of the elements in each cycle into account.

11.1.3

Prefix conditions

Some types of permutations can be generated efficiently by a routine that produces the lexicographically
ordered list of permutations subject to conditions for all prefixes. The implementation (following [215,
alg.X, sect.7.2.1.2]) is [FXT: class perm restrpref in comb/perm-restrpref.h]. The condition has to be
supplied (as a function pointer) at creation of a class instance. The program [FXT: comb/perm-restrprefdemo.cc] demonstrates the usage, it can be used to generate all involutions, up-down permutations,
connected permutations, or derangements, see figure 11.1-B..

11.1: The number of certain permutations
involutions
1:
1 2 3
2:
1 2 4
3:
1 3 2
4:
1 4 3
5:
2 1 3
6:
2 1 4
7:
3 2 1
8:
3 4 1
9:
4 2 3
10:
4 3 2
#perm = 10

4
3
4
2
4
3
4
2
1
1

279

up-down
1:
1 3 2
2:
1 4 2
3:
2 3 1
4:
2 4 1
5:
3 4 1
#perm = 5

4
3
4
3
2

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
#perm

connected
2 3 4
2 4 1
2 4 3
3 1 4
3 2 4
3 4 1
3 4 2
4 1 2
4 1 3
4 2 1
4 2 3
4 3 1
4 3 2
= 13

1
3
1
2
1
2
1
3
2
3
1
2
1

derangements
1:
2 1 4 3
2:
2 3 4 1
3:
2 4 1 3
4:
3 1 4 2
5:
3 4 1 2
6:
3 4 2 1
7:
4 1 2 3
8:
4 3 1 2
9:
4 3 2 1
#perm = 9

Figure 11.1-B: Examples of permutations subject to conditions on prefixes. From left to right: involutions, up-down permutations, connected permutations, and derangements.
11.1.3.1

Involutions

The sequence of numbers of involutions (self-inverse permutations), I(n), starts as (n ≥ 1)
1, 2, 4, 10, 26, 76, 232, 764, 2620, 9496, 35696, 140152, 568504, 2390480, ...
This is sequence A000085 in [312]. The first element in an involution can be a fixed point or a 2-cycle
with any of the n − 1 other elements, so
= I(n − 1) + (n − 1) I(n − 2)

I(n)
N=20; v=vector(N); v[1]=1; v[2]=2;
for(n=3,N,v[n]=v[n-1]+(n-1)*v[n-2]);

v

==

(11.1-6)

[1, 2, 4, 10, 26, 76, ... ]

Let hn (x) be the polynomial such that the coefficient of xk gives the number of involutions of n elements
with k fixed points. The polynomials can be computed recursively via hn+1 = hn + x hn (starting with
h0 = 1). We have hn (1) = I(n):
? h=1;for(k=1,8,h=(deriv(h)+x*h);print(subst(h,x,1),": ",h))
1: x
2: x^2 + 1
4: x^3 + 3*x
10: x^4 + 6*x^2 + 3
26: x^5 + 10*x^3 + 15*x
76: x^6 + 15*x^4 + 45*x^2 + 15
232: x^7 + 21*x^5 + 105*x^3 + 105*x
764: x^8 + 28*x^6 + 210*x^4 + 420*x^2 + 105

The exponential generating function (EGF) is
∞

k=0

I(k) xk
k!

=

exp x + x2 /2

(11.1-7)

We further have (set c1 = t, c2 = 1, and ck = 0 for k ≥ 2 in 11.1-5a)
∞

k=0

hk (t) xk
k!

=

exp t x + x2 /2

(11.1-8)

The EGF for the number permutations whose m-th power is identity is [359, p.85]:


exp 

xd /d

dm

The special case m = 2 gives relation 11.1-7. The condition function for involutions is
1
2

bool cond_inv(const ulong *a, ulong k)
{

(11.1-9)

280
3
4
5
6

ulong ak = a[k];
if ( (ak<=k) && (a[ak]!=k) )
return true;

return false;

}

The recurrence 11.1-6 can be generalized for permutations where only cycles of certain lengths are allowed.
Set tk = 1 if cycles of length k are allowed, else set tk = 0. The recurrence relation for PT (n), the number
of permutations corresponding to the vector T = [t1 , t2 , . . . , tu ] is (by relation 11.1-1)
u

PT (n)

tk F (n − 1, k − 1) PT (n − k)

=

where

(11.1-10a)

k=1

F (n − 1, e)

:=

(n − 1) (n − 2) (n − 3) . . . (n − e + 1)

F (n − 1, 0) := 1

and

(11.1-10b)

Initialize by setting PT (0) = 1 and PT (n) = 0 for n < 0. For example, if only cycles of length 1 or 3 are
allowed (t1 = t3 = 1, else tk = 0), the recurrence is
P (n)

=

P (n − 1) + (n − 1) (n − 2) P (n − 3)

(11.1-11)

The sequence of numbers of these permutations (whose order divides 3) is entry A001470 in [312]:
1, 1, 1, 3, 9, 21, 81, 351, 1233, 5769, 31041, 142011, 776601, 4874013, ...
11.1.3.2

Derangements

A permutation is a derangement if ak = k for all k:
1

bool cond_derange(const ulong *a, ulong k)

{ return ( a[k] != k ); }

The sequence D(n) of the number of derangements starts as (n ≥ 1)
0, 1, 2, 9, 44, 265, 1854, 14833, 133496, 1334961, 14684570, 176214841, ...
This is sequence A000166 in [312], the subfactorial numbers. Compute D(n) using either of
D(n)

=

(n − 1) [D(n − 1) + D(n − 2)]

(11.1-12a)

n

= n D(n − 1) + (−1)
n

(−1)n−k

=
k=0

D(n)

=

(n! + 1)/e

(11.1-12b)

n!
= n!
(n − k)!

n

k=0

(−1)
k!

k

for n ≥ 1

(11.1-12c)
(11.1-12d)

where e = exp(1). We use the recurrence 11.1-12a:
N=20; v=vector(N); v[1]=0; v[2]=1;
for(n=3,N,v[n]=(n-1)*(v[n-1]+v[n-2]));

v

== [0, 1, 2, 9, 44, 265, 1854, 14833, ... ]

The exponential generating function can be found by setting t1 = 0 and tk = 1 for k = 1 in relation 11.15a: we have L(z) = log (1/(1 − z)) − z and
∞

k=0

D(n) z n
n!

=

exp L(z) =

exp(−z)
1−z

(11.1-13)

The number of derangements with prescribed ﬁrst element is K(n) := D(n)/(n − 1), The sequence of
values K(n), entry A000255 in [312], starts as
1, 1, 3, 11, 53, 309, 2119, 16687, 148329, 1468457, 16019531, 190899411, ...
We have K(n) = n K(n − 1) + (n − 1) K(n − 2), and K(n) counts the permutations with no occurrence
of [x, x + 1], see ﬁgure 11.1-C. The condition used is
1
2
3
4
5

bool cond_xx1(const ulong *a, ulong k)
{
if ( k==1 ) return true;
return ( a[k-1] != a[k]-1 ); // must look backward
}

Note that the routine is for the permutations of the elements 1, 2, . . . , n in a one-based array.

11.1: The number of certain permutations
no [x, x+1]
1: 1 3 2 4
2: 1 4 3 2
3: 2 1 4 3
4: 2 4 1 3
5: 2 4 3 1
6: 3 1 4 2
7: 3 2 1 4
8: 3 2 4 1
9: 4 1 3 2
10: 4 2 1 3
11: 4 3 2 1

281

derangements with
1: 2 1 4 5
2: 2 1 5 3
3: 2 3 1 5
4: 2 3 4 5
5: 2 3 5 1
6: 2 4 1 5
7: 2 4 5 1
8: 2 4 5 3
9: 2 5 1 3
10: 2 5 4 1
11: 2 5 4 3

p(1)=2
3
4
4
1
4
3
3
1
4
3
1

Figure 11.1-C: Permutations of 4 elements with no occurrence of [x, x + 1] (left) and derangements of
5 elements starting with 2.
11.1.3.3

Connected permutations

The connected (or indecomposable) permutations satisfy, for k = 0, 1, . . . , n − 2, the inequality of sets
{a0 , a1 , . . . , ak }

= {0, 1, . . . , k}

(11.1-14)

That is, there is no preﬁx of length < n which is a permutation of itself. The condition function is
1
2
3
4
5
6
7
8

ulong N; // set to n in main()
bool cond_indecomp(const ulong *a, ulong k)
// indecomposable condition: {a1,...,ak} != {1,...,k} for all k<n
{
if ( k==N ) return true;
for (ulong i=1; i<=k; ++i) if ( a[i]>k ) return true;
return false;
}

The sequence of numbers C(n) of indecomposable permutations starts as (n ≥ 1)
1, 1, 3, 13, 71, 461, 3447, 29093, 273343, 2829325, 31998903, 392743957, ...
This is entry A003319 in [312]. Compute C(n) using
n−1

C(n)

=

k! C(n − k)

n! −

(11.1-15)

k=1

N=20; v=vector(N);
for(n=1,N,v[n]=n!-sum(k=1,n-1,k!*v[n-k]));

v

== [1, 1, 3, 13, 71, 461, 3447, ... ]

The ordinary generating function can be given as
∞

C(n) z n

=

1

1−

∞
k=0

n=1

k! z k

= z + z 2 + 3 z 3 + 13 z 4 + 71 z 5 + . . .

(11.1-16)

The following recursion (and a Gray code for the connected permutations) is given in [205]:
n−1

C(n)

(n − k) (k − 1)! C(n − k)

=

(11.1-17)

k=1

11.1.3.4

Alternating permutations

The alternating permutations (or up-down permutations) satisfy a0 < a1 > a2 < a3 > . . .. The condition
function is
1
2
3
4
5
6
7

bool cond_updown(const ulong *a, ulong k)
// up-down condition: a1 < a2 > a3 < a4 > ...
{
if ( k<2 ) return true;
if ( (k%2) ) return ( a[k]<a[k-1] );
else
return ( a[k]>a[k-1] );
}

282


The sequence A(n) of the number of alternating permutations starts as (n ≥ 1)
1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521, 353792, 2702765, 22368256, ...
It is sequence A000111 in [312], the sequence of the Euler numbers. The list can be computed using the
relation
A(n)

=

1
2

n−1

k=0

n−1
A(k) A(n − 1 − k)
k

(11.1-18)

N=20; v=vector(N+1); v[0+1]=1; v[1+1]=1; v[2+1]=1; start with zero: v[x] == A(x-1)
for(n=3,N,v[n+1]=1/2*sum(k=0,n-1,binomial(n-1,k)*v[k+1]*v[n-1-k+1])); v
== [1, 1, 1, 2, 5, 16, 61, 272, ... ]

An exponential generating function is
∞

1 + sin(z)
cos(z)

=
k=0

A(k) z k
k!

(11.1-19)

? serlaplace((1+sin(z))/cos(z))
1 + z + z^2 + 2*z^3 + 5*z^4 + 16*z^5 + 61*z^6 + 272*z^7 + 1385*z^8 + 7936*z^9 + ...

11.2

Permutations with distance restrictions

We present constructions for Gray codes for permutations with certain restrictions. These are computed
from Gray codes of mixed radix numbers with factorial base. We write p(k) for the position of the element
k in a given permutation.

11.2.1
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

Permutations where p(k) ≤ k + 1
.
.
.
.
.
.
.
.
1
1
1
1
2
2
3
4

ffact
3 . .
2 . .
1 . .
1 . 1
. . 1
. . .
. 1 .
. 2 .
. 2 .
. 1 .
. . .
. . 1
. . 1
. . .
. . .
. . .

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

0
0
0
0
0
0
0
0
1
1
1
1
2
2
3
4

perm
4 1
3 1
2 1
2 1
1 2
1 2
1 3
1 4
0 4
0 3
0 2
0 2
0 1
0 1
0 1
0 1

2
2
3
4
4
3
2
2
2
2
3
4
4
3
2
2

3
4
4
3
3
4
4
3
3
4
4
3
3
4
4
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv. perm
0 2 3 4 1
0 2 3 1 4
0 2 1 3 4
0 2 1 4 3
0 1 2 4 3
0 1 2 3 4
0 1 3 2 4
0 1 3 4 2
1 0 3 4 2
1 0 3 2 4
1 0 2 3 4
1 0 2 4 3
1 2 0 4 3
1 2 0 3 4
1 2 3 0 4
1 2 3 4 0

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

ffact(inv)
. 1 1 1
. 1 1 .
. 1 . .
. 1 . 1
. . . 1
. . . .
. . 1 .
. . 1 1
1 . 1 1
1 . 1 .
1 . . .
1 . . 1
1 1 . 1
1 1 . .
1 1 1 .
1 1 1 1

Figure 11.2-A: Gray code for the permutations of 5 elements where no element lies more than one place
to the right of its position in the identical permutation.
Let M (n) be the number of permutations of n elements where no element can move more than one place
to the right. We have M (n) = 2n−1 , see entry A000079 in [312]. A Gray code for these permutations
is shown in ﬁgure 11.2-A which was created with the program [FXT: comb/perm-right1-gray-demo.cc].
M (n) also counts the permutations that start as a rising sequence (ending in the maximal element) and
end as a falling sequence. The list in the leftmost column of ﬁgure 11.2-A can be generated by the
recursion
1
2
3
4
5
6

void Y_rec(ulong d, bool z)
{
if ( d>=n ) visit();
else
{

11.2: Permutations with distance restrictions
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

283

{
// words 0, 10, 200, 3000, 40000, ...
ulong k = 0;
do
{
ff[d] = k;
Y_rec(d+k+1, !z);
}
while ( ++k <= (n-d) );
}
else
// backward:
{
// words ..., 40000, 3000, 200, 10, 0
ulong k = n-d+1;
do
{
--k;
ff[d] = k;
Y_rec(d+k+1, !z);
}
while ( k != 0 );
}
}
}

The array ff (of length n) must be initialized with zeros and the initial call is Y_rec(0, true);. About
85 million words per second are generated. In the inverse permutations (where no element is more than
one place left of its original position) the swaps are adjacent and their position is determined by the
ruler function. Therefore the inverse permutations can be generated using [FXT: class ruler func in
comb/ruler-func.h] which is described in section 8.2.3 on page 207.

11.2.2
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

Permutations where k − 1 ≤ p(k) ≤ k + 1
1
1
1
1
1
1
1
1
.
.
.
.
.

ffact
. . 1
. . 1
. . .
. . .
. . .
. 1 .
. 1 .
. 1 .
. 1 .
. 1 .
. 1 .
. . .
. . .

.
.
.
.
1
1
.
.
.
.
1
1
.

.
1
1
.
.
.
.
1
1
.
.
.
.

[
[
[
[
[
[
[
[
[
[
[
[
[

1
1
1
1
1
1
1
1
0
0
0
0
0

perm
0 2 4
0 2 4
0 2 3
0 2 3
0 2 3
0 3 2
0 3 2
0 3 2
1 3 2
1 3 2
1 3 2
1 2 3
1 2 3

3
3
4
4
5
5
4
4
4
4
5
5
4

5
6
6
5
4
4
5
6
6
5
4
4
5

6
5
5
6
6
6
6
5
5
6
6
6
6

]
]
]
]
]
]
]
]
]
]
]
]
]

14:
15:
16:
17:
18:
19:
20:
21:

.
.
.
.
.
.
.
.

ffact
. . .
. . 1
. . 1
1 . 1
1 . 1
1 . .
1 . .
1 . .

.
.
.
.
.
.
.
1

1
1
.
.
1
1
.
.

[
[
[
[
[
[
[
[

0
0
0
0
0
0
0
0

perm
1 2 3
1 2 4
1 2 4
2 1 4
2 1 4
2 1 3
2 1 3
2 1 3

4
3
3
3
3
4
4
5

6
6
5
5
6
6
5
4

5
5
6
6
5
5
6
6

]
]
]
]
]
]
]
]

Figure 11.2-B: Gray code for the permutations of 7 elements where no element lies more than one place
away from its position in the identical permutation. The permutations are self-inverse.
Let F (n) the number of permutations of n elements where no element can move more than one place to
the left. Then F (n) is the (n + 1)-st Fibonacci number. A Gray code for these permutations is shown in
ﬁgure 11.2-B which was created with the program [FXT: comb/perm-dist1-gray-demo.cc].

11.2.3

Permutations where k − 1 ≤ p(k) ≤ k + d

A Gray code for the permutations where no element lies more than one place to the left or d places to
the right of its original position can be generated using the Gray codes for binary words with at most d
consecutive ones given in section 14.3 on page 307. Figure 11.2-C shows the permutations of 6 elements
with d = 2. It was created with the program [FXT: comb/perm-l1r2-gray-demo.cc]. The array shown
leftmost in ﬁgure 11.2-C can be generated via the recursion
1
2
3
4
5
6

void Y_rec(ulong d, bool z)
{
else
{
const ulong w = n-d;

284


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

1
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.

ffact
1 . .
1 . .
1 . 1
1 . 1
. . 1
. . 1
. . .
. . .
. 1 .
. 1 .
. 1 1
. 1 1
. 1 .
. 1 .
. . .
. . .
. . 1
. . 1
1 . 1
1 . 1
1 . .
1 . .
1 1 .
1 1 .

1
.
.
1
1
.
.
1
1
.
.
.
.
1
1
.
.
1
1
.
.
1
1
.

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

1
1
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0

perm
2 0 3
2 0 3
2 0 4
2 0 4
0 2 4
0 2 4
0 2 3
0 2 3
0 3 2
0 3 2
0 3 4
1 3 4
1 3 2
1 3 2
1 2 3
1 2 3
1 2 4
1 2 4
2 1 4
2 1 4
2 1 3
2 1 3
2 3 1
2 3 1

5
4
3
5
5
3
4
5
5
4
2
2
4
5
5
4
3
5
5
3
4
5
5
4

4
5
5
3
3
5
5
4
4
5
5
5
5
4
4
5
5
3
3
5
5
4
4
5

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv. perm
2 0 1 3 5
2 0 1 3 4
2 0 1 4 3
2 0 1 5 3
1 0 2 5 3
1 0 2 4 3
1 0 2 3 4
1 0 2 3 5
1 0 3 2 5
1 0 3 2 4
1 0 4 2 3
0 1 4 2 3
0 1 3 2 4
0 1 3 2 5
0 1 2 3 5
0 1 2 3 4
0 1 2 4 3
0 1 2 5 3
0 2 1 5 3
0 2 1 4 3
0 2 1 3 4
0 2 1 3 5
0 3 1 2 5
0 3 1 2 4

4
5
5
4
4
5
5
4
4
5
5
5
5
4
4
5
5
4
4
5
5
4
4
5

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

ffact(inv)
2 . . . 1
2 . . . .
2 . . 1 .
2 . . 2 .
1 . . 2 .
1 . . 1 .
1 . . . .
1 . . . 1
1 . 1 . 1
1 . 1 . .
1 . 2 . .
. . 2 . .
. . 1 . .
. . 1 . 1
. . . . 1
. . . . .
. . . 1 .
. . . 2 .
. 1 . 2 .
. 1 . 1 .
. 1 . . .
. 1 . . 1
. 2 . . 1
. 2 . . .

Figure 11.2-C: Gray code for the permutations of 6 elements where no element lies more than one place
to the left or two places to the right of its position in the identical permutation.
7
8
9
10
11
12
13
14
15
16
17
18
19
20

if ( z )
{
if ( w>1
ff[d]=1;
ff[d]=0;
}
else
{
ff[d]=0;
ff[d]=1;
if ( w>1
}

) { ff[d]=1; ff[d+1]=1; ff[d+2]=0;
ff[d+1]=0; Y_rec(d+2, !z);
Y_rec(d+1, !z);

Y_rec(d+3, !z); }

Y_rec(d+1, !z);
ff[d+1]=0; Y_rec(d+2, !z);
) { ff[d]=1; ff[d+1]=1; ff[d+2]=0; Y_rec(d+3, !z); }

}
}

If the two lines starting with if ( w>1 ) are omitted, the Fibonacci words are computed. About 100
million words per second are generated.

11.3

Self-inverse permutations (involutions)
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

[
[
[
[
[
[
[
[
[
[
[
[
[

.
.
.
.
4
.
.
4
.
.
4
3
3

1
1
1
4
1
1
4
1
3
3
3
1
1

2
2
4
2
2
3
3
3
2
4
2
2
4

3
4
3
3
3
2
2
2
1
1
1
.
.

4
3
2
1
.
4
1
.
4
2
.
4
2

]
]
]
]
]
]
]
]
]
]
]
]
]

13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

[
[
[
[
[
[
[
[
[
[
[
[
[

3
.
.
4
3
2
2
2
2
1
1
1
1

4
2
2
2
2
1
1
4
3
.
.
.
.

2
1
1
1
1
.
.
.
.
2
2
4
3

.
3
4
3
.
3
4
3
1
3
4
3
2

1
4
3
.
4
4
3
1
4
4
3
2
4

]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 11.3-A: All self-inverse permutations of 5 elements.
An involution is a self-inverse permutation (see section 2.3.1 on page 106). The involutions of 5 elements
are shown in ﬁgure 11.3-A. To generate all involutions, use [FXT: class perm involution in comb/perm-

11.4: Cyclic permutations

285

involution.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class perm_involution
{
public:
ulong *p_; // self-inverse permutation in 0, 1, ..., n-1
ulong n_;
public:
perm_involution(ulong n)
{
n_ = n;
p_ = new ulong[n_];
first();
}
~perm_involution() { delete [] p_; }
void first() { for (ulong i=0; i<n_; i++) p_[i] = i; }
const ulong * data() const { return p_; }

The successor of a permutation is computed as follows:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

bool next()
{
for (ulong j=n_-1; j!=0; --j)
{
ulong ip = p_[j];
// inverse perm == perm
p_[j] = j; p_[ip] = ip; // undo prior swap
while ( (long)(--ip)>=0 )
{
if ( p_[ip]==ip )
{
p_[j] = ip; p_[ip] = j; // swap2(p_[j], p_[ip]);
return true;
}
}
}
return false; // current permutation is last
}
[--snip--]
};

The rate of generation is about 50 million per second [FXT: comb/perm-involution-demo.cc].

11.4

Cyclic permutations

Cyclic permutations consist of exactly one cycle of full length, see section 2.2.1 on page 105.

11.4.1

Recursive algorithm for cyclic permutations

A simple recursive algorithm for the generation of all (not only cyclic!) permutations of n elements can
be described as follows: Put each of the n elements of the array to the ﬁrst position and generate all
permutations of the remaining n − 1 elements. If n = 1, print the permutation.
The generated order is shown in ﬁgure 11.4-A, it corresponds to the alternative (swaps) factorial representation with falling base, given in section 10.1.4 on page 239.
The algorithm is implemented in [FXT: class perm rec in comb/perm-rec.h]:
1
2
3
4
5
6
7
8
9
10
11
12

class perm_rec
{
public:
ulong *x_;
// permutation
ulong n_;
// number of elements
void (*visit_)(const perm_lex_rec &);
public:
perm_rec(ulong n)
{
n_ = n;
x_ = new ulong[n_];

// function to call with each permutation

286

permutation
[ . 1 2 3 ]
[ . 1 3 2 ]
[ . 2 1 3 ]
[ . 2 3 1 ]
[ . 3 2 1 ]
[ . 3 1 2 ]
[ 1 . 2 3 ]
[ 1 . 3 2 ]
[ 1 2 . 3 ]
[ 1 2 3 . ]
[ 1 3 2 . ]
[ 1 3 . 2 ]
[ 2 1 . 3 ]
[ 2 1 3 . ]
[ 2 . 1 3 ]
[ 2 . 3 1 ]
[ 2 3 . 1 ]
[ 2 3 1 . ]
[ 3 1 2 . ]
[ 3 1 . 2 ]
[ 3 2 1 . ]
[ 3 2 . 1 ]
[ 3 . 2 1 ]
[ 3 . 1 2 ]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inverse
. 1 2 3
. 1 3 2
. 2 1 3
. 3 1 2
. 3 2 1
. 2 3 1
1 . 2 3
1 . 3 2
2 . 1 3
3 . 1 2
3 . 2 1
2 . 3 1
2 1 . 3
3 1 . 2
1 2 . 3
1 3 . 2
2 3 . 1
3 2 . 1
3 1 2 .
2 1 3 .
3 2 1 .
2 3 1 .
1 3 2 .
1 2 3 .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

ffact-swp
[ . . . ]
[ . . 1 ]
[ . 1 . ]
[ . 1 1 ]
[ . 2 . ]
[ . 2 1 ]
[ 1 . . ]
[ 1 . 1 ]
[ 1 1 . ]
[ 1 1 1 ]
[ 1 2 . ]
[ 1 2 1 ]
[ 2 . . ]
[ 2 . 1 ]
[ 2 1 . ]
[ 2 1 1 ]
[ 2 2 . ]
[ 2 2 1 ]
[ 3 . . ]
[ 3 . 1 ]
[ 3 1 . ]
[ 3 1 1 ]
[ 3 2 . ]
[ 3 2 1 ]

Figure 11.4-A: All permutations of 4 elements (left) and their inverses (middle), and their (swaps)
representations as mixed radix numbers with falling factorial base. Permutations with common preﬁxes
appear in succession. Dots denote zeros.
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

}
~perm_rec()
{ delete [] x_; }
void init()
{
}

x_[k] = k;

void generate(void (*visit)(const perm_lex_rec &))
{
visit_ = visit;
init();
next_rec(0);
}

The recursive function next_rec() is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void next_rec(ulong d)
{
if ( d==n_-1 ) visit_(*this);
else
{
const ulong pd = x_[d];
for (ulong k=d; k<n_; ++k)
{
ulong px = x_[k];
x_[k] = pd; x_[d] = px;
next_rec(d+1);
x_[k] = px; x_[d] = pd;

// =^= swap2(x_[d], x_[k]);
// =^= swap2(x_[d], x_[k]);

}
}
}

The algorithm works because at each recursive call the elements x[d],...,x[n-1] are in a diﬀerent
order and when the function returns the elements are in the same order as they were initially. With the
for-statement changed to
for (ulong x=n_-1; (long)x>=(long)d; --x)

the permutations would appear in reversed order. Changing the loop in the function next_rec() to

287

for (ulong k=d; k<n_; ++k)
{
swap2(x_[d], x_[k]);
next_rec(d+1, qq);
}
rotate_left1(x_+d, n_-d);

produces lexicographic order.

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

permutation
[ 1 2 3 4 . ]
[ 1 2 4 . 3 ]
[ 1 3 . 4 2 ]
[ 1 3 4 2 . ]
[ 1 4 3 . 2 ]
[ 1 4 . 2 3 ]
[ 2 . 3 4 1 ]
[ 2 . 4 1 3 ]
[ 2 3 1 4 . ]
[ 2 3 4 . 1 ]
[ 2 4 3 1 . ]
[ 2 4 1 . 3 ]
[ 3 2 . 4 1 ]
[ 3 2 4 1 . ]
[ 3 . 1 4 2 ]
[ 3 . 4 2 1 ]
[ 3 4 . 1 2 ]
[ 3 4 1 2 . ]
[ 4 2 3 . 1 ]
[ 4 2 . 1 3 ]
[ 4 3 1 . 2 ]
[ 4 3 . 2 1 ]
[ 4 . 3 1 2 ]
[ 4 . 1 2 3 ]

(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,

cycle
1, 2, 3,
1, 2, 4,
1, 3, 4,
1, 3, 2,
1, 4, 2,
1, 4, 3,
2, 3, 4,
2, 4, 3,
2, 1, 3,
2, 4, 1,
2, 3, 1,
2, 1, 4,
3, 4, 1,
3, 1, 2,
3, 4, 2,
3, 2, 4,
3, 1, 4,
3, 2, 1,
4, 1, 2,
4, 3, 1,
4, 2, 1,
4, 1, 3,
4, 2, 3,
4, 3, 2,

4)
3)
2)
4)
3)
2)
1)
1)
4)
3)
4)
3)
2)
4)
1)
1)
2)
4)
3)
2)
3)
2)
1)
1)

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inverse
4 . 1 2
3 . 1 4
2 . 4 1
4 . 3 1
3 . 4 2
2 . 3 4
1 4 . 2
1 3 . 4
4 2 . 1
3 4 . 1
4 3 . 2
3 2 . 4
2 4 1 .
4 3 1 .
1 2 4 .
1 4 3 .
2 3 4 .
4 2 3 .
3 4 1 2
2 3 1 4
3 2 4 1
2 4 3 1
1 3 4 2
1 2 3 4

3
2
3
2
1
1
3
2
3
2
1
1
3
2
3
2
1
1
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

ffact-swp
[ 1 1 1 1 ]
[ 1 1 2 1 ]
[ 1 2 1 1 ]
[ 1 2 2 1 ]
[ 1 3 1 1 ]
[ 1 3 2 1 ]
[ 2 1 1 1 ]
[ 2 1 2 1 ]
[ 2 2 1 1 ]
[ 2 2 2 1 ]
[ 2 3 1 1 ]
[ 2 3 2 1 ]
[ 3 1 1 1 ]
[ 3 1 2 1 ]
[ 3 2 1 1 ]
[ 3 2 2 1 ]
[ 3 3 1 1 ]
[ 3 3 2 1 ]
[ 4 1 1 1 ]
[ 4 1 2 1 ]
[ 4 2 1 1 ]
[ 4 2 2 1 ]
[ 4 3 1 1 ]
[ 4 3 2 1 ]

Figure 11.4-B: All cyclic permutations of 5 elements and the permutations as cycles, their inverses, and
their (swaps) representations as mixed radix numbers with falling factorial base (from left to right).
A modified function generates the cyclic permutations. We skip the case x = d in the loop:
for (ulong k=d+1; k<n_; ++k)

// omit k==d

The cyclic permutations of five elements are shown in figure 11.4-B. The program [FXT: comb/perm-recdemo.cc] was used to create the figures in this section.
void visit(const perm_rec &P) // function to call with each permutation
{
// Print the permutation
}
int
main(int argc, char **argv)
{
ulong n = 5; // Number of elements to permute
bool cq = 1; // Whether to generate only cyclic permutations
perm_rec P(n);
if ( cq ) P.generate_cyclic(visit);
else
P.generate(visit);
return 0;
}

The routines generate about 57 million permutations and about 37 million cyclic permutations per second.

11.4.2

Minimal-change order for cyclic permutations

All cyclic permutations can be generated from a mixed radix Gray code with falling factorial base (see
section 9.2 on page 220). Two successive permutations differ at three positions as shown in figure 11.4-C.
A constant amortized time (CAT) implementation is [FXT: class cyclic perm in comb/cyclic-perm.h]:

288


0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

permutation
4 0 1 2 3 ]
3 4 1 2 0 ]
3 0 4 2 1 ]
3 0 1 4 2 ]
2 3 1 4 0 ]
2 3 4 0 1 ]
2 4 1 0 3 ]
4 3 1 0 2 ]
4 0 3 1 2 ]
2 4 3 1 0 ]
2 0 4 1 3 ]
2 0 3 4 1 ]
1 2 3 4 0 ]
1 2 4 0 3 ]
1 4 3 0 2 ]
4 2 3 0 1 ]
4 3 0 2 1 ]
1 4 0 2 3 ]
1 3 4 2 0 ]
1 3 0 4 2 ]
3 2 0 4 1 ]
3 2 4 1 0 ]
3 4 0 1 2 ]
4 2 0 1 3 ]

fact.num.
[ . . . ]
[ 1 . . ]
[ 2 . . ]
[ 3 . . ]
[ 3 1 . ]
[ 2 1 . ]
[ 1 1 . ]
[ . 1 . ]
[ . 2 . ]
[ 1 2 . ]
[ 2 2 . ]
[ 3 2 . ]
[ 3 2 1 ]
[ 2 2 1 ]
[ 1 2 1 ]
[ . 2 1 ]
[ . 1 1 ]
[ 1 1 1 ]
[ 2 1 1 ]
[ 3 1 1 ]
[ 3 . 1 ]
[ 2 . 1 ]
[ 1 . 1 ]
[ . . 1 ]

(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(4,

cycle
3, 2, 1,
0, 3, 2,
1, 0, 3,
2, 1, 0,
0, 2, 1,
1, 3, 0,
3, 0, 2,
2, 1, 3,
2, 3, 1,
0, 2, 3,
3, 1, 0,
1, 0, 2,
0, 1, 2,
3, 0, 1,
2, 3, 0,
1, 2, 3,
1, 3, 2,
3, 2, 0,
0, 1, 3,
2, 0, 1,
1, 2, 0,
0, 3, 1,
2, 0, 3,
3, 1, 2,

0)
1)
2)
3)
3)
2)
1)
0)
0)
1)
2)
3)
3)
2)
1)
0)
0)
1)
2)
3)
3)
2)
1)
0)

Figure 11.4-C: All cyclic permutations of 5 elements in a minimal-change order.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class cyclic_perm
{
public:
mixedradix_gray *M_;
ulong n_;
ulong *ix_; // current permutation (of {0, 1, ..., n-1})
ulong *x_; // inverse permutation
public:
cyclic_perm(ulong n)
: n_(n)
{
x_ = new ulong[n_];
first();
}
[--snip--]

// falling factorial base

The computation of the successor uses the position and direction of the mixed radix digit changed with
the last increment:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

private:
void setup()
{
const ulong *fc = M_->data();
for (ulong k=0; k<n_; ++k) ix_[k] = k;
for (ulong k=n_-1; k>1; --k)
{
ulong z = n_-3-(k-2); // 0, ..., n-3
ulong i = fc[z];
swap2(ix_[k], ix_[i]);
}
if ( n_>1 ) swap2(ix_[0], ix_[1]);
make_inverse(ix_, x_, n_);
}
public:
void first()
{
M_->first();

22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

289

setup();
}
bool next()
{
if ( false == M_->next() )
ulong j = M_->pos();

{ first();

return false; }

if ( j && (x_[0]==n_-1) ) // once in 2*n cases
{
setup(); // work proportional to n
// only 3 elements are interchanged
}
else // easy case
{
int d = M_->dir();
ulong x2 = (M_->data())[j];
ulong x1 = x2 - d, x3 = n_-1;
ulong i1 = x_[x1], i2 = x_[x2], i3 = x_[x3];
swap2(x_[x1], x_[x2]);
swap2(x_[x1], x_[x3]);
swap2(ix_[i1], ix_[i2]);
swap2(ix_[i2], ix_[i3]);
}
return true;
}
[--snip--]

The listing in ﬁgure 11.4-C was created with the program [FXT: comb/cyclic-perm-demo.cc]. About 58
million permutations per second are generated.

11.4.3

Cyclic permutations from factorial numbers

falling fact.
[ . . . ]
[ 1 . . ]
[ 2 . . ]
[ 3 . . ]
[ . 1 . ]
[ 1 1 . ]
[ 2 1 . ]
[ 3 1 . ]
[ . 2 . ]
[ 1 2 . ]
[ 2 2 . ]
[ 3 2 . ]
[ . . 1 ]
[ 1 . 1 ]
[ 2 . 1 ]
[ 3 . 1 ]
[ . 1 1 ]
[ 1 1 1 ]
[ 2 1 1 ]
[ 3 1 1 ]
[ . 2 1 ]
[ 1 2 1 ]
[ 2 2 1 ]
[ 3 2 1 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

permutation
1 2 3 4 0 ]
4 2 3 0 1 ]
1 4 3 0 2 ]
1 2 4 0 3 ]
3 2 4 1 0 ]
3 2 0 4 1 ]
3 4 0 1 2 ]
4 2 0 1 3 ]
1 3 4 2 0 ]
4 3 0 2 1 ]
1 3 0 4 2 ]
1 4 0 2 3 ]
2 3 1 4 0 ]
2 3 4 0 1 ]
4 3 1 0 2 ]
2 4 1 0 3 ]
2 4 3 1 0 ]
2 0 3 4 1 ]
4 0 3 1 2 ]
2 0 4 1 3 ]
3 4 1 2 0 ]
3 0 4 2 1 ]
3 0 1 4 2 ]
4 0 1 2 3 ]

(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,

cycle
1, 2, 3,
4, 1, 2,
1, 4, 2,
1, 2, 4,
3, 1, 2,
3, 4, 1,
3, 1, 4,
4, 3, 1,
1, 3, 2,
4, 1, 3,
1, 3, 4,
1, 4, 3,
2, 1, 3,
2, 4, 1,
4, 2, 1,
2, 1, 4,
2, 3, 1,
2, 3, 4,
4, 2, 3,
2, 4, 3,
3, 2, 1,
3, 2, 4,
3, 4, 2,
4, 3, 2,

4)
3)
3)
3)
4)
2)
2)
2)
4)
2)
2)
2)
4)
3)
3)
3)
4)
1)
1)
1)
4)
1)
1)
1)

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv.perm.
4 0 1 2 3
3 4 1 2 0
3 0 4 2 1
3 0 1 4 2
4 3 1 0 2
2 4 1 0 3
2 3 4 0 1
2 3 1 4 0
4 0 3 1 2
2 4 3 1 0
2 0 4 1 3
2 0 3 4 1
4 2 0 1 3
3 4 0 1 2
3 2 4 1 0
3 2 0 4 1
4 3 0 2 1
1 4 0 2 3
1 3 4 2 0
1 3 0 4 2
4 2 3 0 1
1 4 3 0 2
1 2 4 0 3
1 2 3 4 0

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 11.4-D: Numbers in falling factorial base and the corresponding cyclic permutations.
The cyclic permutations of n elements can be computed from length-(n − 2) factorial numbers. We give
routines for both falling and rising base [FXT: comb/fact2cyclic.cc]:
1
2
3
4

void ffact2cyclic(const ulong *fc, ulong n, ulong *x)
// Generate cyclic permutation in x[]
//
from the (n-2) digit factorial number in fc[0,...,n-3].
// Falling radices: [n-1, ..., 3, 2]

290

rising
[ . .
[ 1 .
[ . 1
[ 1 1
[ . 2
[ 1 2
[ . .
[ 1 .
[ . 1
[ 1 1
[ . 2
[ 1 2
[ . .
[ 1 .
[ . 1
[ 1 1
[ . 2
[ 1 2
[ . .
[ 1 .
[ . 1
[ 1 1
[ . 2
[ 1 2

fact.
. ]
. ]
. ]
. ]
. ]
. ]
1 ]
1 ]
1 ]
1 ]
1 ]
1 ]
2 ]
2 ]
2 ]
2 ]
2 ]
2 ]
3 ]
3 ]
3 ]
3 ]
3 ]
3 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

permutation
1 2 3 4 0 ]
2 3 1 4 0 ]
3 2 4 1 0 ]
2 4 3 1 0 ]
1 3 4 2 0 ]
3 4 1 2 0 ]
4 2 3 0 1 ]
2 3 4 0 1 ]
3 2 0 4 1 ]
2 0 3 4 1 ]
4 3 0 2 1 ]
3 0 4 2 1 ]
1 4 3 0 2 ]
4 3 1 0 2 ]
3 4 0 1 2 ]
4 0 3 1 2 ]
1 3 0 4 2 ]
3 0 1 4 2 ]
1 2 4 0 3 ]
2 4 1 0 3 ]
4 2 0 1 3 ]
2 0 4 1 3 ]
1 4 0 2 3 ]
4 0 1 2 3 ]

(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,
(0,

cycle
1, 2, 3,
2, 1, 3,
3, 1, 2,
2, 3, 1,
1, 3, 2,
3, 2, 1,
4, 1, 2,
2, 4, 1,
3, 4, 1,
2, 3, 4,
4, 1, 3,
3, 2, 4,
1, 4, 2,
4, 2, 1,
3, 1, 4,
4, 2, 3,
1, 3, 4,
3, 4, 2,
1, 2, 4,
2, 1, 4,
4, 3, 1,
2, 4, 3,
1, 4, 3,
4, 3, 2,

4)
4)
4)
4)
4)
4)
3)
3)
2)
1)
2)
1)
3)
3)
2)
1)
2)
1)
3)
3)
2)
1)
2)
1)

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv.perm.
4 0 1 2 3
4 2 0 1 3
4 3 1 0 2
4 3 0 2 1
4 0 3 1 2
4 2 3 0 1
3 4 1 2 0
3 4 0 1 2
2 4 1 0 3
1 4 0 2 3
2 4 3 1 0
1 4 3 0 2
3 0 4 2 1
3 2 4 1 0
2 3 4 0 1
1 3 4 2 0
2 0 4 1 3
1 2 4 0 3
3 0 1 4 2
3 2 0 4 1
2 3 1 4 0
1 3 0 4 2
2 0 3 4 1
1 2 3 4 0

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 11.4-E: Numbers in rising factorial base and corresponding cyclic permutations.
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13

{

x[k] = k;

{
ulong z = n-1-k; // 0, ..., n-3
ulong i = fc[z];
swap2(x[k], x[i]);
}
if ( n>1 )

swap2(x[0], x[1]);

}
void rfact2cyclic(const ulong *fc, ulong n, ulong *x)
// Rising radices: [2, 3, ..., n-1]
{
{
ulong i = fc[k-2]; // k-2 == n-3, ..., 0
swap2(x[k], x[i]);
}
if ( n>1 )

swap2(x[0], x[1]);

}

The cyclic permutations of 5 elements are shown in figures 11.4-D (falling base) and 11.4-E (rising base).
The listings were created with the program [FXT: comb/fact2cyclic-demo.cc].
The cycle representation could be computed by applying the transformations in (all) permutations to all
but the first element. That is, we can generate all cyclic permutations in cycle form by permuting all
elements but the first with any permutation algorithm.

291

Chapter 12

k-permutations

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

ffact.
[ . . .
[ 1 . .
[ 2 . .
[ 3 . .
[ 4 . .
[ 5 . .
[ . 1 .
[ 1 1 .
[ 2 1 .
[ 3 1 .
[ 4 1 .
[ 5 1 .
[ . 2 .
[ 1 2 .
[ 2 2 .
[ 3 2 .
[ 4 2 .
[ 5 2 .
[ . 3 .
[ 1 3 .
[ 2 3 .
[ 3 3 .
[ 4 3 .
[ 5 3 .
[ . 4 .
[ 1 4 .
[ 2 4 .
[ 3 4 .
[ 4 4 .
[ 5 4 .

num.
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]
. . ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

permutation
. 1 ][ 2 3 4
1 . ][ 2 3 4
2 . ][ 1 3 4
3 . ][ 1 2 4
4 . ][ 1 2 3
5 . ][ 1 2 3
. 2 ][ 1 3 4
1 2 ][ . 3 4
2 1 ][ . 3 4
3 1 ][ . 2 4
4 1 ][ . 2 3
5 1 ][ . 2 3
. 3 ][ 1 2 4
1 3 ][ . 2 4
2 3 ][ . 1 4
3 2 ][ . 1 4
4 2 ][ . 1 3
5 2 ][ . 1 3
. 4 ][ 1 2 3
1 4 ][ . 2 3
2 4 ][ . 1 3
3 4 ][ . 1 2
4 3 ][ . 1 2
5 3 ][ . 1 2
. 5 ][ 1 2 3
1 5 ][ . 2 3
2 5 ][ . 1 3
3 5 ][ . 1 2
4 5 ][ . 1 2
5 4 ][ . 1 2

5
5
5
5
5
4
5
5
5
5
5
4
5
5
5
5
5
4
5
5
5
5
5
4
4
4
4
4
3
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 12.0-A: The falling factorial numbers with n−1 digits where only k leading digits can be nonzero
correspond to the k-permutations of n elements (here n = 6 and k = 2).
The length-k prefixes of the permutations of n elements are called k-permutations. The 2-permutations
of 6 elements are shown in figure 12.0-A. We have n choices for the first element, n − 1 for the second,
and so on. Therefore the number of the k-permutations of n elements is
n (n − 1) (n − 1) . . . (n − k + 1)

=

nk =

n
k!
k

(12.0-1)

The second equality shows that the k-permutations could be generated by listing all k-subsets of the
n-set (combinations n ), each in k! orderings. The expression as falling factorial power shows that the
k
k-permutations correspond to the falling factorial numbers where only the first k digits can be nonzero:
the permutations in figure 12.0-A are obtained by converting the left column (as inversion table) into a
permutation (by the routine ffact2perm() described in section 10.1.1 on page 232). This is done in the
program [FXT: comb/ffact2kperm-demo.cc] which was used to create the figure.

292

Chapter 12: k-permutations

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

permutation
[ . 1 ][ 2 3
[ . 2 ][ 1 3
[ . 3 ][ 1 2
[ . 4 ][ 1 2
[ . 5 ][ 1 2
[ 1 . ][ 5 2
[ 1 2 ][ 5 .
[ 1 3 ][ 5 .
[ 1 4 ][ 5 .
[ 1 5 ][ 4 .
[ 2 . ][ 4 5
[ 2 1 ][ 4 5
[ 2 3 ][ 4 5
[ 2 4 ][ 3 5
[ 2 5 ][ 3 4
[ 3 . ][ 2 4
[ 3 1 ][ 2 4
[ 3 2 ][ 1 4
[ 3 4 ][ 1 2
[ 3 5 ][ 1 2
[ 4 . ][ 1 2
[ 4 1 ][ . 2
[ 4 2 ][ . 1
[ 4 3 ][ . 1
[ 4 5 ][ . 1
[ 5 . ][ 4 1
[ 5 1 ][ 4 .
[ 5 2 ][ 4 .
[ 5 3 ][ 4 .
[ 5 4 ][ 3 .

4
4
4
3
3
3
3
2
2
2
1
.
.
.
.
5
5
5
5
4
3
3
3
2
2
2
2
1
1
1

5
5
5
5
4
4
4
4
3
3
3
3
1
1
1
1
.
.
.
.
5
5
5
5
3
3
3
3
2
2

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . . .
. 1 . .
. 2 . .
. 3 . .
. 4 . .
1 . . .
1 1 . .
1 2 . .
1 3 . .
1 4 . .
2 . . .
2 1 . .
2 2 . .
2 3 . .
2 4 . .
3 . . .
3 1 . .
3 2 . .
3 3 . .
3 4 . .
4 . . .
4 1 . .
4 2 . .
4 3 . .
4 4 . .
5 . . .
5 1 . .
5 2 . .
5 3 . .
5 4 . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv. perm.
. 1 2 3 4 5
. 2 1 3 4 5
. 2 3 1 4 5
. 2 3 4 1 5
. 2 3 4 5 1
1 . 3 4 5 2
3 . 1 4 5 2
3 . 4 1 5 2
3 . 4 5 1 2
3 . 4 5 2 1
1 4 . 5 2 3
4 1 . 5 2 3
4 5 . 1 2 3
4 5 . 2 1 3
4 5 . 2 3 1
1 5 2 . 3 4
5 1 2 . 3 4
5 2 1 . 3 4
5 2 3 . 1 4
5 2 3 . 4 1
1 2 3 4 . 5
2 1 3 4 . 5
2 3 1 4 . 5
2 3 4 1 . 5
2 3 4 5 . 1
1 3 4 5 2 .
3 1 4 5 2 .
3 4 1 5 2 .
3 4 5 1 2 .
3 4 5 2 1 .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 12.1-A: The 2-permutations of 6 elements in lexicographic order (left), the corresponding numbers in falling factorial basis (middle), and the inverse permutations (right).

12.1

Lexicographic order

For the generation of k-permutations in lexicographic order we use mixed radix numbers to determine
the position of the leftmost change which is restricted to the ﬁrst k elements. We also store the inverse
permutation to simplify the update routine [FXT: comb/kperm-lex.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class kperm_lex
{
public:
ulong *p_;
ulong *ip_;
ulong *d_;
ulong n_;
ulong k_;
ulong u_;

//
//
//
//
//
//

permutation
inverse permutation
falling factorial number
total number of elements
permutations of k elements
sort up to position u+1

public:
kperm_lex(ulong n)
{
n_ = n;
k_ = n;
p_ = new ulong[n_];
ip_ = new ulong[n_];
d_ = new ulong[n_+1];
d_[0] = 0; // sentinel
++d_; // nota bene
first(k_);
}
~kperm_lex()
{
delete [] p_;
delete [] ip_;
--d_;
delete [] d_;

12.2: Minimal-change order
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

293

}
void first(ulong k)
{
k_ = k;
u_ = n_ - 1;
if ( k_ < u_ ) u_ = k_;

// == min(k, n-1)


p_[i] = i;
ip_[i] = i;
d_[i] = 0;

}
[--snip--]

const

{ return p_; }

Note that k is determined only with the call to first(). In the update routine we swap the leftmost
changed element (at position i < k) as for the lexicographic order of all permutations. Then we replace
the elements up to position k by the smallest elements lying right of i. The positions k, . . . , n − 1 are not
put in ascending order for reasons of efficiency. Therefore the falling factorial numbers in figure 12.1-A
are not (in general) the inversion tables of the permutations.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

bool next()
{
ulong i = k_ - 1;
ulong m1 = n_ - i - 1;
while ( d_[i] == m1 ) // increment mixed radix number
{
d_[i] = 0;
++m1;
--i;
}
if ( (long)i<0 )

return false;

// current is last

++d_[i];
{ // find
ulong
do {
const

smallest element p[j] < p[i] that lies right of position i:
z = p_[i];
++z; } while ( ip_[z]<=i );
ulong j = ip_[z];

swap2( p_[i], p_[j] );
swap2( ip_[p_[i]], ip_[p_[j]] );
++i;
}
ulong z = 0;
while ( i < u_ )
{
// find smallest element right of position i:
while ( ip_[z] < i ) { ++z; }
const ulong j = ip_[z];
swap2( p_[i], p_[j] );
swap2( ip_[p_[i]], ip_[p_[j]] );
++i;
}
return true;
}
};

The update is most efficient for small k, the rate of generation is about 80 M/s for k = 4 and n = 100
(best case), and about 30 M/s for k = n = 12 (worst case) [FXT: comb/kperm-lex-demo.cc].

12.2


A Gray code for k-permutations is given by the first inverse permutations in Trotter’s order (see section
10.9.1 on page 258). The update routine in the generator [FXT: class kperm gray in comb/kpermgray.h] differs from that in [FXT: class perm gray ffact in comb/perm-gray-ffact.h] just be the test
whether the left of the swapped elements lies inside the k-prefix:

294

Chapter 12: k-permutations

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

.
1
2
3
4
5
5
4
3
2
1
.
.
1
2
3
4
5
5
4
3
2
1
.
.
1
2
3
4
5

permutation
1 ][ 2 3 4 5
. ][ 2 3 4 5
. ][ 1 3 4 5
. ][ 1 2 4 5
. ][ 1 2 3 5
. ][ 1 2 3 4
1 ][ . 2 3 4
1 ][ . 2 3 5
1 ][ . 2 4 5
1 ][ . 3 4 5
2 ][ . 3 4 5
2 ][ 1 3 4 5
3 ][ 1 2 4 5
3 ][ . 2 4 5
3 ][ . 1 4 5
2 ][ . 1 4 5
2 ][ . 1 3 5
2 ][ . 1 3 4
3 ][ . 1 2 4
3 ][ . 1 2 5
4 ][ . 1 2 5
4 ][ . 1 3 5
4 ][ . 2 3 5
4 ][ 1 2 3 5
5 ][ 1 2 3 4
5 ][ . 2 3 4
5 ][ . 1 3 4
5 ][ . 1 2 4
5 ][ . 1 2 3
4 ][ . 1 2 3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

swap
(-, -)
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(0, 1)
(5, 4)
(4, 3)
(3, 2)
(2, 1)
(1, 0)
(2, 3)
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(2, 3)
(5, 4)
(4, 3)
(3, 2)
(2, 1)
(1, 0)
(4, 5)
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

ffact
. . . .
1 . . .
2 . . .
3 . . .
4 . . .
5 . . .
5 1 . .
4 1 . .
3 1 . .
2 1 . .
1 1 . .
. 1 . .
. 2 . .
1 2 . .
2 2 . .
3 2 . .
4 2 . .
5 2 . .
5 3 . .
4 3 . .
3 3 . .
2 3 . .
1 3 . .
. 3 . .
. 4 . .
1 4 . .
2 4 . .
3 4 . .
4 4 . .
5 4 . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

inv. perm.
. 1 2 3 4 5
1 . 2 3 4 5
1 2 . 3 4 5
1 2 3 . 4 5
1 2 3 4 . 5
1 2 3 4 5 .
2 1 3 4 5 .
2 1 3 4 . 5
2 1 3 . 4 5
2 1 . 3 4 5
2 . 1 3 4 5
. 2 1 3 4 5
. 2 3 1 4 5
2 . 3 1 4 5
2 3 . 1 4 5
2 3 1 . 4 5
2 3 1 4 . 5
2 3 1 4 5 .
2 3 4 1 5 .
2 3 4 1 . 5
2 3 4 . 1 5
2 3 . 4 1 5
2 . 3 4 1 5
. 2 3 4 1 5
. 2 3 4 5 1
2 . 3 4 5 1
2 3 . 4 5 1
2 3 4 . 5 1
2 3 4 5 . 1
2 3 4 5 1 .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 12.2-A: The 2-permutations of 6 elements in minimal-change order (left), the corresponding
numbers in falling factorial basis (middle), and the inverse permutations (right).
1
2
3
4
5
6
7

bool next()
{
[--snip--]
if ( j>=k_ )
}
return false;
}

return false;

The rate of generation grows slightly with n and does not depend on k. For example, the rate is about
160 M/s (for k = n = 12) and 190 M/s (for k = 4 and n = 100) [FXT: comb/kperm-gray-demo.cc].

295

Chapter 13

Multisets
A multiset (or bag) is a collection of elements where elements can be repeated and order does not matter.

13.1

Subsets of a multiset
n == 630
primes
= [
exponents = [
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

d
1
2
3
6
9
18
5
10
15
30
45
90
7
14
21
42
63
126
35
70
105
210
315
630

2
1

3
2

5
1

auxiliary
[
1
1
[
2
1
[
3
3
[
6
3
[
9
9
[ 18
9
[
5
5
[ 10
5
[ 15 15
[ 30 15
[ 45 45
[ 90 45
[
7
7
[ 14
7
[ 21 21
[ 42 21
[ 63 63
[ 126 63
[ 35 35
[ 70 35
[ 105 105
[ 210 105
[ 315 315
[ 630 315

7 ]
1 ]
products
1
1
1
1
1
1
1
1
1
1
1
1
5
1
5
1
5
1
5
1
5
1
5
1
7
7
7
7
7
7
7
7
7
7
7
7
35
7
35
7
35
7
35
7
35
7
35
7

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

exponents
[ . . . . ]
[ 1 . . . ]
[ . 1 . . ]
[ 1 1 . . ]
[ . 2 . . ]
[ 1 2 . . ]
[ . . 1 . ]
[ 1 . 1 . ]
[ . 1 1 . ]
[ 1 1 1 . ]
[ . 2 1 . ]
[ 1 2 1 . ]
[ . . . 1 ]
[ 1 . . 1 ]
[ . 1 . 1 ]
[ 1 1 . 1 ]
[ . 2 . 1 ]
[ 1 2 . 1 ]
[ . . 1 1 ]
[ 1 . 1 1 ]
[ . 1 1 1 ]
[ 1 1 1 1 ]
[ . 2 1 1 ]
[ 1 2 1 1 ]

change @
4
0
1
0
1
0
2
0
1
0
1
0
3
0
1
0
1
0
2
0
1
0
1
0

Figure 13.1-A: Divisors of 630 = 21 · 32 · 51 · 71 generated as subsets of the multiset of exponents.
A subset of a set of n elements can be identiﬁed with the bits of all n-bit binary words. The subsets of
a multiset can be computed as mixed radix numbers: if the j-th element is repeated rj times, then the
radix of digit j has to be rj + 1. Therefore all methods of chapter 9 on page 217 can be applied.
e

n−1
As an example, all divisors of a number x whose factorization x = pe0 · pe1 · · · pn−1 is known can be
0
1
computed via the length-n mixed radix numbers with radices [e0 + 1, e1 + 1, . . . , en−1 + 1]. The implementation [FXT: class divisors in mod/divisors.h] generates the subsets of the multiset of exponents
in counting order (ﬁgure 13.1-A shows the data for x = 630). An auxiliary array T of products is updated
with each step: if the changed digit (at position j) became 1, then set t := Tj+1 · pj , else set t := Tj · pj .
Set Ti = t for all 0 ≤ i ≤ j. A sentinel element Tn = 1 avoids unnecessary code. Figure 13.1-A was
created with the program [FXT: mod/divisors-demo.cc]. The computation of all products of k out of n
given factors is described in section 6.2.2 on page 178.

296

Chapter 13: Multisets

Subsets with prescribed number of elements
The k-subsets (or combinations) of a multiset are the subsets with k elements. They are one-to-one with
the mixed radix numbers where the sum of digits equals k, see section 9.6 on page 229.

13.2

Permutations of a multiset
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

(2,
. .
. .
. .
. 1
. 1
. 1
. 1
. 1
. 1
. 2
. 2
. 2
1 .
1 .
1 .
1 .
1 .
1 .
1 1
1 1
1 1
1 2
1 2
1 2
2 .
2 .
2 .
2 1
2 1
2 1

2, 1)
1 1 2
1 2 1
2 1 1
. 1 2
. 2 1
1 . 2
1 2 .
2 . 1
2 1 .
. 1 1
1 . 1
1 1 .
. 1 2
. 2 1
1 . 2
1 2 .
2 . 1
2 1 .
. . 2
. 2 .
2 . .
. . 1
. 1 .
1 . .
. 1 1
1 . 1
1 1 .
. . 1
. 1 .
1 . .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1

(6,
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
. 1
. 1
. 1
. 1
. 1
1 .
1 .
1 .
1 .
1 .
1 1
. .
. .
. .
. .
. .
. 1
1 .

2)
. .
. .
. .
. 1
. 1
. 1
1 .
1 .
1 .
1 1
. .
. .
. .
. 1
1 .
. .
. .
. .
. 1
1 .
. .
. .
. .
. .
. 1
1 .
. .
. .

.
1
1
.
.
1
.
.
1
.
.
.
1
.
.
.
.
1
.
.
.
.
.
1
.
.
.
.

1
.
1
.
1
.
.
1
.
.
.
1
.
.
.
.
1
.
.
.
.
.
1
.
.
.
.
.

1
1
.
1
.
.
1
.
.
.
1
.
.
.
.
1
.
.
.
.
.
1
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

(1, 1,
[ . 1
[ . 1
[ . 2
[ . 2
[ . 3
[ . 3
[ 1 .
[ 1 .
[ 1 2
[ 1 2
[ 1 3
[ 1 3
[ 2 .
[ 2 .
[ 2 1
[ 2 1
[ 2 3
[ 2 3
[ 3 .
[ 3 .
[ 3 1
[ 3 1
[ 3 2
[ 3 2

1, 1)
2 3 ]
3 2 ]
1 3 ]
3 1 ]
1 2 ]
2 1 ]
2 3 ]
3 2 ]
. 3 ]
3 . ]
. 2 ]
2 . ]
1 3 ]
3 1 ]
. 3 ]
3 . ]
. 1 ]
1 . ]
1 2 ]
2 1 ]
. 2 ]
2 . ]
. 1 ]
1 . ]

Figure 13.2-A: Permutations of multisets in lexicographic order: the multiset (2, 2, 1) (left), (6, 2)
(combinations 6+2 , middle), and (1, 1, 1, 1) (permutations of four elements, right). Dots denote zeros.
2
We write (r0 , r1 , . . . , rk−1 ) for a multiset with r0 elements of the first sort, r1 of the second sort, . . . ,
k−1
rk−1 elements of the k-th sort. The total number of elements is n = j=0 rk . For the elements of the
j-th sort we always use the number j. The number of permutations P (r0 , r1 , . . . , rk−1 ) of the multiset
(r0 , r1 , . . . , rk−1 ) is a multinomial coefficient:
P (r0 , r1 , . . . , rk−1 )

=
=

n
r0
r0
r0

n − r0
r1
r0 + r1
r1

=

n
r0 , r1 , r2 , . . . , rk−1

=

n!
r0 ! r1 ! r2 ! · · · rk−1 !

n − r0 − r1
rk−3 + rk−2 + rk−1
rk−2 + rk−1
...
r2
rk−3
rk−2
r0 + r1 + r2
r0 + r1 + r2 + r3
n
...
rk−1
r2
r3

(13.2-1a)

rk−1
rk−1

(13.2-1b)
(13.2-1c)

Relation 13.2-1a is obtained by observing that among the n! ways to arrange all n elements r0 ! permutations of the first sort of elements, r1 ! of the second, and so on, lead to identical permutations.

13.2: Permutations of a multiset

13.2.1

297


Let [r0 , r1 , r2 , . . . , rk−1 ] denote the list of all permutations of the multiset (r0 , r1 , r2 , . . . , rk−1 ). We use
the recursion

[r0 , r1 , r2 , . . . , rk−1 ]

=

r0 . [r0 − 1, r1 , r2 , . . . , rk−1 ]
r1 . [r0 , r1 − 1, r2 , . . . , rk−1 ]
r2 . [r0 , r1 , r2 − 1, . . . , rk−1 ]
.
.
.

(13.2-2)

rk−1 . [r0 , r1 , r2 , . . . , rk−1 − 1]
The following routine generates all multiset permutations in lexicographic order when called with argument zero [FXT: comb/mset-perm-lex-rec-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

ulong
ulong
ulong
ulong

n;
*ms;
k;
*r;

//
//
//
//

number of objects
multiset data in ms[0], ..., ms[n-1]
number of different sorts of objects
number of elements ’0’ in r[0], ’1’ in r[1], ..., ’k-1’ in r[k-1]

void mset_perm_rec(ulong d)
{
else
{
for (ulong j=0; j<k; ++j) // for all buckets
{
++wct;
if ( r[j] )
// bucket has elements left
{
++rct;
--r[j];
// take element from bucket
ms[d] = j; // put element in place
mset_perm_rec(d+1); // recursion
++r[j];
// put element back
}
}
}
}

As given the routine is ineﬃcient when used with (many) small numbers rj . An extreme case is rj = 1
for all j, corresponding to the (usual) permutations: we have n = k and the work for all n! permutations
is O(nn ). The method can be made eﬃcient by maintaining a list of pointers to the next nonzero ‘bucket’
nk[] [FXT: class mset perm lex rec in comb/mset-perm-lex-rec.h]:
1
2
3
4
5
6
7
8
9
10
11
12

class mset_perm_lex_rec
{
public:
ulong k_;
// number of different sorts of objects
ulong *r_;
// number of elements ’0’ in r[0], ’1’ in r[1], ..., ’k-1’ in r[k-1]
ulong n_;
// number of objects
ulong *ms_; // multiset data in ms[0], ..., ms[n-1]
ulong *nn_; // position of next nonempty bucket
void (*visit_)(const mset_perm_lex_rec &); // function to call with each permutation
ulong ct_; // count objects
ulong rct_; // count recursions (==work)
[--snip--]

The initializer takes as arguments an array of multiplicities and its length:
1
2
3
4
5
6
7
8
9
10
11
12

public:
mset_perm_lex_rec(ulong *r, ulong k)
{
k_ = k;
r_ = new ulong[k];
for (ulong j=0; j<k_; ++j) r_[j] = r[j];
n_ = 0;
ms_ = new ulong[n_];
nn_ = new ulong[k_+1];

n_ += r_[j];

// incl sentinel

// get buckets

298
13
14
15
16

for (ulong j=0; j<k_; ++j) nn_[j] = j+1;
nn_[k] = 0; // pointer to first nonempty bucket
}
[--snip--]

The method to generate all permutations takes a ‘visit’ function as argument:
1
2
3
4
5
6
7
8
9
10
11

void generate(void (*visit)(const mset_perm_lex_rec &))
{
visit_ = visit;
ct_ = 0;
rct_ = 0;
mset_perm_rec(0);
}
private:
void mset_perm_rec(ulong d);
};

The recursion itself is [FXT: comb/mset-perm-lex-rec.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

void mset_perm_lex_rec::mset_perm_rec(ulong d)
{
if ( d>=n_ )
{
++ct_;
visit_( *this );
}
else
{
for (ulong jf=k_, j=nn_[jf]; j<k_; jf=j, j=nn_[j])
{
++rct_; // work == number of recursions
--r_[j];
ms_[d] = j;

// for all nonempty buckets

// take element from bucket
// put element in place

if ( r_[j]==0 ) // bucket now empty?
{
ulong f = nn_[jf]; // where we come from
nn_[jf] = nn_[j]; // let recursions skip over j
mset_perm_rec(d+1);
// recursion
nn_[jf] = f;
// remove skip
}
else mset_perm_rec(d+1);
// recursion
++r_[j];

// put element back

}
}
}

The test whether the current bucket is nonempty is omitted, as empty buckets are skipped. Now the
work involved with (regular) permutations is less than e = 2.71828 . . . times the number of the generated
permutations. Usage of the class is shown in [FXT: comb/mset-perm-lex-rec2-demo.cc]. The permutations of 12 elements are generated at a rate of about 25 million per second, the combinations 30 at
15
about 40 million per second, and the permutations of (2, 2, 2, 3, 3, 3) at about 20 million per second.

13.2.2

Iterative generation

The algorithm to generate the next permutation in lexicographic order given in section 10.2 on page
242 can be adapted for an iterative method for multiset permutations [FXT: class mset perm lex in
comb/mset-perm-lex.h]:
1
2
3
4
5
6
7
8
9
10

class mset_perm_lex
{
public:
ulong k_;
//
ulong *r_;
//
ulong n_;
//
ulong *ms_; //

number of different sorts of objects
number of elements ’0’ in r[0], ’1’ in r[1], ..., ’k-1’ in r[k-1]
number of objects
multiset data in ms[0], ..., ms[n-1], sentinel at [-1]

public:
mset_perm_lex(const ulong *r, ulong k)

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

299

{
k_ = k;
r_ = new ulong[k];
n_ = 0;
ms_ = new ulong[n_+1];
ms_[0] = 0; // sentinel
++ms_; // nota bene

r_[j] = r[j];

// get buckets

n_ += r_[j];

first();
}
void first()
{
for (ulong j=0, i=0; j<k_; ++j)
for (ulong h=r_[j]; h!=0; --h, ++i)
}
[--snip--]

ms_[i] = j;

The only change in the update routine is to replace the operators > by >= in the scanning loops:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

bool next()
{
// find rightmost pair with ms[i] < ms[i+1]:
const ulong n1 = n_ - 1;
ulong i = n1;
do { --i; } while ( ms_[i] >= ms_[i+1] ); // can touch sentinel
if ( (long)i<0 ) return false; // last sequence is falling seq.
// find rightmost element p[j] less than p[i]:
ulong j = n1;
while ( ms_[i] >= ms_[j] ) { --j; }
swap2(ms_[i], ms_[j]);
// Here the elements ms[i+1], ..., ms[n-1] are a falling sequence.
// Reverse order to the right:
ulong r = n1;
ulong s = i + 1;
while ( r > s ) { swap2(ms_[r], ms_[s]); --r; ++s; }
return true;
}
}

Usage of the class is shown in [FXT: comb/mset-perm-lex-demo.cc]:
ulong ct = 0;
do
{
// visit
}
while ( P.next() );

The permutations of 12 elements are generated at a rate of about 127 million per second, the combinations
30
15 at about 60 million per second, and the permutations of (2, 2, 2, 3, 3, 3) at about 93 million per second.

13.2.3


An ordering in which each transition involves a cyclic shift of a preﬁx is described in [360]. Figure
13.2-B shows examples of the ordering that were generated with the program [FXT: comb/mset-permpref-demo.cc]. The implementation is [FXT: comb/mset-perm-pref.h]:
1
2
3
4
5
6
7
8
9
10

class mset_perm_pref
{
public:
ulong k_;
ulong *r_;
// number of elements ’0’ in r[0], ’1’ in r[1], ..., ’k-1’ in r[k-1]
ulong n_;
ulong *ms_; // multiset data in ms[0], ..., ms[n-1], sentinel at [n]
public:
mset_perm_pref(const ulong *r, ulong k)

300


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

(2,
. 2
2 .
1 2
. 1
1 .
2 1
. 2
2 .
. 2
. .
2 .
1 2
. 1
1 .
. 1
. .
1 .
2 1
1 2
1 1
. 1
1 .
1 1
. 1
1 .
. 1
. .
1 .
1 1
2 1

2, 1)
1 1 .
1 1 .
. 1 .
2 1 .
2 1 .
. 1 .
1 . 1
1 . 1
. 1 1
2 1 1
. 1 1
. . 1
2 . 1
2 . 1
. 2 1
1 2 1
. 2 1
. . 1
1 . .
2 . .
1 2 .
1 2 .
. 2 .
1 . 2
1 . 2
. 1 2
1 1 2
. 1 2
. . 2
1 . .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

.
1
.
.
1
.
.
.
1
.
.
.
.
1
.
.
.
.
.
1
.
.
.
.
.
.
1
1

(6,
1 1
. 1
1 .
. 1
. .
1 .
. 1
. .
. .
1 .
. 1
. .
. .
. .
1 .
. 1
. .
. .
. .
. .
1 .
. 1
. .
. .
. .
. .
. .
1 .

2)
. .
. .
1 .
1 .
1 .
. 1
. 1
1 1
. 1
. .
. .
1 .
. 1
. .
. .
. .
1 .
. 1
. .
. .
. .
. .
1 .
. 1
. .
. .
. .
. .

.
.
.
.
.
.
.
.
.
1
1
1
1
1
.
.
.
.
1
.
.
.
.
.
1
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
.
.
.
.
.
1
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

(1, 1,
[ . 3
[ 3 .
[ 2 3
[ . 2
[ 2 .
[ 3 2
[ 1 3
[ 3 1
[ . 3
[ 3 .
[ 1 3
[ . 1
[ 1 .
[ 3 1
[ 2 3
[ 1 2
[ 2 1
[ . 2
[ 2 .
[ 1 2
[ . 1
[ 1 .
[ 2 1
[ 3 2

1, 1)
2 1 ]
2 1 ]
. 1 ]
3 1 ]
3 1 ]
. 1 ]
2 . ]
2 . ]
1 2 ]
1 2 ]
. 2 ]
3 2 ]
3 2 ]
. 2 ]
1 . ]
3 . ]
3 . ]
1 3 ]
1 3 ]
. 3 ]
2 3 ]
2 3 ]
. 3 ]
1 . ]

Figure 13.2-B: Permutations of multisets in ‘cool-lex’ order: the multiset (2, 2, 1) (left), (6, 2) (combinations 6+2 , middle), and (1, 1, 1, 1) (permutations of four elements, right). Dots denote zeros.
2
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

{
k_ = k;
r_ = new ulong[k];

r_[j] = r[j];

// get buckets

n_ = 0;
for (ulong j=0; j<k_; ++j) n_ += r_[j];
ms_[n_] = k_; // sentinel (must be greater than all elements)
first();
}
void first()
{

ms_[i] = j;

reverse(ms_, n_);
// non-increasing permutation
rotate_right1(ms_, n_); // ... shall be the last
}
[--snip--]

The cited paper uses a linked list for the multiset permutation. We simply use an array and determine
the length of the longest non-increasing preﬁx in an unsophisticated way:
1
2
3
4
5
6
7
8
9
10
11

ulong next()
// Return length of rotated prefix, zero with last permutation.
{
// scan for prefix:
ulong i = -1UL;
do { ++i; } while ( ms_[i] >= ms_[i+1] ); // can touch sentinel
++i;
// here: i == length of longest non-increasing prefix
if ( i >= n_-1 )
{

12
13
14
15
16
17
18
19
20
21
22
23
24
25

rotate_right1(ms_, n_);
if ( i==n_ ) return 0;
return n_;

301

// was last

}
else
{
// compare last of prefix with element 2 positions right:
i += ( ms_[i+1] <= ms_[i-1] );
++i;
rotate_right1(ms_, i);
return i;
}
}
};

The rate of generation is about 68 M/s for the permutations of 12 elements, 46 M/s for the combinations
30
15 , and 62 M/s for the permutations of (2, 2, 2, 3, 3, 3). The equivalent order for combinations is given
in section 6.3 on page 180.
As suggested in the paper, the length of the next longest non-increasing prefix can be computed with
just one comparison, we store it in a variable ln_. Usage of the fast update is enabled via the line
#define MSET_PERM_PREF_LEN

near the top of the file [FXT: comb/mset-perm-pref.h]. The initialization has to be modified as follows:
1
2
3
4
5
6
7
8

void first()
{
[--snip--]
// as before
#ifdef MSET_PERM_PREF_LEN
ln_ = 1;
if ( k_ == 1 ) ln_ = n_;
#endif
}

// only one type of object

The computation of the successor can be implemented as
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ulong next()
// Return length of rotated prefix, zero with last permutation.
{
const ulong i = ln_;
ulong nr; // number of elements rotated
if ( i >= n_-1 )
{
nr = n_;
rotate_right1(ms_, nr);
if ( i==n_ ) return 0; // was last
}
else
{
nr = ln_ + 1 + ( ms_[i+1] <= ms_[i-1] );
rotate_right1(ms_, nr);
}
const bool cmp = ( ms_[0] < ms_[1] );
ln_ =
( cmp ? 1 : ln_ + 1 );
return nr;
}

The rate of generation is improved to about 71 M/s for the permutations of 12 elements, 62 M/s for the
combinations 30 , and 69 M/s for the permutations of (2, 2, 2, 3, 3, 3).
15

13.2.4


An algorithm for the generation of a Gray code for the permutations of a multiset is given by Fred Lunnon
[priv. comm.], figure 13.2-C shows examples of the ordering. It is a generalization of Trotter’s order for
permutations described in section 10.7 on page 254. The implementation is [FXT: class mset perm gray
in comb/mset-perm-gray.h]:
1
2
3
4
5

class mset_perm_gray
{
public:
ulong *ms_; // permuted elements (Lunnon’s R_[])
ulong *P_;
// permutation

302


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

(2,
. .
2 .
. 2
. 2
2 .
2 2
2 2
2 2
2 .
. 2
. 3
3 .
3 2
3 2
3 2
3 .
. 3
. 3
3 .
. .
. .
2 .
. 2
. 2
2 .
2 3
2 3
2 3
2 .
. 2

2, 1)
2 2 3
. 2 3
. 2 3
2 . 3
2 . 3
. . 3
3 . .
. 3 .
2 3 .
2 3 .
2 2 .
2 2 .
. 2 .
2 . .
. . 2
2 . 2
2 . 2
. 2 2
. 2 2
3 2 2
2 3 2
. 3 2
. 3 2
3 . 2
3 . 2
. . 2
2 . .
. 2 .
3 2 .
3 2 .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

(2,
(0,
(3,
(1,
(2,
(4,
(2,
(1,
(0,
(3,
(1,
(2,
(3,
(2,
(1,
(0,
(2,
(1,
(0,
(2,
(2,
(0,
(3,
(1,
(2,
(4,
(2,
(1,
(0,

0)
1)
2)
0)
1)
2)
3)
2)
1)
1)
0)
1)
2)
4)
2)
1)
3)
0)
2)
3)
0)
1)
2)
0)
1)
2)
3)
2)
1)

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

(6, 2)
. . . .
2 . . .
. 2 . .
. . 2 .
. . . 2
. . . .
. . . .
. . . .
2 . . .
. 2 . .
. . 2 .
. . . 2
. . . .
. . . .
2 . . .
. 2 . .
. . 2 .
. . . 2
. . . 2
2 . . .
. 2 . .
. . 2 .
. . 2 2
2 . . 2
. 2 . 2
. 2 2 .
2 . 2 .
2 2 . .

.
.
.
.
.
2
.
.
.
.
.
.
2
2
.
.
.
.
2
2
2
2
.
.
.
.
.
.

.
.
.
.
.
.
2
2
.
.
.
.
.
2
2
2
2
2
.
.
.
.
.
.
.
.
.
.

2
.
.
.
.
.
.
2
2
2
2
2
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

2
2
2
2
2
2
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

(1, 1,
[ . 2
[ 2 .
[ 2 3
[ 2 3
[ 3 2
[ 3 2
[ 3 .
[ . 3
[ . 3
[ 3 .
[ 3 4
[ 3 4
[ 4 3
[ 4 3
[ 4 .
[ . 4
[ . 4
[ 4 .
[ 4 2
[ 4 2
[ 2 4
[ 2 4
[ 2 .
[ . 2

1, 1)
3 4 ]
3 4 ]
. 4 ]
4 . ]
4 . ]
. 4 ]
2 4 ]
2 4 ]
4 2 ]
4 2 ]
. 2 ]
2 . ]
2 . ]
. 2 ]
3 2 ]
3 2 ]
2 3 ]
2 3 ]
. 3 ]
3 . ]
3 . ]
. 3 ]
4 3 ]
4 3 ]

Figure 13.2-C: Gray code for permutations of multisets: the multiset (2, 2, 1) (left, with swaps), (6, 2)
(combinations 6+2 , middle), and (1, 1, 1, 1) (permutations of four elements, right). Dots denote ones.
2
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

ulong
ulong
ulong
ulong
ulong
ulong

*Q_;
*D_;
// direction
k_;
n_;
sw1_, sw2_; // positions swapped with last update
*r_;
// number of elements ’1’ in r[0], ’2’ in r[1], ..., ’k’ in r[k-1]

public:
mset_perm_gray(const ulong *r, ulong k)
{
k_ = k;
r_ = new ulong[k_];
for (ulong j=0; j<k_; ++j) r_[j] = r[j];
n_ = 0;
for (ulong j=0; j<k_; ++j) n_ += r_[j];
P_ = new ulong[n_+4];
Q_ = new ulong[n_+4];
D_ = new ulong[n_+4];
first();
}
[--snip--] // destructor
const ulong * data() const { return ms_+1; }
void get_swaps(ulong &sw1, ulong &sw2) const { sw1=sw1_;

The arrays have four extra elements that are used as sentinels:
1
2
3
4

void first()
{
sw1_ = sw2_ = 0;

sw2=sw2_; }

5
6
7
8
9
10
11
12
13
14
15
16
17

303

const ulong n = n_;
for (ulong j=1; j<=n;
// sentinels:
ms_[0] = 0; P_[0]
ulong j;
j = n+1; ms_[j] =
j = n+2; ms_[j] =
j = n+3; ms_[j] =

= 0;

++j)

{ P_[j] = j;

0;
k_+1;
k_+2;

Q_[0] = 0;

ms_[i] = j + 1;
Q_[j] = j;

D_[j] = +1UL; }

D_[0] = 0;

P_[j] = 0;
P_[j] = n+1;
P_[j] = n+2;

Q_[j] = n+2;
Q_[j] = n+3;
Q_[j] = 0;

D_[j] = 0;
D_[j] = +1;
D_[j] = +1;

}

To compute the successor we ﬁnd the ﬁrst run of identical elements that can be moved:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

bool next()
{
// locate earliest unblocked element at j, starting at blocked element 0
ulong j = 0, i = 0, d = 0, l = 0; // init of l not needed
while ( ms_[j] >= ms_[i] )
{
D_[j] = -d; // blocked at j; reverse drift d pre-emptively
// next element at j, neighbor at i:
j = Q_[P_[j]+1];
d = D_[j];
i = j+d;
if ( ms_[j-1] != ms_[j] ) l = j;
else
{
if ( (long)d < 0) i = l-1;
}

// save left end of run in l

}
if ( j > n_ )

return false;


// restore left end at head of run
// shift run of equal rank from i-d,i-2d,...,l to i,i-d,...,l+d
if ( (long)d < 0 ) l = j;
ulong e = D_[i], p = P_[i]; // save neighbor drift e and identifier p
for (ulong k=i; k!=l; k-=d)
{
P_[k] = P_[k-d];
Q_[P_[k]] = k;
D_[k] = -1UL; // reset drifts of run tail elements
}
sw1_ = i - 1; sw2_ = l - 1;
swap2(ms_[i], ms_[l]);
D_[l] = e;
P_[l] = p;
return

D_[i] = d;
Q_[p] = l;

// save positions swapped

// restore drifts of head and neighbor
// wrap neighbor around to other end

true;

}
};

The rate of generation is roughly 40 M/s [FXT: comb/mset-perm-gray-demo.cc].

304

Chapter 14: Gray codes for strings with restrictions

Chapter 14

Gray codes for strings with
restrictions
We give constructions for Gray codes for strings with certain restrictions, such as forbidding two successsive zeros or nonzero digits. The constraints considered are such that the number of strings of a given
type satisfies a linear recursion with constant coefficients.

14.1

List recursions
111111111111111111111.............
22222222..........................
.............1111111111111111.....
11111.............222222..........
22........111111..........111111..
...1111.....22.....1111.....22....
1...22...11....11...22...11....11.
[120 W(n-3)]
11111111
22222222
........
11111...
22......
...1111.
1...22..

+

rev([10 W(n-2)])
1111111111111
.............
.....11111111
..........222
..111111.....
....22.....11
.11....11...2

W(n) ==

+

[00 W(n-2)]
.............
.............
11111111.....
222..........
.....111111..
11.....22....
2...11....11.

Figure 14.1-A: Computing a Gray code by a sublist recursion.
The algorithms are given as list recursions. For example, write W (n) for the list of n-digit words (of a
certain type), write W R (n) for the reversed list, and [x . W (n)] for the list with the word x prepended at
each word. The recursion for a Gray code is
W (n)

=

[0 0 . W (n − 2) ]
[1 0 . W R (n − 2)]
[1 2 0 . W (n − 3)]

(14.1-1)

A relation like this always implies another version which is obtained by reversing the order of the sublists
on the right side and additionally reversing each sublist
R

W (n)

[1 2 0 . W R (n − 3)]
= [1 0 . W (n − 2) ]
[0 0 . W R (n − 2) ]

(14.1-2)

The construction is illustrated in figure 14.1-A. An implementation of the algorithm is [FXT: comb/fibalt-gray-demo.cc]:
1
2

void X_rec(ulong d, bool z)
{

14.2: Fibonacci words
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

305

if ( d>=n )
{
if ( d<=n+1 )
{
visit();
}
}
else
{
if ( z )
{
rv[d]=0;
rv[d]=1;
rv[d]=1;
}
else
{
rv[d]=1;
rv[d]=1;
rv[d]=0;
}
}

// avoid duplicates

rv[d+1]=0;
rv[d+1]=0;
rv[d+1]=2;

X_rec(d+2, z);
X_rec(d+2, ! z);
rv[d+2]=0; X_rec(d+3, z);

rv[d+1]=2;
rv[d+1]=0;
rv[d+1]=0;

rv[d+2]=0; X_rec(d+3, z);
X_rec(d+2, ! z);
X_rec(d+2, z);

}

The initial call is X_rec(0, 0);. The parameter z determines whether the list is generated in forward or
backward order. No optimizations are made as these tend to obscure the idea. Here we could omit one
statement rv[d]=1; in both branches, replace the arguments z and !z in the recursive calls by constants,
or create an iterative version.
The number w(n) of words W (n) is determined by (some initial values and) a recursion. Counting the
size of the lists on both sides of the recursion relation gives a relation for w(n). Relation 14.1-1 leads to
the recursion
w(n)

=

2 w(n − 2) + w(n − 3)

(14.1-3)

We can typically set w(0) = 1, there is one empty list and it satisfies all conditions. The numbers w(n)
are in fact the Fibonacci numbers.

14.2
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

Fibonacci words
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1
1

.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1

.
.
.
.
.
1
1
1
.
.
.
.
.
.
.
.
.
.
1
1
1
.
.
.
.
.
1
1
1
.
.
.
.
.

.
.
.
1
1
.
.
.
.
.
.
1
1
.
.
.
1
1
.
.
.
.
.
.
1
1
.
.
.
.
.
.
1
1

.
.
1
.
.
.
.
1
.
.
1
.
.
.
.
1
.
.
.
.
1
.
.
1
.
.
.
.
1
.
.
1
.
.

.
1
.
.
1
.
1
.
.
1
.
.
1
.
1
.
.
1
.
1
.
.
1
.
.
1
.
1
.
.
1
.
.
1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.

.
.
.
.
.
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1

1
1
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
.
.
.
.
.
.
1
1
1
1
.
.
.
.
.
.

.
.
.
.
1
1
.
.
.
.
1
1
.
.
.
.
.
.
.
.
1
1
.
.
.
.
.
.
.
.
1
1
.
.

.
1
1
.
.
.
.
1
1
.
.
.
.
1
1
.
.
1
1
.
.
.
.
1
1
.
.
1
1
.
.
.
.
1

.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1

1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
.
.
.
.
.

.
.
.
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
1
1

1
.
.
.
.
.
.
.
.
1
1
.
.
.
.
1
1
.
.
.
.

.
.
1
1
.
.
1
1
.
.
.
.
1
1
.
.
.
.
1
1
.

.
.
.
.
.
.
.
.
1
1
1
1
1

1
1
1
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
1
1
1
1
.
.
.

.
.
1
1
.
.
.
.
.
.
.
.
1

1
.
.
.
.
1
1
.
.
1
1
.
.

Figure 14.2-A: The first 34 Fibonacci words in counting order (left) and Gray codes through the first
34, 21, and 13 Fibonacci words (right). Dots are used for zeros.

306


A recursive routine to generate the Fibonacci words (binary words not containing two consecutive ones)
can be given as follows:
1
2
3
4
5
6
7
8
9
10
11
12

ulong n;
ulong *rv;

// number of bits in words
// bits of the word

void fib_rec(ulong d)
{
else
{
rv[d]=0; fib_rec(d+1);
rv[d]=1; rv[d+1]=0; fib_rec(d+2);
}
}

We allocate one extra element (a sentinel) to reduce the number of if-statements in the code:
int main()
{
n = 7;
rv = new ulong[n+1];
fib_rec(0);
return 0;
}

// incl. sentinel rv[n]

The output (assuming visit() simply prints the array) is given in the left of figure 14.2-A.
A simple modification of the routine generates a Gray code through the Fibonacci words [FXT:
comb/fibgray-rec-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

void fib_rec(ulong d, bool z)
{
else
{
z = !z; // change direction for Gray code
if ( z )
{
rv[d]=0; fib_rec(d+1, z);
rv[d]=1; rv[d+1]=0; fib_rec(d+2, z);
}
else
{
rv[d]=1; rv[d+1]=0; fib_rec(d+2, z);
rv[d]=0; fib_rec(d+1, z);
}
}
}

The variable z controls the direction in the recursion, it is changed unconditionally with each step. The
if-else blocks can be merged into
1
2

rv[d]=!z;
rv[d]= z;

rv[d+1]= z;
rv[d+1]=!z;

fib_rec(d+1+!z, z);
fib_rec(d+1+ z, z);

In the n-bit Fibonacci Gray code the number of ones in the first and last, second and second-last, etc.
tracks are equal. Therefore the sequence of reversed words is also a Fibonacci Gray code.
The algorithm needs constant amortized time and about 70 million objects are generated per second. A
bit-level algorithm is given in section 1.27.2 on page 76.
The algorithm for the list of the length-n Fibonacci words F (n) can be given as a recursion:
F (n)

=

[1 0 . F R (n − 2)]
[0 . F R (n − 1) ]

(14.2-1)

The generation can be sped up by merging two steps:

F (n)

[1 0 0 . F (n − 3) ]
[1 0 1 0 . F (n − 4)]
=
[0 0 . F (n − 2) ]
[0 1 0 . F (n − 3) ]

(14.2-2)

14.3: Generalized Fibonacci words

14.3

307

Generalized Fibonacci words

............................................1111111111111111111111111111111111111
........................11111111111111111111........................1111111111111
.............11111111111.............1111111.............11111111111.............
.......111111.......1111.......111111..............111111.......1111.......111111
....111....11....111........111....11....111....111....11....111........111....11
..11..1..11....11..1..11..11..1..11....11..1..11..1..11....11..1..11..11..1..11..
.1.1.1..1.1.1.1.1.1..1.1.1.1.1..1.1.1.1.1.1..1.1.1..1.1.1.1.1.1..1.1.1.1.1..1.1.1
1111111111111111111111111111111111111............................................
1111111111111................................................11111111111111111111
..........................1111111111111111111111..........................1111111
.......111111111111..............11111111..............111111111111..............
111........1111........111111................111111........1111........111111....
1....1111........1111....11....1111....1111....11....1111........1111....11....11
..11..11..11..11..11..11....11..11..11..11..11....11..11..11..11..11..11....11..1
Figure 14.3-A: The 7-bit binary words with at most 2 consecutive ones in lexicographic (top) and
minimal-change (bottom) order. Dots denote zeros.
1111111111111 111111111111111111111111 ............................................
1111111111111 ........................
.............
........................11111111111111111111
.............11111111111 11111111111..........................1111111
.......111111 111111..............1111 1111..............111111111111..............
111........11 11........111111........ ........111111........1111........111111....
1....1111.... ....1111....11....1111.. ..1111....11....1111........1111....11....11
..11..11..11. .11..11..11....11..11..1 1..11..11....11..11..11..11..11..11....11..1
Figure 14.3-B: Recursive structure for the 7-bit binary words with at most 2 consecutive ones.
We generalize the Fibonacci words by allowing a ﬁxed maximum value r of consecutive ones in a binary
word. The Fibonacci words correspond to r = 1. Figure 14.3-A shows the 7-bit words with r = 2. The
method to generate a Gray code for these words is a generalization of the recursion for the Fibonacci
words. Write Lr (n) for the list of n-bit words with at most r consecutive ones, then the recursive structure
for the Gray code is

Lr (n)

=

[0 . LR (n − 1)
r
[1 0 . LR (n − 2)
r
[1 1 0 . LR (n − 3)
r
.
.
[
.
r−2

[1
0 . LR (n − 1 − r
r
r−1
[1
0 . LR (n − 1 − r
r
[1r 0 . LR (n − 1 − r)
r

]
]
]
]
+ 2)]
+ 1)]
]

(14.3-1)

Figure 14.3-B shows the structure for L2 (7), corresponding to the three lowest sublists on the right side
of the equation. An implementation is [FXT: comb/maxrep-gray-demo.cc]:
1
2
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14

ulong n;
ulong *rv;
long mr;

// bits of the word
// maximum number of consecutive ones

void maxrep_rec(ulong d, bool z)
{
else
{
z = !z;
long km = mr;
if ( d+km > n )

km = n - d;

if ( z )
{
// words: 0, 10, 110, 1110, ...
for (long k=0; k<=km; ++k)

308


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

r
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1

=
1
1
1
1
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
1
1
1
1

5
1
1
.
.
.
.
1
1
1
1
.
.
.
.
1
1
1
1
.
.
.
.
1
1
1
1
.
.
.
.
1
1

1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

r
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1

=
1
1
1
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
1
1
1
1

4
1
.
.
.
.
1
1
1
1
.
.
.
.
1
1
1
1
.
.
.
.
1
1
1
1
.
.
.
.
1
1

.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1

r
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

=
1
1
.
.
.
.
.
.
.
.
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
1
1
1

3
.
.
.
.
1
1
1
1
.
.
.
.
1
1
1
1
.
.
.
.
1
1
1
1
.
.
.
.
1

.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.
1
1
.
.

1
1
1
1
1
1
1
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.

r
1
1
1
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1

=
.
.
.
.
.
.
.
.
1
1
1
1
1
1
.
.
.
.
.
.
.
.
1
1

2
.
.
1
1
1
1
.
.
.
.
1
1
.
.
.
.
1
1
1
1
.
.
.
.

1
.
.
1
1
.
.
1
1
.
.
.
.
1
1
.
.
1
1
.
.
1
1
.

1
1
1
1
1
.
.
.
.
.
.
.
.

r
.
.
.
.
.
.
.
.
.
.
1
1
1

=
.
.
.
1
1
1
1
.
.
.
.
.
.

1
1
.
.
.
.
.
.
.
.
1
1
.
.

.
.
1
1
.
.
1
1
.
.
.
.
1

Figure 14.3-C: Gray codes of the 5-bit binary words with at most r consecutive ones. The leftmost
column is the complement of the Gray code of all binary words, the rightmost column is the Gray code
for the Fibonacci words.
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

{
rv[d+k] = 0;
maxrep_rec(d+1+k, z);
rv[d+k] = 1;
}
}
else
{
// words: ... 1110, 110, 10, 0
for (long k=0; k<km; ++k) rv[d+k] = 1;
for (long k=km; k>=0; --k)
{
rv[d+k] = 0;
maxrep_rec(d+1+k, z);
}
}
}
}

Figure 14.3-C shows the 5-bit Gray codes for r ∈ {1, 2, 3, 4, 5}. Observe that all sequences are subsequences of the leftmost column.
n:
r=1:
r=2:
r=3:
r=4:
r=5:

0 1 2 3
4
1 2 3 5
8
1 2 4 7 13
1 2 4 8 15
1 2 4 8 16
1 2 4 8 16
Figure 14.3-D:

5
6
7
8
9
13 21
34
55
89
24 44
81 149 274
29 56 108 208 401
31 61 120 236 464
32 63 125 248 492
Number of length-n binary

10
144
504
773
912
976
words

11
233
927
1490
1793
1936
with at

12
13
14
15
377
610
987
1597
1705 3136
5768 10609
2872 5536 10671 20569
3525 6930 13624 26784
3840 7617 15109 29970
most r consecutive ones.

Let wr (n) be the number of n-bit words Wr (n) with ≤ r consecutive ones. Taking the length of the lists
on both sides of relation 14.3-1 gives the recursion
r

wr (n)

wr (n − 1 − j)

=
j=0

(14.3-2)

14.3: Generalized Fibonacci words

309

where we set wr (n) = 2k for 0 ≤ n ≤ r. The sequences for r ≤ 5 start as shown in figure 14.3-D. The
sequences are the following entries in [312]: r = 1 is entry A000045 (the Fibonacci numbers), r = 2 is
A000073, r = 3 is A000078, r = 4 is A001591, and r = 5 is A001592. The variant of the Fibonacci
sequence where each number is the sum of its k predecessors is also called Fibonacci k-step sequence. The
generating function for wr (n) is
∞

wr (n) xn

=

n=0

1−

r
k
k=0 x
r+1 k
k=1 x

(14.3-3)

Alternative Gray code for words without substrings 111 (r = 2) ‡
............................................1111111111111111111111111111111111111
........................111111111111111111111111111111111........................
.............111111111111111111.......................................11111111111
.......1111111111.....................111111111111..............1111111111.......
....11111............111111........11111........11111........11111............111
..111......1111....111....111....111......1111......111....111......1111....111..
.11...11..11..11..11...11...11..11...11..11..11..11...11..11...11..11..11..11...1
Figure 14.3-E: The 7-bit binary words with at most 2 consecutive ones in a minimal-change order.
The list recursion for the Gray code for binary words without substrings 111 is the special case r = 2 of
relation 14.3-1 on page 307:
L2 (n)

[1 1 0 . LR (n − 3)]
2
= [1 0 . LR (n − 2) ]
2
[0 . LR (n − 1) ]
2

(14.3-4)

A different Gray code is generated by the recursion
L2 (n)

=

[1 0 . L2 (n − 2) ]
R
[1 1 0 . L 2 (n − 3)]
[0 . L2 (n − 1)
]

(14.3-5)

The ordering is shown in figure 14.3-E. It was created with the program [FXT: comb/no111-gray-demo.cc].
Alternative Gray code for words without substrings 1111 (r = 3) ‡
1111111111111111111111111111111111111.........................
.............................1111111111111111.................
1111...............111111111111111111111111111111111111.......
111111111........1111................................1111.....
........11....1111111111....11....111111....11....1111111111..
1..11..1111..11........11..1111..11....11..1111..11........11.
..1111......1111..11..1111......1111..1111......1111..11..1111
...............................111111111111111
............1111111111111111111111111111111111
........11111111..............................
...111111111111111111........1111........11111
..11................11....1111111111....11....
.1111..11..11..11..1111..11........11..1111..1
......1111....1111......1111..11..1111......11
Figure 14.3-F: The 7-bit binary words with at most 3 consecutive ones in a minimal-change order.
A list recursion for an alternative Gray code for binary words without substrings 1111 (r = 3) is
R

L3 (n)

[1 1 0 . L 3 (n − 3) ]
R
[0 . L 3 (n − 1)
]
=
R
[1 1 1 0 . L 3 (n − 4)]
R
[1 0 . L 3 (n − 2) ]

(14.3-6)

310


The ordering is shown in figure 14.3-F. It was created with the program [FXT: comb/no1111-graydemo.cc]. For all odd r ≥ 3 a Gray code is generated by a list recursion where the prefixes with an even
number of ones are followed by those with an odd number of ones. For example, with r = 5 the recursion
is
R

[1 1 1 1 0 . L 5 (n − 7) ]
R
[1 1 0 . L 5 (n − 3)
]
R
[0 . L 5 (n − 1)
]
L5 (n) =
R
[1 1 1 1 1 0 . L 5 (n − 6)]
R
[1 1 1 0 . L 5 (n − 4) ]
R
[1 0 . L 5 (n − 2)
]

14.4

(14.3-7)

Run-length limited (RLL) words
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

RLL(2)
. . 1 .
. . 1 .
. . 1 .
. . 1 .
. . 1 .
. . 1 .
. . 1 .
. . 1 .
. . 1 1
. . 1 1
. . 1 1
. . 1 1
. . 1 1
. 1 . .
. 1 . .
. 1 . .
. 1 . .
. 1 . .
. 1 . 1
. 1 . 1
. 1 . 1
. 1 . 1
. 1 . 1
. 1 . 1
. 1 . 1
. 1 . 1
. 1 1 .
. 1 1 .
. 1 1 .
. 1 1 .
. 1 1 .
. 1 1 .
. 1 1 .
. 1 1 .

words
. 1 .
. 1 .
. 1 1
1 . .
1 . 1
1 . 1
1 1 .
1 1 .
. . 1
. . 1
. 1 .
. 1 .
. 1 1
1 . .
1 . 1
1 . 1
1 1 .
1 1 .
. . 1
. . 1
. 1 .
. 1 .
. 1 1
1 . .
1 . 1
1 . 1
. 1 .
. 1 .
. 1 1
1 . .
1 . 1
1 . 1
1 1 .
1 1 .

.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1
.
1

Fibonacci words
1 . . 1 . . 1
1 . . 1 . . .
1 . . 1 . 1 .
1 . . . . 1 .
1 . . . . . .
1 . . . . . 1
1 . . . 1 . 1
1 . . . 1 . .
1 . 1 . 1 . .
1 . 1 . 1 . 1
1 . 1 . . . 1
1 . 1 . . . .
1 . 1 . . 1 .
. . 1 . . 1 .
. . 1 . . . .
. . 1 . . . 1
. . 1 . 1 . 1
. . 1 . 1 . .
. . . . 1 . .
. . . . 1 . 1
. . . . . . 1
. . . . . . .
. . . . . 1 .
. . . 1 . 1 .
. . . 1 . . .
. . . 1 . . 1
. 1 . 1 . . 1
. 1 . 1 . . .
. 1 . 1 . 1 .
. 1 . . . 1 .
. 1 . . . . .
. 1 . . . . 1
. 1 . . 1 . 1
. 1 . . 1 . .

Figure 14.4-A: Lex order for RLL(2) words (left) corresponds to Gray code for Fibonacci words (right).
Words with conditions on the minimum and maximum number of repetitions of a value are called runlength limited (RLL) words. Here we consider only binary words where the number of both consecutive
zeros and ones is at most r where r ≥ 2. We call the RLL words starting with zero as RLL(r) words.
RLL(r) words of length n correspond to generalized Fibonacci words (with at most r − 1 ones) of length
n − 1: the k-th digit (k ≥ 1) of the Fibonacci word is one if the k-th digit of the RLL word is unchanged.
The list of RLL(2) words in lexicographic order is shown in figure 14.4-A, note that the corresponding
Fibonacci words are in minimal change order. The listing was generated by the following recursion [FXT:
comb/rll-rec-demo.cc]:
1
2
3
4
5
6
7

ulong n;


void rll_rec(ulong d, bool z)
{
else
{

14.5: Digit x followed by at least x zeros

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

RLL(2)
. 1 1 .
. 1 1 .
. 1 1 .
. 1 1 .
. 1 1 .
. 1 . .
. 1 . .
. 1 . .
. 1 . 1
. 1 . 1
. 1 . 1
. 1 . 1
. 1 . 1
1 1 . .
1 1 . .
1 1 . .
1 1 . 1
1 1 . 1
1 1 . 1
1 1 . 1
1 1 . 1
1 . . 1
1 . . 1
1 . . 1
1 . . 1
1 . . 1
1 . 1 1
1 . 1 1
1 . 1 1
1 . 1 .
1 . 1 .
1 . 1 .
1 . 1 .
1 . 1 .

words
. 1 1
. 1 .
1 1 .
1 . .
1 . 1
1 1 .
1 . .
1 . 1
1 . .
1 . 1
. . 1
. 1 1
. 1 .
1 1 .
1 . .
1 . 1
1 . .
1 . 1
. . 1
. 1 1
. 1 .
1 . .
1 . 1
. . 1
. 1 1
. 1 .
. . 1
. 1 1
. 1 .
. 1 1
. 1 .
1 1 .
1 . .
1 . 1

change
1
1
1
1
3
1
1
2
1
1
1
1
3
1
1
2
1
1
1
1
3
1
1
1
1
3
1
1
2
1
1
1
1

311
Fibonacci words
1 . 1 . 1 . 1
1 . 1 . 1 . .
1 . 1 . . 1 .
1 . 1 . . . 1
1 . 1 . . . .
1 . . 1 . 1 .
1 . . 1 . . 1
1 . . 1 . . .
1 . . . 1 . 1
1 . . . 1 . .
1 . . . . 1 .
1 . . . . . 1
1 . . . . . .
. 1 . 1 . 1 .
. 1 . 1 . . 1
. 1 . 1 . . .
. 1 . . 1 . 1
. 1 . . 1 . .
. 1 . . . 1 .
. 1 . . . . 1
. 1 . . . . .
. . 1 . 1 . 1
. . 1 . 1 . .
. . 1 . . 1 .
. . 1 . . . 1
. . 1 . . . .
. . . 1 . 1 .
. . . 1 . . 1
. . . 1 . . .
. . . . 1 . 1
. . . . 1 . .
. . . . . 1 .
. . . . . . 1
. . . . . . .

Figure 14.4-B: Order for RLL(2) words (left) corresponding to lex order for Fibonacci words (right).
8
9
10
11
12
13
14
15
16
17
18
19

if ( z==0 )
{
rv[d]=0;
rv[d]=1;
}
else // z==1
{
rv[d]=0;
rv[d]=1;
}

rv[d+1]=1; rll_rec(d+2, 1);
rll_rec(d+1, 1);

rll_rec(d+1, 0);
rv[d+1]=0; rll_rec(d+2, 0);

}
}

The variable z records whether the last bit was a one. By swapping the lines in the branch for z = 1 we
obtain an ordering which corresponds to the (reversed) lexicographic order of the Fibonacci words shown
√
in ﬁgure 14.4-B. The average number of changes per between successive elements tends to 1 + 1/ 5 ≈
1.44721 for n → ∞. The order is not a Gray code for the RLL words, the maximum number of changed
bits among all transitions for n ≤ 30 is
n: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 ...
1 1 1 2 3 3 3 4 5 5 5 6 7 7 7 8 9 9 9 10 11 11 11 12 13 13 13 14 15 15 ...

14.5

Digit x followed by at least x zeros

.................................................111111111111111111111111122222222222223333333
333322222221111111111111......................................................................
.....................................111111122223322221111111.................................
..................111123321111......................................111123321111..............
........123321....................123321..................123321....................123321....
.123321........123321......123321........123321....123321........123321......123321........123

Figure 14.5-A: Gray code for the length-6 words with maximal digit 3 where a digit x is followed by at
least x zeros. Dots denote zeros.
Figure 14.5-A shows a Gray code for the length-5 words with maximal digit 3 where a digit x is followed

312


by at least x zeros. For the Gray code list Zr (n) of the length-n words with maximal digit r we have
R
[0 . Zr (n − 1)
R
[1 0 . Zr (n − 2)
R
[2 0 0 . Zr (n − 3)
Zr (n) = [3 0 0 0 . Z R (n − 4)
r
.
.
[
.

]
]
]
]

(14.5-1)

]
R
[r 0r . Zr (n − r − 1)]

An implementation is [FXT: comb/gexz-gray-demo.cc]:
1
2
3

ulong n;
ulong *rv;
ulong mr;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// number of digits in words
// digits of the word
// radix== mr+1

void gexz_rec(ulong d, bool z)
{
else
{
if ( z )
{
// words 0, 10, 200, 3000, 40000, ...
ulong k = 0;
do
{
rv[d]=k;
rv[d+j] = 0;
gexz_rec(d+k+1, !z);
}
while ( ++k <= mr );
}
else
{
// words ..., 40000, 3000, 200, 10, 0
ulong k = mr + 1;
do
{
--k;
rv[d]=k;
rv[d+j] = 0;
gexz_rec(d+k+1, !z);
}
while ( k != 0 );
}
}
}

n:
r=1:
r=2:
r=3:
r=4:
r=5:
Figure

0 1 2
3
4
1 2 3
5
8
1 3 5
9 17
1 4 7 13 25
1 5 9 17 33
1 6 11 21 41
14.5-B: Number of

5
6
7
8
9
13
21
34
55
89
31
57 105 193
355
49
94 181 349
673
65 129 253 497
977
81 161 321 636 1261
radix-(r + 1), length-n words

10
144
653
1297
1921
2501
where

11
233
1201
2500
3777
4961
a digit

12
13
377
610
2209
4063
4819
9289
7425 14597
9841 19521
x is followed by

14
987
7473
17905
28697
38721
at least

15
1597
13745
34513
56417
76806
x zeros.

Let zr (n) be the number of n-bit words Zr (n), then
r+1

zr (n)

zr (n − j)

=

(14.5-2)

j=1

where we set zr (n) = 1 for n ≤ 0. The sequences for r ≤ 5 start as shown in ﬁgure 14.5-B. The sequences
are the following entries in [312]: r = 1 is entry A000045 (the Fibonacci numbers), r = 2 is A000213,
r = 3 is A000288, r = 4 is A000322, and r = 5 is A000383.

14.6: Generalized Pell words

14.6

Generalized Pell words

14.6.1

313

Gray code for Pell words

.........................................111111111111111111111111111111111
.................111111111111111112222222.................1111111111111111
.......1111111222.......1111111222..............1111111222.......111111122
...1112...1112......1112...1112......1112...1112...1112......1112...1112..
.12.12..12.12..12.12.12..12.12..12.12.12..12.12..12.12..12.12.12..12.12..1

2222222
.......
1111222
1112...
.12..12

.........................................111111111111111111111111111111111
.................111111111111111112222222222222211111111111111111.........
.......11111112222221111111............................1111111222222111111
...11122111............11122111......11122111......11122111............111
.1221....1221..1221..1221....1221..1221....1221..1221....1221..1221..1221.

2222222
.......
1111222
1......
221..12

Figure 14.6-A: Start and end of the lists of 5-digit Pell words in counting order (top) and Gray code
order (bottom). The lowest row is the least significant digit, dots denote zeros.
A Gray code of the Pell words (ternary words without the substrings "21" and "22") can be computed
as follows:
1
2
3

ulong n;
ulong *rv;
bool zq;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// digits of the word
// order: 0==>Lex, 1==>Gray

void pell_rec(ulong d, bool z)
{
else
{
if ( 0==z )
{
rv[d]=0; pell_rec(d+1, z);
rv[d]=1; pell_rec(d+1, zq^z);
rv[d]=2; rv[d+1]=0; pell_rec(d+2, z);
}
else
{
rv[d]=2; rv[d+1]=0; pell_rec(d+2, z);
rv[d]=1; pell_rec(d+1, zq^z);
rv[d]=0; pell_rec(d+1, z);
}
}
}

The global Boolean variable zq controls whether the counting order or the Gray code is generated. The
code is given in [FXT: comb/pellgray-rec-demo.cc]. Both orderings are shown in figure 14.6-A. About 110
million words per second are generated. The computation of a function whose power series coefficients
are related to the Pell Gray code is described in section 38.12.3 on page 760.

14.6.2

Gray code for generalized Pell words

...........................................1111111111111111111111111111111
333322222222222221111111111111..........................111111111111122222
........111122223322221111........111122223322221111........11112222332222
.123321..123321....123321..123321..123321....123321..123321..123321....123
11111111111122222222222222222222222222222222222222222223333333333333
222222223333333322222222222221111111111111..........................
1111................111122223322221111........111122223322221111....
321..123321..123321..123321....123321..123321..123321....123321..123
Figure 14.6-B: Gray code for 4-digit radix-4 strings with no substring 3x with x = 0.
A generalization of the Pell words are the radix-(r + 1) strings where the substring rx with x = 0 is
forbidden (that is, a nine can only be followed by a zero). Let Pr (n) be the list of length-n words in Gray

314


code order. The list can be generated by the recursion
[0 . Pr (n − 1)
R
[1 . Pr (n − 1)
[2 . Pr (n − 1)
R
Pr (n) = [3 . Pr (n − 1)
.
.
[
.

]
]
]
]

R
[0 . Pr (n − 1)
[1 . Pr (n − 1)
R
[2 . Pr (n − 1)
= [3 . Pr (n − 1)
.
.
[
.

]
]
]
]

(14.6-1a)

]
R
[(r − 1) . Pr (n − 1)]
[(r) 0 . Pr (n − 2) ]

if r is even, and by the recursion

Pr (n)

(14.6-1b)

]
[(r − 1) . Pr (n − 1)]
R
[(r) 0 . Pr (n − 2) ]

if r is odd. Figure 14.6-B shows a Gray code for the 4-digit strings with r = 3. An implementation of
the algorithm is [FXT: comb/pellgen-gray-demo.cc]:
1
2
3

ulong n;
ulong *rv;
long r;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// digits of the word (radix r+1)
// Forbidden substrings are [r, x] where x!=0

void pellgen_rec(ulong d, bool z)
{
else
{
const bool p = r & 1; // parity of r
rv[d] = 0;
if ( z )
{
for (long k=0; k<r; ++k) { rv[d] = k; pellgen_rec(d+1, z ^ p ^ (k&1)); }
{ rv[d] = r; rv[d+1] = 0; pellgen_rec(d+2, p ^ z); }
}
else
{
{ rv[d] = r; rv[d+1] = 0; pellgen_rec(d+2, p ^ z); }
for (long k=r-1; k>=0; --k) { rv[d] = k; pellgen_rec(d+1, z ^ p ^ (k&1)); }
}
}
}

With r = 1 we again get the Gray code for Fibonacci words.
n:
0 1
2
3
4
5
6
7
8
9
10
11
r=1: 1 2
3
5
8
13
21
34
55
89
144
233
r=2: 1 3
7
17
41
99
239
577
1393
3363
8119
19601
r=3: 1 4 13
43 142
469
1549
5116
16897
55807
184318
608761
r=4: 1 5 21
89 377 1597
6765
28657 121393
514229
2178309
9227465
r=5: 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281
Figure 14.6-C: Number of length-n, radix-(r + 1) words with no substring r x with x = 0.
Taking the number pr (n) of words Pr (n) on both sides of relations 14.6-1a and 14.6-1b we ﬁnd
pr (n)

= r pr (n) + pr (n − 2)

(14.6-2)

where pr (0) = 1 and pr (1) = r +1. For r ≤ 5 the sequences start as shown in ﬁgure 14.6-C. The sequences
are the following entries in [312]: r = 1: A000045; r = 2: A001333; r = 3: A003688; r = 4: A015448;

14.7: Sparse signed binary words

315

r = 5: A015449. The generating function for pr (n) is
∞

pr (n) xn

1+x
1 − r x − x2

=

n=0

14.7

(14.6-3)

Sparse signed binary words

...........................................MMMMMMMMMMMMMMMMMMMMMPPPPPPPPPPPPPPPPPPPPP
PPPPPPPPPPPMMMMMMMMMMM...............................................................
.................................MMMMMPPPPPPPPPPMMMMM......................MMMMMPPPPP
PPPMMM..........MMMPPPPPPMMM..............................MMMPPPPPPMMM...............
.........MPPM..................MPPM......MPPM......MPPM..................MPPM......MP
PM..MPPM......MPPM..MPPM..MPPM......MPPM......MPPM......MPPM..MPPM..MPPM......MPPM...
Figure 14.7-A: A Gray code through the 85 sparse 6-bit signed binary words. Dots are used for zeros,
the symbols ‘P’ and ‘M’ denote +1 and −1, respectively.
Figure 14.7-A shows a minimal-change order (Gray code) for the sparse signed binary words (nonadjacent
form (NAF), see section 1.23 on page 61). Note that we allow a digit to switch between +1 and −1. If
all words with any positive digit (‘P’) are omitted, we obtain the Gray code for Fibonacci words given in
A recursive routine for the generation of the Gray code is given in [FXT: comb/naf-gray-rec-demo.cc]:
1
2

ulong n;
int *rv;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// number of digits of the string
// the string

void sb_rec(ulong d, bool z)
{
else
{
if ( 0==z )
{
rv[d]=0; sb_rec(d+1, 1);
rv[d]=-1; rv[d+1]=0; sb_rec(d+2,
rv[d]=+1; rv[d+1]=0; sb_rec(d+2,
}
else
{
rv[d]=+1; rv[d+1]=0; sb_rec(d+2,
rv[d]=-1; rv[d+1]=0; sb_rec(d+2,
rv[d]=0; sb_rec(d+1, 0);
}
}
}

1);
0);

1);
0);

About 120 million words per second are generated.
Let S(n) be the number of n-digit sparse signed binary numbers (of both signs) and P (n) be the number
of positive n-digit sparse signed binary numbers, then
n: 0 1 2 3 4 5 6 7
8
9
10
11
12
13
14
15
16
S(n): 1 3 5 11 21 43 85 171 341 683 1365 2731 5461 10923 21845 43691 87381
P(n): 1 2 3 6 11 22 43 86 171 342 683 1366 2731 5462 10923 21846 43691
The sequence of values S(n) and P (n) are respectively entries A001045 and A005578 in [312]. We have

316


(with e := n mod 2)
2n+2 − 1 + 2 e
= 2 S(n − 1) − 1 + 2 e
3
= S(n − 1) + 2 S(n − 2) = 3 S(n − 2) + 2 S(n − 3) = 2 P (n) − 1
2n+1 + 1 + e
= 2 P (n − 1) − 1 − e = S(n − 1) + e
P (n) =
3
= P (n − 1) + S(n − 2) = P (n − 2) + S(n − 2) + S(n − 3)
S(n)

=

= S(n − 2) + S(n − 3) + S(n − 4) + . . . + S(2) + S(1) + 3
=

2 P (n − 1) + P (n − 2) − 2 P (n − 3)

(14.7-1a)
(14.7-1b)
(14.7-1c)
(14.7-1d)
(14.7-1e)
(14.7-1f)

Almost Gray code for positive words ‡
><
><
...........................................PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
PPPPPPPPPPPPPPPPPPPPP.................................................................
................................PPPPPPPPPPPPPPPPPPPPPPMMMMMMMMMMM.....................
PPPPPMMMMM...........PPPPP..................................................MMMMMPPPPP
...............MMMPPP........PPP.....MMMPPPPPPMMM..........MMMPPPPPPMMM...............
PM......MPPM............MPP.....PM..................MPPM..................MPPM......MP
...MPPM......MPPM..MPPM.....PPM....MPPM..MPPM..MPPM......MPPM..MPPM..MPPM......MPPM...
><
><
Figure 14.7-B: An ordering of the 86 sparse 7-bit positive signed binary words that is almost a Gray
code. The transitions that are not minimal are marked with ‘><’. Dots denote zeros.
If we start with the following routine that calls sb_rec() only after a one has been inserted, we get an
ordering of the positive numbers:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void pos_rec(ulong d, bool z)
{
else
{
if ( 0==z )
{
rv[d]=0; pos_rec(d+1,
rv[d]=+1; rv[d+1]=0;
}
else
{
rv[d]=+1; rv[d+1]=0;
rv[d]=0; pos_rec(d+1,
}
}
}

1);
sb_rec(d+2, 1);

sb_rec(d+2, 0);
0);

The ordering with n-digit words is a Gray code, except for n − 4 transitions. An ordering with only
about n/2 non-Gray transitions is generated by the more complicated recursion [FXT: comb/naf-pos-recdemo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1

void pos_AAA(ulong d, bool z)
{
else
{
if ( 0==z )
{
rv[d]=+1; rv[d+1]=0;
rv[d]=0; pos_AAA(d+1,
}
else
{
rv[d]=0; pos_BBB(d+1,
rv[d]=+1; rv[d+1]=0;
}
}
}
void pos_BBB(ulong d, bool z)

sb_rec(d+2, 0);
1); // 1

0); // 0
sb_rec(d+2, 1);

// 0

// 1

14.8: Strings with no two consecutive nonzero digits
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

317

{
else
{
if ( 0==z )
{
rv[d]=+1; rv[d+1]=0;
rv[d]=0; pos_BBB(d+1,
}
else
{
rv[d]=0; pos_AAA(d+1,
rv[d]=+1; rv[d+1]=0;
}
}

sb_rec(d+2, 1);
1); // 1

0); // 0
sb_rec(d+2, 0);

// 1

// 0

}

The initial call is pos_AAA(0,0). The result for n = 7 is shown in ﬁgure 14.7-B. We list the number N
of non-Gray transitions and the number of digit changes X in excess of a Gray code for n ≤ 30:
n: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
N: 0 0 0 0 1 2 2 2 3 4 4 4 5 6 6 6 7 8 8 8 9 10 10 10 11 12 12 12 13 14
X: 0 0 0 0 1 3 4 4 5 7 8 8 9 11 12 12 13 15 16 16 17 19 20 20 21 23 24 24 25 27

14.8

Strings with no two consecutive nonzero digits
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

.3..3
.3..2
.3..1
.3...
.3.1.
.3.2.
.3.3.
.2.3.
.2.2.
.2.1.
.2...
.2..1
.2..2
.2..3
.1..3
.1..2
.1..1
.1...
.1.1.
.1.2.
.1.3.
...3.
...2.
...1.
.....

26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

....1
....2
....3
..1.3
..1.2
..1.1
..1..
..2..
..2.1
..2.2
..2.3
..3.3
..3.2
..3.1
..3..
1.3..
1.3.1
1.3.2
1.3.3
1.2.3
1.2.2
1.2.1
1.2..
1.1..
1.1.1

51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:

1.1.2
1.1.3
1...3
1...2
1...1
1....
1..1.
1..2.
1..3.
2..3.
2..2.
2..1.
2....
2...1
2...2
2...3
2.1.3
2.1.2
2.1.1
2.1..
2.2..
2.2.1
2.2.2
2.2.3
2.3.3

76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:

2.3.2
2.3.1
2.3..
3.3..
3.3.1
3.3.2
3.3.3
3.2.3
3.2.2
3.2.1
3.2..
3.1..
3.1.1
3.1.2
3.1.3
3...3
3...2
3...1
3....
3..1.
3..2.
3..3.

Figure 14.8-A: Gray code for the length-4 radix-4 strings with no two consecutive nonzero digits.
A Gray code for the length-n strings with radix (r + 1) and no two consecutive nonzero digits is generated
by the following recursion for the list Dr (n):

Dr (n)

R
[ 0 . Dr (n − 1)]
R
[1 0 . Dr (n − 1)]
[2 0 . Dr (n − 1) ]
R
= [3 0 . Dr (n − 1)]
[4 0 . Dr (n − 1) ]
R
[5 0 . Dr (n − 1)]
.
.
[
.
]

An implementation is [FXT: comb/ntnz-gray-demo.cc]:
1
2
3

ulong n;
ulong *rv;
ulong mr;

// length of strings
// digits of strings
// max digit

(14.8-1)

318
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17


void ntnz_rec(ulong d, bool z)
{
else
{
if ( 0==z )
{
rv[d]=0; ntnz_rec(d+1, 1);
for (ulong t=1; t<=mr; ++t) { rv[d]=t; rv[d+1]=0; ntnz_rec(d+2, t&1); }
}
else
{
for (ulong t=mr; t>0; --t) { rv[d]=t; rv[d+1]=0; ntnz_rec(d+2, !(t&1)); }
rv[d]=0; ntnz_rec(d+1, 0);
}
}
}

Figure 14.8-A shows the Gray code for length-4, radix-4 (r = 3) strings. Setting r = 2, replacing 1 with
−1, and 2 with +1, gives the Gray code for the sparse binary words (figure 14.7-A on page 315). With
r = 1 we get the Gray code for the Fibonacci words.
n: 0 1 2 3 4
5
6
7
8
9
r=1: 1 2 3 5 8 13 21
34
55
89
r=2: 1 3 5 11 21 43 85 171 341
683
r=3: 1 4 7 19 40 97 217 508 1159 2683
r=4: 1 5 9 29 65 181 441 1165 2929 7589
r=5: 1 6 11 41 96 301 781 2286 6191 17621
Figure 14.8-B: Number of radix-(r + 1), length-n

10
11
12
13
14
144
233
377
610
987
1365
2731
5461
10923
21845
6160 14209 32689
75316 173383
19305 49661 126881 325525 833049
48576 136681 379561 1062966 2960771
words with no two consecutive nonzero digits.

Counting the elements on both sides of relation 14.8-1 we find that for the number dr (n) of strings in the
list Dr (n) we have
dr (n)

=

dr (n − 1) + r dr (n − 2)

(14.8-2)

where dr (0) = 1 and dr (1) = r +1. The sequences of these numbers start as shown in figure 14.8-B. These
are the following entries in [312]: r = 1: A000045; r = 2: A001045; r = 3: A006130; r = 4: A006131;
r = 5: A015440; r = 6: A015441; r = 7: A015442; r = 8: A015443. The generating function for dr (n) is
∞

dr (n) xn
n=0

14.9

=

1+rx
1 − x − r x2

(14.8-3)

Strings with no two consecutive zeros

............111111111111111222222222222222333333333333333
111122223333333322221111......111122223333333322221111...
321..123321..123321..123321123321..123321..123321..123321
................11111111111111111111112222222222222222222222
11111111222222222222222211111111............1111111122222222
222111....111222222111....111222222111111222222111....111222
21..12211221..1221..12211221..1221..1221..1221..12211221..12
Figure 14.9-A: Gray codes for strings with no two consecutive zeros: length-3 radix-4 (left) and length-4
radix-3 (right). Dots denote zeros.
Gray codes for strings with no two consecutive zeros are shown in figure 14.9-A. The recursion for the

14.9: Strings with no two consecutive zeros

319

list Zr (n) with radix (r + 1) is
R
[0 1 . Zr (n − 2)]
[0 2 . Zr (n − 2) ]
R
[0 3 . Zr (n − 2)]
[0 4 . Zr (n − 2) ]
R
[0 5 . Zr (n − 2)]
.
.
[
.
]

[0 1 . Zr (n − 2) ]
R
[0 2 . Zr (n − 2)]
[0 3 . Zr (n − 2) ]
R
[0 4 . Zr (n − 2)]
[0 5 . Zr (n − 2) ]
.
.
[
.
]
Zr (n)

R
= [0 r . Zr (n − 2)] for r even,
R
[1 . Zr (n − 1) ]
[2 . Zr (n − 1) ]
R
[3 . Zr (n − 1) ]
[4 . Zr (n − 1) ]
.
.
[
.
]

R
Zr (n) = [0 r . Zr (n − 2)] for r odd.
[1 . Zr (n − 1) ]
R
[2 . Zr (n − 1) ]
[3 . Zr (n − 1) ]
R
[4 . Zr (n − 1) ]
.
.
[
.
]

R
[r . Zr (n − 1) ]

[r . Zr (n − 1)

]

An implementation is given in [FXT: comb/ntz-gray-demo.cc]:
1
2
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

ulong n;
ulong *rv;
long r;

// digits of the word (radix r+1)
// Forbidden substrings are [r, x] where x!=0

void ntz_rec(ulong d, bool z)
{
else
{
bool w = 0; // r-parity: w depends on z ...
if ( r&1 ) w = !z;
// ... if r odd
if ( z )
{
// words 0X:
rv[d] = 0;
if ( d+2<=n )
{
for (long k=1; k<=r; ++k, w=!w)
}
else
{
ntz_rec(d+1, w);
w = !w;
}
w ^= (r&1);

//

r-parity:

{ rv[d+1]=k;

ntz_rec(d+2, w); }

change direction if r odd

// words X:
for (long k=1; k<=r; ++k, w=!w)

{ rv[d]=k;

ntz_rec(d+1, w); }

}
else
{
// words X:
for (long k=r; k>=1; --k, w=!w)

{ rv[d]=k;

ntz_rec(d+1, w); }

w ^= (r&1);

//

r-parity:

change direction if r odd

// words 0X:
rv[d] = 0;
if ( d+2<=n )
{
for (long k=r; k>=1; --k, w=!w)
}
else
{
ntz_rec(d+1, w);
w = !w;
}
}
}
}

{ rv[d+1]=k;

ntz_rec(d+2, w); }

(14.9-1)

320


With r = 1 we obtain the complement of the minimal-change list of Fibonacci words.
n: 0 1
2
3
4
r=1: 1 2
3
5
8
r=2: 1 3
8
22
60
r=3: 1 4 15
57
216
r=4: 1 5 24 116
560
r=5: 1 6 35 205 1200
Figure 14.9-B: Number

5
6
7
8
9
10
11
13
21
34
55
89
144
233
164
448
1224
3344
9136
24960
68192
819
3105
11772
44631
169209
641520
2432187
2704 13056
63040
304384 1469696
7096320
34264064
7025 41125 240750 1409375 8250625 48300000 282753125
of radix-(r + 1), length-n words with no two consecutive zeros.

Let zr (n) be the number of words Wr (n), we find
= r zr (n − 1) + r zr (n − 1)

zr (n)

(14.9-2)

where zr (0) = 1 and zr (1) = r + 1. The sequences for r ≤ 5 start as shown in figure 14.9-B. These (for
r ≤ 4) are the following entries in [312]: r = 1: A000045; r = 2: A028859; r = 3: A125145; r = 4:
A086347. The generating function for zr (n) is
∞

zr (n) xn

=

n=0

1+x
1 − r x − r x2

14.10

Binary strings without substrings 1x1 or 1xy1 ‡

14.10.1

(14.9-3)

No substrings 1x1
........................................111111111111111111111111
.........................111111111111111...............111111111
...............1111111111.........111111........................
.........111111......1111........................111111.........
......111....11................111............111....11......111
....11..1..........11........11..1....11....11..1..........11..1
..11.1.....11....11.1..11..11.1.....11.1..11.1.....11....11.1...
.1.1...1..1.1.1.1.1...1.1.1.1...1..1.1...1.1...1..1.1.1.1.1...1.
........................................111111111111111111111111
.........................111111111111111111111111...............
...............1111111111111111.................................
.........1111111111.......................................111111
......11111..........................111111............11111....
....111................1111........111....111........111........
..111........1111....111..111....111........111....111........11
.11.....11..11..11..11......11..11.....11.....11..11.....11..11.

Figure 14.10-A: The length-8 binary strings with no substring 1x1 (where x is either 0 or 1): lex order
(top) and minimal-change order (bottom). Dots denote zeros.
A Gray code for binary strings with no substring 1x1 is shown in figure 14.10-A. The recursive structure
for the list V (n) of the n-bit words is
V (n)

=

[1 0 0 . V (n − 3) ]
[1 1 0 0 . V R (n − 4)]
[0 . V (n − 1)
]

The implied algorithm can be implemented as [FXT: comb/no1x1-gray-demo.cc]:
1
2

ulong n;
ulong *rv;

1
2
3
4
5
6
7

void no1x1_rec(ulong d, bool z)
{
if ( d>=n ) { if ( d<=n+2 )
else
{
if ( z )
{

// bits of the word

visit(); }

(14.10-1)

14.10: Binary strings without substrings 1x1 or 1xy1 ‡
8
9
10
11
12
13
14
15
16
17
18
19

rv[d]=1;
rv[d]=1;
rv[d]=0;
}
else
{
rv[d]=0;
rv[d]=1;
rv[d]=1;
}

rv[d+1]=0; rv[d+2]=0;
rv[d+1]=1; rv[d+2]=0;
no1x1_rec(d+1, z);

no1x1_rec(d+3, z);
rv[d+3]=0; no1x1_rec(d+4, !z);

no1x1_rec(d+1, z);
rv[d+1]=1; rv[d+2]=0;
rv[d+1]=0; rv[d+2]=0;

321

rv[d+3]=0; no1x1_rec(d+4, !z);
no1x1_rec(d+3, z);

}
}

The sequence of the numbers v(n) of length-n strings starts as
n:
v(n):

0 1 2 3 4 5 6 7 8
9 10 11 12 13
14
15
16
17
1 2 4 6 9 15 25 40 64 104 169 273 441 714 1156 1870 3025 4895

This is entry A006498 in [312]. The recurrence relation is
v(n)

= v(n − 1) + v(n − 3) + v(n − 4)

(14.10-2)

The generating function is
∞

v(n) xn
n=0

14.10.2

=

1 + x + 2 x2 + x3
1 − x − x3 − x4

(14.10-3)

No substrings 1xy1

..........................................................................................
.....................................................................111111111111111111111
.........................................111111111111111111111111111111111111111111111111.
.........................1111111111111111111111111111............................111111111
.................11111111111111..................11111111.................................
............11111111.........1111.........................................................
........111111.....11............................................11111111.................
....111111...11......................11111111................111111....111111........11111
..1111...11............1111........1111....1111....1111....1111...11..11...1111....1111...
.11..11.........11....11..11..11..11..11..11..11..11..11..11..11..........11..11..11..11..
........................111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111.....................................
.........................................111111111111111111111111.........................
1111111...................................................................................
..................................................................................11111111
...................1111111111................................................11111111.....
...............111111......111111................11111111................111111.....11....
111........111111...11....11...111111........111111....111111........111111...11..........
.1111....1111...11............11...1111....1111...11..11...1111....1111...11............11
11..11..11..11.........11.........11..11..11..11..........11..11..11..11.........11....11.

Figure 14.10-B: The length-10 binary strings with no substring 1xy1 (where x and y are either 0 or 1)
in minimal-change order. Dots denote zeros.
Figure 14.10-B shows a Gray code for binary words with no substring 1xy1. The recursion for the list of
n-bit words Y (n) is
[1 0 0 0 . Y (n − 4)
]
[1 0 1 0 0 0 . Y R (n − 6)]
Y (n) = [1 1 1 0 0 0 . Y (n − 6) ]
[1 1 0 0 0 . Y R (n − 5) ]
[0 . Y (n − 1)
]
An implementation is given in [FXT: comb/no1xy1-gray-demo.cc]:
1
2
3
4
5
6
7

void Y_rec(long p1, long p2, bool z)
{
if ( p1>p2 ) { visit(); return; }
#define S1(a) rv[p1+0]=a
#define S2(a,b) S1(a); rv[p1+1]=b;
#define S3(a,b,c) S2(a,b); rv[p1+2]=c;

(14.10-4)

322
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#define S4(a,b,c,d) S3(a,b,c); rv[p1+3]=d;
#define S5(a,b,c,d,e) S4(a,b,c,d); rv[p1+4]=e;
#define S6(a,b,c,d,e,f) S5(a,b,c,d,e); rv[p1+5]=f;
long d
if ( z
{
if
if
if
if
if
}
else
{
if
if
if
if
if
}

= p2 - p1;
)
(
(
(
(
(

d
d
d
d
d

>=
>=
>=
>=
>=

0
2
2
1
0

)
)
)
)
)

{
{
{
{
{

S4(1,0,0,0);
S6(1,0,1,0,0,0);
S6(1,1,1,0,0,0);
S5(1,1,0,0,0);
S1(0);

Y_rec(p1+4,
Y_rec(p1+6,
Y_rec(p1+6,
Y_rec(p1+5,
Y_rec(p1+1,

p2, z); }
p2, !z); }
p2, z); }
p2, !z); }
p2, z); }

//
//
//
//
//

1
1
1
1
0

(
(
(
(
(

d
d
d
d
d

>=
>=
>=
>=
>=

0
1
2
2
0

)
)
)
)
)

{
{
{
{
{

S1(0);
S5(1,1,0,0,0);
S6(1,1,1,0,0,0);
S6(1,0,1,0,0,0);
S4(1,0,0,0);

Y_rec(p1+1,
Y_rec(p1+5,
Y_rec(p1+6,
Y_rec(p1+6,
Y_rec(p1+4,

p2, z); }
p2, !z); }
p2, z); }
p2, !z); }
p2, z); }

//
//
//
//
//

0
1
1
1
1

0
0
1
1

0
1
1
0

0
0 0 0
0 0 0
0 0

1
1
0
0

0
1
1
0

0 0
0 0 0
0 0 0
0

}

Note the conditions if ( d >= ? ) that make sure that no string appears repeated. The initial call is
Y_rec(0, n-1, 0). The sequence of the numbers y(n) of length-n strings starts as
n:
y(n):

0 1 2 3 4 5 6 7 8
9 10 11 12 13
14
15
16
17
1 2 4 8 12 17 25 41 69 114 180 280 440 705 1137 1825 2905 4610

∞

y(n) xn

=

n=0

14.10.3

1 + x + 2 x2 + 4 x3 + 3 x4 + 2 x5
1 − x − x4 − x5 − 2 x6

(14.10-5)

Neither substrings 1x1 nor substrings 1xy1

............................................................1111111111111111111111111111
.........................................111111111111111111111111111111.................
...........................1111111111111111111111.......................................
.................1111111111111111.......................................................
...........1111111111.............................................................111111
........11111............................................111111................11111....
......111..............................1111............111....111............111........
....111..................1111........111..111........111........111........111..........
..111..........1111....111..111....111......111....111............111....111..........11
.11.......11..11..11..11......11..11..........11..11.......11.......11..11.......11..11.

Figure 14.10-C: A Gray code for the length-10 binary strings with no substring 1x1 or 1xy1.
A recursion for a Gray code of the n-bit binary words Z(n) with no substrings 1x1 or 1xy1 (shown in
ﬁgure 14.10-C) is
Z(n)

[1 0 0 0 . Z(n − 4) ]
= [1 1 0 0 0 . Z R (n − 5)]
[0 . Z(n − 1)
]

(14.10-6)

The sequence of the numbers z(n) of length-n strings starts as
n:
z(n):

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
16
17
1 2 4 6 8 11 17 27 41 60 88 132 200 301 449 669 1001 1502

The sequence is (apart from three leading ones) entry A079972 in [312] where two combinatorial interpretations are given:
Number of permutations satisfying -k<=p(i)-i<=r and p(i)-i not in I, i=1..n,
with k=1, r=4, I={1,2}.
Number of compositions (ordered partitions) of n into elements of the set {1,4,5}.

∞

z(n) xn
n=0

=

1 + x + 2 x2 + 2 x3 + x4
1 − x − x4 − x5

(14.10-7)

323

Chapter 15

Parentheses strings
We give algorithms to list all well-formed strings of n pairs of parentheses. In the spirit of [211] we use
the term paren string for a well-formed string of parentheses. A generalization, the k-ary Dyck words, is
described at the end of the section.
If the problem at hand appears to be somewhat esoteric, then see [319, vol.2, exercise 6.19, p.219] for
many kinds of objects isomorphic to our paren strings. Indeed, as of May 2010, 180 kinds of combinatorial
objects counted by the Catalan numbers (which may be called Catalan objects) have been identified, see
[321] and also [320].

15.1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

((((()))))
(((()())))
((()(())))
(()((())))
()(((())))
(((())()))
((()()()))
(()(()()))
()((()()))
((())(()))
(()()(()))
()(()(()))
(())((()))
()()((()))
(((()))())
((()())())
(()(())())
()((())())
((())()())
(()()()())
()(()()())

11111.....
1111.1....
111.11....
11.111....
1.1111....
1111..1...
111.1.1...
11.11.1...
1.111.1...
111..11...
11.1.11...
1.11.11...
11..111...
1.1.111...
1111...1..
111.1..1..
11.11..1..
1.111..1..
111..1.1..
11.1.1.1..
1.11.1.1..

22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

(())(()())
()()(()())
((()))(())
(()())(())
()(())(())
(())()(())
()()()(())
(((())))()
((()()))()
(()(()))()
()((()))()
((())())()
(()()())()
()(()())()
(())(())()
()()(())()
((()))()()
(()())()()
()(())()()
(())()()()
()()()()()

11..11.1..
1.1.11.1..
111...11..
11.1..11..
1.11..11..
11..1.11..
1.1.1.11..
1111....1.
111.1...1.
11.11...1.
1.111...1.
111..1..1.
11.1.1..1.
1.11.1..1.
11..11..1.
1.1.11..1.
111...1.1.
11.1..1.1.
1.11..1.1.
11..1.1.1.
1.1.1.1.1.

Figure 15.1-A: All (42) valid strings of 5 pairs of parentheses in co-lexicographic order.
An iterative scheme to generate all valid ways to group parentheses can be derived from a modified
version of the combinations in co-lexicographic order (see section 6.2.2 on page 178). For n = 5 pairs the
possible combinations are shown in figure 15.1-A. This is the output of [FXT: comb/paren-demo.cc].
Consider the sequences to the right of the paren strings as binary words (these are often called (binary)
Dyck words). If the leftmost block has more than a single one, then its rightmost one is moved one
position to the right. Otherwise (the leftmost block consists of a single one and) the ones of the longest
run of the repeated pattern ‘1.’ at the left are gathered at the left end and the rightmost one in the next
block of ones (which contains at least two ones) is moved by one position to the right and the rest of the
block is gathered at the left end (see the transitions from #14 to #15 or #37 to #38).
The generator is [FXT: class paren in comb/paren.h]:

324
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Chapter 15: Parentheses strings

class paren
{
public:
ulong k_; // Number of paren pairs
ulong n_; // ==2*k
ulong *x_; // Positions where an opening paren occurs
char *str_; // String representation, e.g. "((())())()"
public:
paren(ulong k)
{
k_ = (k>1 ? k : 2); // not zero (empty) or one (trivial: "()")
n_ = 2 * k_;
x_ = new ulong[k_ + 1];
x_[k_] = 999; // sentinel
str_ = new char[n_ + 1];
str_[n_] = 0;
first();
}
~paren()
{
delete [] x_;
delete [] str_;
}
void first()
void last()

{ for (ulong i=0; i<k_; ++i)
{ for (ulong i=0; i<k_; ++i)

x_[i] = i; }
x_[i] = 2*i; }

[--snip--]

The code for the computation of the successor and predecessor is quite concise. A sentinel x[k] is used
to save one branch in the generation of the next string
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

ulong next() // return zero if current paren is the last
{
// if ( k_==1 ) return 0; // uncomment to make algorithm work for k_==1
ulong j = 0;
if ( x_[1] == 2 )
{
// scan for low end == 010101:
j = 2;
while ( x_[j]==2*j ) ++j; // can touch sentinel
if ( j==k_ ) { first(); return 0; }
}
// scan block:
while ( 1 == (x_[j+1] - x_[j]) )

{ ++j; }

++x_[j]; // move edge element up
for (ulong i=0; i<j; ++i) x_[i] = i; // attach block at low end
return 1;
}
ulong prev() // return zero if current paren is the first
{
// if ( k_==1 ) return 0; // uncomment to make algorithm work for k_==1
ulong j = 0;
// scan for first gap:
while ( x_[j]==j ) ++j;
if ( j==k_ ) { last();

return 0; }

if ( x_[j]-x_[j-1] == 2 ) --x_[j]; // gap of length one
else
{
ulong i = --x_[j];
--j;
--i;
// j items to go, distribute as 1.1.1.11111
for ( ; 2*i>j; --i,--j) x_[j] = i;
for ( ; i; --i) x_[i] = 2*i;
x_[0] = 0;
}

15.2: Gray code via restricted growth strings
43
44
45
46
47
48
49

325

return 1;
}
[--snip--]

const

{ return x_; }

The strings are set up on demand only:
1
2
3
4
5
6
7

const char * string() // generate on demand
{
for (ulong j=0; j<n_; ++j) str_[j] = ’)’;
for (ulong j=0; j<k_; ++j) str_[x_[j]] = ’(’;
return str_;
}
};

The 477, 638, 700 paren words for n = 18 are generated at a rate of about 67 million objects per second.
Section 1.28 on page 78 gives a bit-level algorithm for the generation of the paren words in colex order.

15.2

Gray code via restricted growth strings
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

[
[
[
[
[
[
[
[
[
[
[
[
[
[

0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,

0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,

0,
0,
1,
1,
1,
0,
0,
1,
1,
1,
2,
2,
2,
2,

0,
1,
0,
1,
2,
0,
1,
0,
1,
2,
0,
1,
2,
3,

]
]
]
]
]
]
]
]
]
]
]
]
]
]

()()()()
()()(())
()(())()
()(()())
()((()))
(())()()
(())(())
(()())()
(()()())
(()(()))
((()))()
((())())
((()()))
(((())))

1.1.1.1.
1.1.11..
1.11..1.
1.11.1..
1.111...
11..1.1.
11..11..
11.1..1.
11.1.1..
11.11...
111...1.
111..1..
111.1...
1111....

Figure 15.2-A: Length-4 restricted growth strings in lexicographic order (left) and the corresponding
paren strings (middle) and delta sets (right).
The valid paren strings can be represented by sequences a0 , a1 , . . . , an where a0 = 0 and ak ≤ ak−1 + 1.
These sequences are examples of restricted growth strings (RGS). Some sources use the term restricted
growth functions.
The RGSs for n = 4 are shown in ﬁgure 15.2-A (left). The successor of an RGS is computed by
incrementing the highest (rightmost in ﬁgure 15.2-A) digit aj where aj ≤ aj−1 and setting ai = 0 for all
i > j. The predecessor is computed by decrementing the highest digit aj = 0 and setting ai = ai−1 + 1
for all i > j.
The RGSs for a given n can be generated as follows [FXT: class catalan in comb/catalan.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

class catalan
// Catalan restricted growth strings (RGS)
// By default in near-perfect minimal-change order, i.e.
// exactly two symbols in paren string change with each step
{
public:
int *as_;
// digits of the RGS: as_[k] <= as[k-1] + 1
int *d_;
// direction with recursion (+1 or -1)
ulong n_;
// Number of digits (paren pairs)
char *str_; // paren string
bool xdr_; // whether to change direction in recursion (==> minimal-change order)
int dr0_;
// dr0: starting direction in each recursive step:
//
dr0=+1 ==> start with as[]=[0,0,0,...,0]
== "()()()...()"
//
dr0=-1 ==> start with as[]=[0,1,2,...,n-1] == "((( ... )))"

326

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0

2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
1

3
3
3
3
3
2
2
2
2
1
1
1
0
0
0
0
1
1
1
2
2
2
2
1
1
1
0
0
0
0
1
1
1
2
2
2
2
1
1
1
0
0

4
3
2
1
0
0
1
2
3
2
1
0
0
1
1
0
0
1
2
3
2
1
0
0
1
2
1
0
0
1
2
1
0
0
1
2
3
2
1
0
0
1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

-

-

+
+
+
+
+
+
+
+
+
+
+
+
+
+

+
+
+
+
+
+
+
+
+
+
+
+
+
+
-

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

((((()))))
(((()())))
(((())()))
(((()))())
(((())))()
((()()))()
((()())())
((()()()))
((()(())))
((())(()))
((())()())
((())())()
((()))()()
((()))(())
(()())(())
(()())()()
(()()())()
(()()()())
(()()(()))
(()((())))
(()(()()))
(()(())())
(()(()))()
(())(())()
(())(()())
(())((()))
(())()(())
(())()()()
()()()()()
()()()(())
()()((()))
()()(()())
()()(())()
()((()))()
()((())())
()((()()))
()(((())))
()(()(()))
()(()()())
()(()())()
()(())()()
()(())(())

11111.....
1111.1....
1111..1...
1111...1..
1111....1.
111.1...1.
111.1..1..
111.1.1...
111.11....
111..11...
111..1.1..
111..1..1.
111...1.1.
111...11..
11.1..11..
11.1..1.1.
11.1.1..1.
11.1.1.1..
11.1.11...
11.111....
11.11.1...
11.11..1..
11.11...1.
11..11..1.
11..11.1..
11..111...
11..1.11..
11..1.1.1.
1.1.1.1.1.
1.1.1.11..
1.1.111...
1.1.11.1..
1.1.11..1.
1.111...1.
1.111..1..
1.111.1...
1.1111....
1.11.11...
1.11.1.1..
1.11.1..1.
1.11..1.1.
1.11..11..

((((XA))))
(((()XA)))
(((())XA))
(((()))XA)
(((XA)))()
((()())AX)
((()()AX))
((()(AX)))
((()X(A)))
((())(XA))
((())()XA)
((())XA)()
((()))(AX)
((XA))(())
(()())(XA)
(()()AX)()
(()()()AX)
(()()(AX))
(()(A(X)))
(()((XA)))
(()(()XA))
(()(())XA)
(()X(A))()
(())(()AX)
(())((AX))
(())(X(A))
(())()(XA)
(XA)()()()
()()()(AX)
()()(A(X))
()()((XA))
()()(()XA)
()(A(X))()
()((())AX)
()((()AX))
()(((AX)))
()((X(A)))
()(()(XA))
()(()()XA)
()(()XA)()
()(())(AX)

2

2

2
2

2
2

2

Figure 15.2-B: Minimal-change order for the paren strings of 5 pairs. From left to right: restricted
growth strings, arrays of directions, paren strings, delta sets, and diﬀerence strings. If the changes are not
adjacent, then the distance of changed positions is given at the right. The order corresponds to dr0=-1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public:
catalan(ulong n, bool xdr=true, int dr0=+1)
{
n_ = n;
as_ = new int[n_];
d_ = new int[n_];
str_ = new char[2*n_+1]; str_[2*n_] = 0;
init(xdr, dr0);
}
~catalan()
{
delete [] as_;
delete [] d_;
delete [] str_;
}
void init(bool xdr, int dr0)
{
dr0_ = ( (dr0>=0) ? +1 : -1 );
xdr_ = xdr;
ulong n = n_;
if ( dr0_>0 )
else


as_[k] = 0;
as_[k] = k;

15.2: Gray code via restricted growth strings
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

0
0
0
0
0
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
1
1
1
1
1
1
1
1
0
0
0
0
0

0
0
1
1
1
2
2
2
2
1
1
1
0
0
0
0
1
1
1
2
2
2
2
3
3
3
3
3
2
2
2
2
1
1
1
0
0
0
0
1
1
1

0
1
2
1
0
0
1
2
3
2
1
0
0
1
1
0
0
1
2
3
2
1
0
0
1
2
3
4
3
2
1
0
0
1
2
1
0
0
1
2
1
0

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+
+
+
+
+
+
+
+
+
+
+
+
+
+
-

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-

327
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

()()()()()
()()()(())
()()((()))
()()(()())
()()(())()
()((()))()
()((())())
()((()()))
()(((())))
()(()(()))
()(()()())
()(()())()
()(())()()
()(())(())
((()))(())
((()))()()
((())())()
((())()())
((())(()))
((()(())))
((()()()))
((()())())
((()()))()
(((())))()
(((()))())
(((())()))
(((()())))
((((()))))
(()((())))
(()(()()))
(()(())())
(()(()))()
(()()())()
(()()()())
(()()(()))
(()())(())
(()())()()
(())()()()
(())()(())
(())((()))
(())(()())
(())(())()

1.1.1.1.1.
1.1.1.11..
1.1.111...
1.1.11.1..
1.1.11..1.
1.111...1.
1.111..1..
1.111.1...
1.1111....
1.11.11...
1.11.1.1..
1.11.1..1.
1.11..1.1.
1.11..11..
111...11..
111...1.1.
111..1..1.
111..1.1..
111..11...
111.11....
111.1.1...
111.1..1..
111.1...1.
1111....1.
1111...1..
1111..1...
1111.1....
11111.....
11.111....
11.11.1...
11.11..1..
11.11...1.
11.1.1..1.
11.1.1.1..
11.1.11...
11.1..11..
11.1..1.1.
11..1.1.1.
11..1.11..
11..111...
11..11.1..
11..11..1.

()()()(AX)
()()(A(X))
()()((XA))
()()(()XA)
()(A(X))()
()((())AX)
()((()AX))
()(((AX)))
()((X(A)))
()(()(XA))
()(()()XA)
()(()XA)()
()(())(AX)
(A(X))(())
((()))(XA)
((())AX)()
((())()AX)
((())(AX))
((()A(X)))
((()(XA)))
((()()XA))
((()())XA)
(((AX)))()
(((()))AX)
(((())AX))
(((()AX)))
((((AX))))
((X((A))))
(()((XA)))
(()(()XA))
(()(())XA)
(()(XA))()
(()()()AX)
(()()(AX))
(()()X(A))
(()())(XA)
(()XA)()()
(())()(AX)
(())(A(X))
(())((XA))
(())(()XA)

2
2

2

2

2

3

2

2

Figure 15.2-C: Minimal-change order for the paren strings of 5 pairs. From left to right: restricted
growth strings, arrays of directions, paren strings, delta sets, and diﬀerence strings. If the changes are not
adjacent, then the distance of changed positions is given at the right. The order corresponds to dr0=+1.
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


d_[k] = dr0_;

}
bool next()

{ return next_rec(n_-1); }

const int *get()
const char* str()

const

{ return as_; }

{ make_str();

return (const char*)str_; }

[--snip--]
void make_str()
{
for (ulong k=0; k<2*n_; ++k) str_[k] = ’)’;
for (ulong k=0,j=0; k<n_; ++k,j+=2) str_[ j-as_[k] ] = ’(’;
}
};

The minimal-change order is obtained by changing the ‘direction’ in the recursion, an essentially identical
mechanism (for the generation of set partitions) is shown in chapter 17 on page 354. The function is
given in [FXT: comb/catalan.cc]:
1
2
3

bool
catalan::next_rec(ulong k)
{

328
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

if ( k<1 )

return false;

// current is last

int d = d_[k];
int as = as_[k] + d;
bool ovq = ( (d>0) ? (as>as_[k-1]+1) : (as<0) );
if ( ovq ) // have to recurse
{
ulong ns1 = next_rec(k-1);
if ( 0==ns1 ) return false;
d = ( xdr_ ? -d : dr0_ );
d_[k] = d;
as = ( (d>0) ? 0 : as_[k-1]+1 );
}
as_[k] = as;
return true;
}

The program [FXT: comb/catalan-demo.cc] demonstrates the usage:
ulong n = 4;
bool xdr = true;
int dr0 = -1;
catalan C(n, xdr, dr0);
do { /* visit string */ }

while ( C.next() );

About 69 million strings per second are generated. Figure 15.2-B shows the minimal-change order for
n = 5 and dr0=-1, and ﬁgure 15.2-C for dr0=+1.
More minimal-change orders
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1

0
0
0
0
0
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
2

0
0
1
1
1
2
2
2
2
1
1
1
0
0
3
3
3
3
3
2
2

0
1
2
1
0
3
2
1
0
0
1
2
1
0
0
1
2
3
4
3
2

1.1.1.1.1.
1.1.1.11..
1.1.111...
1.1.11.1..
1.1.11..1.
1.1111....
1.111.1...
1.111..1..
1.111...1.
1.11.1..1.
1.11.1.1..
1.11.11...
1.11..11..
1.11..1.1.
1111....1.
1111...1..
1111..1...
1111.1....
11111.....
111.11....
111.1.1...

22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

2
2
2
2
2
2
2
1
1
1
1
1
1
1
1
1
0
0
0
0
0

2
2
1
1
1
0
0
0
0
1
1
1
2
2
2
2
1
1
1
0
0

1
0
0
1
2
1
0
0
1
2
1
0
0
1
2
3
0
1
2
1
0

111.1..1..
111.1...1.
111..1..1.
111..1.1..
111..11...
111...11..
111...1.1.
11.1..1.1.
11.1..11..
11.1.11...
11.1.1.1..
11.1.1..1.
11.11...1.
11.11..1..
11.11.1...
11.111....
11..11..1.
11..11.1..
11..111...
11..1.11..
11..1.1.1.

Figure 15.2-D: Strings of 5 pairs of parentheses in a Gray code order.
The Gray code order shown in ﬁgure 15.2-D can be generated via a simple recursion:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ulong n;
ulong *rv;

// Number of paren pairs
// restricted growth strings

void next_rec(ulong d, bool z)
{
if ( d==n ) visit();
else
{
const long rv1 = rv[d-1]; // left neighbor
if ( 0==z )
{
for (long x=0; x<=rv1+1; ++x) // forward
{
rv[d] = x;
next_rec(d+1, (x&1));
}
}
else

15.3: Order by prefix shifts (cool-lex)
19
20
21
22
23
24
25
26
27

329

{
for (long x=rv1+1; x>=0; --x)
{
rv[d] = x;
next_rec(d+1, !(x&1));
}

// backward

}
}
}

The initial call is next_rec(0, 0);.
comb/paren-gray-rec-demo.cc].
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

()()()()()
()()()(())
()()(()())
()()((()))
()()(())()
()(()())()
()(()(()))
()(()()())
()((())())
()((()()))
()(((())))
()((()))()
()(())()()
()(())(())
(()())(())
(()())()()
(()(()))()
(()((())))
(()(()()))
(()(())())
(()()()())

About 81 million strings per second are generated [FXT:

1.1.1.1.1.
1.1.1.11..
1.1.11.1..
1.1.111...
1.1.11..1.
1.11.1..1.
1.11.11...
1.11.1.1..
1.111..1..
1.111.1...
1.1111....
1.111...1.
1.11..1.1.
1.11..11..
11.1..11..
11.1..1.1.
11.11...1.
11.111....
11.11.1...
11.11..1..
11.1.1.1..

22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

(()()(()))
(()()())()
((())())()
((())(()))
((())()())
((()())())
((()()()))
((()(())))
((()()))()
(((())))()
((((()))))
(((()())))
(((())()))
(((()))())
((()))(())
((()))()()
(())()()()
(())()(())
(())(()())
(())((()))
(())(())()

11.1.11...
11.1.1..1.
111..1..1.
111..11...
111..1.1..
111.1..1..
111.1.1...
111.11....
111.1...1.
1111....1.
11111.....
1111.1....
1111..1...
1111...1..
111...11..
111...1.1.
11..1.1.1.
11..1.11..
11..11.1..
11..111...
11..11..1.

Figure 15.2-E: Strings of 5 pairs of parentheses in Gray code order as generated by a loopless algorithm.
A loopless algorithm (that does not use RGS) given in [329] is implemented in [FXT: class paren gray
in comb/paren-gray.h]. The generated order for five paren pairs is shown in figure 15.2-E. About 80
million strings per second are generated [FXT: comb/paren-gray-demo.cc]. Still more algorithms for the
parentheses strings in minimal-change order are given in [90], [337], and [363].
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

....1111
...1.111
...11.11
...111.1
..1.11.1
..1.1.11
..1..111
.1...111
.1..1.11
.1..11.1
.1.1.1.1
..11.1.1
..11..11
.1.1..11

==
==
==
==
==
==
==
==
==
==
==
==
==
==

(((())))
((()()))
(()(()))
()((()))
()(()())
(()()())
((())())
((()))()
(()())()
()(())()
()()()()
()()(())
(())(())
(())()()

^=
^=
^=
^=
^=
^=
^=
^=
^=
^=
^=
^=
^=

...11...
....11..
.....11.
..11....
.....11.
....11..
.11.....
....11..
.....11.
...11...
.11.....
.....11.
.11.....

Figure 15.2-F: A strong minimal-change order for the paren strings of 4 pairs.
For even values of n it is possible to generate paren strings in strong minimal-change order where changes
occur only in adjacent positions. Figure 15.2-F shows an example for four pairs of parens. The listing
was generated with [FXT: graph/graph-parengray-demo.cc] that uses directed graphs and the search
algorithms described in chapter 20 on page 391.

330

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

((((()))))
()(((())))
(()((())))
((()(())))
(((()())))
()((()()))
(()(()()))
((()()()))
()(()(()))
(()()(()))
()()((()))
(())((()))
((())(()))
(((())()))
()((())())
(()(())())
((()())())
()(()()())
(()()()())
()()(()())
(())(()())

11111.....
1.1111....
11.111....
111.11....
1111.1....
1.111.1...
11.11.1...
111.1.1...
1.11.11...
11.1.11...
1.1.111...
11..111...
111..11...
1111..1...
1.111..1..
11.11..1..
111.1..1..
1.11.1.1..
11.1.1.1..
1.1.11.1..
11..11.1..

22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

((())()())
()(())(())
(()())(())
()()()(())
(())()(())
((()))(())
(((()))())
()((()))()
(()(()))()
((()()))()
()(()())()
(()()())()
()()(())()
(())(())()
((())())()
()(())()()
(()())()()
()()()()()
(())()()()
((()))()()
(((())))()

111..1.1..
1.11..11..
11.1..11..
1.1.1.11..
11..1.11..
111...11..
1111...1..
1.111...1.
11.11...1.
111.1...1.
1.11.1..1.
11.1.1..1.
1.1.11..1.
11..11..1.
111..1..1.
1.11..1.1.
11.1..1.1.
1.1.1.1.1.
11..1.1.1.
111...1.1.
1111....1.

Figure 15.3-A: All strings of 5 pairs of parentheses generated via prefix shifts.

15.3


The binary words corresponding to paren strings can be generated in an order where each word differs
from its successor by a cyclic shift of a prefix (ignoring the first bit which is always one). Moreover, each
transition changes either two or four bits, see figure 15.3-A.
The (loopless) algorithm described in [292] can generate slightly more general objects: strings of t ones
and s zeros where the number of zeros in any prefix does not exceed the number of ones. Paren strings
correspond to t = s. The generator is implemented as follows [FXT: comb/paren-pref.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class paren_pref
{
public:
const ulong t_, s_; // t: number of ones, s: number of zeros
const ulong nq_; // aux
ulong x_, y_; // aux
ulong *b_;
// array of t ones and s zeros
public:
paren_pref(ulong t, ulong s)
// Must have: t >= s > 0
: t_(t), s_(s), nq_(s+t-(s==t))
{
b_ = new ulong[s_+t_+1]; // element [0] unused
first();
}
~paren_pref()

{ delete [] b_; }


const

{ return b_+1; }

void first()
{
for (ulong j=0; j<=t_; ++j) b_[j] = 1;
for (ulong j=t_+1; j<=s_+t_; ++j) b_[j] = 0;
x_ = y_ = t_;
}

The method for updating is
1
2
3
4
5
6

bool next()
{
if ( x_ >= nq_ )
b_[x_] = 0;
b_[y_] = 1;
++x_;

return false;

15.4: Catalan numbers
7
8
9
10
11
12
13
14
15
16
17
18
19
20

331

++y_;
if ( b_[x_] == 0 )
{
if ( x_ == 2*y_ - 2 )
else
{
b_[x_] = 1;
b_[2] = 0;
x_ = 3;
y_ = 2;
}
}
return true;

++x_;

}

Note that the array b[] is one-based, as in the cited paper. A zero-based version is used if the line
#define PAREN_PREF_BASE1

// default on (faster)

near the top of the ﬁle is commented out. The rate of generation (with t = s = 18) is impressive: about
268 M/s when using a pointer and about 281 M/s when using an array [FXT: comb/paren-pref-demo.cc].

15.4

Catalan numbers

The number of valid combinations of n parentheses pairs is
Cn

=

2n
n

=

n+1

2 n+1
n

2n + 1

2n
n−1

=

n

2n
2n
−
n
n−1

=

(15.4-1)

as nicely explained in [166, p.343-346]. These are the Catalan numbers, sequence A000108 in [312]:
n:
Cn
1:
1
2:
2
3:
5
4:
14
5:
42
6:
132
7:
429
8:
1430
9:
4862
10: 16796

n:
Cn
11:
58786
12:
208012
13:
742900
14:
2674440
15:
9694845
16:
35357670
17:
129644790
18:
477638700
19: 1767263190
20: 6564120420

n:
Cn
21:
24466267020
22:
91482563640
23:
343059613650
24:
1289904147324
25:
4861946401452
26:
18367353072152
27:
69533550916004
28: 263747951750360
29: 1002242216651368
30: 3814986502092304

The Catalan numbers are generated most easily with the relation
Cn+1
√
1 − 1 − 4x
C(x) =
=
2x

=

2 (2 n + 1)
Cn
n+2

(15.4-2)

∞

Cn xn = 1 + x + 2 x2 + 5 x3 + 14 x4 + 42 x5 + . . .

(15.4-3)

n=0
2

The function C(x) satisﬁes the equation [x C(x)] = x + [x C(x)] which is equivalent to the following
convolution property for the Catalan numbers:
n−1

Cn

=

Ck Cn−1−k

(15.4-4)

k=0

√
The quadratic equation has a second solution (1 + 1 − 4 x)/(2 x) = x−1 − 1 − x − 2 x2 − 5 x3 − 14 x4 − . . .
which we ignore here.

332


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

RGS
0 0
0 0
0 0
0 1
0 1
0 1
0 1
0 2
0 2
0 2
0 2
0 2
1 0
1 0
1 0
1 1
1 1
1 1
1 1
1 2
1 2
1 2
1 2
1 2
1 3
1 3
1 3
1 3
1 3
1 3
2 0
2 0
2 0
2 1
2 1
2 1
2 1
2 2
2 2
2 2
2 2
2 2
2 3
2 3
2 3
2 3
2 3
2 3
2 4
2 4
2 4
2 4
2 4
2 4
2 4

0
1
2
0
1
2
3
0
1
2
3
4
0
1
2
0
1
2
3
0
1
2
3
4
0
1
2
3
4
5
0
1
2
0
1
2
3
0
1
2
3
4
0
1
2
3
4
5
0
1
2
3
4
5
6

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Dyck word
1..1..1..1..
1..1..1.1...
1..1..11....
1..1.1...1..
1..1.1..1...
1..1.1.1....
1..1.11.....
1..11....1..
1..11...1...
1..11..1....
1..11.1.....
1..111......
1.1...1..1..
1.1...1.1...
1.1...11....
1.1..1...1..
1.1..1..1...
1.1..1.1....
1.1..11.....
1.1.1....1..
1.1.1...1...
1.1.1..1....
1.1.1.1.....
1.1.11......
1.11.....1..
1.11....1...
1.11...1....
1.11..1.....
1.11.1......
1.111.......
11....1..1..
11....1.1...
11....11....
11...1...1..
11...1..1...
11...1.1....
11...11.....
11..1....1..
11..1...1...
11..1..1....
11..1.1.....
11..11......
11.1.....1..
11.1....1...
11.1...1....
11.1..1.....
11.1.1......
11.11.......
111......1..
111.....1...
111....1....
111...1.....
111..1......
111.1.......
1111........

positions
[ 0 3 6 9 ]
[ 0 3 6 8 ]
[ 0 3 6 7 ]
[ 0 3 5 9 ]
[ 0 3 5 8 ]
[ 0 3 5 7 ]
[ 0 3 5 6 ]
[ 0 3 4 9 ]
[ 0 3 4 8 ]
[ 0 3 4 7 ]
[ 0 3 4 6 ]
[ 0 3 4 5 ]
[ 0 2 6 9 ]
[ 0 2 6 8 ]
[ 0 2 6 7 ]
[ 0 2 5 9 ]
[ 0 2 5 8 ]
[ 0 2 5 7 ]
[ 0 2 5 6 ]
[ 0 2 4 9 ]
[ 0 2 4 8 ]
[ 0 2 4 7 ]
[ 0 2 4 6 ]
[ 0 2 4 5 ]
[ 0 2 3 9 ]
[ 0 2 3 8 ]
[ 0 2 3 7 ]
[ 0 2 3 6 ]
[ 0 2 3 5 ]
[ 0 2 3 4 ]
[ 0 1 6 9 ]
[ 0 1 6 8 ]
[ 0 1 6 7 ]
[ 0 1 5 9 ]
[ 0 1 5 8 ]
[ 0 1 5 7 ]
[ 0 1 5 6 ]
[ 0 1 4 9 ]
[ 0 1 4 8 ]
[ 0 1 4 7 ]
[ 0 1 4 6 ]
[ 0 1 4 5 ]
[ 0 1 3 9 ]
[ 0 1 3 8 ]
[ 0 1 3 7 ]
[ 0 1 3 6 ]
[ 0 1 3 5 ]
[ 0 1 3 4 ]
[ 0 1 2 9 ]
[ 0 1 2 8 ]
[ 0 1 2 7 ]
[ 0 1 2 6 ]
[ 0 1 2 5 ]
[ 0 1 2 4 ]
[ 0 1 2 3 ]

Figure 15.5-A: The 55 increment-2 restricted growth strings of length 4 (left), the corresponding 3-ary
Dyck words (middle), and positions of ones in the Dyck words (right).

15.5: Increment-i RGS, k-ary Dyck words, and k-ary trees

15.5

333

Increment-i RGS, k-ary Dyck words, and k-ary trees

We generalize the restricted growth strings for paren word by allowing increments at most i: sequences
a0 , a1 , . . . , an where a0 = 0 and ak ≤ ak−1 + i. The case i = 1 corresponds to the RGS for paren words.
A k-ary Dyck word is a binary word where each prefix contains at least k − 1 times many ones as zeros.
The increment-i RGS correspond to k-ary Dyck words where k = i + 1, see figure 15.5-A. The positions
of the ones in the Dyck words are computed as cj = k · j − aj (rightmost column).
The length-n increment-i RGS also correspond to k-ary trees with n internal nodes: start at the root,
move out by i positions for every one and follow back by one position for every zero.

15.5.1

Generation in lexicographic order

Figure 15.5-A shows the increment-2 restricted growth strings of length 4. The strings can be generated
in lexicographic order via [FXT: class dyck rgs in comb/dyck-rgs.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class dyck_rgs
{
public:
ulong *s_;
ulong n_;
ulong i_;
[--snip--]

// restricted growth string
// Length of strings
// s[k] <= s[k-1]+i

ulong next()
// Return index of first changed element in s[],
// Return zero if current string is the last
{
ulong k = n_;
start:
--k;
if ( k==0 )

return 0;

ulong sk = s_[k] + 1;
ulong mp = s_[k-1] + i_;
if ( sk > mp ) // "carry"
{
s_[k] = 0;
goto start;
}
s_[k] = sk;
return k;
}
[--snip--]

The rate of generation is about 168 M/s for i = 1, 194 M/s for i = 2, and 218 M/s with i = 3 [FXT:
comb/dyck-rgs-demo.cc].

15.5.2

Gray codes with homogeneous moves

A loopless algorithm for the generation of a Gray code with only homogeneous moves is given in [37]. The
RGS used in the algorithm gives the positions (one-based) of the ones in the delta sets, see figure 15.5-B
(created with [FXT: comb/dyck-gray-demo.cc]). An implementation is given in [FXT: class dyck gray
in comb/dyck-gray.h].
A Gray code where in addition all transitions are two-close is shown in figure 15.5-C (created with [FXT:
comb/dyck-gray2-demo.cc]). Note that the moves are enup-moves, compare to figure 6.6-B on page 189.
The underlying algorithm is described in [338] an implementation is given in [FXT: class dyck gray2
in comb/dyck-gray2.h]:
1
2
3
4
5

class dyck_gray2
{
public:
ulong m, k; // m ones (and m*(k-1) zeros)
bool ptt;
// Parity of Total number of Tories (variable ’Odd’ in paper)

334


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

positions
[ 1 4 7 A ]
[ 1 4 7 8 ]
[ 1 4 7 9 ]
[ 1 4 5 9 ]
[ 1 4 5 8 ]
[ 1 4 5 7 ]
[ 1 4 5 6 ]
[ 1 4 5 A ]
[ 1 4 6 A ]
[ 1 4 6 7 ]
[ 1 4 6 8 ]
[ 1 4 6 9 ]
[ 1 2 6 9 ]
[ 1 2 6 8 ]
[ 1 2 6 7 ]
[ 1 2 6 A ]
[ 1 2 5 A ]
[ 1 2 5 6 ]
[ 1 2 5 7 ]
[ 1 2 5 8 ]
[ 1 2 5 9 ]
[ 1 2 4 9 ]
[ 1 2 4 8 ]
[ 1 2 4 7 ]
[ 1 2 4 6 ]
[ 1 2 4 5 ]
[ 1 2 4 A ]
[ 1 2 3 A ]
[ 1 2 3 4 ]
[ 1 2 3 5 ]
[ 1 2 3 6 ]
[ 1 2 3 7 ]
[ 1 2 3 8 ]
[ 1 2 3 9 ]
[ 1 2 7 9 ]
[ 1 2 7 8 ]
[ 1 2 7 A ]
[ 1 3 7 A ]
[ 1 3 7 8 ]
[ 1 3 7 9 ]
[ 1 3 4 9 ]
[ 1 3 4 8 ]
[ 1 3 4 7 ]
[ 1 3 4 6 ]
[ 1 3 4 5 ]
[ 1 3 4 A ]
[ 1 3 5 A ]
[ 1 3 5 6 ]
[ 1 3 5 7 ]
[ 1 3 5 8 ]
[ 1 3 5 9 ]
[ 1 3 6 9 ]
[ 1 3 6 8 ]
[ 1 3 6 7 ]
[ 1 3 6 A ]

Dyck word
1..1..1..1..
1..1..11....
1..1..1.1...
1..11...1...
1..11..1....
1..11.1.....
1..111......
1..11....1..
1..1.1...1..
1..1.11.....
1..1.1.1....
1..1.1..1...
11...1..1...
11...1.1....
11...11.....
11...1...1..
11..1....1..
11..11......
11..1.1.....
11..1..1....
11..1...1...
11.1....1...
11.1...1....
11.1..1.....
11.1.1......
11.11.......
11.1.....1..
111......1..
1111........
111.1.......
111..1......
111...1.....
111....1....
111.....1...
11....1.1...
11....11....
11....1..1..
1.1...1..1..
1.1...11....
1.1...1.1...
1.11....1...
1.11...1....
1.11..1.....
1.11.1......
1.111.......
1.11.....1..
1.1.1....1..
1.1.11......
1.1.1.1.....
1.1.1..1....
1.1.1...1...
1.1..1..1...
1.1..1.1....
1.1..11.....
1.1..1...1..

direction
[ + + + + ]
[ + + + + ]
[ + + + - ]
[ + + + - ]
[ + + + - ]
[ + + + - ]
[ + + + - ]
[ + + + + ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - - ]
[ + + - - ]
[ + + - - ]
[ + + - - ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - - ]
[ + + - - ]
[ + + - - ]
[ + + - - ]
[ + + - - ]
[ + + - - ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - + ]
[ + + - - ]
[ + + + - ]
[ + + + - ]
[ + + + + ]
[ + - + + ]
[ + - + + ]
[ + - + - ]
[ + - + - ]
[ + - + - ]
[ + - + - ]
[ + - + - ]
[ + - + - ]
[ + - + + ]
[ + - + + ]
[ + - + + ]
[ + - + + ]
[ + - + + ]
[ + - + - ]
[ + - - - ]
[ + - - - ]
[ + - - - ]
[ + - - + ]

Figure 15.5-B: Gray code for 3-ary Dyck words where all changes are homogeneous. The left column
shows the vectors of (one-based) positions, the symbol ‘A’ is used for the number 10.


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

positions
[ 1 2 3 4 ]
[ 1 2 3 6 ]
[ 1 2 3 8 ]
[ 1 2 3 A ]
[ 1 2 3 9 ]
[ 1 2 3 7 ]
[ 1 2 3 5 ]
[ 1 2 4 5 ]
[ 1 2 4 6 ]
[ 1 2 4 8 ]
[ 1 2 4 A ]
[ 1 2 4 9 ]
[ 1 2 4 7 ]
[ 1 2 6 7 ]
[ 1 2 6 8 ]
[ 1 2 6 A ]
[ 1 2 6 9 ]
[ 1 2 7 9 ]
[ 1 2 7 A ]
[ 1 2 7 8 ]
[ 1 2 5 8 ]
[ 1 2 5 A ]
[ 1 2 5 9 ]
[ 1 2 5 7 ]
[ 1 2 5 6 ]
[ 1 4 5 6 ]
[ 1 4 5 7 ]
[ 1 4 5 9 ]
[ 1 4 5 A ]
[ 1 4 5 8 ]
[ 1 4 7 8 ]
[ 1 4 7 A ]
[ 1 4 7 9 ]
[ 1 4 6 9 ]
[ 1 4 6 A ]
[ 1 4 6 8 ]
[ 1 4 6 7 ]
[ 1 3 6 7 ]
[ 1 3 6 8 ]
[ 1 3 6 A ]
[ 1 3 6 9 ]
[ 1 3 7 9 ]
[ 1 3 7 A ]
[ 1 3 7 8 ]
[ 1 3 5 8 ]
[ 1 3 5 A ]
[ 1 3 5 9 ]
[ 1 3 5 7 ]
[ 1 3 5 6 ]
[ 1 3 4 6 ]
[ 1 3 4 8 ]
[ 1 3 4 A ]
[ 1 3 4 9 ]
[ 1 3 4 7 ]
[ 1 3 4 5 ]

Dyck word
1111........
111..1......
111....1....
111......1..
111.....1...
111...1.....
111.1.......
11.11.......
11.1.1......
11.1...1....
11.1.....1..
11.1....1...
11.1..1.....
11...11.....
11...1.1....
11...1...1..
11...1..1...
11....1.1...
11....1..1..
11....11....
11..1..1....
11..1....1..
11..1...1...
11..1.1.....
11..11......
1..111......
1..11.1.....
1..11...1...
1..11....1..
1..11..1....
1..1..11....
1..1..1..1..
1..1..1.1...
1..1.1..1...
1..1.1...1..
1..1.1.1....
1..1.11.....
1.1..11.....
1.1..1.1....
1.1..1...1..
1.1..1..1...
1.1...1.1...
1.1...1..1..
1.1...11....
1.1.1..1....
1.1.1....1..
1.1.1...1...
1.1.1.1.....
1.1.11......
1.11.1......
1.11...1....
1.11.....1..
1.11....1...
1.11..1.....
1.111.......

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

335

direction
. . . .
. . . +2
. . . +2
. . . -2
. . . -2
. . . -2
. . . .
. . +2 .
. . +2 +2
. . +2 +3
. . +2 -3
. . +2 -3
. . +2 .
. . +3 .
. . +3 +2
. . +3 -3
. . +3 .
. . -3 .
. . -3 -1
. . -3 .
. . . .
. . . -1
. . . -1
. . . -1
. . . .
. -2 . .
. -2 . +2
. -2 . +3
. -2 . -3
. -2 . .
. -2 -2 .
. -2 -2 -2
. -2 -2 .
. -2 . .
. -2 . -1
. -2 . -1
. -2 . .
. . . .
. . . +2
. . . -3
. . . .
. . -1 .
. . -1 -1
. . -1 .
. . -1 .
. . -1 -1
. . -1 -1
. . -1 -1
. . -1 .
. . . .
. . . +1
. . . -1
. . . -1
. . . -1
. . . .

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 15.5-C: Gray code for 3-ary Dyck words where all changes are both homogeneous and two-close.
The left column shows the vectors of (one-based) positions, the symbol ‘A’ is used for the number 10.

336
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

ulong *c_;
// positions of ones (1-based)
ulong *e_;
// Ehrlich array (focus pointers)
bool *p_;
// parity (1-based)
int *s_;
// directions: whether last/first (==0) or
// rising (>0) or falling (<0); (1-based)

public:
dyck_gray2(ulong tk, ulong tm)
// must have tk>=2, tm>=1
{
k = tk;
m = tm;
ptt = false;
c_ = new ulong[m+2];
// sentinels c_[0] (with computing MN) and c_[m+1] (with condition in next())
e_ = new ulong[m+1];
p_ = new bool[m+1];
s_ = new int[m+1];
first();

// p_[0] unused
// s_[0] unused

}
~dyck_gray2()
[--snip--]
void first()
{
for (ulong j=0; j<=m; ++j) e_[j] =
for (ulong j=0; j<=m; ++j) s_[j] =
for (ulong j=0; j<=m; ++j) p_[j] =
for (ulong j=0; j<=m; ++j) c_[j] =
c_[m+1] = 0; // sentinel, c_[0] is
}

j;
// {e_[j] = j for 0
0;
// {s_[j] = 0 for 1
false; // {p_[j] = 0 for 1
j;
// first word == [1,
also sentinel

<=
<=
<=
2,

j <= m}
j <= m}
j <= m}
3, ..., m]

The following comments in curly braces are from the paper:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

ulong next()
// Return zero if current==last, else
// position (!=0) in (zero-based) array c_[]
// (the first element never changes).
{
ulong i = e_[m]; // The pivot
if ( i==1 ) return 0; // current is last
const ulong MN = c_[i-1] + 1; // {MN is the minimum value of c_[i]}
// can touch sentinel c_[0]
const ulong MX = (i - 1)*k + 1;

// { MX is the maximum value of c_[i]}

if ( s_[i] == 0 ) // { c_[i] is at its first value }
{
p_[i] = ptt; // { parity of total number of tories }
s_[i] = +1; // {c_[i] starts rising unless it starts at max(i)}
if ( c_[i] == MX ) // {one of these tories is not to c_[i]’s left}
{
p_[i] = 1 - p_[i];
s_[i] = -s_[i];
}
if ( c_[i+1] == MX+k )
{
p_[i] = 1 - p_[i];
}

// can touch sentinel c_[m+1]==0

}
if ( s_[i] > 0 ) // { c_[i] is rising }
{
if ( c_[i] == MN ) // {MN is taken and c_[i] can’t end there}
{
s_[i] = 2;
}
else
{
if ( (c_[i] == MN+1) && (s_[i] == 2) ) // {MN+1 is also taken}
{
s_[i] = 3;

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

337

}
}
c_[i] += ( 1 + ( ((c_[i] % 2) == p_[i]) && (c_[i] < MX-1) ) );
if ( c_[i] == MX ) // {one more tory}
{
ptt = 1 - ptt;
s_[i] = -s_[i];
}
}
else
{

// { c_[i] is falling }

if ( c_[i] == MX ) {

ptt = 1 - ptt; }

// {one fewer tory}

c_[i] -= ( 1 + ( ((c_[i] % 2) != p_[i] ) && (c_[i] > MN+1) ) );
}
e_[m] = m; // {beginning to update Ehrlich array}
if ( c_[i] + s_[i] == MN-1 ) // {c_[i] is at its last value}
{
s_[i] = 0; // {c_[i] will be at its first value the next time i is the pivot}
e_[i] = e_[i-1];
e_[i-1] = i - 1;
}
return

i - 1;

// position in zero-based array c_[]

}
const ulong *data()

const

{ return c_+1; }

// zero-based array

};

15.5.3

The number of increment-i RGS

n:
i=1:
i=2:
i=3:
i=4:

1
1
1
1
1

2 3
4
5
6
7
8
9
10
11
2 5 14
42
132
429
1430
4862
16796
58786
3 12 55 273 1428
7752
43263
246675
1430715
8414640
4 22 140 969 7084 53820 420732 3362260 27343888 225568798
5 35 285 2530 23751 231880 2330445 23950355 250543370 2658968130

Figure 15.5-D: The numbers Cn,i of increment-i RGS of length n for i ≤ 4 and n ≤ 11.
The number Cn,i of length-n increment-i strings equals
Cn,i

=

(i+1) n
n

(15.5-1)

in + 1

A recursion generalizing relation 15.4-2 is
Cn+1,i

=

(i + 1)

i
k=1 [(i + 1) n + k]
i
k=1 [i n + k + 1]

Cn,i

(15.5-2)

The sequences of numbers of length-n strings for i = 1, 2, 3, 4 start as sown in ﬁgure 15.5-D. These are
respectively the entries A000108, A001764, A002293, A002294 in [312] where combinatorial interpretations are given. We can express the generating function Ci (x) as a hypergeometric series (see chapter 36
on page 685):
∞

Ci (x)

Cn,i xn

=

(15.5-3a)

1/(i + 1), 2/(i + 1), 3/(i + 1), . . . , (i + 1)/(i + 1) (i + 1)(i+1)
x
2/i, 3/i, . . . , i/i, (i + 1)/i
ii

(15.5-3b)

n=0

=

F

Note that the last upper and second last lower parameter cancel. Now let fi (x) := x Ci (xi ), then
fi (x) − fi (x)i+1

= x

(15.5-4)

That is, fi (x) can be computed as the series reversion of x − xi+1 . We choose i = 2 as an example:

338


? t1=serreverse(x-x^3+O(x^(17)))
x + x^3 + 3*x^5 + 12*x^7 + 55*x^9 + 273*x^11 + 1428*x^13 + 7752*x^15 + O(x^17)
? t2=hypergeom([1/3,2/3,3/3],[2/2,3/2],3^3/2^2*x)+O(x^17)
1 + x + 3*x^2 + 12*x^3 + 55*x^4 + 273*x^5 + 1428*x^6 + 7752*x^7 + ... + O(x^17)
? f=x*subst(t2,x,x^2);
? t1-f
O(x^17)
f is actually the series reversion of x-x^3
? f-f^3
x + O(x^35) ... so f - f^3 == id

We further have the following convolution property which generalizes relation 15.4-4:
Cn,i

=
j1 + j2 + . . . + ji + j(i+1) = n − 1

Cj1 , i Cj2 , i Cj3 , i · · · Cji , i Cj(i+1) , i

(15.5-5)

An explicit expression for the function Ci (x) is
Ci (x)

=

exp

1
i+1

∞

n=1

(i + 1) n
n

xn
n

(15.5-6)

The expression generalizes a relation given in [227, rel.6] (set i = 1 and take the logarithm on both sides)
∞

1
n
n=1

2n n
x
n

=

2 log

1−

√

1 − 4x
2x

(15.5-7)

A curious property of the functions Ci (x) is given in [349, entry “Hypergeometric Function”]:
i

Ci x (1 − x)

=

1
1−x

(15.5-8)

339

Chapter 16

Integer partitions
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

6
6
6
6
6
6
6
6
6
6
6

==
==
==
==
==
==
==
==
==
==
==

6*
4*
2*
0
3*
1*
0
2*
0
1*
0

1 + 0
1 + 1* 2
1 + 2* 2
+ 3* 2
1 + 0
1 + 1* 2
+ 0
1 + 0
+ 1* 2
1 + 0
+ 0

+
+
+
+
+
+
+
+
+
+
+

0
+ 0
+ 0
+
0
+ 0
+ 0
+
0
+ 0
+ 0
+
0
+ 0
+ 0
+
1* 3 + 0
+ 0
+
1* 3 + 0
+ 0
+
2* 3 + 0
+ 0
+
0
+ 1* 4 + 0
+
0
+ 1* 4 + 0
+
0
+ 0
+ 1* 5 +
0
+ 0
+ 0
+

0
0
0
0
0
0
0
0
0
0
1* 6

==
==
==
==
==
==
==
==
==
==
==

1
1
1
2
1
1
3
1
2
1
6

+
+
+
+
+
+
+
+
+
+

1
1
1
2
1
2
3
1
4
5

+
+
+
+
+
+

1
1
2
2
1
3

+ 1 + 1 + 1
+ 1 + 2
+ 2
+ 3

+ 4

Figure 16.0-A: All (eleven) integer partitions of 6.
An integer x is the sum of the positive integers less than or equal to itself in various ways. The decompositions into sums of integers are called the integer partitions of the number x. Figure 16.0-A shows all
integer partitions of x = 6.

16.1

Solution of a generalized problem

We can solve a more general problem and find all partitions of a number x with respect to a set V =
n−1
{v0 , v1 , . . . , vn−1 } where vi > 0, that is all decompositions of the form x = k=0 ck · vk where ci ≥ 0.
The integer partitions are the special case V = {1, 2, 3, . . . , n}.
To generate the partitions assign to the first bucket r0 an integer multiple of the first element v0 : r0 = c·v0 .
This has to be done for all c ≥ 0 for which r0 ≤ x. Now set c0 = c. If r0 = x, we already found a
partition (consisting of c0 only), else (if r0 < x) solve the remaining problem where x := x − c0 · v0 and
V := {v1 , v2 , . . . , vn−1 }.
A C++ class for the generation of all partitions is [FXT: class partition gen in comb/partition-gen.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class partition_gen
// Integer partitions of x into supplied values pv[0],...,pv[n-1].
// pv[] defaults to [1,2,3,...,x]
{
public:
ulong ct_; // Number of partitions found so far
ulong n_;
// Number of values
ulong i_;
// level in iterative search
long *pv_;
ulong *pc_;
ulong pci_;
long *r_;
long ri_;
long x_;

//
//
//
//
//
//

values into which to partition
multipliers for values
temporary for pc_[i_]
rest
temporary for r_[i_]
value to partition

partition_gen(ulong x, ulong n=0, const ulong *pv=0)
{
if ( 0==n ) n = x;
n_ = n;
pv_ = new long[n_+1];

340
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

Chapter 16: Integer partitions
if ( pv ) for (ulong j=0; j<n_; ++j)
else
pc_ = new ulong[n_+1];
r_ = new long[n_+1];
init(x);

pv_[j] = pv[j];
pv_[j] = j + 1;

}
void init(ulong x)
{
x_ = x;
ct_ = 0;
r_[n_-1] = x_;
r_[n_] = x_;
i_ = n_ - 1;
pci_ = 0;
ri_ = x_;
}

pc_[k] = 0;
r_[k] = 0;

~partition_gen()
{
delete [] pv_;
delete [] pc_;
delete [] r_;
}
ulong next(); // generate next partition
ulong next_func(ulong i); // aux
[--snip--]
};

The routine to compute the next partition is given in [FXT: comb/partition-gen.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ulong
partition_gen::next()
{
if ( i_>=n_ ) return

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ulong
partition_gen::next_func(ulong i)
{
start:
if ( 0!=i )
{
while ( r_[i]>0 )
{
pc_[i-1] = 0;
r_[i-1] = r_[i];
--i; goto start;
// iteration
}
}
else // iteration end
{
if ( 0!=r_[i] )
{
long d = r_[i] / pv_[i];
r_[i] -= d * pv_[i];
pc_[i] = d;
}
}

n_;

r_[i_] = ri_;
pc_[i_] = pci_;
i_ = next_func(i_);
for (ulong j=0; j<i_; ++j)

pc_[j] = r_[j] = 0;

++i_;
ri_ = r_[i_] - pv_[i_];
pci_ = pc_[i_] + 1;
return

i_ - 1;

// >=0

}

if ( 0==r_[i] )
{

// valid partition found

16.2: Iterative algorithm
26
27
28
29
30
31
32
33
34
35
36
37

341

++ct_;
return i;
}
++i;
if ( i>=n_ )

return n_;

// search finished

r_[i] -= pv_[i];
++pc_[i];
goto start;

// iteration

}

The routines can easily be adapted to the generation of partitions satisfying certain restrictions, for
example, partitions into distinct parts (that is, ci ≤ 1).
The listing shown in figure 16.0-A can be generated with [FXT: comb/partition-gen-demo.cc]. The
190, 569, 292 partitions of 100 are generated at a rate of about 18 M/s.

16.2

Iterative algorithm

An iterative implementation for the generation of the integer partitions is given in [FXT: class
partition in comb/partition.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

class partition
{
public:
ulong *c_; // partition: c[1]* 1 + c[2]* 2 + ... + c[n]* n == n
ulong *s_; // cumulative sums: s[j+1] = c[1]* 1 + c[2]* 2 + ... + c[j]* j
ulong n_;
// partitions of n
public:
partition(ulong n)
{
n_ = n;
c_ = new ulong[n+1];
s_ = new ulong[n+1];
s_[0] = 0; // unused
c_[0] = 0; // unused
first();
}
~partition()
{
delete [] c_;
delete [] s_;
}
void first()
{
c_[1] = n_;
for (ulong i=2; i<=n_; i++)
s_[1] = 0;
for (ulong i=2; i<=n_; i++)
}

{ c_[i] = 0; }
{ s_[i] = n_; }

void last()
{
for (ulong i=1; i<n_; i++) { c_[i] = 0; }
c_[n_] = 1;
for (ulong i=1; i<n_; i++) { s_[i] = 0; }
// s_[n_+1] = n_; // unused (and out of bounds)
}

To compute the next partition, find the smallest index i ≥ 2 so that [c1 , c2 , . . . , ci−1 , ci ] can be replaced
by [z, 0, 0, . . . , 0, ci + 1] where z ≥ 0. The index i is determined using cumulative sums. The partitions
are generated in the same order as shown in figure 16.0-A. The algorithm was given (2006) by Torsten
Finke [priv. comm.].
1
2
3
4

bool next()
{
if ( c_[n_]!=0 )

return false;

// last == 1* n (c[n]==1)

342
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Find first coefficient c[i], i>=2 that can be increased:
ulong i = 2;
while ( s_[i] 1 )
{
s_[i] = z;
c_[i] = 0;
}
c_[1] = z; // z* 1 == z
// s_[1] unused
return true;
}

The preceding partition can be computed as follows:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

bool prev()
{
if ( c_[1]==n_ )

return false;

// first == n* 1 (c[1]==n)

// Find first nonzero coefficient c[i] where i>=2:
ulong i = 2;
while ( c_[i]==0 ) ++i;
--c_[i];
s_[i] += i;
ulong z = s_[i];
// Now set c[1], c[2], ..., c[i-1] to the last partition
// of z into i-1 parts:
while ( --i > 1 )
{
ulong q = (z>=i ? z/i : 0); // == z/i;
c_[i] = q;
s_[i+1] = z;
z -= q*i;
}
c_[1] = z;
s_[2] = z;
// s_[1] unused
return true;
}
[--snip--]
};

Divisions which result in q = 0 are avoided, leading to a small speedup. The program [FXT:
comb/partition-demo.cc] demonstrates the usage of the class. About 200 million partitions per second
are generated, and about 70 million for the reversed order.

16.3

Partitions into m parts
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
2

1
1
1
1
1
2
2
2
3
3
2

1
2
3
4
5
2
3
4
3
4
2

9
8
7
6
5
7
6
5
5
4
6

12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
1
1
1
1
2

1
1
1
1
1
1
1
1
1
2
2

1
1
1
1
1
1
1
2
2
2
2

1
1
1
1
2
2
2
2
2
2
2

2
2
2
3
2
2
2
2
2
2
2

2
2
3
3
2
2
3
2
2
2
2

3
4
3
3
2
3
3
2
3
2
2

5
4
4
3
5
4
3
4
3
3
2

Figure 16.3-A: The 22 partitions of 19 into 11 parts in lexicographic order.
An algorithm for the generation of all partitions of n into m parts is given in [123, vol2, p.106]:

16.3: Partitions into m parts

343

The initial partition contains m−1 units and the element n−m+1. To obtain a new partition
from a given one, pass over the elements of the latter from right to left, stopping at the first
element f which is less, by at least two units, than the final element [...]. Without altering
any element at the left of f , write f + 1 in place of f and every element to the right of f with
the exception of the final element, in whose place is written the number which when added
to all the other new elements gives the sum n. The process to obtain partitions stops when
we reach one in which no part is less than the final part by at least two units.
Figure 16.3-A shows the partitions of 19 into 11 parts. The data was generated with the program [FXT: comb/mpartition-demo.cc]. The implementation used is [FXT: class mpartition in
comb/mpartition.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class mpartition
// Integer partitions of n into m parts
{
public:
ulong *x_; // partition: x[1]+x[2]+...+x[m] = n
ulong *s_; // aux: cumulative sums of x[] (s[0]=0)
ulong n_;
// integer partitions of n (must have n>0)
ulong m_;
// ... into m parts (must have 0<m<=n)
mpartition(ulong n, ulong m)
: n_(n), m_(m)
{
x_ = new ulong [m_+1];
s_ = new ulong [m_+1];
init();
}
[--snip--]
void init()
{
x_[0] = 0;
for (ulong k=1; k<m_; ++k) x_[k] = 1;
x_[m_] = n_ - m_ + 1;
ulong s = 0;
for (ulong k=0; k<=m_; ++k) { s+=x_[k]; s_[k]=s; }
}

The successor is computed as follows:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

bool next()
{
ulong u = x_[m_]; // last element
ulong k = m_;
while ( --k ) { if ( x_[k]+2<=u ) break; }
if ( k==0 )

return

false;

ulong f = x_[k] + 1;
ulong s = s_[k-1];
while ( k < m_ )
{
x_[k] = f;
s += f;
s_[k] = s;
++k;
}
x_[m_] = n_ - s_[m_-1];
// s_[m_] = n_; // unchanged
return

true;

}
};

The auxiliary array of cumulative sums allows the recalculation of the final element without rescanning
more than the elements just changed. About 134 million partitions per second are generated. A Gray
code for integer partitions is described in [279], for algorithmic details see [215, sect.7.2.1.4].

344

16.4


The number of integer partitions

We give expressions for generating functions for various types of partitions, as, for example, unrestricted
partitions, partitions into an even or odd number of parts, partitions into exactly m parts, partitions into
distinct parts, and partitions into square-free parts.
N

The following relations will be useful. The first is found by setting P0 = 1 and PN = n=1 (1 + an ) so
PN = (1 + aN ) PN −1 = aN PN −1 + PN −1 = aN PN −1 + aN −1 PN −2 + PN −2 and so on. For the second,
replace an by an /(1 − an ) (for the other direction replace an by an /(1 + an )):
N

N

(1 + an )

=

1+

n=1

n=1

=

(1 − an )

N

(1 + ak ) = 1 +

N

an
n=1

k=1

N

1
N
n=1

n−1

an

(1 + ak )

N

an
= 1+
n
k=1 (1 − ak )
n=1

1+
n=1

(16.4-1a)

k=n+1

an
N
k=n

(1 − ak )

(16.4-1b)

The next two are given in [248, p.7, id.7 and id.6]:
∞

∞

(1 + x q n )

=

n=0
∞
n=0

n=0
∞

1
(1 − x q n )

xn q n (n−1)/2
n
k
k=1 (1 − q )

=
n=0

(16.4-2a)

xn q n(n−1)
n−1
k=0

n−1
k=0

(1 − q q k )

(1 − x q k )

(16.4-2b)

The relations are the limits M → ∞ of the following:
M −1

M

(1 + x q n )
n=0

n=0
M

1
M −1
n=0

n−1
M −k
)
k=0 (1 − q
n
(1 − q k )
k=1

=

n−1
k=0

=

(1 − x q n )

n−1
k=0

n=0

xn q n (n−1)/2

(1 − q M −k )

(1 − q q k )

n−1
k=0

(1 − x q k )

(16.4-3a)
xn q n (n−1)

(16.4-3b)

These relations are respectively the special cases (a, b) = (−1, 0) and (a, b) = (0, 1) of an identity due to
Jacobi [194, p.795]:
M −1

n=0

(1 − a x q n )
(1 − b x q n )

M

=
n=0

n−1
n−1
M −k
) k=0 (b q k − a)
k=0 (1 − q
n
n−1
k
k
k=1 (1 − q )
k=0 (1 − b x q )

xn q n (n−1)/2

(16.4-4)

In the limit M → ∞ the first product in the numerator on the right is 1, setting a = −1 and b = 0 gives
16.4-2a, setting a = 0 and b = 1 gives 16.4-2b. The following identity (given in [99, p.70, rel.1.3] and [15,
p.19, rel.2.2.7]) is due to Cauchy, setting a = −1 and b = 0 gives 16.4-2a:
∞

∞

(1 − a x q n )
(1 − b x q n )
n=0

=
n=0

n−1
k
k=0 (b − a q )
n
k
k=1 (1 − q )

xn

(16.4-5)

We will use two functions (eta functions, or η-functions) defined as
∞

η(x)

(1 − xn )

(16.4-6a)

(1 + xn )

:=

(16.4-6b)

n=1
∞

η + (x)

:=
n=1

16.4: The number of integer partitions
n : Pn
1:
1
2:
2
3:
3
4:
5
5:
7
6: 11
7: 15
8: 22
9: 30
10: 42

n:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

345

Pn
56
77
101
135
176
231
297
385
490
627

n:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

Pn
792
1002
1255
1575
1958
2436
3010
3718
4565
5604

n:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:

Pn
6842
8349
10143
12310
14883
17977
21637
26015
31185
37338

n:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

Pn
44583
53174
63261
75175
89134
105558
124754
147273
173525
204226

Figure 16.4-A: The number Pn of integer partitions of n for n ≤ 50.
n:

P(n)

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

1
2
3
5
7
11
15
22
30
42
56
77
101
135
176
231

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

2
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8

P(n,m) for m =
3
4
5
6
1
1
2
3
4
5
7
8
10
12
14
16
19
21

1
1
2
3
5
6
9
11
15
18
23
27
34

1
1
2
3
5
7
10
13
18
23
30
37

1
1
2
3
5
7
11
14
20
26
35

7

8

9

10

11

12

13

14

15

16

1
1
2
3
5
7
11
15
21
28

1
1
2
3
5
7
11
15
22

1
1
2
3
5
7
11
15

1
1
2
3
5
7
11

1
1
2
3
5
7

1
1
2
3
5

1
1
2
3

1
1
2

1
1

1

Figure 16.4-B: Numbers P (n, m) of partitions of n into m parts.

16.4.1

Unrestricted partitions and partitions into m parts

The number of integer partitions of n is sequence A000041 in [312], the values for 1 ≤ x ≤ 50 are shown
in ﬁgure 16.4-A. If we denote the number of partitions of n into exactly m parts by P (n, m), then
P (n, m)

=

P (n − 1, m − 1) + P (n − m, m)

(16.4-7)

n

where we set P (0, 0) = 1. We obviously have Pn = m=1 P (n, m). Figure 16.4-B shows P (n, m) for
n ≤ 16. It was created with the program [FXT: comb/num-partitions-demo.cc]. The number of partitions
into m parts equals the number of partitions with maximal part equal to m. This can easily be seen by
drawing a Ferrers diagram (or Young diagram) and its transpose as follows, for the partition 5 + 2 + 2 + 1
of 10:
43111
5221
5 xxxxx
4 xxxx
2 xx
3 xxx
2 xx
1 x
1 x
1 x
1 x
Any partition with maximal part m (here 5) corresponds to a partition into exactly m parts. The
generating function for the partitions into exactly m parts is
∞

P (n, m) xn
n=1

=

m
k=1

xm
(1 − xk )

For example, the row for m = 3 in ﬁgure 16.4-B corresponds to the power series
? m=3; (x^m/prod(k=1,m,1-x^k)+O(x^17))
x^3 + x^4 + 2*x^5 + 3*x^6 + 4*x^7 + 5*x^8 + 7*x^9 + 8*x^10 +
10*x^11 + 12*x^12 + 14*x^13 + 16*x^14 + 19*x^15 + 21*x^16 + O(x^17)

(16.4-8)

346


We have
∞

1
∞
(1 − u xn )
n=1

∞

P (n, m) xn um

=

(16.4-9)

n=1 m=1

The rows of figure 16.4-B correspond to a fixed power of x:
? 1/prod(n=1,N,1-u*x^n)
1 + u*x + (u^2 + u)*x^2 + (u^3 + u^2 + u)*x^3 + (u^4 + u^3 + 2*u^2 + u)*x^4
+ (u^5 + u^4 + 2*u^3 + 2*u^2 + u)*x^5 + (u^6 + u^5 + 2*u^4 + 3*u^3 + 3*u^2 + u)*x^6 + ...

The generating function for the number Pn of integer partitions of n is found by setting u = 1:
∞

Pn x n

=

∞
n=1

n=0

1
1
=
η(x)
(1 − xn )

(16.4-10)

The partitions are found in the expansion of
∞
k=1

1
(1 − tk xk )

(16.4-11)

? N=5; z=’x+O(’x^(N+1)); 1/prod(k=1,N,1-eval(Str("t"k))*z^k)
1 + t1*x + (t1^2 + t2)*x^2 + (t1^3 + t2*t1 + t3)*x^3
+ (t1^4 + t2*t1^2 + t3*t1 + t2^2 + t4)*x^4
+ (t1^5 + t2*t1^3 + t3*t1^2 + (t2^2 + t4)*t1 + t3*t2 + t5)*x^5

Summing over m in relation 16.4-8 we find that
∞

1
η(x)

xn
n
k
k=1 (1 − x )

=
n=0

(16.4-12)

This relation also is the special case an = xn (and N → ∞) of 16.4-1b on page 344. We also have (setting
x = q in 16.4-2b)
1
η(x)

∞

xn

=
n=0

n
k=1

[

2

(16.4-13)

2

(1 − xk ) ]

The expression can also be found by observing that a partition can be decomposed into a square and two
partitions whose maximal part does not exceed the length of the side of the square [176, sect.19.7]:
5
2
2
1

43111
##xxx
##
xx
x

Let P (n, m, r) be the number of partitions of n into at most m parts with largest part r, then [17, ex.15,
p.575]
∞

∞
n

m

P (n, m, r) q x y
n,m,r=0

r

xn y n q n

=

n−1
k=0

n=0

(1 − x q k )

2

n−1
k=0

(1 − y q k )

(16.4-14)

Euler’s pentagonal number theorem is (see [41] and [16]):
∞

+∞

η(x)

(−1)n xn (3n−1)/2

=
n=−∞

=

(−1)n xn (3n−1)/2 (1 + xn )

= 1+

n=1
22

1 − x − x2 + x5 + x7 − x12 − x15 + x

(16.4-15a)

+ x26 − x35 − x40 + x51 + x57 ± . . . (16.4-15b)

The sequence of exponents is entry A001318 in [312], the generalized pentagonal numbers.


347

Further expressions for η are (set q := x and x := −x in relation 16.4-2a for the first equality)
∞

∞

∞

η(x)

n=0
2

(−1)n xn(n+1)/2
=
n
k
k=1 (1 − x )
n=0

=

∞

xn

=

2

1 − xk

n=0

x2n

2

+n

1 − 2 x2n+1

2n+1
k=1
∞

∞

(−x)n

=

2

n=0

k=n+1

(16.4-16a)

(1 − xk )
1 − x2k

(16.4-16b)

k=n+1

∞

Write η(x) = j=0 J(x2j+1 ) where J is defined by relation 38.1-2a on page 726. Then a divisionless
expression for 1/η is obtained via relation 38.1-11d on page 728:
1
η(x)

∞

∞

1 + x(2j+1) 2

=

k

∞

k+1

k

η + x2

=

k=0 j=0

(16.4-17)

k=0

The sequences of the numbers of partitions into an even/odd number of parts start respectively as
1, 0, 1, 1, 3, 3, 6, 7, 12, 14, 22, 27, 40, 49, 69, 86, 118, 146, 195, 242, ...
0, 1, 1, 2, 2, 4, 5, 8, 10, 16, 20, 29, 37, 52, 66, 90, 113, 151, 190, 248, ...
These are the entries A027193/A027187 in [312]. Their generating functions are found by respectively
setting an = x2n and an = x2n+1 in 16.4-1b (see relation 31.3-1c on page 604 for the definition of Θ4 ):
∞

n=0
∞

n=0

x2n
2n
k=1

(1 − xk )

x2n+1
2n+1
k=1

(1 − xk )

∞

=

1
2

1
1
+
η(x) η + (x)

=

2
1
1 + Θ4 (x)
·
(−x)n =
η(x) n=0
2 η(x)

=

1
2

1
1
−
η(x) η + (x)

=

2
−1
1 − Θ4 (x)
(−x)n =
·
η(x) n=1
2 η(x)

(16.4-18a)

∞

(16.4-18b)

Adding the leftmost sums gives yet another expression for 1/η:
1
η(x)

∞

=

x2n 1 − x2n+1 + x2n+1
2n+1
k=1

n=0

(16.4-19)

(1 − xk )

This relation can be generalized by adding the generating functions for partitions into parts r + j for
j = 0, 1, . . . , r − 1. For example, for r = 3 we have:
1
η(x)

∞

=

x3n 1 − x3n+1

1 − x3n+2 + x3n+1 1 − x3n+2 + x3n+2

n=0

3n+2
k=1

(1 − xk )

(16.4-20)

The Rogers-Ramanujan identities for the numbers of partitions into parts congruent to 1 or 4 (and 2 or
3, respectively) modulo 5 are [176, sec.19.13, p.290]:
∞

1
(1 − x5n+1 ) (1 − x5n+4 )
n=0

∞

=
n=0
∞

∞

1
(1 − x5n+2 ) (1 − x5n+3 )
n=0

=
n=0

2

xn
n
k
k=1 (1 − x )

(16.4-21a)

2

xn +n
n
k
k=1 (1 − x )

(16.4-21b)

Many identities of this kind are listed in [311] and [268], a generalization is given in [87]. The sequences
of coefficients are entries A003114 and A003106 in [312]:
1, 1, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 9, 10, 12, 14, 17, 19, 23, 26, 31, 35, 41, ...
1, 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 6, 6, 8, 9, 11, 12, 15, 16, 20, 22, 26, ...

348

n : Dn
1:
1
2:
1
3:
2
4:
2
5:
3
6:
4
7:
5
8:
6
9:
8
10: 10

n : Dn
11: 12
12: 15
13: 18
14: 22
15: 27
16: 32
17: 38
18: 46
19: 54
20: 64

n:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

Dn
76
89
104
122
142
165
192
222
256
296

n:
Dn
31: 340
32: 390
33: 448
34: 512
35: 585
36: 668
37: 760
38: 864
39: 982
40: 1113

n:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

Dn
1260
1426
1610
1816
2048
2304
2590
2910
3264
3658

Figure 16.4-C: The number Dn of integer partitions into distinct parts of n for n ≤ 50.

16.4.2

Partitions into distinct parts

The generating function for the number Dn of partitions of n into distinct parts is
∞

∞

D n xn

(1 + xn ) = η + (x)

=

n=0

(16.4-22)

n=1

The number of partitions into distinct parts equals the number of partitions into odd parts:
η + (x)

=

η(x2 )
=
η(x)

∞
k=1

1
(1 − x2k−1 )

(16.4-23)

The sequence of coeﬃcients Dn is entry A000009 in [312], see ﬁgure 16.4-C. The generating function for
D(n, m), the number of partitions of n into exactly m distinct parts, is (see [17, p.559])
∞

D(n, m) xn

xm (m+1)/2
m
k
k=1 (1 − x )

=

n=0

(16.4-24)

Summing over m (or setting q = x in 16.4-2a) gives
∞

η + (x)

xn (n+1)/2
(1 − xk )

=

(16.4-25)

n
k=1

n=0

Equivalently, the Ferrers diagram of a partition into m distinct parts can be decomposed into a triangle
of size m (m + 1)/2 and a partition into at most m elements:
#####xxxxx
#####
xxxxx
####xxxx
==
####
+ xxxx
###xxxx
###
xxxx
##x
##
x
#x
#
x
The connection between relations 16.4-24 and 16.4-13 can be seen by drawing a diagonal in the diagram
of an unrestricted partition:
#xxxxxxx
x#xxxxxx
xx#xxxxx
xx
x

#
x#
xx#
xx
x

==

+

xxxxxxx
xxxxxx
xxxxx

#

==

#

#

xxxxxxx
xxxxxx
xxxxx

+

+

xxxx
xx

So each unrestricted partition is decomposed into a diagonal (of, say, m elements) and two partitions into
either m or m − 1 distinct parts. The term corresponding to a diagonal of length m is
2

x

m

2

[D(n, m) + D(n, m − 1)]

xm

=
[

m
k=1

2

(1 − xk ) ]

(16.4-26)


349

See [265] for a survey about proving identities using Ferrers diagrams. We also have
∞

∞

(1 + u xn )

∞

D(n, m) xn um

=

n=1

(16.4-27)

n=1 m=1

? prod(n=1,N,1+u*x^n)
1 + u*x + u*x^2 + (u^2 + u)*x^3 + (u^2 + u)*x^4 + (2*u^2 + u)*x^5
+ (u^3 + 2*u^2 + u)*x^6 + (u^3 + 3*u^2 + u)*x^7 + (2*u^3 + 3*u^2 + u)*x^8
+ (3*u^3 + 4*u^2 + u)*x^9 + (u^4 + 4*u^3 + 4*u^2 + u)*x^10 + ...

The partitions into distinct parts can be computed as the expansion of
∞

1 + t k xk

(16.4-28)

k=1

? N=9; z=’x+O(’x^(N+1));
? prod(k=1,N,1+eval(Str("t"k))*z^k)
1 + t1*x + t2*x^2 + (t2*t1 + t3)*x^3 + (t3*t1 + t4)*x^4
+ (t4*t1 + t3*t2 + t5)*x^5 + ((t3*t2 + t5)*t1 + t4*t2 + t6)*x^6
+ ((t4*t2 + t6)*t1 + t5*t2 + t4*t3 + t7)*x^7
+ ((t5*t2 + t4*t3 + t7)*t1 + t6*t2 + t5*t3 + t8)*x^8
+ ((t6*t2 + t5*t3 + t8)*t1 + (t4*t3 + t7)*t2 + t6*t3 + t5*t4 + t9)*x^9

Let E(n, m) be the number of partitions of n into distinct parts with maximal part m, then
∞

m−1

E(n, m) xn

= xm

m=0

1 + xk

(16.4-29)

k=1

Summing over m (or setting an = xn and N → ∞ in relation 16.4-1a on page 344) gives:
∞

η + (x)

=

n−1

xn

1+

1 + xk

n=1

(16.4-30)

k=1

For the ﬁrst of the following equalities, set q := x2 in 16.4-2b, the second is given in [310, p.100]:
∞

η + (x)

=
n=0

2

x2n
2n
k=1

∞

−n

(1 − xk )

2

x2n

=

2n+1
k=1

n=0

∞

+n

(1 − xk )

=
n=0

n
k=1

xn
(1 − x2k )

(16.4-31)

Set x := −q in relation 16.4-2b to obtain an expression for 1/η + :
1
η + (x)

∞

=
n=0

2

(−x)n
n
2k
k=1 (1 − x )

(16.4-32)

The sequences of numbers of partitions into distinct even/odd parts start respectively as (see entries
A035457 and A000700 in [312])
1, 0, 1, 0, 1, 0, 2, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 8, 0, 10, 0, 12, 0, 15, ...
1, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 5, 5, 5, 6, 7, 8, 8, 9, 11, ...
The generating function for the partitions into distinct even parts is
∞

1 + x2n

= η + x2

= η + (−x) η + (+x) =

n=1

η x4
=
η (x2 )

∞
n=0

1
(1 − x4n+2 )

(16.4-33)

The last equality tells us that the function also enumerates the partitions into even parts that are not a
multiple of 4. Setting q := x2 and x := 1 in 16.4-2a gives
∞

∞

1 + x2n
n=1

=
n=0

2

xn +n
(1 − x2k )

n
k=1

(16.4-34)

350


The generating function for partitions into distinct odd parts is
2

∞

1 + x2n+1

η x2
η + (x)
1
η(−x)
=
=
=
2)
2)
η + (x
η + (−x)
η(x
η (x) η (x4 )

=

n=0

(16.4-35)

Also (for the ﬁrst equality set q := x2 in relation 16.4-2a):
∞

∞

1 + x2n+1
n=0

∞

2

xn
=
n
2k
k=1 (1 − x )

=
n=0

n
k=1

n=0

xn
(1 − (−x)k )

(16.4-36)

The number of partitions where each part is repeated at most r − 1 times has the generating function
∞

1 + xn + x2n + x3n + . . . + x(r−1) n

η(xr )
=
η(x)

=

n=1

1
k=0 mod r

(1 − xk )

(16.4-37)

The second equality tells us that the number of such partitions equals the number of partitions into parts
not divisible by r, equivalently, partitions into m parts where m is not divisible by r.
Replacing x by xr and q by xm in relation 16.4-2b gives an identity for the partitions into parts ≡ r mod m
(valid for 0 < r < m, for r = 0 replace x by xm in 16.4-13):
∞
n=0

1
(1 − xm n+r )

∞

xm n

=

n−1
k=0

n=0

2

+(r−m) n

(1 − xm k+m )

n−1
k=0

(1 − xm k+r )

(16.4-38)

The same replacements (where 0 ≤ r < m) in relation 16.4-2a give an identity for the partitions into
distinct parts ≡ r mod m:
∞

∞
m n+r

1+x

=

x[m n

+(2r−m) n]/2

n
k=0

n=0

n=0

2

(16.4-39)

(1 − xm k )

A generating function for the partitions into distinct parts that diﬀer by at least d is
∞

n=0

xT (d,n)
(1 − xk )

n
k=1

where

T (d, n) := d

n (n + 1)
− (d − 1) n
2

(16.4-40)

See sequences A003114 (d = 2), A025157 (d = 3), A025158 (d = 4), A025159 (d = 5), A025160 (d = 6),
A025161 (d = 7), and A025162 (d = 8) in [312]. The relation follows from cutting out a (incomplete)
stretched triangle in the Ferrers diagram (here for d = 2):
dist. >= d=2
x^(d*(n*(n+1))/2 - (d-1)*n) * 1/prod(...)
xxxxxxxxxxxxx
#########xxxx
W#########
W
xxxx
xxxxxxxxx
==
#######xx
==
W#######
W
+
xx
xxxxxx
#####x
W#####
W
x
xxx
###
W###
W
x
#
W#
W
The sequences of numbers of partitions into an even/odd number of distinct parts are entries A067661
and A067659 in [312], respectively:
1, 0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 9, 11, 13, 16, 19, 23, 27, 32, 38, 45, ...
0, 1, 1, 1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 9, 11, 14, 16, 19, 23, 27, 32, 38, 44, ...
The corresponding generating functions are
∞

η + (x) + η(x)
2

=

η + (x) − η(x)
2

=

n=0
∞

n=0

x2n
2n
k=1

x2n

2

+n

(16.4-41a)

(1 − xk )
2

2n+1
k=1

∞

+3n+1

(1 − xk )

=

x2n+1
1 − x2n+1
n=0

x2n
2n
k=1

2

+n

(1 − xk )

(16.4-41b)

Adding relations 16.4-41a and 16.4-41b gives the second equality in 16.4-31, subtraction gives the second
equality in 16.4-16a.


16.4.3

351

Partitions into square-free parts ‡

We give relations for the ordinary generating functions for partitions into square-free parts. The M¨bius
o
function µ is deﬁned in section 37.1.2 on page 705. The sequence of power series coeﬃcients is given at
the end of each relation.
Partitions into square-free parts (entry A073576 in [312]):
∞

∞

1
1 − µ(n)2 xn
n=1

η xn

=

−µ(n)

2

(16.4-42)

n=1

1, 1, 2, 3, 4, 6, 9, 12, 16, 21, 28, 36, 47, 60, 76, 96, 120, 150, ...
Partitions into parts that are not square-free, note the start index on the right side product, (entry
A114374):
∞

∞

1
1 − (1 − µ(n)2 ) xn
n=1

η xn

=

+µ(n)

2

(16.4-43)

n=2

1, 0, 0, 0, 1, 0, 0, 0, 2, 1, 0, 0, 3, 1, 0, 0, 5, 2, 2, 0, 7, 3, 2, 0,
11, 6, 4, 3, 15, 8, 6, 3, 22, 13, 11, 6, 34, 18, 15, 9, 46, 27, 24, 17, ...
Partitions into distinct square-free parts (entry A087188):
∞

∞

1 + µ(n)2 xn

η + xn

=

n=1

+µ(n)

2

(16.4-44)

n=1

1, 1, 1, 2, 1, 2, 3, 3, 4, 4, 5, 6, 6, 8, 9, 10, 13, 14, 16, 18, 20, ...
Partitions into odd square-free parts, also partitions into parts m such that 2m is square-free (entry
A134345):
∞

1
1 − µ(2n − 1)2 x2n−1
n=1

−µ(2n−1)
2
∞
η x(2n−1)


η x2 (2n−1)2
n=1

∞

=

1
=
1 − µ(2n)2 xn
n=1
∞
2

η + x(2n−1)

=

(16.4-45a)

+µ(2n−1)

(16.4-45b)

n=1

1, 1, 1, 2, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 19, 23, 27, 32, 38, 44, ...
Partitions into distinct odd square-free parts, also partitions into distinct parts m such that 2m is squarefree (entry A134337):
∞

∞

1 + µ(2n − 1)2 x2n−1

1 + µ(2n)2 xn

=

n=1

=

η + x(2n−1)

η + x2 (2n−1)2

n=1

n=1

2




∞

+µ(2n−1)


(16.4-46)

1, 1, 0, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 3, 4, 3, 4, 5, 5, 6, 6, 7, ...
Partitions into square-free parts m ≡ 0 mod p where p is prime:
1
1 − µ(p n)2 xn
n=1

2

=
n=1 r=1



η x(p n−r)



∞ p−1

∞

η xp (p n−r)2

−µ(p n−r)


(16.4-47)

352


For example, partitions into square-free parts m ≡ 0 mod 3:
∞

1
1 − µ(3 n)2 xn
n=1

∞

1
=
1 − µ(n)2 xn

=
n=1, n≡0 mod 3

−µ(3 n−1) 

2



=

η x(3 n−1)



∞

η x3 (3 n−1)2

n=1

(16.4-48a)





2

η x(3 n−2)

η x3 (3 n−2)2

−µ(3 n−2)
(16.4-48b)



1, 1, 2, 2, 3, 4, 5, 7, 8, 10, 13, 16, 20, 24, 30, 36, 43, 52, 61, 73, 86, ...
Partitions into distinct square-free parts m ≡ 0 mod p where p is prime:

1 + µ(p n)2 xn

2

=

n=1

n=1 r=1



η + x(p n−r)



∞ p−1

∞

η + xp (p n−r)2

+µ(p n−r)
(16.4-49)



For example, partitions into distinct square-free parts m ≡ 0 mod 3:
∞

∞

1 + µ(3 n)2 xn

1 + µ(n)2 xn

=

n=1

=

(16.4-50a)

n=1, n≡0 mod 3
2

=
n=1



η + x(3 n−1)



∞

η + x3 (3 n−1)2

+µ(3 n−1) 




η + x(3 n−2)

2

η + x3 (3 n−2)2

+µ(3 n−2)


(16.4-50b)

1, 1, 1, 1, 0, 1, 1, 2, 2, 1, 2, 2, 3, 4, 4, 4, 4, 5, 6, 7, 7, 7, 8, 9, 12, 12, ...

16.4.4

Relations involving sums of divisors ‡

The logarithmic generating function (LGF) for objects counted by the sequence cn has the following form:
∞

cn xn
n
n=1

(16.4-51)

The LGF for σ(n), the sum of divisors of n, is connected to the ordinary generating function for the
partitions as follows (compare with relation 37.2-15a on page 712):
∞

σ(n) xn
n
n=1

=

log (1/η(x))

(16.4-52)

We generate the sequence of the σ(n), entry A000203 in [312], using GP:
? N=25; L=ceil(sqrt(N))+1; x=’x+O(’x^N);
? s=log(1/eta(x))
x + 3/2*x^2 + 4/3*x^3 + 7/4*x^4 + 6/5*x^5 + ...
? v=Vec(s); vector(#v,j,v[j]*j)
[1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, 42, 32, 36, 24, 60]

Write o(n) for the sum of odd divisors of n (entry A000593). The LGF is related to the partitions into
distinct parts:
∞

o(n) xn
n
n=1

=

log η + (x)

? s=log(eta(x^2)/eta(x))
x + 1/2*x^2 + 4/3*x^3 + 1/4*x^4 + 6/5*x^5 + ...
? v=Vec(s); vector(#v,j,v[j]*j)
[1, 1, 4, 1, 6, 4, 8, 1, 13, 6, 12, 4, 14, 8, 24, 1, 18, 13, 20, 6, 32, 12, 24, 4]

(16.4-53)


353

Let s(n) be the sum of square-free divisors of n. The LGF for the sums s(n) is the logarithm of the
generating function for the partitions into square-free parts:
∞

s(n) xn
n
n=1

∞

=

η xn

log

2

−µ(n)

(16.4-54)

n=1

The sequence of the s(n) is entry A048250 in [312]:
? s=log(prod(n=1,L,eta(x^(n^2))^(-moebius(n))))
x + 3/2*x^2 + 4/3*x^3 + 3/4*x^4 + 6/5*x^5 + ...
? v=Vec(s);vector(#v,j,v[j]*j)
[1, 3, 4, 3, 6, 12, 8, 3, 4, 18, 12, 12, 14, 24, 24, 3, 18, 12, 20, 18, 32, 36, 24, 12]

A divisor d of n is called a unitary divisor if gcd(d, n/d) = 1. We have the following identity, note the
exponent −µ(n)/n on the right side:
∞

∞

u(n) xn
n
n=1

=

η xn

log

−µ(n)/n

2

(16.4-55)

n=1

The sequence of the u(n) is entry A034448:
? s=(log(prod(n=1,L,eta(x^(n^2))^(-moebius(n)/n))))
x + 3/2*x^2 + 4/3*x^3 + 5/4*x^4 + 6/5*x^5 + ...
? v=Vec(s);vector(#v,j,v[j]*j)
[1, 3, 4, 5, 6, 12, 8, 9, 10, 18, 12, 20, 14, 24, 24, 17, 18, 30, 20, 30, 32, 36, 24, 36]

The sums u(n) of the divisors of n that are not unitary have a LGF connected to the partitions into
distinct square-free parts:
∞

∞

u(n) xn
n
n=1

=

η xn

log

+µ(n)/n

2

(16.4-56)

n=1

The sequence of the sums u(n) is entry A048146:
? s=log(prod(n=2,L,eta(x^(n^2))^(+moebius(n)/n)))
1/2*x^4 + 3/4*x^8 + 1/3*x^9 + 2/3*x^12 + 7/8*x^16 + ...
? v=Vec(s+’x); v[1]=0; let vector start with 3 zeros
? vector(#v,j,v[j]*j)
[0, 0, 0, 2, 0, 0, 0, 6, 3, 0, 0, 8, 0, 0, 0, 14, 0, 9, 0, 12, 0, 0, 0, 24, 5, 0, 12]

For the sums s(n) of the divisors of n that are not square-free we have the LGF
∞

s(n) xn
n
n=1

∞

=

2

η xn

log

+µ(n)

(16.4-57)

n=1

The sequence of the sums s(n) is entry A162296:
? s=log(prod(n=2,L,eta(x^(n^2))^(+moebius(n))))
x^4 + 3/2*x^8 + x^9 + 4/3*x^12 + 7/4*x^16 + ...
? v=Vec(s+’x); v[1]=0; let vector start with 3 zeros
? vector(#v,j,v[j]*j)
[0, 0, 0, 4, 0, 0, 0, 12, 9, 0, 0, 16, 0, 0, 0, 28, 0, 27, 0, 24, 0, 0, 0, 48, 25, 0, 36]

354

Chapter 17: Set partitions

Chapter 17

Set partitions
For a set of n elements, say Sn := {1, 2, . . . , n}, a set partition is a set P = {s1 , s2 , . . . , sk } of nonempty
subsets si of Sn whose intersection is empty and whose union equals Sn .
For example, there are 5 set partitions of the set S3 = {1, 2, 3}:
1:
2:
3:
4:
5:

{
{
{
{
{

{1, 2, 3} }
{1, 2}, {3} }
{1, 3}, {2} }
{1}, {2, 3} }
{1}, {2}, {3} }

The following sets are not set partitions of S3 :
{ {1, 2, 3}, {1} }
{ {1}, {3} }

// intersection not empty
// union does not contain 2

As the order of elements in a set does not matter we sort them in ascending order. For a set of sets we
order the sets in ascending order of the first elements. The number of set partitions of the n-set is the
Bell number Bn , see section 17.2 on page 358.

17.1


We write Zn for the list of all set partitions of the n-element set Sn . To generate Zn we observe that with
a complete list Zn−1 of partitions of the set Sn−1 we can generate the elements of Zn in the following
way: For each element (set partition) P ∈ Zn−1 , create set partitions of Sn by appending the element n
to the first, second, . . . , last subset, and one more by appending the set {n} as the last subset.
For example, the partition {{1, 2}, {3, 4}} ∈ Z4 leads to 3 partitions of S5 :
P = { {1, 2}, {3, 4} }
--> { {1, 2, 5}, {3, 4} }
--> { {1, 2}, {3, 4, 5} }
--> { {1, 2}, {3, 4}, {5} }

Now we start with the only partition {{1}} of the 1-element set and apply the described step n − 1 times.
The construction (given in [261, p.89]) is shown in the left column of figure 17.1-A, the right column
shows all set partitions for n = 5.
A modified version of the recursive construction generates the set partitions in a minimal-change order.
We can generate the ‘incremented’ partitions in two ways, forward (left to right)
P = { {1, 2}, {3, 4} }
--> { {1, 2, 5}, {3, 4} }
--> { {1, 2}, {3, 4, 5} }
--> { {1, 2}, {3, 4}, {5} }

or backward (right to left)
P = { {1, 2}, {3, 4} }
--> { {1, 2}, {3, 4}, {5} }
--> { {1, 2}, {3, 4, 5} }
--> { {1, 2, 5}, {3, 4} }

17.1: Recursive generation

355

-----------------p1={1}
--> p={1, 2}
--> p={1}, {2}
-----------------p1={1, 2}
--> p={1, 2, 3}
--> p={1, 2}, {3}
p1={1}, {2}
--> p={1, 3}, {2}
--> p={1}, {2, 3}
--> p={1}, {2}, {3}
-----------------p1={1, 2, 3}
--> p={1, 2, 3, 4}
--> p={1, 2, 3}, {4}
p1={1, 2}, {3}
--> p={1, 2, 4}, {3}
--> p={1, 2}, {3, 4}
--> p={1, 2}, {3}, {4}
p1={1, 3}, {2}
--> p={1, 3, 4}, {2}
--> p={1, 3}, {2, 4}
--> p={1, 3}, {2}, {4}
p1={1}, {2, 3}
--> p={1, 4}, {2, 3}
--> p={1}, {2, 3, 4}
--> p={1}, {2, 3}, {4}
p1={1}, {2}, {3}
--> p={1, 4}, {2}, {3}
--> p={1}, {2, 4}, {3}
--> p={1}, {2}, {3, 4}
--> p={1}, {2}, {3}, {4}
------------------

setpart(4) ==
1:
{1, 2, 3, 4}
2:
{1, 2, 3}, {4}
3:
{1, 2, 4}, {3}
4:
{1, 2}, {3, 4}
5:
{1, 2}, {3}, {4}
6:
{1, 3, 4}, {2}
7:
{1, 3}, {2, 4}
8:
{1, 3}, {2}, {4}
9:
{1, 4}, {2, 3}
10:
{1}, {2, 3, 4}
11:
{1}, {2, 3}, {4}
12:
{1, 4}, {2}, {3}
13:
{1}, {2, 4}, {3}
14:
{1}, {2}, {3, 4}
15:
{1}, {2}, {3}, {4}

Figure 17.1-A: Recursive construction of the set partitions of the 4-element set S4 = {1, 2, 3, 4} (left)
and the resulting list of all set partitions of 4 elements (right).
-----------------P={1}
--> {1, 2}
--> {1}, {2}

-----------------P={1, 2, 3}
--> {1, 2, 3, 4}
--> {1, 2, 3}, {4}
P={1,
-->
-->
-->

-----------------P={1, 2}
--> {1, 2, 3}
--> {1, 2}, {3}
P={1}, {2}
-->{1}, {2}, {3}
-->{1}, {2, 3}
-->{1, 3}, {2}

2},
{1,
{1,
{1,

{3}
2}, {3}, {4}
2}, {3, 4}
2, 4}, {3}

P={1}, {2}, {3}
--> {1, 4}, {2}, {3}
--> {1}, {2, 4}, {3}
--> {1}, {2}, {3, 4}
--> {1}, {2}, {3}, {4}

setpart(4)==
{1, 2, 3, 4}
{1, 2, 3}, {4}
{1, 2}, {3}, {4}
{1, 2}, {3, 4}
{1, 2, 4}, {3}
{1, 4}, {2}, {3}
{1}, {2, 4}, {3}
{1}, {2}, {3, 4}
{1}, {2}, {3}, {4}
{1}, {2, 3}, {4}
{1}, {2, 3, 4}
{1, 4}, {2, 3}
{1, 3, 4}, {2}
{1, 3}, {2, 4}
{1, 3}, {2}, {4}

P={1}, {2, 3}
--> {1}, {2, 3}, {4}
--> {1}, {2, 3, 4}
--> {1, 4}, {2, 3}
P={1,
-->
-->
-->

3},
{1,
{1,
{1,

{2}
3, 4}, {2}
3}, {2, 4}
3}, {2}, {4}

Figure 17.1-B: Construction of a Gray code for set partitions as an interleaving process.

356

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

{1, 2, 3, 4}
{1, 2, 3}, {4}
{1, 2}, {3}, {4}
{1, 2}, {3, 4}
{1, 2, 4}, {3}
{1, 4}, {2}, {3}
{1}, {2, 4}, {3}
{1}, {2}, {3, 4}
{1}, {2}, {3}, {4}
{1}, {2, 3}, {4}
{1}, {2, 3, 4}
{1, 4}, {2, 3}
{1, 3, 4}, {2}
{1, 3}, {2, 4}
{1, 3}, {2}, {4}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

{1}, {2}, {3}, {4}
{1}, {2}, {3, 4}
{1}, {2, 4}, {3}
{1, 4}, {2}, {3}
{1, 4}, {2, 3}
{1}, {2, 3, 4}
{1}, {2, 3}, {4}
{1, 3}, {2}, {4}
{1, 3}, {2, 4}
{1, 3, 4}, {2}
{1, 2, 3, 4}
{1, 2, 3}, {4}
{1, 2}, {3}, {4}
{1, 2}, {3, 4}
{1, 2, 4}, {3}

Figure 17.1-C: Set partitions of S4 = {1, 2, 3, 4} in two different minimal-change orders.
The resulting process of interleaving elements is shown in figure 17.1-B. The method is similar to Trotter’s
construction for permutations, see figure 10.7-B on page 253. If we change the direction with every subset
that is to be incremented, we get the minimal-change order shown in figure 17.1-C for n = 4. The left
column is generated when starting with the forward direction in each step of the recursion, the right when
starting with the backward direction. The lists can be computed with [FXT: comb/setpart-demo.cc].
The C++ class [FXT: class setpart in comb/setpart.h] stores the list in an array of signed characters.
The stored value is negated if the element is the last in the subset. The work involved with the creation
n
of Zn is proportional to k=1 k Bk where Bk is the k-th Bell number.
The parameter xdr of the constructor determines the order in which the partitions are being created:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

class setpart
// Set partitions of the set {1,2,3,...,n}
// By default in minimal-change order
{
public:
ulong n_;
// Number of elements of set (set = {1,2,3,...,n})
int *p_;
// p[] contains set partitions of length 1,2,3,...,n
int **pp_; // pp[k] points to start of set partition k
int *ns_;
// ns[k] Number of Sets in set partition k
int *as_;
// element k attached At Set (0<=as[k]<=k) of set(k-1)
int *d_;
int *x_;
// current set partition (==pp[n])
bool xdr_; // whether to change direction in recursion (==> minimal-change order)
int dr0_;
// dr0: starting direction in each recursive step:
//
dr0=+1 ==> start with partition {{1,2,3,...,n}}
//
dr0=-1 ==> start with partition {{1},{2},{3},...,{n}}}
public:
setpart(ulong n, bool xdr=true, int dr0=+1)
{
n_ = n;
ulong np = (n_*(n_+1))/2; // == sum_{k=1}^{n}{k}
p_ = new int[np];
pp_ = new int *[n_+1];
pp_[0] = 0; // unused
pp_[1] = p_;
for (ulong k=2; k<=n_; ++k)

pp_[k] = pp_[k-1] + (k-1);

ns_ = new int[n_+1];
as_ = new int[n_+1];
d_ = new int[n_+1];
x_ = pp_[n_];
init(xdr, dr0);
}
bool next()

{ return next_rec(n_); }

17.1: Recursive generation
40
41
42
43
44
45
46
47
48
49
50
51
52
53

const int* data()

357

const

{ return x_; }

ulong print() const
// Print current set partition
// Return number of chars printed
{ return print_p(n_); }
ulong print_p(ulong k) const;
void print_internal() const; // print internal state
protected:
[--snip--]
};

// internal methods

The actual work is done by the methods next_rec() and cp_append() [FXT: comb/setpart.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

int
setpart::cp_append(const int *src, int *dst, ulong k, ulong a)
// Copy partition in src[0,...,k-2] to dst[0,...,k-1]
// append element k at subset a (a>=0)
// Return number of sets in created partition.
{
ulong ct = 0;
for (ulong j=0; j<k-1; ++j)
{
int e = src[j];
if ( e > 0 ) dst[j] = e;
else
{
if ( a==ct ) { dst[j]=-e; ++dst; dst[j]=-k; }
else dst[j] = e;
++ct;
}
}
if ( a>=ct ) { dst[k-1] = -k; ++ct; }
return ct;
}
int
setpart::next_rec(ulong k)
// Update partition in level k from partition in level k-1
// Return number of sets in created partition
{
if ( k<=1 ) return 0; // current is last

(k<=n)

int d = d_[k];
int as = as_[k] + d;
bool ovq = ( (d>0) ? (as>ns_[k-1]) : (as<0) );
if ( ovq ) // have to recurse
{
ulong ns1 = next_rec(k-1);
if ( 0==ns1 ) return 0;
d = ( xdr_ ? -d : dr0_ );
d_[k] = d;
as = ( (d>0) ? 0 : ns_[k-1] );
}
as_[k] = as;
ulong ns = cp_append(pp_[k-1], pp_[k], k, as);
ns_[k] = ns;
return ns;
}

The partitions are represented by an array of integers whose absolute value is ≤ n. A negative value
indicates that it is the last of the subset. The set partitions of S4 together with their ‘signed value’
representations are shown in ﬁgure 17.1-D. The array as[ ] contains a restricted growth string (RGS)
with the condition aj ≤ 1 + maxi<j (ai ). A diﬀerent sort of RGS is described in section 15.2 on page 325.
The copying is the performance bottleneck of the algorithm. Therefore only about 11 million partitions
are generated per second. An O(1) algorithm for the Gray code starting with all elements in one set is
given in [201].

358

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

as[
as[
as[
as[
as[
as[
as[
as[
as[
as[
as[
as[
as[
as[
as[

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
1
1
1
1
1
1
1
1
1
1

0
0
1
1
1
0
0
0
1
1
1
2
2
2
2

0
1
0
1
2
0
1
2
0
1
2
0
1
2
3

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

x[
x[
x[
x[
x[
x[
x[
x[
x[
x[
x[
x[
x[
x[
x[

+1
+1
+1
+1
+1
+1
+1
+1
+1
-1
-1
+1
-1
-1
-1

+2
+2
+2
-2
-2
+3
-3
-3
-4
+2
+2
-4
+2
-2
-2

+3
-3
-4
+3
-3
-4
+2
-2
+2
+3
-3
-2
-4
+3
-3

-4
-4
-3
-4
-4
-2
-4
-4
-3
-4
-4
-3
-3
-4
-4

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

{1, 2, 3, 4}
{1, 2, 3}, {4}
{1, 2, 4}, {3}
{1, 2}, {3, 4}
{1, 2}, {3}, {4}
{1, 3, 4}, {2}
{1, 3}, {2, 4}
{1, 3}, {2}, {4}
{1, 4}, {2, 3}
{1}, {2, 3, 4}
{1}, {2, 3}, {4}
{1, 4}, {2}, {3}
{1}, {2, 4}, {3}
{1}, {2}, {3, 4}
{1}, {2}, {3}, {4}

Figure 17.1-D: The partitions of the set S4 = {1, 2, 3, 4} together with the internal representations:
the ‘signed value’ array x[ ] and the ‘attachment’ array as[ ].

17.2

The number of set partitions: Stirling set numbers and
Bell numbers

n:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

B(n)
1
2
5
15
52
203
877
4140
21147
115975

k: 1
1
1
1
1
1
1
1
1
1
1

2
1
3
7
15
31
63
127
255
511

3

4

5

6

1
6
1
25
10
1
90
65
15
1
301
350
140
21
966 1701 1050
266
3025 7770 6951 2646
9330 34105 42525 22827

7

8

9

1
28
462
5880

1
36
750

1
45

10

1

Figure 17.2-A: Stirling numbers of the second kind (Stirling set numbers) and Bell numbers.
The numbers S(n, k) of partitions of the n-set into k subsets are called the Stirling numbers of the second
kind (or Stirling set numbers), see entry A008277 in [312]. They can be computed by the relation
S(n, k)

= k S(n − 1, k) + S(n − 1, k − 1)

(17.2-1)

which is obtained by counting the partitions in our recursive construction. In the triangular array shown
in ﬁgure 17.2-A each entry is the sum of its upper left neighbor plus k times its upper neighbor. The
ﬁgure was generated with the program [FXT: comb/stirling2-demo.cc].
The sum over all elements S(n, k) of row n gives the Bell number Bn , the number of set partitions of the
n-set. The sequence starts as 1, 2, 5, 15, 52, 203, 877, . . ., it is entry A000110 in [312]. The Bell numbers
can also be computed by the recursion
n

Bn+1

=
k=0

n
Bk
k

As GP code:
? N=11; v=vector(N); v[1]=1;
? for (n=2, N, v[n]=sum(k=1, n-1, binomial(n-2,k-1)*v[k])); v
[1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975]

Another way of computing the Bell numbers is given in section 3.5.3 on page 151.

(17.2-2)

17.2: The number of set partitions: Stirling set numbers and Bell numbers

17.2.1

359

Generating functions

The ordinary generating function for the Bell numbers can be given as
∞

∞

Bn xn
n=0

=
k=0

xk
k
j=1

(1 − j x)

= 1 + x + 2 x2 + 5 x3 + 15 x4 + 52 x5 + . . .

(17.2-3)

The exponential generating function (EGF) is
∞

exp [exp(x) − 1]

=

Bn
n=0

? sum(k=0,11,x^k/prod(j=1,k,1-j*x))+O(x^8)
1 + x + 2*x^2 + 5*x^3 + 15*x^4 + 52*x^5 +
? serlaplace(exp(exp(x)-1))
1 + x + 2*x^2 + 5*x^3 + 15*x^4 + 52*x^5 +

xn
n!

(17.2-4)

OGF
203*x^6 + 877*x^7 + O(x^8)
EGF
203*x^6 + 877*x^7 + 4140*x^8 + ...

Dobinski’s formula for the Bell numbers is [349, entry “Bell Number”]
Bn

=

∞

1
e

k=1

nk
k!

(17.2-5)

The array of Stirling numbers shown in figure 17.2-A can also be computed in polynomial form by setting
B0 (x) = 1 and
Bn+1 (x)

= x [Bn (x) + Bn (x)]

(17.2-6)

The coefficients of Bn (x) are the Stirling numbers and Bn (1) = Bn :
? B=1; for(k=1,6, B=x*(deriv(B)+B); print(subst(B,x,1),": ",B))
1: x
2: x^2 + x
5: x^3 + 3*x^2 + x
15: x^4 + 6*x^3 + 7*x^2 + x
52: x^5 + 10*x^4 + 25*x^3 + 15*x^2 + x
203: x^6 + 15*x^5 + 65*x^4 + 90*x^3 + 31*x^2 + x

The polynomials are called Bell polynomials, see [349, entry “Bell Polynomial”].

17.2.2

Set partitions of a given type

We say a set partition of the n-element set is of type C = [c1 , c2 , c3 , . . . , cn ] if it has c1 1-element sets,
c2 2-element sets, c3 3-element sets, and so on. Define
∞

L(z)

=
k=1

tk z k
k!

(17.2-7a)

then we have
∞

exp (L(z))

=

Zn,C
n=0

C

tck
k

zn
n!

(17.2-7b)

where Zn,C is the number of set partitions of the n-element set with type C.
? n=8;R=O(z^(n+1));
? L=sum(k=1,n,eval(Str("t"k))*z^k/k!)+R
t1*z + 1/2*t2*z^2 + 1/6*t3*z^3 + 1/24*t4*z^4 + [...] + 1/40320*t8*z^8 + O(z^9)
? serlaplace(exp(L))
1
+ t1 *z
+ (t1^2 + t2) *z^2
+ (t1^3 + 3*t2*t1 + t3) *z^3
+ (t1^4 + 6*t2*t1^2 + 4*t3*t1 + 3*t2^2 + t4) *z^4
+ (t1^5 + 10*t2*t1^3 + 10*t3*t1^2 + 15*t1*t2^2 + 5*t1*t4 + 10*t3*t2 + t5) *z^5
+ (t1^6 + 15*t2*t1^4 + 20*t3*t1^3 + [...] + 15*t2^3 + 15*t4*t2 + 10*t3^2 + t6) *z^6
+ (t1^7 + 21*t2*t1^5 + 35*t3*t1^4 + [...] + 105*t3*t2^2 + 21*t5*t2 + 35*t4*t3 + t7) *z^7
+ (t1^8 + 28*t2*t1^6 + 56*t3*t1^5 + [...] + 28*t6*t2 + 56*t5*t3 + 35*t4^2 + t8) *z^8
+ O(z^9)

360


Specializations give generating functions for set partitions with certain restrictions. For example, the
EGF for the partitions without sets of size one is (set t1 = 0 and tk = 1 for k = 1) exp (exp(z) − 1 − z),
see entry A000296 in [312]. Section 11.1.2 on page 278 gives a similar construction for the EGF for
permutations of prescribed cycle type.

17.3

Restricted growth strings

For some applications the restricted growth strings (RGS) may suffice. We give algorithms for their
generation and describe classes of generalized RGS that contain the RGS for set partitions as a special
case.

17.3.1

RGS for set partitions in lexicographic order

The C++ implementation [FXT: class setpart rgs lex in comb/setpart-rgs-lex.h] generates the RGS
for set partitions in lexicographic order:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11

class setpart_rgs_lex
// Set partitions of the n-set as restricted growth strings (RGS).
// Lexicographic order.
{
public:
ulong n_;
ulong *m_;
// m[k+1] = max(s[0], s[1],..., s[k]) + 1
ulong *s_;
// RGS
public:
setpart_rgs_lex(ulong n)
{
n_ = n;
m_ = new ulong[n_+1];
m_[0] = ~0UL;
// sentinel m[0] = infinity
s_ = new ulong[n_];
first();
}
[--snip--]
void first()
{
for (ulong k=0; k<n_; ++k) s_[k] = 0;
for (ulong k=1; k<=n_; ++k) m_[k] = 1;
}
void last()
{
for (ulong k=0; k<n_; ++k) s_[k] = k;
for (ulong k=1; k<=n_; ++k) m_[k] = k;
}

The method to compute the successor resembles the one used with mixed radix counting (see section 9.1
on page 217): find the first digit that can be incremented and increment it, then set all skipped digits to
zero and adjust the array of maxima accordingly.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

bool next()
{
if ( m_[n_] == n_ )

return false;

ulong k = n_;
do { --k; } while ( (s_[k] + 1) > m_[k] );
s_[k] += 1UL;
ulong mm = m_[k];
mm += (s_[k]>=mm);
m_[k+1] = mm; // == max2(m_[k], s_[k]+1)
while ( ++k<n_ )
{
s_[k] = 0;
m_[k+1] = mm;
}
return true;

17.3: Restricted growth strings
20
21

361

}

The method for the predecessor is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

bool prev()
{
if ( m_[n_] == 1 )

return false;

ulong k = n_;
do { --k; } while ( s_[k]==0 );
s_[k] -= 1;
ulong mm = m_[k+1] = max2(m_[k], s_[k]+1);
while ( ++k<n_ )
{
s_[k] = mm; // == m[k]
++mm;
m_[k+1] = mm;
}
return true;
}

The rate of generation is about 157 M/s with next() and 190 M/s with prev() [FXT: comb/setpartrgs-lex-demo.cc].

17.3.2

RGS for set partitions into p parts
array of minimal values for m[]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[
s[

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

.
1
1
1
1
1
.
.
.
.
.
1
1
1
1
1
2
2
2
2
2
2
2
2
2

1
.
1
2
2
2
.
1
2
2
2
.
1
2
2
2
.
.
.
1
1
1
2
2
2

2
2
2
.
1
2
2
2
.
1
2
2
2
.
1
2
.
1
2
.
1
2
.
1
2

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[
m[

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

1
1
1
1
1
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2

1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
3
3
3
3
3
3
3
3
3

2
2
2
3
3
3
2
2
3
3
3
2
2
3
3
3
3
3
3
3
3
3
3
3
3

3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3
3

is
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[ 1 1 1 2 3 ]
{1, 2, 3}, {4}, {5}
{1, 2, 4}, {3}, {5}
{1, 2}, {3, 4}, {5}
{1, 2, 5}, {3}, {4}
{1, 2}, {3, 5}, {4}
{1, 2}, {3}, {4, 5}
{1, 3, 4}, {2}, {5}
{1, 3}, {2, 4}, {5}
{1, 3, 5}, {2}, {4}
{1, 3}, {2, 5}, {4}
{1, 3}, {2}, {4, 5}
{1, 4}, {2, 3}, {5}
{1}, {2, 3, 4}, {5}
{1, 5}, {2, 3}, {4}
{1}, {2, 3, 5}, {4}
{1}, {2, 3}, {4, 5}
{1, 4, 5}, {2}, {3}
{1, 4}, {2, 5}, {3}
{1, 4}, {2}, {3, 5}
{1, 5}, {2, 4}, {3}
{1}, {2, 4, 5}, {3}
{1}, {2, 4}, {3, 5}
{1, 5}, {2}, {3, 4}
{1}, {2, 5}, {3, 4}
{1}, {2}, {3, 4, 5}

Figure 17.3-A: Restricted growth strings in lexicographic order (left, dots for zeros) and array of prefixmaxima (middle) for the set partitions of the 5-set into 3 parts (right).
Figure 17.3-A shows all set partitions of the 5-set into 3 parts, together with their RGSs. The list of
RGSs of the partitions of an n-set into p parts contains all length-n patterns with p letters. A pattern
is a word where the first occurrence of u precedes the first occurrence of v if u < v. That is, the list of
patterns is the list of words modulo permutations of the letters.
The restricted growth strings corresponding to set partitions into p parts can be generated with [FXT:
class setpart p rgs lex in comb/setpart-p-rgs-lex.h]:
1

class setpart_p_rgs_lex

362
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


{
public:
ulong
ulong
ulong
ulong

n_;
p_;
*m_;
*s_;

//
//
//
//

Number of elements of set (set = {1,2,3,...,n})
Exactly p subsets
m[k+1] = max(s[0], s[1],..., s[k]) + 1
RGS

public:
setpart_p_rgs_lex(ulong n, ulong p)
{
n_ = n;
m_[0] = ~0UL;
s_ = new ulong[n_];
first(p);
}
void first(ulong p)
// Must have 2<=p<=n
{
for (ulong k=0; k<n_; ++k) s_[k] = 0;
for (ulong k=n_-p+1, j=1; k<n_; ++k, ++j)
for (ulong k=1; k<=n_; ++k)
p_ = p;

s_[k] = j;

m_[k] = s_[k-1]+1;

}

The method to compute the successor also checks whether the digit is less than p and has an additional
loop to repair the rightmost digits when needed:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

bool next()
{
// if ( 1==p_ )

return false;

// make things work with p==1

ulong k = n_;
bool q;
do
{
--k;
const ulong sk1 = s_[k] + 1;
q = (sk1 > m_[k]);
// greater max
q |= (sk1 >= p_);
// more than p parts
}
while ( q );
if ( k == 0 )

return false;

s_[k] += 1UL;
ulong mm = m_[k];
mm += (s_[k]>=mm);
m_[k+1] = mm; // == max2(m_[k], s_[k]+1);
while ( ++k<n_ )
{
s_[k] = 0;
m_[k+1] = mm;
}
ulong p =
if ( mm<p
{
do {
while
}

p_;
) // repair tail
m_[k] = p; --k; --p; s_[k] = p; }
( m_[k] < p );

return true;
}

As given the computation will fail for p = 1, the line commented out removes this limitation. The rate
of generation is about 108 M/s [FXT: comb/setpart-p-rgs-lex-demo.cc].

17.3.3

363

RGS for set partitions in minimal-change order

For the Gray code we need an additional array of directions, see section 9.2 on page 220 for the equivalent
routines with mixed radix numbers. The implementation allows starting either with the partition into
one set or the partition into n sets [FXT: class setpart rgs gray in comb/setpart-rgs-gray.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class setpart_rgs_gray
{
public:
ulong n_;
ulong *m_;
// m[k+1] = max(s[0], s[1],..., s[k]) + 1
ulong *s_;
// RGS
ulong *d_;
public:
setpart_rgs_gray(ulong n, int dr0=+1)
// dr0=+1 ==> start with partition {{1,2,3,...,n}}
// dr0=-1 ==> start with partition {{1},{2},{3},...,{n}}}
{
n_ = n;
m_[0] = ~0UL;
s_ = new ulong[n_];
d_ = new ulong[n_];
first(dr0);
}
[--snip--]
void first(int dr0)
{
const ulong n = n_;
const ulong dd = (dr0 >= 0 ? +1UL : -1UL);
if ( dd==1 )
{
for (ulong k=0; k<n; ++k) s_[k] = 0;
for (ulong k=1; k<=n; ++k) m_[k] = 1;
}
else
{
for (ulong k=0; k<n; ++k) s_[k] = k;
for (ulong k=1; k<=n; ++k) m_[k] = k;
}

d_[k] = dd;

}

The method to compute the successor is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

bool next()
{
ulong k = n_;
do { --k; } while ( (s_[k] + d_[k]) > m_[k] );
if ( k == 0 )

// <0 or >max

return false;

s_[k] += d_[k];
m_[k+1] = max2(m_[k], s_[k]+1);
while ( ++k<n_ )
{
const ulong d = d_[k] = -d_[k];
const ulong mk = m_[k];
s_[k] = ( (d==1UL) ? 0 : mk );
m_[k+1] = mk + (d!=1UL); // == max2(mk, s_[k]+1)
}
return true;
}

The rate of generation is about 154 M/s [FXT: comb/setpart-rgs-gray-demo.cc]. It must be noted that
while the corresponding set partitions are in minimal-change order (see ﬁgure 17.1-C on page 356) the
RGS occasionally changes in more than one digit. A Gray code for the RGS for set partitions into p parts
where only one position changes with each update is described in [288].

364


17.3.4

Max-increment RGS ‡

The generation of RGSs s = [s0 , s1 , . . . , sn−1 ] where sk ≤ i + maxj<k (sj ) is a generalization of the RGSs
for set partitions (where i = 1). Figure 17.3-B show RGSs in lexicographic order for i = 2 (left) and
i = 1 (right). The strings can be generated in lexicographic order using [FXT: class rgs maxincr in
comb/rgs-maxincr.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class rgs_maxincr
{
public:
ulong *s_; // restricted growth string
ulong *m_; // m_[k-1] == max possible value for s_[k]
ulong n_;
ulong i_;
// s[k] <= max_{j<k}(s[j]+i)
// i==1 ==> RGS for set partitions
public:
rgs_maxincr(ulong n, ulong i=1)
{
n_ = n;
m_ = new ulong[n_];
s_ = new ulong[n_];
i_ = i;
first();
}
~rgs_maxincr()
{
delete [] m_;
delete [] s_;
}
void first()
{
ulong n = n_;
}
[--snip--]

s_[k] = 0;
m_[k] = i_;

The computation of the successor returns the index of ﬁrst (leftmost) changed element in the string. Zero
is returned if the current string is the last:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

ulong next()
{
ulong k = n_;
start:
--k;
if ( k==0 ) return 0;
ulong m1 = m_[k-1];
if ( sk > m1+i_ ) // "carry"
{
s_[k] = 0;
goto start;
}
s_[k] = sk;
if ( sk>m1 ) m1 = sk;
for (ulong j=k; j<n_; ++j )

m_[j] = m1;

return k;
}
[--snip--]

About 115 million RGSs per second are generated with the routine. Figure 17.3-B was created with
the program [FXT: comb/rgs-maxincr-demo.cc]. The sequence of numbers of max-increment RGSs with
increment i =1, 2, 3, and 4, start
n:
i=1:
i=2:
i=3:
i=4:

0
1
1
1
1

1
1
1
1
1

2
2
3
4
5

3
5
12
22
35

4
15
59
150
305

5
52
339
1200
3125

6
203
2210
10922
36479

7
877
16033
110844
475295

8
4140
127643
1236326
6811205

9
21147
1103372
14990380
106170245

10
115975
10269643
195895202
1784531879


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

RGS(4,2)
. . . . ]
. . . 1 ]
. . . 2 ]
. . 1 . ]
. . 1 1 ]
. . 1 2 ]
. . 1 3 ]
. . 2 . ]
. . 2 1 ]
. . 2 2 ]
. . 2 3 ]
. . 2 4 ]
. 1 . . ]
. 1 . 1 ]
. 1 . 2 ]
. 1 . 3 ]
. 1 1 . ]
. 1 1 1 ]
. 1 1 2 ]
. 1 1 3 ]
. 1 2 . ]
. 1 2 1 ]
. 1 2 2 ]
. 1 2 3 ]
. 1 2 4 ]
. 1 3 . ]
. 1 3 1 ]
. 1 3 2 ]
. 1 3 3 ]
. 1 3 4 ]
. 1 3 5 ]
. 2 . . ]
. 2 . 1 ]
. 2 . 2 ]
. 2 . 3 ]
. 2 . 4 ]
. 2 1 . ]
. 2 1 1 ]
. 2 1 2 ]
. 2 1 3 ]
. 2 1 4 ]
. 2 2 . ]
. 2 2 1 ]
. 2 2 2 ]
. 2 2 3 ]
. 2 2 4 ]
. 2 3 . ]
. 2 3 1 ]
. 2 3 2 ]
. 2 3 3 ]
. 2 3 4 ]
. 2 3 5 ]
. 2 4 . ]
. 2 4 1 ]
. 2 4 2 ]
. 2 4 3 ]
. 2 4 4 ]
. 2 4 5 ]
. 2 4 6 ]

365

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

max(4,2)
. . . . ]
. . . 1 ]
. . . 2 ]
. . 1 1 ]
. . 1 1 ]
. . 1 2 ]
. . 1 3 ]
. . 2 2 ]
. . 2 2 ]
. . 2 2 ]
. . 2 3 ]
. . 2 4 ]
. 1 1 1 ]
. 1 1 1 ]
. 1 1 2 ]
. 1 1 3 ]
. 1 1 1 ]
. 1 1 1 ]
. 1 1 2 ]
. 1 1 3 ]
. 1 2 2 ]
. 1 2 2 ]
. 1 2 2 ]
. 1 2 3 ]
. 1 2 4 ]
. 1 3 3 ]
. 1 3 3 ]
. 1 3 3 ]
. 1 3 3 ]
. 1 3 4 ]
. 1 3 5 ]
. 2 2 2 ]
. 2 2 2 ]
. 2 2 2 ]
. 2 2 3 ]
. 2 2 4 ]
. 2 2 2 ]
. 2 2 2 ]
. 2 2 2 ]
. 2 2 3 ]
. 2 2 4 ]
. 2 2 2 ]
. 2 2 2 ]
. 2 2 2 ]
. 2 2 3 ]
. 2 2 4 ]
. 2 3 3 ]
. 2 3 3 ]
. 2 3 3 ]
. 2 3 3 ]
. 2 3 4 ]
. 2 3 5 ]
. 2 4 4 ]
. 2 4 4 ]
. 2 4 4 ]
. 2 4 4 ]
. 2 4 4 ]
. 2 4 5 ]
. 2 4 6 ]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

RGS(5,1)
. . . . .
. . . . 1
. . . 1 .
. . . 1 1
. . . 1 2
. . 1 . .
. . 1 . 1
. . 1 . 2
. . 1 1 .
. . 1 1 1
. . 1 1 2
. . 1 2 .
. . 1 2 1
. . 1 2 2
. . 1 2 3
. 1 . . .
. 1 . . 1
. 1 . . 2
. 1 . 1 .
. 1 . 1 1
. 1 . 1 2
. 1 . 2 .
. 1 . 2 1
. 1 . 2 2
. 1 . 2 3
. 1 1 . .
. 1 1 . 1
. 1 1 . 2
. 1 1 1 .
. 1 1 1 1
. 1 1 1 2
. 1 1 2 .
. 1 1 2 1
. 1 1 2 2
. 1 1 2 3
. 1 2 . .
. 1 2 . 1
. 1 2 . 2
. 1 2 . 3
. 1 2 1 .
. 1 2 1 1
. 1 2 1 2
. 1 2 1 3
. 1 2 2 .
. 1 2 2 1
. 1 2 2 2
. 1 2 2 3
. 1 2 3 .
. 1 2 3 1
. 1 2 3 2
. 1 2 3 3
. 1 2 3 4

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

max(5,1)
. . . . .
. . . . 1
. . . 1 1
. . . 1 1
. . . 1 2
. . 1 1 1
. . 1 1 1
. . 1 1 2
. . 1 1 1
. . 1 1 1
. . 1 1 2
. . 1 2 2
. . 1 2 2
. . 1 2 2
. . 1 2 3
. 1 1 1 1
. 1 1 1 1
. 1 1 1 2
. 1 1 1 1
. 1 1 1 1
. 1 1 1 2
. 1 1 2 2
. 1 1 2 2
. 1 1 2 2
. 1 1 2 3
. 1 1 1 1
. 1 1 1 1
. 1 1 1 2
. 1 1 1 1
. 1 1 1 1
. 1 1 1 2
. 1 1 2 2
. 1 1 2 2
. 1 1 2 2
. 1 1 2 3
. 1 2 2 2
. 1 2 2 2
. 1 2 2 2
. 1 2 2 3
. 1 2 2 2
. 1 2 2 2
. 1 2 2 2
. 1 2 2 3
. 1 2 2 2
. 1 2 2 2
. 1 2 2 2
. 1 2 2 3
. 1 2 3 3
. 1 2 3 3
. 1 2 3 3
. 1 2 3 3
. 1 2 3 4

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

Figure 17.3-B: Length-4 max-increment RGS with i = 2 and the corresponding array of maxima (left)
and length-5 RGSs with i = 1 (right). Dots denote zeros.

366


The sequence for i = 2 is entry A080337 in [312], it has the exponential generating function (EGF)
∞

Bn+1,2
n=0

xn
n!

=

exp(2 x) 3
−
2
2

(17.3-1)

exp(2 x) exp(3 x) 11
+
−
2
3
6

(17.3-2)

exp x + exp(x) +

The sequence of numbers of increment-3 RGSs has the EGF
∞

Bn+1,3
n=0

xn
n!

=

exp x + exp(x) +

Omitting the empty set, we restate the EGF for the Bell numbers (relation 17.2-4 on page 359) as
∞

Bn+1,1
n=0

xn
n!

=

exp [x + exp(x) − 1] =

1
2
5
15 3 52 4
+ x + x2 +
x +
x + ...
0! 1!
2!
3!
4!

(17.3-3)

The EGF for the increment-i RGS is
∞

Bn+1,i
n=0

17.3.5

xn
n!


=

i

exp x +
j=1


exp(j x) − 1 
j

(17.3-4)

F-increment RGS ‡

For a different generalization of the RGS for set partitions, we rewrite the condition sk ≤ i + maxj<k (sj )
for the RGS considered in the previous section:
sk
M (k + 1)

≤ M (k) + i where M (0) = 0
sk+1 if sk+1 − sk > 0
=
M (k) otherwise

and

(17.3-5a)
(17.3-5b)

The function M (k) is maxj<k (sj ) in notational disguise. We define F-increment RGSs with respect to a
function F as follows:
sk
F (k + 1)

≤ F (k) + i where F (0) = 0
sk+1 if sk+1 − sk = i
=
F (k) otherwise

and

(17.3-6a)
(17.3-6b)

The function F (k) is a ‘maximum’ that is increased only if the last increment (sk − sk−1 ) was maximal.
For i = 1 we get the RGSs for set partitions. Figure 17.3-C shows all length-4 F-increment RGSs for
i = 2 (left) and all length-3 RGSs for i = 5 (right), together with the arrays of F-values. The listings were
created with the program [FXT: comb/rgs-fincr-demo.cc] which uses the implementation [FXT: class
rgs fincr in comb/rgs-fincr.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class rgs_fincr
{
public:
ulong *s_;
ulong *f_;
ulong n_;
ulong i_;
[--snip--]

//
//
//
//

restricted growth string
values F(k)
Length of strings
s[k] <= f[k]+i

ulong next()
{
ulong k = n_;
start:
--k;
if ( k==0 )

return 0;


1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

RGS(4,2)
. . . . ]
. . . 1 ]
. . . 2 ]
. . 1 . ]
. . 1 1 ]
. . 1 2 ]
. . 2 . ]
. . 2 1 ]
. . 2 2 ]
. . 2 3 ]
. . 2 4 ]
. 1 . . ]
. 1 . 1 ]
. 1 . 2 ]
. 1 1 . ]
. 1 1 1 ]
. 1 1 2 ]
. 1 2 . ]
. 1 2 1 ]
. 1 2 2 ]
. 1 2 3 ]
. 1 2 4 ]
. 2 . . ]
. 2 . 1 ]
. 2 . 2 ]
. 2 . 3 ]
. 2 . 4 ]
. 2 1 . ]
. 2 1 1 ]
. 2 1 2 ]
. 2 1 3 ]
. 2 1 4 ]
. 2 2 . ]
. 2 2 1 ]
. 2 2 2 ]
. 2 2 3 ]
. 2 2 4 ]
. 2 3 . ]
. 2 3 1 ]
. 2 3 2 ]
. 2 3 3 ]
. 2 3 4 ]
. 2 4 . ]
. 2 4 1 ]
. 2 4 2 ]
. 2 4 3 ]
. 2 4 4 ]
. 2 4 5 ]
. 2 4 6 ]

367

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

F(2)
. . .
. . .
. . .
. . .
. . .
. . .
. . 2
. . 2
. . 2
. . 2
. . 2
. . .
. . .
. . .
. . .
. . .
. . .
. . 2
. . 2
. . 2
. . 2
. . 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 2
. 2 4
. 2 4
. 2 4
. 2 4
. 2 4
. 2 4
. 2 4

.
.
2
.
.
2
2
2
2
2
4
.
.
2
.
.
2
2
2
2
2
4
2
2
2
2
4
2
2
2
2
4
2
2
2
2
4
2
2
2
2
4
4
4
4
4
4
4
6

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:

RGS(3,5)
[ . . . ]
[ . . 1 ]
[ . . 2 ]
[ . . 3 ]
[ . . 4 ]
[ . . 5 ]
[ . 1 . ]
[ . 1 1 ]
[ . 1 2 ]
[ . 1 3 ]
[ . 1 4 ]
[ . 1 5 ]
[ . 2 . ]
[ . 2 1 ]
[ . 2 2 ]
[ . 2 3 ]
[ . 2 4 ]
[ . 2 5 ]
[ . 3 . ]
[ . 3 1 ]
[ . 3 2 ]
[ . 3 3 ]
[ . 3 4 ]
[ . 3 5 ]
[ . 4 . ]
[ . 4 1 ]
[ . 4 2 ]
[ . 4 3 ]
[ . 4 4 ]
[ . 4 5 ]
[ . 5 . ]
[ . 5 1 ]
[ . 5 2 ]
[ . 5 3 ]
[ . 5 4 ]
[ . 5 5 ]
[ . 5 6 ]
[ . 5 7 ]
[ . 5 8 ]
[ . 5 9 ]
[ . 5 10 ]

[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[

F(5)
. . . ]
. . . ]
. . . ]
. . . ]
. . . ]
. . 5 ]
. . . ]
. . . ]
. . . ]
. . . ]
. . . ]
. . 5 ]
. . . ]
. . . ]
. . . ]
. . . ]
. . . ]
. . 5 ]
. . . ]
. . . ]
. . . ]
. . . ]
. . . ]
. . 5 ]
. . . ]
. . . ]
. . . ]
. . . ]
. . . ]
. . 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 5 ]
. 5 10 ]

Figure 17.3-C: Length-4 F-increment restricted growth strings with maximal increment 2 and the
corresponding array of values of F (left) and length-3 RGSs with maximal increment 5 (right). Dots
denote zeros.

368
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


ulong m1 = f_[k-1];
ulong mp = m1 + i_;
{
s_[k] = 0;
goto start;
}
s_[k] = sk;
if ( sk==mp ) m1 += i_;
for (ulong j=k; j<n_; ++j )

f_[j] = m1;

return k;
}
[--snip--]

The sequences of numbers of F-increment RGSs with increments i =1, 2, 3, and 4, start
n:
i=1:
i=2:
i=3:
i=4:
i=5:

0
1
1
1
1
1

1
2
3
4
5
6

2
5
11
19
29
41

3
15
49
109
201
331

4
52
257
742
1657
3176

5
203
1539
5815
15821
35451

6
877
10299
51193
170389
447981

7
4140
75905
498118
2032785
6282416

8
9
21147
115975
609441
5284451
5296321
60987817
26546673 376085653
96546231 1611270851

These are respectively entries A000110 (Bell numbers), A004211, A004212, A004213, and A005011 in
[312]. The shown array appears in [203]. In general, the number Fn,i of F-increment RGSs (length n,
with increment i) is
n

Fn,i

in−k S(n, k)

=

(17.3-7)

k=0

where S(n, k) are the Stirling numbers of the second kind. The exponential generating functions are
∞

Fn,i
n=0

xn
n!

=

exp

exp(i x) − 1
i

(17.3-8)

The ordinary generating functions are
∞

∞

Fn,i xn

=

n=0

17.3.6
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

n=0

n
k=1

xn
(1 − i k x)

(17.3-9)

K-increment RGS ‡
[
[
[
[
[
[
[
[
[
[

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
1
1
1
1
1
2

.
1
2
3
.
1
2
3
4
.

]
]
]
]
]
]
]
]
]
]

11:
12:
13:
14:
15:
16:
17:
18:
19:

[
[
[
[
[
[
[
[
[

.
.
.
.
.
.
.
.
.

.
.
.
.
.
1
1
1
1

2
2
2
2
2
.
.
.
.

1
2
3
4
5
.
1
2
3

]
]
]
]
]
]
]
]
]

20:
21:
22:
23:
24:
25:
26:
27:
28:

[
[
[
[
[
[
[
[
[

.
.
.
.
.
.
.
.
.

1
1
1
1
1
1
1
1
1

1
1
1
1
1
2
2
2
2

.
1
2
3
4
.
1
2
3

]
]
]
]
]
]
]
]
]

29:
30:
31:
32:
33:
34:
35:
36:
37:

[
[
[
[
[
[
[
[
[

.
.
.
.
.
.
.
.
.

1
1
1
1
1
1
1
1
1

2
2
3
3
3
3
3
3
3

4
5
.
1
2
3
4
5
6

]
]
]
]
]
]
]
]
]

Figure 17.3-D: The 37 K-increment RGS of length 4 in lexicographic order.
We mention yet another type of restricted growth strings, the K-increment RGS, which satisfy
sk

≤ sk−1 + k

(17.3-10)

An implementation for their generation in lexicographic order is given in [FXT: comb/rgs-kincr.h]:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

369

class rgs_kincr
{
public:
ulong *s_; // restricted growth string
ulong n_;
[--snip--]
ulong next()
{
ulong k = n_;
start:
--k;
if ( k==0 )

return 0;

ulong mp = s_[k-1] + k;
{
s_[k] = 0;
goto start;
}
s_[k] = sk;
return k;
}
[--snip--]

The sequence of the numbers of K-increment RGS of length n is entry A107877 in [312]:
n:

0
1

1
1

2
2

3
7

4
37

5
268

6
2496

7
28612

8
391189

9
6230646

10
113521387

The strings of length 4 are shown in ﬁgure 17.3-D. They can be generated with the program [FXT:
comb/rgs-kincr-demo.cc].

370

Chapter 18: Necklaces and Lyndon words

Chapter 18

Necklaces and Lyndon words
A sequence that is minimal among all its cyclic rotations is called a necklace (see section 3.5.2 on page 149
for the definition in terms of equivalence classes). Necklaces with k possible values for each element are
called k-ary (or k-bead) necklaces. We restrict our attention to binary necklaces: only two values are
allowed and we represent them by 0 and 1.
0:
.
1
1:
1
1
n=1: #=2
0:
..
1
1:
.1
2
2:
11
1
n=2: #=3
0: ...
1: ..1
2: .11
3: 111
n=3: #=4
0: ....
1: ...1
2: ..11
3: .1.1
4: .111
5: 1111
n=4: #=6
0: .....
1: ....1
2: ...11
3: ..1.1
4: ..111
5: .1.11
6: .1111
7: 11111
n=5: #=8

1
3
3
1
1
4
4
2
4
1
1
5
5
5
5
5
5
1

0: ......
1: .....1
2: ....11
3: ...1.1
4: ...111
5: ..1..1
6: ..1.11
7: ..11.1
8: ..1111
9: .1.1.1
10: .1.111
11: .11.11
12: .11111
13: 111111
n=6: #=14

1
6
6
6
6
3
6
6
6
2
6
3
6
1

0: .......
1: ......1
2: .....11
3: ....1.1
4: ....111
5: ...1..1
6: ...1.11
7: ...11.1
8: ...1111
9: ..1..11
10: ..1.1.1
11: ..1.111
12: ..11.11
13: ..111.1
14: ..11111
15: .1.1.11
16: .1.1111
17: .11.111
18: .111111
19: 1111111
n=7: #=20

1
7
7
7
7
7
7
7
7
7
7
7
7
7
7
7
7
7
7
1

0:
........
1:
.......1
2:
......11
3:
.....1.1
4:
.....111
5:
....1..1
6:
....1.11
7:
....11.1
8:
....1111
9:
...1...1
10:
...1..11
11:
...1.1.1
12:
...1.111
13:
...11..1
14:
...11.11
15:
...111.1
16:
...11111
17:
..1..1.1
18:
..1..111
19:
..1.1.11
20:
..1.11.1
21:
..1.1111
22:
..11..11
23:
..11.1.1
24:
..11.111
25:
..111.11
26:
..1111.1
27:
..111111
28:
.1.1.1.1
29:
.1.1.111
30:
.1.11.11
31:
.1.11111
32:
.11.1111
33:
.111.111
34:
.1111111
35:
11111111
n=8: #=36

1
8
8
8
8
8
8
8
8
4
8
8
8
8
8
8
8
8
8
8
8
8
4
8
8
8
8
8
2
8
8
8
8
4
8
1

Figure 18.0-A: All binary necklaces of lengths up to 8 and their periods. Dots represent zeros.
To find all length-n necklaces we can, for all binary words of length n, test whether a word is equal to
its cyclic minimum (see section 1.13 on page 29). The sequences of binary necklaces for n ≤ 8 are shown
in figure 18.0-A. As 2n words have to be tested, this approach is inefficient for large n. Luckily there is
both a much better algorithm for generating all necklaces and a formula for their number.
Not all necklaces are created equal. Each necklace can be assigned a period that is a divisor of the length.
That period is the smallest (nonzero) cyclic shift that transforms the word into itself. The periods are
given directly right to each necklace in figure 18.0-A. For n prime the only periodic necklaces are those
two that contain all ones or zeros. Aperiodic (or equivalently, period equals length) necklaces are called
Lyndon words.

18.1: Generating all necklaces

371

For a length-n binary word x the function bit_cyclic_period(x,n) from section 1.13 on page 29 returns
the period of the word.

18.1

Generating all necklaces

We give several methods to generate all necklaces of a given size. An efficient algorithm for the generation
of bracelets (see section 3.5.2.4 on page 150) is given in [299].

18.1.1

The FKM algorithm

1:
[ . . . . ]
j=1 N
2:
[ . . . 1 ]
j=4 N L
3:
[ . . . 2 ]
j=4 N L
4:
[ . . 1 . ]
j=3
5:
[ . . 1 1 ]
j=4 N L
6:
[ . . 1 2 ]
j=4 N L
7:
[ . . 2 . ]
j=3
8:
[ . . 2 1 ]
j=4 N L
9:
[ . . 2 2 ]
j=4 N L
10:
[ . 1 . 1 ]
j=2 N
11:
[ . 1 . 2 ]
j=4 N L
12:
[ . 1 1 . ]
j=3
13:
[ . 1 1 1 ]
j=4 N L
14:
[ . 1 1 2 ]
j=4 N L
15:
[ . 1 2 . ]
j=3
16:
[ . 1 2 1 ]
j=4 N L
17:
[ . 1 2 2 ]
j=4 N L
18:
[ . 2 . 2 ]
j=2 N
19:
[ . 2 1 . ]
j=3
20:
[ . 2 1 1 ]
j=4 N L
21:
[ . 2 1 2 ]
j=4 N L
22:
[ . 2 2 . ]
j=3
23:
[ . 2 2 1 ]
j=4 N L
24:
[ . 2 2 2 ]
j=4 N L
25:
[ 1 1 1 1 ]
j=1 N
26:
[ 1 1 1 2 ]
j=4 N L
27:
[ 1 1 2 1 ]
j=3
28:
[ 1 1 2 2 ]
j=4 N L
29:
[ 1 2 1 2 ]
j=2 N
30:
[ 1 2 2 1 ]
j=3
31:
[ 1 2 2 2 ]
j=4 N L
32:
[ 2 2 2 2 ]
j=1 N
32 (4, 3) pre-necklaces.
24 necklaces and 18 Lyndon words.

1:
[ . . . . . . ]
j=1 N
2:
[ . . . . . 1 ]
j=6 N
3:
[ . . . . 1 . ]
j=5
4:
[ . . . . 1 1 ]
j=6 N
5:
[ . . . 1 . . ]
j=4
6:
[ . . . 1 . 1 ]
j=6 N
7:
[ . . . 1 1 . ]
j=5
8:
[ . . . 1 1 1 ]
j=6 N
9:
[ . . 1 . . 1 ]
j=3 N
10:
[ . . 1 . 1 . ]
j=5
11:
[ . . 1 . 1 1 ]
j=6 N
12:
[ . . 1 1 . . ]
j=4
13:
[ . . 1 1 . 1 ]
j=6 N
14:
[ . . 1 1 1 . ]
j=5
15:
[ . . 1 1 1 1 ]
j=6 N
16:
[ . 1 . 1 . 1 ]
j=2 N
17:
[ . 1 . 1 1 . ]
j=5
18:
[ . 1 . 1 1 1 ]
j=6 N
19:
[ . 1 1 . 1 1 ]
j=3 N
20:
[ . 1 1 1 . 1 ]
j=4
21:
[ . 1 1 1 1 . ]
j=5
22:
[ . 1 1 1 1 1 ]
j=6 N
23:
[ 1 1 1 1 1 1 ]
j=1 N
23 (6, 2) pre-necklaces.
14 necklaces and 9 Lyndon words.

L
L
L
L
L
L
L
L

L

Figure 18.1-A: Ternary length-4 (left) and binary length-6 (right) pre-necklaces as generated by the
FKM algorithm. Dots are used for zeros, necklaces are marked with ‘N’, Lyndon words with ‘L’.
The following algorithm for generating all necklaces actually produces pre-necklaces, a subset of which
are the necklaces. A pre-necklace is a string that is the prefix of some necklace. The FKM algorithm (for
Fredericksen, Kessler, Maiorana) to generate all k-ary length-n pre-necklaces proceeds as follows:
1. Initialize the word F = [f1 , f2 , . . . , fn ] to all zeros. Set j = 1.
2. (Visit pre-necklace F . If j divides n, then F is a necklace. If j equals n, then F is a Lyndon word.)
3. Find the largest index j so that fj < k−1. If there is no such index (then F = [k−1, k−1, . . . , k−1],
the last necklace), then terminate.
4. Increment fj . Fill the suffix starting at fj+1 with copies of [f1 , . . . , fj ]. Goto step 2.

372


The crucial steps are [FXT: comb/necklace-fkm-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

for (ulong i=1; i<=n; ++i) f[i] = 0; // Initialize to zero
bool nq = 1; // whether pre-necklace is a necklace
bool lq = 0; // whether pre-necklace is a Lyndon word
ulong j = 1;
while ( 1 )
{
// Print necklace:
cout << setw(4) << pct << ":";
print_vec("
", f+1, n, true);
cout << "
j=" << j;
if ( nq ) cout << " N";
if ( lq ) cout << " L";
cout << endl;
// Find largest index where we can increment:
j = n;
while ( f[j]==k-1 ) { --j; };
if ( j==0 )

break;

++f[j];
// Copy periodically:
for (ulong i=1,t=j+1; t<=n; ++i,++t)
nq = ( (n%j)==0 );
lq = ( j==n );

f[t] = f[i];

// necklace if j divides n
// Lyndon word if j equals n

}

Two example runs are shown in ﬁgure 18.1-A. An eﬃcient implementation of the algorithm is [FXT:
class necklace in comb/necklace.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class necklace
{
public:
ulong *a_;
ulong *dv_;
ulong n_;
ulong m1_;
ulong j_;

//
//
//
//
//

the string, NOTE: one-based
delta sequence of divisors of n
length of strings
m-ary strings, m1=m-1
period of the word (if necklaces)

public:
necklace(ulong m, ulong n)
{
n_ = ( n ? n : 1 ); // at least 1
m1_ = ( m>1 ? m-1 : 1); // at least 2
dv_ = new ulong[n_+1];
for (ulong j=1; j<=n; ++j) dv_[j] = ( 0==(n_%j ) );
first();
}
[--snip--]
void first()
{
for (ulong j=0; j<=n_; ++j)
j_ = 1;
}
[--snip--]

a_[j] = 0;

The method to compute the next pre-necklace is
1
2
3
4
5
6
7
8
9
10
11
12

ulong next_pre() // next pre-necklace
// return j (zero when finished)
{
// Find rightmost digit that can be incremented:
ulong j = n_;
while ( a_[j] == m1_ ) { --j; }
// Increment:
// if ( 0==j_ )
++a_[j];

return 0;

// Copy periodically:

// last

// divisors

13
14
15
16
17

373

for (ulong k=j+1; k<=n_; ++k)

a_[k] = a_[k-j];

j_ = j;
return j;
}

Note the commented out return with the last word, this gives a speedup (and no harm is done with the
following copying). The array dv is used to determine whether the current pre-necklace is also a necklace
(or Lyndon word) via simple lookups:
1
2
3
4
5
6
7
8
9
10

bool is_necklace() const
{
return ( 0!=dv_[j_] );
}
bool is_lyn() const
{
return ( j_==n_ );
}

// whether j divides n

// whether j equals n

The methods for the computation of the next necklace or Lyndon word are
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

ulong next() // next necklace
{
do
{
next_pre();
if ( 0==j_ ) return 0;
}
while ( 0==dv_[j_] ); // until j divides n
return j_;
}
ulong next_lyn() // next Lyndon word
{
do
{
next_pre();
if ( 0==j_ ) return 0;
}
while ( j_==n_ ); // until j equals n
return j_; // == n
}
};

The rate of generation for pre-necklaces is about 98 M/s for base 2, 140 M/s for base 3, and 180 M/s for
base 4 [FXT: comb/necklace-demo.cc]. A specialization of the algorithm for binary necklaces is [FXT:
class binary necklace in comb/binary-necklace.h]. The rate of generation for pre-necklaces is about
128 M/s [FXT: comb/binary-necklace-demo.cc]. A version of the algorithm that produces the binary
necklaces as bits of a word is given in section 1.13.3 on page 30.
The binary necklaces of length n can be used as cycle leaders in the length-2n zip permutation (and its
inverse) that is discussed in section 2.10 on page 125. An algorithm for the generation of all irreducible
binary polynomials via Lyndon words is described in section 40.10 on page 856.

18.1.2

Binary Lyndon words with length a Mersenne exponent

The length-n binary Lyndon words for n an exponent of a Mersenne prime Mn = 2n − 1 can be generated
efficiently as binary expansions of the powers of a primitive root r of Mn until the second word with just
one bit is reached. With n = 7, M7 = 127 and the primitive root r = 3 we get the sequence shown in
figure 18.1-B. The sequence of minimal primitive roots rn of the first Mersenne primes Mn = 2n − 1 is
entry A096393 in [312]:
2:
3:
5:
7:
13:

2
3
3
3
17

17:
19:
31:
61:
89:

3
3
7
37
3

107:
127:
521:
607:
1279:

3
43
3
5 <--= 5 is a primitive root of 2**607-1
5

374

0 :
a= ......1
1 :
a= .....11
2 :
a= ...1..1
3 :
a= ..11.11
4 :
a= 1.1...1
5 :
a= 111.1..
6 :
a= 1.1111.
7 :
a= ..111..
8 :
a= 1.1.1..
9 :
a= 11111.1
10 :
a= 1111..1
11 :
a= 11.11.1
12 :
a= 1..1..1
13 :
a= 1.111..
14 :
a= ..1.11.
15 :
a= 1....1.
16 :
a= 1...111
17 :
a= 1.1.11.
18 :
a= ....1..
19 :
a= ...11..
20 :
a= .1..1..
21 :
a= 11.11..
22 :
a= 1...11.
23 :
a= 1.1..11
24 :
a= 1111.1.
25 :
a= 111....
[--snip--]

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

1
3
9
27
81
116
94
28
84
125
121
109
73
92
22
66
71
86
4
12
36
108
70
83
122
112

==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==
==

......1
.....11
...1..1
..11.11
...11.1
..111.1
.1.1111
....111
..1.1.1
.111111
..11111
.11.111
..1..11
..1.111
...1.11
....1.1
...1111
.1.1.11
......1 <--= sequence restarts
.....11
...1..1
..11.11
...11.1
..111.1
.1.1111
....111

Figure 18.1-B: Generation of all (18) 7-bit Lyndon words as binary representations of the powers
modulo 127 of the primitive root 3. The right column gives the cyclic minima. Dots are used for zeros.

18.1.3

A constant amortized time (CAT) algorithm

A constant amortized time (CAT) algorithm to generate all k-ary length-n pre-necklaces is given in [95].
The crucial part of a recursive algorithm [FXT: comb/necklace-cat-demo.cc] is the function
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ulong K, N; // K-ary pre-necklaces of length N
ulong f[N];
void crsms_gen(ulong n, ulong j)
{
if ( n > N ) visit(j); // pre-necklace in f[1,...,N]
else
{
f[n] = f[n-j];
crsms_gen(n+1, j);
for (ulong i=f[n-j]+1; i<K; ++i)
{
f[n] = i;
crsms_gen(n+1, n);
}
}
}

After initializing the array with zeros the function must be called with both arguments equal to 1. The
routine generates about 71 million binary pre-necklaces per second. Ternary and 5-ary pre-necklaces are
generated at a rate of about 100 and 113 million per second, respectively.

18.1.4

An order with fewer transitions

The following routine generates the binary pre-necklaces words in the order that would be generated by
selecting valid words from the binary Gray code:
1
2
3
4
5
6
7
8
9
10

void xgen(ulong n, ulong j, int x=+1)
{
if ( n > N ) visit(j);
else
{
if ( -1==x )
{
if ( 0==f[n-j] ) { f[n] = 1; xgen(n+1, n, -x); }
f[n] = f[n-j]; xgen(n+1, j, +x);
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

.......1
......11
.....111
.....1.1
....11.1
....1111
....1.11
....1..1
...11..1
...11.11

375
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

...11111
...111.1
...1.1.1
...1.111
...1..11
..11.111 <<+1
..11.1.1
..1111.1
..111111
..111.11

21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

..1.1.11
..1.1111
..1.11.1
..1..111 <<+1
..1..1.1
.11.1111 <<+2
.1111111
.1.11.11 <<+1
.1.11111
.1.1.111

Figure 18.1-C: The 30 binary 8-bit Lyndon words in an order with few changes between successive
words. Transitions where more than one bit changes are marked with a ‘<<’.
n : Xn
1:
0
2:
0
3:
0
4:
0
5:
1
6:
1

n : Xn
7:
2
8:
5
9: 11
10: 15
11: 34
12: 54

n:
Xn
13:
95
14: 163
15: 290
16: 479
17: 859
18: 1450

n:
19:
20:
21:
22:
23:
24:

Xn
2598
4546
8135
14427
26122
46957

n:
25:
26:
27:
28:
29:
30:

Xn
85449
155431
284886
522292
963237
1778145

Figure 18.1-D: Excess (with respect to Gray code) of the number of bits changed.
11
12
13
14
15
16
17

else
{
f[n] = f[n-j]; xgen(n+1, j, +x);
if ( 0==f[n-j] ) { f[n] = 1; xgen(n+1, n, -x); }
}
}
}

The program [FXT: comb/necklace-gray-demo.cc] computes the binary Lyndon words with the given
routine. The ordering has fewer transitions between successive words but is in general not a Gray code
(for up to 6-bit words a Gray code is generated). Figure 18.1-C shows the output with 8-bit Lyndon
words. The ﬁrst 2 n/2 −1 Lyndon words of length n are in Gray code order. The number Xn of additional
transitions of the length-n Lyndon words is, for n ≤ 30, shown in ﬁgure 18.1-D.

18.1.5

An order with at most three changes per transition
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

.1111111
.111.111
.11.1111 <<+1
.1.1.111 <<+2
.1.1.1.1
.1.11.11 <<+2
.1.11111
...11111
...111.1
...11..1
...11.11
...1..11

13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

...1...1
...1.1.1
...1.111
.....111
.....1.1
.......1
........
......11 <<+1
....1.11
....1..1
....11.1
....1111

25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

..1.1111
..1.11.1
..1.1.11
..1..1.1
..1..111
..11.111
..11.1.1
..11..11
..111.11
..1111.1
..111111
11111111

<<+1
<<+2
<<+1
<<+1
<<+1

Figure 18.1-E: The 30 binary 8-bit necklaces in an order with at most 3 changes per transition. Transitions where more than one bit changes are marked with a ‘<<’.
An algorithm to generate necklaces in an order such that at most 3 elements change with each update
is given in [352]. The recursion can be given as (corrected and shortened) [FXT: comb/necklace-gray3demo.cc]:
1
2
3
4
5
6
7

long *f; // data in f[1..m], f[0] = 0
long N; // word length
int k; // k-ary necklaces, k==sigma in the paper
void gen3(int z, int t, int j)
{
if ( t > N ) { visit(j); }

376

n : Xn
1:
0
2:
1
3:
2
4:
2
5:
2
6:
4

n : Xn
7:
6
8:
12
9:
20
10:
38
11:
64
12: 116

n:
Xn
13: 200
14: 360
15: 628
16: 1128
17: 1998
18: 3606

n:
19:
20:
21:
22:
23:
24:

Xn
6462
11722
21234
38754
70770
129970

n:
Xn
25: 239008
26: 441370
27: 816604
28: 1515716
29: 2818928
30: 5256628

Figure 18.1-F: Excess (with respect to Gray code) of number of bits changed.
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

else
{
if ( (z&1)==0 ) // z (number of elements ==(k-1)) is even?
{
for (int i=f[t-j]; i<=k-1; ++i)
{
f[t] = i;
gen3( z+(i!=k-1), t+1, (i!=f[t-j]?t:j) );
}
}
else
{
for (int i=k-1; i>=f[t-j]; --i)
{
f[t] = i;
gen3( z+(i!=k-1), t+1, (i!=f[t-j]?t:j) );
}
}
}
}

The variable z counts the number of maximal elements. The output with length-8 binary necklaces is
shown in ﬁgure 18.1-E. Selecting the necklaces from the reversed list of complemented Gray codes of the
n-bit binary words produces the same list.

18.1.6
L=
L=
L=
L=
L=
L=
L=
L=
L=
L=
L=
L=
L=
L=
L=
L=

Binary necklaces of length 2n via Gray-cycle leaders ‡

16 cycles of length= 8
1....... [ 1.......
1......1 [ .1111111
1.....1. [ ..1.1.1.
1.....11 [ 11.1.1.1
1....1.. [ .1..11..
1....1.1 [ 1.11..11
1....11. [ 111..11.
1....111 [ ...11..1
1..1.... [ .111....
1..1...1 [ 1...1111
1..1..1. [ 11.11.1.
1..1..11 [ ..1..1.1
1..1.1.. [ 1.1111..
1..1.1.1 [ .1....11
1..1.11. [ ...1.11.
1..1.111 [ 111.1..1

]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]

L=
-->
-->
-->
-->
-->
-->
-->

1..1.11.
11.111.1
1.11..11
111.1.1.
1..11111
11.1....
1.111...
111..1..

[
[
[
[
[
[
[
[

...1.11.
....1.11
1....1.1
11....1.
.11....1
1.11....
.1.11...
..1.11..

]
]
]
]
]
]
]
]

L=
-->
-->
-->
-->
-->
-->
-->

1..1.111
11.111..
1.11..1.
111.1.11
1..1111.
11.1...1
1.111..1
111..1.1

[
[
[
[
[
[
[
[

111.1..1
1111.1..
.1111.1.
..1111.1
1..1111.
.1..1111
1.1..111
11.1..11

]
]
]
]
]
]
]
]

Figure 18.1-G: Left: the cycle leaders (minima) L of the Gray permutation with highest bit at index 7
and their bit-wise Reed-Muller transforms Y (L). Right: the last two cycles and the transforms of their
elements.
The algorithm for the generation of cycle leaders for the Gray permutation given section 2.12.1 on page 128
and relation 1.19-10c on page 53, written as
Sk Y x = Y g k x

(18.1-1)

(Y is the yellow code, the bit-wise Reed-Muller transform) can be used for generating the necklaces of
length 2n : The cyclic shifts of Y x are equal to Y g k x for k = 0, . . . , l − 1 where l is the cycle length.

18.2: Lex-min De Bruijn sequence from necklaces

377

Figure 18.1-G shows the correspondence between cycles of the Gray permutation and cyclic shifts. It was
generated with the program [FXT: comb/necklaces-via-gray-leaders-demo.cc].
If no better algorithm for the cycle leaders of the Gray permutation was known, we could generate them as
Y −1 (N ) = Y (N ) where N are the necklaces of length 2n . The same idea, together with relation 1.19-11b
on page 53, give the relation
Sk B x = B e−k x

(18.1-2)

where B is the blue code and e the reversed Gray code.

18.1.7

Binary necklaces via cyclic shifts and complements ‡

1:
2:
3:

n = 3
..1
.11
111

1:
2:
3:
4:
5:

n = 4
...1
..11
.111
1111
.1.1

1:
2:
3:
4:
5:
6:
7:

n = 5
....1
...11
..111
.1111
11111
..1.1
.1.11

n = 6
.....1
....11
...111
..1111
.11111
111111
..11.1
.11.11
...1.1
..1.11
.1.111
.1.1.1
..1..1

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

n = 7
......1
.....11
....111
...1111
..11111
.111111
1111111
..111.1
...11.1
..11.11
.11.111
....1.1
...1.11
..1.111
.1.1111
..1.1.1
.1.1.11
...1..1
..1..11

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

n = 8
.......1
......11
.....111
....1111
...11111
..111111
.1111111
11111111
..1111.1
...111.1
..111.11
.111.111
....11.1
...11.11
..11.111
.11.1111
..11.1.1
...11..1

[n=8 cont.]
19: ..11..11
20: .....1.1
21: ....1.11
22: ...1.111
23: ..1.1111
24: .1.11111
25: ..1.11.1
26: .1.11.11
27: ...1.1.1
28: ..1.1.11
29: .1.1.111
30: .1.1.1.1
31: ....1..1
32: ...1..11
33: ..1..111
34: ..1..1.1
35: ...1...1

Figure 18.1-H: Nonzero binary necklaces of lengths n = 3, 4, . . . , 8 as generated by the shift and
complement algorithm.
A recursive algorithm to generate all nonzero binary necklaces via cyclic shifts and complements of the
lowest bit is described in [287]. An implementation of the method is given in [FXT: comb/necklacesigma-tau-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

inline ulong sigma(ulong x) { return bit_rotate_left(x, 1, n); }
inline ulong tau(ulong x) { return x ^ 1; }
void search(ulong y)
{
visit(y);
ulong t = y;
while ( 1 )
{
t = sigma(t);
ulong x = tau(t);
if ( (x&1) && (x == bit_cyclic_min(x, n)) )
else break;
}
}

search(x);

The initial call is search(1). The generated ordering for lengths n = 3, 4, . . . , 8 is shown in figure 18.1-H.

18.2

Lex-min De Bruijn sequence from necklaces

The lexicographically minimal De Bruijn sequence can be obtained from the necklaces in lexicographic
order as shown in figure 18.2-A. Let W be a necklace with period p, and define its primitive part P (W )
to be the p rightmost digits of W . Then the lex-min De Bruijn sequence is the concatenation of the
primitive parts of the necklaces in lex order.
An implementation is [FXT: class debruijn in comb/debruijn.h]:

378

neckl.

period

P(neckl.)

1
4
4
4
4
4
4
2
4
4
4
4
4
2
4
4
4
4
1
4
4
2
4
1

0
0001
0002
0011
0012
0021
0022
01
0102
0111
0112
0121
0122
02
0211
0212
0221
0222
1
1112
1122
12
1222
2

0000
0001
0002
0011
0012
0021
0022
0101
0102
0111
0112
0121
0122
0202
0211
0212
0221
0222
1111
1112
1122
1212
1222
2222

0 0001 0002 0011 0012 0021 0022 01 0102 0111 0112 [--snip--] 1122 12 1222 2 ==
000010002001100120021002201010201110112012101220202110212022102221111211221212222
Figure 18.2-A: The 3-ary necklaces of length 4 (left) and their primitive parts (right). The concatenation
of the primitive parts gives a De Bruijn sequence (bottom).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

class debruijn : public necklace
// Lexicographic minimal De Bruijn sequence.
{
public:
ulong i_;
// position of current digit in current string
public:
debruijn(ulong m, ulong n)
: necklace(m, n)
{ first_string(); }
~debruijn()

{ ; }

ulong first_string()
{
necklace::first();
i_ = 1;
return j_;
}
ulong next_string() // make new string, return its length
{
necklace::next();
i_ = (j_ != 0);
return j_;
}
ulong next_digit()
// Return current digit and move to next digit.
// Return m if previous was last.
{
if ( i_ == 0 ) return necklace::m1_ + 1;
ulong d = a_[ i_ ];
if ( i_ == j_ ) next_string();
else ++i_;
return d;
}
ulong first_digit()
{
first_string();
return next_digit();

18.3: The number of binary necklaces
43
44

379

}
};

Usage is demonstrated in [FXT: comb/debruijn-demo.cc]:
1
2
3
4
5
6
7
8
9
10
11

ulong m = 3; // m-ary De Bruijn sequence
ulong n = 4; // length = m**n
debruijn S(m, n);
ulong i = S.first_string();
do
{
cout << " ";
for (ulong u=1; u<=i; ++u) cout << S.a_[u];
i = S.next_string();
}
while ( i );

// note: one-based array

For digit by digit generation, use
1
2
3
4
5
6
7

ulong i = S.first_digit();
do
{
cout << i;
i = S.next_digit();
}
while ( i!=m );

A special version for binary necklaces is [FXT: class binary debruijn in comb/binary-debruijn.h].

18.3

The number of binary necklaces
n : Nn
1:
2
2:
3
3:
4
4:
6
5:
8
6:
14
7:
20
8:
36
9:
60
10: 108

n:
Nn
11:
188
12:
352
13:
632
14:
1182
15:
2192
16:
4116
17:
7712
18: 14602
19: 27596
20: 52488

n:
Nn
21:
99880
22:
190746
23:
364724
24:
699252
25: 1342184
26: 2581428
27: 4971068
28: 9587580
29: 18512792
30: 35792568

n:
Nn
31:
69273668
32:
134219796
33:
260301176
34:
505294128
35:
981706832
36: 1908881900
37: 3714566312
38: 7233642930
39: 14096303344
40: 27487816992

Figure 18.3-A: The number of binary necklaces for n ≤ 40.
n : Ln
1:
2
2:
1
3:
2
4:
3
5:
6
6:
9
7: 18
8: 30
9: 56
10: 99

n:
Ln
11:
186
12:
335
13:
630
14:
1161
15:
2182
16:
4080
17:
7710
18: 14532
19: 27594
20: 52377

n:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

Ln
99858
190557
364722
698870
1342176
2580795
4971008
9586395
18512790
35790267

n:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:

Ln
69273666
134215680
260300986
505286415
981706806
1908866960
3714566310
7233615333
14096302710
27487764474

Figure 18.3-B: The number of binary Lyndon words for n ≤ 40.

380


The number of binary necklaces of length n equals
Nn

1
n

=

n

1
n

ϕ(d) 2n/d =
dn

2gcd(j,n)

(18.3-1)

j=1

The values for n ≤ 40 are shown in figure 18.3-A. The sequence is entry A000031 in [312].
The number of Lyndon words (aperiodic necklaces) equals
Ln

=

1
n

1
n

µ(d) 2n/d =
dn

µ(n/d) 2d

(18.3-2)

dn

The M¨bius function µ is defined in relation 37.1-6 on page 705. The values for n ≤ 40 are given in figure
o
18.3-B. The sequence is entry A001037 in [312]. Replacing 2 by k in the formulas for Nn and Ln gives
expressions for k-ary necklaces and Lyndon words.
For prime n = p we have Lp = Np − 2 and
Lp

1
2p − 2
=
p
p

=

p−1

k=1

p
k

(18.3-3)

p
The latter form tells us that there are exactly k /p Lyndon words with k ones for 1 ≤ k ≤ p − 1. The
difference of 2 is due to the necklaces that consist of all zeros or ones. The number of irreducible binary
polynomials (see section 40.6 on page 843) of degree n also equals Ln . For the equivalence between
necklaces and irreducible polynomials see section 40.10 on page 856.

Let d be a divisor of n. There are 2n binary words of length n, each having some period d that divides
n. There are d different shifts of the corresponding word, thereby
2n

=

d Ld

(18.3-4)

dn

M¨bius inversion gives relation 18.3-2. The necklaces of length n and period d are a concatenation of
o
n/d Lyndon words of length d, so
Nn

=

Ld

(18.3-5)

dn

We note the relations (see section 37.2 on page 709)
∞

(1 − 2 x)

(1 − xk )Lk

=
k=1
∞

∞

Lk xk

=

k=1

k=1

(18.3-6a)

−µ(k)
log 1 − 2 xk
k

(18.3-6b)

Defining
∞

η B (x)

1 − B xk

(18.3-7a)

(1 − xk )Nk

(18.3-7b)

η 1 (xk )Lk

(18.3-7c)

:=
k=1

we have
∞

η 2 (x)

=
k=1
∞

η 2 (x)

=
k=1

18.3: The number of binary necklaces

n:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

Nn N(n,0) N(n,1) N(n,2) N(n,3) N(n,4) N(n,5) N(n,6) N(n,7) N(n,8)
2
1
1
3
1
1
1
4
1
1
1
1
6
1
1
2
1
1
8
1
1
2
2
1
1
14
1
1
3
4
3
1
1
20
1
1
3
5
5
3
1
1
36
1
1
4
7
10
7
4
1
1
60
1
1
4
10
14
14
10
4
1
108
1
1
5
12
22
26
22
12
5
188
1
1
5
15
30
42
42
30
15
352
1
1
6
19
43
66
80
66
43
632
1
1
6
22
55
99 132 132
99
1182
1
1
7
26
73 143 217 246 217
2192
1
1
7
31
91 201 335 429 429
4116
1
1
8
35 116 273 504 715 810
7712
1
1
8
40 140 364 728 1144 1430
14602
1
1
9
46 172 476 1038 1768 2438
27596
1
1
9
51 204 612 1428 2652 3978
52488
1
1
10
57 245 776 1944 3876 6310

381

N(n,9) N(n,10)

1
1
5
19
55
143
335
715
1430
2704
4862
8398

1
1
6
22
73
201
504
1144
2438
4862
9252

Figure 18.3-C: The number N(n,z) of binary necklaces of length n with z zeros.

n:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

Ln L(n,0) L(n,1) L(n,2) L(n,3) L(n,4) L(n,5) L(n,6) L(n,7) L(n,8)
2
1
1
1
0
1
0
2
0
1
1
0
3
0
1
1
1
0
6
0
1
2
2
1
0
9
0
1
2
3
2
1
0
18
0
1
3
5
5
3
1
0
30
0
1
3
7
8
7
3
1
0
56
0
1
4
9
14
14
9
4
1
99
0
1
4
12
20
25
20
12
4
186
0
1
5
15
30
42
42
30
15
335
0
1
5
18
40
66
75
66
40
630
0
1
6
22
55
99 132 132
99
1161
0
1
6
26
70 143 212 245 212
2182
0
1
7
30
91 200 333 429 429
4080
0
1
7
35 112 273 497 715 800
7710
0
1
8
40 140 364 728 1144 1430
14532
0
1
8
45 168 476 1026 1768 2424
27594
0
1
9
51 204 612 1428 2652 3978
52377
0
1
9
57 240 775 1932 3876 6288

L(n,9) L(n,10)

0
1
5
18
55
143
333
715
1430
2700
4862
8398

0
1
5
22
70
200
497
1144
2424
4862
9225

Figure 18.3-D: The number L(n,z) of binary Lyndon words of length n with z zeros.

382


18.3.1

Binary necklaces with fixed density

Let N(n,n0 ) be the number of binary length-n necklaces with exactly n0 zeros (and n1 = n − n0 ones) the
necklaces with fixed density. We have
N(n,n0 )

=

1
n

ϕ(j)
j gcd(n,n0 )

n/j
n0 /j

(18.3-8)

Bit-wise complementing gives the symmetry relation N(n,n0 ) = N(n,n−n0 ) = N(n,n1 ) . A table of small
values is given in figure 18.3-C.
Let L(n,n0 ) be the number of binary length-n Lyndon words with exactly n0 zeros (Lyndon words with
fixed density), then
L(n,n0 )

=

1
n

µ(j)
j gcd(n,n0 )

n/j
n0 /j

(18.3-9)

The symmetry relation is the same as for N(n,n0 ) . A table of small values is given in figure 18.3-D.

18.3.2

Binary necklaces with even or odd weight

Summing N(n,k) over all even or odd k ≤ n gives the number of necklaces of even (symbol En ) or odd
(On ) weight, respectively. The first few values, the differences En − On , and the sums En + On = Nn :
Neckl.

n: 1 2 3 4 5
En : 1 2 2 4 4
On : 1 1 2 2 4
En − On : 0 1 0 2 0
En + On : 2 3 4 6 8

6
7 8 9
8 10 20 30
6 10 16 30
2
0 4 0
14 20 36 60

10 11 12 13
14
15
16
17
56 94 180 316 596 1096 2068 3856
52 94 172 316 586 1096 2048 3856
4
0
8
0
10
0
20
0
108 188 352 632 1182 2192 4116 7712

The number of Lyndon words of even (en ) and odd (on ) weight can be computed in the same way:
Lyn. n :
1
2
en :
0
0
on :
1
1
en − on : −1 −1
e n + on :
1
1

3
4 5
1
1 3
1
2 3
0 −1 0
2
3 6

6
7
8 9 10 11 12 13
14
15
16
17
4
9 14 28 48 93 165 315 576 1091 2032 3855
5
9 16 28 51 93 170 315 585 1091 2048 3855
−1
0 −2 0 −3
0 −5
0
−9
0 −16
0
9 18 30 56 99 186 335 630 1161 2182 4080 7710

The differences between the number of necklaces and Lyndon words are:
n: 1 2 3 4 5 6 7 8 9
En − en : 1 2 1 3 1 4 1 6 2
O n − on : 0 0 1 0 1 1 1 0 2
E n − on : 0 1 1 2 1 3 1 4 2
On − en : 1 1 1 1 1 2 1 2 2

18.3.3

10
8
1
5
4

11 12
1 15
1 2
1 10
1 7

13 14
1 20
1 1
1 11
1 10

15 16
5 36
5 0
5 20
5 16

17
1
1
1
1

Necklaces with fixed content

Let N(n0 ,n1 ,...,nk−1 ) be the number of k-symbol length-n necklaces with nj occurrences of symbol j, the
number of such necklaces with fixed content, we have (n = j<s nj and):
N(n0 ,n1 ,...,nk−1 )

=

1
n

ϕ(d)
dg

(n/d)!
(n0 /d)! · · · (nk−1 /d)!

(18.3-10)

where g = gcd(n0 , n1 , . . . , nk−1 ). The equivalent formula for the Lyndon words with fixed content is
L(n0 ,n1 ,...,nk−1 )

=

1
n

µ(d)
dg

(n/d)!
(n0 /d)! · · · (nk−1 /d)!

(18.3-11)

18.4: Sums of roots of unity that are zero ‡

383

where g = gcd(n0 , n1 , . . . , nk−1 ). The relations are taken from [289] and [300], which also give efficient
algorithms for the generation of necklaces and Lyndon words with fixed density and content, respectively.
The number of strings with fixed content is a multinomial coefficient, see relation 13.2-1a on page 296.
A method for the generation of all necklaces with forbidden substrings is given in [290].

18.4
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

Sums of roots of unity that are zero ‡
bitstring
............
.....1.....1
....11....11
...1...1...1
...1.1...1.1
...11..1..11
...111...111
..1..1..1..1
..1.11..1.11
..11..11..11
..11.1..11.1
..11.11..111
..1111..1111
.1.1.1.1.1.1
.1.111.1.111
.11.11.11.11
.111.111.111
.11111.11111
111111111111

subset
1
(empty sum)
6
0 6
6
0 1 6 7
4
0 4 8
cyclic shifts are 1 5 9, 2 6 10, 3 7 11
6
0 2 6 8
12 L 0 1 4 7 8
Lyndon word
6
0 1 2 6 7 8
3
0 3 6 9
6
0 1 3 6 7 9
4
0 1 4 5 8 9
6
0 2 3 6 8 9
12 L 0 1 2 5 6 8 9
Lyndon word
6
0 1 2 3 6 7 8 9
2
0 2 4 6 8 10
6
0 1 2 4 6 7 8 10
3
0 1 3 4 6 7 9 10
4
0 1 2 4 5 6 8 9 10
6
0 1 2 3 4 6 7 8 9 10
1
0 1 2 3 4 5 6 7 8 9 10 11 (all roots of unity)

Figure 18.4-A: All subsets of the 12-th roots of unity that add to zero, modulo cyclic shifts.
Let ω = exp(2 π i/n) be a primitive n-th root of unity and S be a subset of the set of n elements. We
compute all S such that σS = 0 where σS := e∈S ω e [FXT: comb/root-sums-demo.cc]. If σS = 0 then
ω k σS = 0 for all k, so we can ignore cyclic shifts, see figure 18.4-A. For n prime only the empty set
and all roots of unity add to zero (no proper subset of all roots can add to zero: ω would be a root of a
polynomial that has the cyclotomic polynomial Yn = 1 + x + . . . + xn−1 as divisor which is impossible).
All necklaces that are not Lyndon words correspond to a zero sum. The smallest nontrivial cases where
Lyndon words lead to zero sums occur for n = 12 (marked with ‘L’ in figure 18.4-A).
Sequence A164896 in [312] gives the number of subsets adding to zero (modulo cyclic shifts), sequence
A110981 the number of subsets that are Lyndon words and A103314 the number of subsets where cyclic
shifts are considered as different.

384

Chapter 19: Hadamard and conference matrices

Chapter 19

Hadamard and conference matrices
The matrices corresponding to the Walsh transforms (see chapter 23 on page 459) are special cases of
Hadamard matrices. Such matrices also exist for certain sizes N × N for N not a power of 2. We give
construction schemes for Hadamard matrices that come from the theory of finite fields.
If we denote the transform matrix for an N -point Walsh transform by H, then
H HT

= N id

(19.0-1)

where id is the unit matrix. The matrix H is orthogonal (up to normalization) and its determinant equals
det(H)

det H HT

=

1/2

= N N/2

(19.0-2)

Further, all entries are either +1 or −1. An orthogonal matrix with these properties is called a Hadamard
matrix. We know that for N = 2n we always can find such a matrix. For N = 2 we have
H2

=

+1
+1

+1
−1

(19.0-3)

and we can use the Kronecker product (see section 23.3 on page 462) to construct H2N from HN via
Hn

=

+HN/2
+HN/2

+HN/2
−HN/2

= H2 ⊗ HN/2

(19.0-4)

The problem of determining Hadamard matrices (especially for N not a power of 2) comes from combinatorics. Hadamard matrices of size N × N can only exist if N equals 1, 2, or 4 k.

19.1

Hadamard matrices via LFSR

We start with a construction for certain Hadamard matrices for N a power of 2 that uses m-sequences
that are created by shift registers (see section 41.1 on page 864). Figure 19.1-A shows three Hadamard
matrices that were constructed as follows:
1. Choose N = 2n and create a maximum length binary shift register sequence S of length N − 1.
2. Make S signed, that is, replace all ones by −1 and all zeros by +1.
3. The N × N matrix H is computed by filling the first row and the first column with ones and filling
the remaining entries with cyclic copies of s: for r = 1, 2, . . . N − 1 and c = 1, 2, . . . N − 1 set
Hr,c := Sc−r+1 mod N −1 .
The matrices in figure 19.1-A were produced with the program [FXT: comb/hadamard-srs-demo.cc].
1
2
3
4
5

#include "bpol/lfsr.h" // class lfsr
#include "aux1/copy.h" // copy_cyclic()
#include "matrix/matrix.h"
typedef matrix<int> Smat;

// class matrix
// matrix with integer entries

19.1: Hadamard matrices via LFSR
Signed SRS:
- + + + - + + Hadamard matrix H:
+ + + + + + + + +
+ - + + + - + + + - - + + + - + +
+ - - - + + + - +
+ - - - - + + + + + - - - - + + +
+ - + - - - - + +
+ + - + - - - - +
+ - + - + - - - + - - + - + - - + + - - + - + - + + + - - + - + + - + + - - + - +
+ + - + + - - + + + + - + + - - +
+ + + + - + + - -

385

- + - + - - +
+
+
+
+
+
+
+

+
+
+
+
+
+
+
+
-

+
+
+
+
+
+
+
+

+
+
+
+
+
+
+
+
-

+
+
+
+
+
+
+
+
-

+
+
+
+
+
+
+
+
-

+
+
+
+
+
+
+
+
-

Signed SRS:
- + + - + - Hadamard matrix H:
+ + + + + + + +
+ - + + - + - + - - + + - + + - - - + + - +
+ + - - - + + + - + - - - + +
+ + - + - - - +
+ + + - + - - -

Signed SRS:
- + Hadamard matrix H:
+ + + +
+ - + + - - +
+ + - -

Figure 19.1-A: Hadamard matrices created with binary shift register sequences (SRS) of maximum
length. Only the sign of the entries is given, all entries are ±1.
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

[--snip--]
ulong n = 5;
ulong N = 1UL << n;
[--snip--]
// --- create signed SRS:
int vec[N-1];
lfsr S(n);
for (ulong k=0; k<N-1; ++k)
{
ulong x = 1UL & S.get_a();
vec[k] = ( x ? -1 : +1 );
S.next();
}
// --- create Hadamard matrix:
Smat H(N,N);
for (c=0; c<N; ++c) H.set(0, c, +1); // first row = [1,1,1,...,1]
for (ulong r=1; r<N; ++r)
{
H.set(r, 0, +1); // first column = [1,1,1,...,1]^T
copy_cyclic(vec, H.rowp_[r]+1, N-1, N-r);
}
[--snip--]

The function copy_cyclic() is deﬁned in [FXT: aux1/copy.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

inline void copy_cyclic(const Type *src, Type *dst, ulong n, ulong s)
// Copy array src[] to dst[]
// starting from position s in src[]
// wrap around end of src[] (src[n-1])
//
// src[] is assumed to be of length n
// dst[] must be length n at least
//
// Equivalent to: { acopy(src, dst, n); rotate_right(dst, n, s)}
{
ulong k = 0;
while ( s<n ) dst[k++] = src[s++];
s = 0;
while ( k<n )
}

dst[k++] = src[s++];

386


If we define the matrix X to be the (N − 1) × (N − 1) block of
column, then we have

N −1
−1
−1
 −1
N −1
−1


−1
N −1
X XT =  −1
 .
.
.
.
 .
.
···
−1
−1
−1

H obtained by deleting the first row and
···
···
···
..
.
···

−1
−1
−1
.
.
.









N −1

(19.1-1)

Equivalently, for the (cyclic) auto-correlation of S (see section 41.6 on page 875):
L−1

Sk Sk+τ

mod L

=

k=0

+L if τ = 0
−1 otherwise

(19.1-2)

where L = N − 1 is the length of the sequence.
An alternative way to find Hadamard matrices of dimension 2n is to use the signs in the multiplication
table for hypercomplex numbers described in section 39.14 on page 815.

19.2

Hadamard matrices via conference matrices
Quadratic characters modulo
0 + - + + - - - - + + 14x14 conference matrix C:
0 + + + + + + + + + + + +
+ 0 + - + + - - - - + + + + 0 + - + + - - - - + +
+ - + 0 + - + + - - - - +
+ + - + 0 + - + + - - - + + + - + 0 + - + + - - + - + + - + 0 + - + + - + - - + + - + 0 + - + + + - - - + + - + 0 + - + +
+ - - - - + + - + 0 + - +
+ + - - - - + + - + 0 + + + + - - - - + + - + 0 +
+ - + + - - - - + + - + 0
+ + - + + - - - - + + - +

13:
+

Quadratic characters modulo 11:
0 + - + + + - - - + 12x12 conference matrix C:
0 + + + + + + + + + + +
- 0 + - + + + - - - + - - 0 + - + + + - - - +
- + - 0 + - + + + - - - - + - 0 + - + + + - - - - + - 0 + - + + + - - - - + - 0 + - + + +
- + - - - + - 0 + - + +
- + + - - - + - 0 + - +
- + + + - - - + - 0 + - - + + + - - - + - 0 +
- + - + + + - - - + - 0

+
+
+
+
+
+
+
0

Figure 19.2-A: Two Conference matrices, the entries not on the diagonal are ±1 and only the sign is
given. The left is a symmetric 14 × 14 matrix (13 ≡ 1 mod 4), the right is an antisymmetric 12 × 12
matrix (11 ≡ 3 mod 4). Replacing all diagonal elements of the right matrix with +1 gives a 12 × 12
Hadamard matrix.
12x12 Hadamard
+ + + + + + + + + - - + +
+ + + + - - +
+ - + + + - +
+ - - + + + +
+ + - - + + +
- + + + + + + - + - - + + + - + - - + - + - + - + - - + - + + + - - + - -

matrix H:
+ + + + +
- + - - +
+ - + - - + - + - - + - +
+ - - + - - - - - - + + - - - + +
+ - - - +
+ + - - - + + - -

Quadratic characters modulo 5:
0 + - - +
6x6 conference matrix C:
0 + + + + +
+ 0 + - - +
+ + 0 + - + - + 0 + + - - + 0 +
+ + - - + 0

Figure 19.2-B: A Hadamard matrix (left) created from a symmetric conference matrix (right).
A conference matrix CQ is a Q × Q matrix with zero diagonal and all other entries ±1 so that
CQ CT
Q

=

(Q − 1) id

(19.2-1)

We give an algorithm for computing a conference matrix CQ for Q = q + 1 where q is an odd prime:

19.2: Hadamard matrices via conference matrices

387

1. Create a length-q array S with entries Sk ∈ {−1, 0, +1} as follows: set S0 = 0 and, for 1 ≤ k < q
set Sk = +1 if k is a square modulo q, Sk = −1 else.
2. Set y = 1 if q ≡ 1 mod 4, else y = −1 (then q ≡ 3 mod 4).
3. Set C0,0 = 0 and CQ [0, k] = +1 for 1 ≤ k < Q (first row). Set CQ [k, 0] = y for 1 ≤ k < Q
(first column). Fill the remaining entries with cyclic copies of S: for 1 ≤ r < q and 1 ≤ c < q set
CQ [r, c] = Sc−r+1 mod q .
The quantity y tells us whether CQ is symmetric (y = +1) or antisymmetric (y = −1). If CQ is
antisymmetric, then
HQ

= CQ + id

(19.2-2)

is a Q × Q Hadamard matrix. For example, replacing all zeros in the 12 × 12 matrix in figure 19.2-A by
+1 gives a 12 × 12 Hadamard matrix. If CQ is symmetric, then a 2Q × 2Q Hadamard matrix is given by
H2Q

:=

+ id +CQ
− id +CQ

− id +CQ
− id −CQ

(19.2-3)

Figure 19.2-B shows a 12 × 12 Hadamard matrix that was created using this formula. The construction
of Hadamard matrices via conference matrices is due to Raymond Paley.
The program [FXT: comb/conference-quadres-demo.cc] outputs for a given q the Q×Q conference matrix
and the corresponding Hadamard matrix:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include "mod/numtheory.h" // kronecker()
#include "matrix/matrix.h" // class matrix
#include "aux1/copy.h" // copy_cyclic()
[--snip--]
int y = ( 1==q%4 ? +1 : -1 );
ulong Q = q+1;
[--snip--]
// --- create table of quadratic characters modulo q:
int vec[q]; fill<int>(vec, q, -1); vec[0] = 0;
for (ulong k=1; k<(q+1)/2; ++k) vec[(k*k)%q] = +1;
[--snip--]
// --- create Q x Q conference matrix:
Smat C(Q,Q);
C.set(0,0, 0);
for (ulong c=1; c<Q; ++c) C.set(0, c, +1); // first row = [1,1,1,...,1]
for (ulong r=1; r<Q; ++r)
{
C.set(r, 0, y); // first column = +-[1,1,1,...,1]^T
copy_cyclic(vec, C.rowp_[r]+1, q, Q-r);
}
[--snip--]
// --- create a N x N Hadamard matrix:
ulong N = ( y<0 ? Q : 2*Q );
Smat H(N,N);
if ( N==Q )
{
copy(C, H);
H.diag_add_val(1);
}
else
{
Smat K2(2,2); K2.fill(+1); K2.set(1,1, -1); // K2 = [+1,+1; +1,-1]
H.kronecker(K2, C); // Kronecker product of matrices
for (ulong k=0; k<Q; ++k) // adjust diagonal of sub-matrices
{
ulong r, c;
r=k;
c=k;
H.set(r,c, H.get(r,c)+1);
r=k;
c=k+Q; H.set(r,c, H.get(r,c)-1);
r=k+Q; c=k;
H.set(r,c, H.get(r,c)-1);
r=k+Q; c=k+Q; H.set(r,c, H.get(r,c)-1);
}
}
[--snip--]

388


If both Ha and Hb are Hadamard matrices (of dimensions a and b, respectively), then their Kronecker
product Hab = Ha ⊗ Hb is again a Hadamard matrix:
Hab HT
ab

=
=

(Ha ⊗ Hb ) (Ha ⊗ Hb )
Ha HT
a

⊗

Hb HT
b

T

=

=∗ (Ha ⊗ Hb ) HT ⊗ HT
a
b
∗

=

(19.2-4a)

(a id) ⊗ (b id) = a b id

(19.2-4b)

The starred equalities use relations 23.3-11a and 23.3-10a on page 464, respectively.

19.3

Conference matrices via finite fields

The algorithm for odd primes q can be modified to work also for powers of odd primes. We have to work
with the finite fields GF(q n ). The entries Cr+1,c+1 for r = 0, 1, . . . , q n − 1 and c = 0, 1, . . . , q n − 1
have to be the quadratic character of zr − zc where z0 , z1 , . . . , zqn −1 are the elements in GF(q n ) in some
(fixed) order.
We give two simple GP routines that map the elements zi ∈ GF(q n ) (represented as polynomials modulo
q) to the numbers 0, 1, . . . , q n − 1. The polynomial p(x) = c0 + c1 x + . . . + cn−1 xn−1 is mapped to
N = c0 + c1 q + . . . + cn−1 q n−1 .
1
2
3
4
5
6

pol2num(p,q)=
Return number for polynomial p.
{
p = lift(p); remove mods, e.g. p=Mod(2, 3)*x^2 + Mod(1, 3) --> 2*x^2+1
return ( subst(p, ’x, q) );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

num2pol(n,q)=
Return polynomial for number n.
{
local(p, mq, k);
p = Pol(0,’x);
k = 0;
while ( 0!=n,
mq = n % q;
p += mq * (’x)^k;
n -= mq;
n = q;
k++;
);
return( p );
}

The quadratic character of an element z can be determined by computing z (q
polynomial. The result will be zero for z = 0, else ±1.

n

−1)/2

modulo the field

For our purpose its is better to precompute a table of the quadratic characters for later lookup:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

quadcharvec(fp, q)=
Return a table of quadratic characters in GF(q^n)
fp is the field polynomial.
{
local(n, qn, sv, pl);
n=poldegree(fp);
qn=q^n-1;
sv=vector(qn+1, j, -1);
sv[1] = 0;
for (k=1, qn,
pl = num2pol(k,q);
pl = Mod(Mod(1,q)*pl, fp);
sq = pl * pl;
sq = lift(sq); remove mod
i = pol2num( sq, q );
sv[i+1] = +1;
);
return( sv );
}

19.3: Conference matrices via finite fields

389

With this table we can compute the quadratic characters of the difference of two elements efficiently:
1
2
3
4
5
6
7
8
9
10
11
12
13

getquadchar_v(n1, n2, q, fp, sv)=
Return the quadratic character of (n2-n1) in GF(q^n)
Table lookup method
{
local(p1, p2, d, nd, sc);
if ( n1==n2, return(0) );
p1 = num2pol(n1, q);
p2 = num2pol(n2, q);
d = (p2-p1) % fp;
nd = pol2num(d, q);
sc = sv[nd+1];
return( sc );
}

Now we can construct conference matrices:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

matconference(q, fp, sv)=
Return a QxQ conference matrix.
q an odd prime.
fp an irreducible polynomial modulo q.
sv table of quadratic characters in GF(q^n)

where n is the degree of fp.
{
local(y, Q, C, n);
n = poldegree(fp);
Q=q^n+1;
if ( sv[2]==sv[Q-1], y=+1, y=-1 ); symmetry
C =
for
for
for

matrix(Q,Q);
(k=2, Q, C[1,k]=+1); first row
(k=2, Q, C[k,1]=y); first column
(r=2, Q,
for (c=2, Q,
sc = getquadchar_v(r-2, c-2, q, fp, sv);
C[r,c] = sc;
);

);
return( C );
}

q = 3
fp = x^2 + 1
GF(3^2)
Table of quadratic characters:
0 + + + - - + - 10x10 conference matrix C:
0 + + + + + + + + +
- 0 + + + - - + - - + 0 + - + - - + - + + 0 - - + - - +
- + - - 0 + + + - - - + - + 0 + - + - - - + + + 0 - - +
- + - - + - - 0 + +
- - + - - + - + 0 +
- - - + - - + + + 0
Figure 19.3-A: A 10 × 10 conference matrix for q = 3 and the field polynomial f = x2 + 1.
To compute a Q × Q conference matrix where Q = q n + 1 we need to find a polynomial of degree n that
is irreducible modulo q. With q = 3 and the field polynomial f = x2 + 1 (so n = 2) we get the 10 × 10
conference matrix shown in figure 19.3-A. A conference matrix for q = 3 and f = x3 − x + 1 is given in
figure 19.3-B. Hadamard matrices can be created in the same manner as before, the symmetry criterion
being whether q n ≡ ± 1 mod 4.
The conference matrices obtained are of size Q = q n + 1 where q is an odd prime. The values Q ≤ 100
are (see sequence A061344 in [312]):
4, 6, 8, 10, 12, 14, 18, 20, 24, 26, 28, 30, 32, 38, 42, 44, 48,
50, 54, 60, 62, 68, 72, 74, 80, 82, 84, 90, 98

Our construction does not give conference matrices for any odd Q, and these even values Q ≤ 100:

390

q = 3
fp = x^3 - x + 1
GF(3^3)
Table of quadratic characters:
0 + - - - - + + + + - + + + - +
28x28 conference matrix C:
0 + + + + + + + + + + + + + + + +
- 0 + - - - - + + + + - + + + - +
- - 0 + - - - + + + + + - - + + - + - 0 - - - + + + - + + + - + +
- + + + 0 + - - - - + + - + - + +
- + + + - 0 + - - - - + + + + - - + + + + - 0 - - - + - + - + + +
- - - - + + + 0 + - + + - + + - +
- - - - + + + - 0 + - + + - + + +
- - - - + + + + - 0 + - + + - + - - - + - + - - + - 0 + - - - - +
- + - - - - + - - + - 0 + - - - +
- - + - + - - + - - + - 0 - - - +
- - + - - - + - + - + + + 0 + - - - - + + - - - - + + + + - 0 + - + - - - + - + - - + + + + - 0 - - + - - + - - - + - - - + + + 0
- - - + - - + + - - - - - + + + - + - - + - - - + - - - - + + + +
- + - + + + - + + - - - + - + - - + + - - + + - + + + - - - - + - - + + + - + + - + - + - + - - +
- + + - + - + + + - - + - - - + - - + + + + - - + + - - + + - - - + - + - + + + - + + - - - + - +
- + + - + + - + - + - + - - + - - - + + - + + + + - - - + - - + +
- + - + + - + - + + + - - + - - -

+ - - - + - + - - + +
+
+
+
+
+
+
+
+
+
+
0
+
+
+

+
+
+
+
+
+
+
+
+
+
+
0
+
+
+
-

+
+
+
+
+
+
+
+
+
+
0
+
+
+
+
-

+
+
+
+
+
+
+
+
+
+
+
0
+
+
+
-

+
+
+
+
+
+
+
+
+
+
+
0
+
+
+
-

+
+
+
+
+
+
+
+
+
+
0
+
+
+
+

+
+
+
+
+
+
+
+
+
+
+
0
+
+
+

+
+
+
+
+
+
+
+
+
+
+
0
+
+
+

+
+
+
+
+
+
+
+
+
+
+
+
+
0
+

+
+
+
+
+
+
+
+
+
+
+
+
+
+
0
-

+
+
+
+
+
+
+
+
+
+
+
+
+
+
0

Figure 19.3-B: A 28 × 28 conference matrix for q = 3 and the ﬁeld polynomial f = x3 − x + 1.
2, 16, 22, 34, 36, 40, 46, 52, 56, 58, 64, 66, 70, 76, 78, 86, 88, 92, 94, 96, 100

For example, Q = 16 = 15 + 1 = 3 · 5 + 1 has not the required form.
If a conference matrix of size Q exists, then we can create Hadamard matrices of sizes N = Q whenever
q n ≡ 3 mod 4 and N = 2 Q whenever q n ≡ 1 mod 4. Further, if Hadamard matrices of sizes N and M
exist, then a (N · M ) × (N · M ) the Kronecker product of those matrices is a Hadamard matrix.
The values of N = 4 k ≤ 2000 such that this construction does not give an N × N Hadamard matrix are:
92, 116, 156, 172, 184, 188, 232, 236, 260, 268, 292, 324, 356, 372,
376, 404, 412, 428, 436, 452, 472, 476, 508, 520, 532, 536, 584,
596, 604, 612, 652, 668, 712, 716, 732, 756, 764, 772, 808, 836,
852, 856, 872, 876, 892, 904, 932, 940, 944, 952, 956, 964, 980,
988, 996, 1004, 1012, 1016, 1028, 1036, 1068, 1072, 1076, 1100,
1108, 1132, 1148, 1168, 1180, 1192, 1196, 1208, 1212, 1220, 1244,
1268, 1276, 1300, 1316, 1336, 1340, 1364, 1372, 1380, 1388, 1396,
1412, 1432, 1436, 1444, 1464, 1476, 1492, 1508, 1528, 1556, 1564,
1588, 1604, 1612, 1616, 1636, 1652, 1672, 1676, 1692, 1704, 1712,
1732, 1740, 1744, 1752, 1772, 1780, 1796, 1804, 1808, 1820, 1828,
1836, 1844, 1852, 1864, 1888, 1892, 1900, 1912, 1916, 1928, 1940,
1948, 1960, 1964, 1972, 1976, 1992

This is sequence A046116 in [312]. It can be computed by starting with a list of all numbers of the form
4 k and deleting all values k = 2a (q + 1) where q is a power of an odd prime.
Constructions for Hadamard matrices for numbers of certain forms are known, see [234] and [157].
Whether Hadamard matrices exist for all values N = 4 k is an open problem. A readable source about
constructions for Hadamard matrices is [316]. Hadamard matrices for all N ≤ 256 are given in [313].

391

Chapter 20

Searching paths in directed graphs ‡
We describe how certain combinatorial structures can be represented as paths or cycles in a directed
graph. As an example consider Gray codes of n-bit binary words: we are looking for sequences of all 2n
binary words such that only one bit changes between two successive words. A convenient representation
of the search space is that of a graph. The nodes are the binary words and an edge is drawn between
two nodes if the node’s values differ by exactly one bit. Every path that visits all nodes of that graph
corresponds to a Gray code. If the path is a cycle, a Gray cycle was found.
Depending on the size of the problem, we can
1. try to find at least one object,
2. generate all objects,
3. show that no such object exists.
The method used is usually called backtracking. We will see how to reduce the search space if additional
constraints are imposed on the paths. Finally, we show how careful optimization can lead to surprising
algorithms for objects of a size where one would hardly expect to obtain a result at all. In fact, Gray
cycles through the n-bit binary Lyndon words for all odd n ≤ 37 are determined.
We use graphs solely as a tool for finding combinatorial structures. For algorithms dealing with the
properties of graphs see, for example, [220] and [307].

Terminology and conventions
We will use the terms node (instead of vertex ) and edge (sometimes called arc). We restrict our attention
to directed graphs (or digraphs) as undirected graphs are just the special case of these: an edge in an
undirected graph corresponds to two antiparallel edges (think: ‘arrows’) in a directed graph.
A length-k path is a sequence of nodes where an edge leads from each node to its successor. A path is
called simple if the nodes are pair-wise distinct. We restrict our attention to simple paths of length N
where N is the number of nodes of the graph. We use the term full path for a simple path of length N .
If in a simple path there is an edge from the last node of the path to the starting node the path is a cycle
(or circuit). A full path that is a cycle is called a Hamiltonian cycle, a graph containing such a cycle is
called Hamiltonian.
We allow for loops (edges that start and point to the same node). Graphs that contain loops are called
pseudo graphs. The algorithms used will effectively ignore loops. We disallow multigraphs (where multiple
edges can start and end at the same two nodes), as these would lead to repeated output of identical objects.
The neighbors of a node are those nodes to which outgoing edges point. Neighbors can be reached with
one step. The neighbors of a node a called adjacent to the node. The adjacency matrix of a graph with
N nodes is an N × N matrix A where Ai,j = 1 if there is an edge from node i to node j, else Ai,j = 0.
While easy to implement (and modify later) we will not use this kind of representation as the memory
requirement would be prohibitive for large graphs.

Chapter 20: Searching paths in directed graphs ‡

392

20.1

Representation of digraphs

For our purposes a static implementation of the graph as arrays of nodes and (outgoing) edges will suﬃce.
The container class digraph merely allocates memory for the nodes and edges. The correct initialization
is left to the user [FXT: class digraph in graph/digraph.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

class digraph
{
public:
ulong ng_;
// number of Nodes of Graph
ulong *ep_; // e[ep[k]], ..., e[ep[k+1]-1]: outgoing connections of node k
ulong *e_;
// outgoing connections (Edges)
ulong *vn_; // optional: sorted values for nodes
// if vn is used, then node k must correspond to vn[k]
public:
digraph(ulong ng, ulong ne, ulong *&ep, ulong *&e, bool vnq=false)
: ng_(0), ep_(0), e_(0), vn_(0)
{
ng_ = ng;
ep_ = new ulong[ng_+1];
e_ = new ulong[ne];
ep = ep_;
e = e_;
if ( vnq ) vn_ = new ulong[ng_];
}
~digraph()
{
delete [] ep_;
delete [] e_;
if ( vn_ ) delete [] vn_;
}
[--snip--]
void get_edge_idx(ulong p, ulong &fe, ulong &en) const
// Setup fe and en so that the nodes reachable from p are
//
e[fe], e[fe+1], ..., e[en-1].
// Must have: 0<=p<ng
{
fe = ep_[p];
// (index of) First Edge
en = ep_[p+1]; // (index of) first Edge of Next node
}
[--snip--]
void print(const char *bla=0)
};

const;

The nodes reachable from node p could be listed using
// ulong p; // == position
cout << "The nodes reachable from node " << p << " are:" << endl;
ulong fe, en;
g_.get_edge_idx(p, fe, en);
for (ulong ep=fe; ep<en; ++ep) cout << e_[ep] << endl;

With our representation there is no cheap method to ﬁnd the incoming edges. We will not need this
information for our purposes. If the graph is known to be undirected, the same routine obviously lists
the incoming edges.
Initialization routines for certain digraphs are declared in [FXT: graph/mk-special-digraphs.h]. A simple
example is [FXT: graph/mk-complete-digraph.cc]:
1
2
3
4
5
6
7
8
9

digraph
make_complete_digraph(ulong n)
// Initialization for the complete graph.
{
ulong ng = n, ne = n*(n-1);
ulong *ep, *e;
digraph dg(ng, ne, ep, e);

20.2: Searching full paths
10
11
12
13
14
15
16
17
18
19
20
21
22

393

ulong j = 0;
for (ulong k=0; k<ng; ++k) // for all nodes
{
ep[k] = j;
for (ulong i=0; i<n; ++i) // connect to all nodes
{
if ( k==i ) continue; // skip loops
e[j++] = i;
}
}
ep[ng] = j;
return dg;
}

We initialize the complete graph (the undirected graph that has edges between any two of its nodes) for
n = 5 and print it [FXT: graph/graph-perm-demo.cc]:
digraph dg = make_complete_digraph(5);
dg.print("Graph =");

The output is
Graph =
Node: Edge0
0:
1
1:
0
2:
0
3:
0
4:
0
#nodes=5

Edge1 ...
2
3
4
2
3
4
1
3
4
1
2
4
1
2
3
#edges=20

For many purposes it suﬃces to implicitly represent the nodes as values p with 0 ≤ p < N where N is
the number of nodes. If not, the values of the nodes have to be stored in the array vn_[]. One such
example is a graph where the value of node p is the p-th (cyclically minimal) Lyndon word that we will
meet at the end of this chapter. To make the search for a node by value reasonably fast, the array vn_[]
should be sorted so that binary search can be used.

20.2

Searching full paths

To search full paths starting from some position p0 we need two additional arrays for the bookkeeping:
A record rv_[] of the path so far, its k-th entry is pk , the node visited at step k. A tag array qq_[] that
contains a one for nodes already visited, otherwise a zero. The crucial parts of the implementation are
[FXT: class digraph paths in graph/digraph-paths.h]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class digraph_paths
// Find all full paths in a directed graph.
{
public:
digraph &g_; // the graph
ulong *rv_; // Record of Visits: rv[k] == node visited at step k
ulong *qq_; // qq[k] == whether node k has been visited yet
[--snip--]
// function to call with each path found with all_paths():
ulong (*pfunc_)(digraph_paths &);
[--snip--]
// function to impose condition with all_cond_paths():
bool (*cfunc_)(digraph_paths &, ulong ns);
public:
// graph/digraph.cc:
digraph_paths(digraph &g);
~digraph_paths();
[--snip--]
bool path_is_cycle() const;
[--snip--]
void print_path() const;
[--snip--]
// graph/digraphpaths-search.cc:
ulong all_paths(ulong (*pfunc)(digraph_paths &),
ulong ns=0, ulong p=0, ulong maxnp=0);

394
28
29
30
31

private:
void next_path(ulong ns, ulong p);
[--snip--]
};

// called by all_paths()

We could have used a bit-array for the tag values qq_[]. It turns out that some additional information
can be saved there as we will see in a moment.
To keep matters simple a recursive algorithm is used to search for (full) paths. The search is started via
call to all_paths() [FXT: graph/digraph-paths.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ulong
digraph_paths::all_paths(ulong (*pfunc)(const digraph_paths &),
ulong ns/*=0*/, ulong p/*=0*/, ulong maxnp/*=0*/)
// pfunc: function to visit (process) paths
// ns: start at node index ns (for fixing start of path)
// p: start at node value p
(for fixing start of path)
// maxnp: stop if maxnp paths were found
{
pct_ = 0;
cct_ = 0;
pfct_ = 0;
pfunc_ = pfunc;
pfdone_ = 0;
maxnp_ = maxnp;
next_path(ns, p);
return pfct_; // Number of paths where pfunc() returned true
}

The search is done by the function next_path():
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

void
digraph_paths::next_path(ulong ns, ulong p)
// ns+1 == how many nodes seen
// p == position (node we are on)
{
if ( pfdone_ ) return;
rv_[ns] = p;
++ns;

// record position

if ( ns==ng_ ) // all nodes seen ?
{
pfunc_(*this);
}
else
{
qq_[p] = 1; // mark position as seen (else loops lead to errors)
ulong fe, en;
ulong fct = 0; // count free reachable nodes // FCT
for (ulong ep=fe; ep<en; ++ep)
{
ulong t = g_.e_[ep]; // next node
if ( 0==qq_[t] ) // node free?
{
++fct;
qq_[p] = fct; // mark position as seen: record turns // FCT
next_path(ns, t);
}
}
// if ( 0==fct ) { "dead end: this is a U-turn"; } // FCT
qq_[p] = 0; // unmark position
}
}

The lines that are commented with // FCT record which among the free nodes is visited. The algorithm
still works if these lines are commented out.

Graph =
Node: Edge0
0:
1
1:
0
2:
0
3:
0
4:
0
#nodes=5

395
0:
1 2 3
1:
1 2 4
2:
1 3 2
3:
1 3 4
4:
1 4 2
5:
1 4 3
6:
2 1 3
7:
2 1 4
8:
2 3 1
[--snip--]
21:
4 2 3
22:
4 3 1
23:
4 3 2

Edge1 ...
2
3
4
2
3
4
1
3
4
1
2
4
1
2
3
#edges=20

4
3
4
2
3
2
4
3
4
1
2
1

Figure 20.2-A: Edges of the complete graph with 5 nodes (left) and full paths starting at node 0 (right).
The paths (where 0 is omitted) correspond to the permutations of 4 elements in lexicographic order.

20.2.1

Paths in the complete graph: permutations

The program [FXT: graph/graph-perm-demo.cc] shows the paths in the complete graph from section 20.1
on page 392. We give a slightly simplified version:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

ulong pfunc_perm(digraph_paths &dp)
// Function to be called with each path:
// print all but the first node.
{
const ulong *rv = dp.rv_;
ulong ng = dp.ng_;
cout << setw(4) << dp.pfct_ << ": ";
for (ulong k=1; k<ng; ++k) cout << " " << rv[k];
cout << endl;
return 1;
}
int
main(int argc, char **argv)
{
ulong n = 5;
digraph dg = make_complete_digraph(n);
digraph_paths dp(dg);
dg.print("Graph =");
cout << endl;
dp.all_paths(pfunc_perm, 0, 0, maxnp);
return 0;
}

The output, shown in figure 20.2-A, is a listing of the permutations of the numbers 1, 2, 3, 4 in lexicographic
order (see section 10.2 on page 242).

20.2.2

Paths in the De Bruijn graph: De Bruijn sequences

The graph with 2 n nodes and two outgoing edges from node k to 2 k mod 2 n and 2 k + 1 mod 2 n is
called a (binary) De Bruijn graph. For n = 8 the graph is (printed horizontally):
Node:
Edge 0:
Edge 1:

0
0
1

1
2
3

2
4
5

3
6
7

4 5 6 7
8 10 12 14
9 11 13 15

8
0
1

9 10 11 12 13 14 15
2 4 6 8 10 12 14
3 5 7 9 11 13 15

The graph has a loop at each the first and the last node. All paths in the De Bruijn graph are cycles,
the graph is Hamiltonian.
With n a power of 2 the paths correspond to the De Bruijn sequences (DBS) of length 2 n. The graph
has as many full paths as there are DBSs and the zeros/ones in the DBS correspond to even/odd values
of the nodes, respectively. This is demonstrated in [FXT: graph/graph-debruijn-demo.cc] (shortened):
1
2
3

ulong pq = 1; // whether and what to print with each cycle
ulong pfunc_db(digraph_paths &dp)

396
Graph =
Node:
Edge 0:
Edge 1:
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

0
0
1

1
2
3

2
4
5

3
6
7

Paths
2 4
2 4
2 5
2 5
2 5
2 5
2 5
2 5
3 6
3 6
3 6
3 6
3 7
3 7
3 7
3 7

9
9
10
10
11
11
11
11
12
13
13
13
15
15
15
15

3
3
4
4
6
6
7
7
9
10
10
11
14
14
14
14

6
7
9
9
12
13
15
15
2
4
5
7
12
13
13
13

n = 8 (ng=16)

4 5 6 7
8 10 12 14
9 11 13 15
13
15
3
3
9
10
14
14
5
9
11
15
9
10
10
11

10
14
6
7
3
4
12
13
11
2
7
14
2
4
5
6

5
13
13
15
7
9
9
10
7
5
15
12
5
9
11
12

11
10
11
14
15
3
3
4
15
11
14
9
11
2
6
9

8
0
1
7
5
7
13
14
7
6
9
14
7
12
2
6
5
12
2

9 10 11 12 13 14 15
2 4 6 8 10 12 14
3 5 7 9 11 13 15
15
11
15
11
13
15
13
3
13
15
9
5
13
11
9
5

14
6
14
6
10
14
10
6
10
14
2
10
10
6
2
10

12
12
12
12
4
12
4
12
4
12
4
4
4
12
4
4

8
8
8
8
8
8
8
8
8
8
8
8
8
8
8
8

DBSs
.1..11.1.1111...
.1..1111.1.11...
.1.1..11.1111...
.1.1..1111.11...
.1.11..1111.1...
.1.11.1..1111...
.1.1111..11.1...
.1.1111.1..11...
.11..1.1111.1...
.11.1..1.1111...
.11.1.1111..1...
.11.1111..1.1...
.1111..1.11.1...
.1111.1..1.11...
.1111.1.11..1...
.1111.11..1.1...

#cycles = 16

Figure 20.2-B: Edges of the De Bruijn graph (top) and all paths starting at node 0 together with the
corresponding De Bruijn sequences (bottom). Dots denote zeros.
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// Function to be called with each cycle.
{
switch ( pq )
{
case 0: break; // just count
case 1: // print lowest bits (De Bruijn sequence)
{
ulong *rv = dp.rv_, ng = dp.ng_;
for (ulong k=0; k<ng; ++k) cout << (rv[k]&1UL ? ’1’ : ’.’);
cout << endl;
break;
}
[--snip--]
}
return 1;
}
int main(int argc, char **argv)
{
ulong n = 8;
NXARG(pq, "what to do in pfunc()");
ulong maxnp = 0;
NXARG(maxnp, "stop after maxnp paths (0: never stop)");
ulong p0 = 0;
NXARG(p0, "start position <2*n");
digraph dg = make_debruijn_digraph(n);
dg.print_horiz("Graph =");
// call pfunc() with each cycle:
dp.all_paths(pfunc_db, 0, p0, maxnp);
cout
cout
cout
cout

<<
<<
<<
<<

"n = " << n;
" (ng=" << dg.ng_ << ")";
"
#cycles = " << dp.cct_;
endl;

return 0;
}

The macro NXARG() reads one argument, it is deﬁned in [FXT: nextarg.h]. Figure 20.2-B was created
with the shown program.
The algorithm is a very eﬀective way for generating all DBSs of a given length, the 67,108,864 DBSs of

397

length 64 are generated in 140 seconds when printing is disabled (set argument pq to zero), corresponding
to a rate of more than 450,000 DBSs per second.
-#----##---#-#---###--#--#-##--##-#--####-#-#-###-##-######------#----##---#-#---###--#--#-##--##-#--####-#-#-###-##-######------#----##---#-#---###--#--#-##--##-#--####-#-#-###-##-######------#----##---#-#---###--#--#-##--##-#--####-#-#-###-##-######------#----##---#-#---###--#--#-##--##-#--####-#-#-###-##-######------#----##---#-#---###--#--#-##--##-#--####-#-#-###-##-######
Figure 20.2-C: A path in the De Bruijn graph with 64 nodes. Each binary word is printed vertically,
the symbols ‘#’ and ‘-’ stand for one and zero, respectively.
Setting the argument pq to 4 prints the binary values of the successive nodes in the path horizontally, see
figure 20.2-C. The graph is constructed in a way that each word is the predecessor shifted by one with
either zero or one inserted at position zero (top row of figure 20.2-C).
The number of cycles in the De Bruijn graph equals the number of degree-n normal binary polynomials,
see section 42.6.3 on page 904. A closed form for the special case n = 2k is given in section 41.5 on page
873.

20.2.3

A modified De Bruijn graph: complement-shift sequences
------#---#-#-##----##--#--#-###---###-#--##-####--######-##-#-#
-######-###-#-#--####--##-##-#---###---#-##--#----##------#--#-#
-#------#---#-#-##----##--#--#-###---###-#--##-####--######-##-#
-#-######-###-#-#--####--##-##-#---###---#-##--#----##------#--#
-#-#------#---#-#-##----##--#--#-###---###-#--##-####--######-##
-#-#-######-###-#-#--####--##-##-#---###---#-##--#----##------#-

Figure 20.2-D: A path in the modified De Bruijn graph with 64 nodes. Each binary word is printed
vertically, the symbols ‘#’ and ‘-’ stand for one and zero, respectively.
A modification of the De Bruijn graph forces the nodes to be the complement of its predecessor shifted
by one (again with either zero or one inserted at position zero). The routine to set up the graph is [FXT:
graph/mk-debruijn-digraph.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

digraph
make_complement_shift_digraph(ulong n)
{
ulong ng = 2*n, ne = 2*ng;
ulong *ep, *e;
digraph dg(ng, ne, ep, e);
ulong j = 0;
for (ulong k=0; k<ng; ++k)
{
ep[k] = j;
ulong r = (2*k) % ng;
e[j++] = r; // connect
r = (2*k+1) % ng;
e[j++] = r; // connect
}
ep[ng] = j;
// Here we have a De Bruijn

// for all nodes

node k to node (2*k) mod ng
node k to node (2*k+1) mod ng
graph.

for (ulong k=0,j=ng-1; k<j; ++k,--j) swap2(e[ep[k]], e[ep[j]]); // end with ones
for (ulong k=0,j=ng-1; k<j; ++k,--j) swap2(e[ep[k]+1], e[ep[j]+1]);
return

dg;

}

The output of the program [FXT: graph/graph-complementshift-demo.cc] is shown in figure 20.2-D.
For n a power of 2 the sequence of binary words has the interesting property that the changes between
successive words depend on their sequency: words with higher sequency change in less positions. Further,

398

if two adjacent bits are set in some word, then the next word never has both bits set again. Out of a run
of k ≥ 2 consecutive set bits in a word only one is contained in the next word.
See section 8.3 on page 208 for the connection with De Bruijn sequences.

20.3

Conditional search

Sometimes one wants to find paths that are subject to certain restrictions. Testing for each path found
whether it has the desired property and discarding it if not is the simplest way. However, this will in
many cases be extremely ineffective. An upper bound for the number of recursive calls of the search
function next_path() with a graph with N nodes and a maximal number of v outgoing edges at each
node is u = N v .
For example, the graph corresponding to Gray codes of n-bit binary words has N = 2n nodes and
(exactly) c = n outgoing edges at each node. The graph is the n-dimensional hypercube.
n:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

N
2
4
8
16
32
64
128
256
512
1024

u = N c = N n = 2n·n
2
16
512
65,536
33,554,432
68,719,476,736
562,949,953,421,312
18,446,744,073,709,551,616
2,417,851,639,229,258,349,412,352
1,267,650,600,228,229,401,496,703,205,376

To reduce the search space we use a function that rejects branches that would lead to a path not satisfying the imposed restrictions. A conditional search can be started via all_cond_paths() that has
an additional function pointer cfunc() as argument. The function must implement the condition. The
corresponding method is declared as [FXT: graph/digraph-paths.h]:
bool (*cfunc_)(digraph_paths &, ulong ns);

Besides the data from the digraph-class it needs the number of nodes seen so far (ns) as an argument. A
slight modification of the search routine does what we want [FXT: graph/search-digraph-cond.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void
digraph_paths::next_cond_path(ulong ns, ulong p)
{
[--snip--] // same as next_path()
if ( ns==ng_ ) // all nodes seen ?
[--snip--] // same as next_path()
else
{
qq_[p] = 1; // mark position as seen (else loops lead to errors)
ulong fe, en;
ulong fct = 0; // count free reachable nodes
for (ulong ep=fe; ep<en; ++ep)
{
ulong t = g_.e_[ep]; // next node
if ( 0==qq_[t] ) // node free?
{
rv_[ns] = t; // for cfunc()
if ( cfunc_(*this, ns) )
{
++fct;
qq_[p] = fct; // mark position as seen: record turns
next_cond_path(ns, t);
}
}
}
qq_[p] = 0; // unmark position

20.3: Conditional search
28
29

399

}
}

The free node under consideration is written to the end of the record of visited nodes so cfunc() does
not need it as an explicit argument.

20.3.1

Modular adjacent changes (MAC) Gray codes
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

....
...1
..11
.111
1111
111.
11..
11.1
.1.1
.1..
.11.
..1.
1.1.
1.11
1..1
1...

0
1
2
3
4
3
2
3
2
1
2
1
2
3
2
1

0
1
3
7
15
14
12
13
5
4
6
2
10
11
9
8

...1
..1.
.1..
1...
...1
..1.
...1
1...
...1
..1.
.1..
1...
...1
..1.
...1
[1...

0
1
2
3
0
1
0
3
0
1
2
3
0
1
0
3]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

....
...1
..11
.111
.1.1
.1..
.11.
..1.
1.1.
111.
11..
11.1
1111
1.11
1..1
1...

0
1
2
3
2
1
2
1
2
3
2
3
4
3
2
1

0
1
3
7
5
4
6
2
10
14
12
13
15
11
9
8

...1
..1.
.1..
..1.
...1
..1.
.1..
1...
.1..
..1.
...1
..1.
.1..
..1.
...1
[1...

0
1
2
1
0
1
2
3
2
1
0
1
2
1
0
3]

Figure 20.3-A: Two 4-bit modular adjacent changes (MAC) Gray codes. Both are cycles.
We search for Gray codes that have the modular adjacent changes (MAC) property: the values of successive elements of the delta sequence can only change by ±1 modulo n. Two examples are show in
ﬁgure 20.3-A. The sequence on the right side even has the stated property if the term ‘modular’ is
omitted: It has the adjacent changes (AC) property.
As bit-wise cyclic shifts and reﬂections of MAC Gray codes are again MAC Gray codes we consider paths
starting 0 → 1 → 2 as canonical paths.
In the demo [FXT: graph/graph-macgray-demo.cc] the search is done as follows (shortened):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

int main(int argc, char **argv)
{
ulong n = 5;
NXARG(n, "size in bits");
cf_nb = n;
digraph dg = make_gray_digraph(n, 0);
ulong ns = 0, p = 0;
// MAC: canonical paths start as 0-->1-->3
{
dp.mark(0, ns);
dp.mark(1, ns);
p = 3;
}
dp.all_cond_paths(pfunc, cfunc_mac, ns, p, maxnp);
return 0;
}

The function used to impose the MAC condition is:
1
2
3
4
5
6
7
8
9
10
11

ulong cf_nb; // number of bits, set in main()
bool cfunc_mac(digraph_paths &dp, ulong ns)
// Condition: difference of successive delta values
{
// path initialized, we have ns>=2
ulong p = dp.rv_[ns], p1 = dp.rv_[ns-1], p2 =
ulong c = p ^ p1, c1 = p1 ^ p2;
if ( c & bit_rotate_left(c1,1,cf_nb) ) return
if ( c1 & bit_rotate_left(c,1,cf_nb) ) return
return false;
}

(modulo n) == +-1
dp.rv_[ns-2];
true;
true;

400

We find paths for n ≤ 7 (n = 7 takes about 15 minutes). Whether MAC Gray codes exist for n ≥ 8 is
unknown (none is found with a 40 hour search).

20.3.2

Adjacent changes (AC) Gray codes

For AC paths we can only discard track-reflected solutions, the canonical paths are those where the delta
sequence starts with a value ≤ n/2 . A function to impose the AC condition is
1
2
3
4
5
6
7
8
9
10
11

ulong cf_mt; // mid track < cf_mt, set in main()
bool cfunc_ac(digraph_paths &dp, ulong ns)
// Condition: difference of successive delta values == +-1
{
if ( ns<2 ) return (dp.rv_[1] < cf_mt); // avoid track-reflected solutions
ulong p = dp.rv_[ns], p1 = dp.rv_[ns-1], p2 = dp.rv_[ns-2];
ulong c = p ^ p1, c1 = p1 ^ p2;
if ( c & (c1<<1) ) return true;
if ( c1 & (c<<1) ) return true;
return false;
}

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

.....
..1..
.11..
111..
1.1..
1....
1..1.
1.11.
1111.
11.1.
11...
11..1
11.11
11111
1.111
1..11
1...1
1.1.1
111.1
.11.1
..1.1
....1
...11
..111
.1111
.1.11
.1..1
.1...
.1.1.
.111.
..11.
...1.

0
1
2
3
2
1
2
3
4
3
2
3
4
5
4
3
2
3
4
3
2
1
2
3
4
3
2
1
2
3
2
1

0
4
12
28
20
16
18
22
30
26
24
25
27
31
23
19
17
21
29
13
5
1
3
7
15
11
9
8
10
14
6
2

..1..
.1...
1....
.1...
..1..
...1.
..1..
.1...
..1..
...1.
....1
...1.
..1..
.1...
..1..
...1.
..1..
.1...
1....
.1...
..1..
...1.
..1..
.1...
..1..
...1.
....1
...1.
..1..
.1...
..1..
[...1.

2
3
4
3
2
1
2
3
2
1
0
1
2
3
2
1
2
3
4
3
2
1
2
3
2
1
0
1
2
3
2
1]

0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

.....
....1
...11
..111
.1111
.1.11
.1..1
.11.1
..1.1
1.1.1
111.1
11..1
11.11
11111
1.111
1..11
1...1
1....
1..1.
1.11.
1111.
11.1.
11...
111..
1.1..
..1..
.11..
.1...
.1.1.
.111.
..11.
...1.

0
1
2
3
4
3
2
3
2
3
4
3
4
5
4
3
2
1
2
3
4
3
2
3
2
1
2
1
2
3
2
1

0
1
3
7
15
11
9
13
5
21
29
25
27
31
23
19
17
16
18
22
30
26
24
28
20
4
12
8
10
14
6
2

....1
...1.
..1..
.1...
..1..
...1.
..1..
.1...
1....
.1...
..1..
...1.
..1..
.1...
..1..
...1.
....1
...1.
..1..
.1...
..1..
...1.
..1..
.1...
1....
.1...
..1..
...1.
..1..
.1...
..1..
[...1.

0
1
2
3
2
1
2
3
4
3
2
1
2
3
2
1
0
1
2
3
2
1
2
3
4
3
2
1
2
3
2
1]

Figure 20.3-B: Two 5-bit adjacent changes (AC) Gray codes that are cycles.
The program [FXT: graph/graph-acgray-demo.cc] allows searches for AC Gray codes. Two cycles for
n = 5 are shown in figure 20.3-B. It turns out that such paths exist for n ≤ 6 (the only path for n = 6 is
shown in figure 20.3-C) but there is no AC Gray code for n = 7:
time ./bin 7
arg 1: 7 == n [size in bits] default=5
arg 2: 0 == maxnp [ stop after maxnp paths (0: never stop)]
n = 7
#pfct = 0
#paths = 0
#cycles = 0

default=0

Nothing is known about the case n ≥ 8. For n = 8 no path is found within 15 days.
By inspection of the AC Gray codes for different values of n we find an ad hoc algorithm. The following
routine computes the delta sequence for AC Gray codes for n ≤ 6 [FXT: comb/acgray.cc]:
1
2
3
4

void
ac_gray_delta(uchar *d, ulong ldn)
// Generate a delta sequence for an adjacent-changes (AC) Gray code
// of length n=2**ldn where ldn<=6.

20.3: Conditional search
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

......
...1..
...11.
....1.
..1.1.
..111.
..11..
..11.1
..1111
..1.11
....11
...111
...1.1
.....1
..1..1
.11..1
.1...1
.1.1.1
.1.111
.1..11
.11.11
.11111
.111.1
.111..
.1111.
.11.1.
.1..1.
.1.11.
.1.1..
.1....
.11...
..1...

0
1
2
1
2
3
2
3
4
3
2
3
2
1
2
3
2
3
4
3
4
5
4
3
4
3
2
3
2
1
2
1

0
4
6
2
10
14
12
13
15
11
3
7
5
1
9
25
17
21
23
19
27
31
29
28
30
26
18
22
20
16
24
8

401
...1..
....1.
...1..
..1...
...1..
....1.
.....1
....1.
...1..
..1...
...1..
....1.
...1..
..1...
.1....
..1...
...1..
....1.
...1..
..1...
...1..
....1.
.....1
....1.
...1..
..1...
...1..
....1.
...1..
..1...
.1....
1.....

2
1
2
3
2
1
0
1
2
3
2
1
2
3
4
3
2
1
2
3
2
1
0
1
2
3
2
1
2
3
4
5

32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

1.1...
111...
11....
11.1..
11.11.
11..1.
111.1.
11111.
1111..
1111.1
111111
111.11
11..11
11.111
11.1.1
11...1
111..1
1.1..1
1....1
1..1.1
1..111
1...11
1.1.11
1.1111
1.11.1
1.11..
1.111.
1.1.1.
1...1.
1..11.
1..1..
1.....

2
3
2
3
4
3
4
5
4
5
6
5
4
5
4
3
4
3
2
3
4
3
4
5
4
3
4
3
2
3
2
1

40
56
48
52
54
50
58
62
60
61
63
59
51
55
53
49
57
41
33
37
39
35
43
47
45
44
46
42
34
38
36
32

.1....
..1...
...1..
....1.
...1..
..1...
...1..
....1.
.....1
....1.
...1..
..1...
...1..
....1.
...1..
..1...
.1....
..1...
...1..
....1.
...1..
..1...
...1..
....1.
.....1
....1.
...1..
..1...
...1..
....1.
...1..
[1.....

4
3
2
1
2
3
2
1
0
1
2
3
2
1
2
3
4
3
2
1
2
3
2
1
0
1
2
3
2
1
2
5]

Figure 20.3-C: The (essentially unique) AC Gray code for n = 6. While the path is a cycle in the
graph, the AC condition does not hold for the transition from the last to the ﬁrst word.
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

{
if ( ldn<=2 ) // standard Gray code
{
d[0] = 0;
if ( ldn==2 ) { d[1] = 1; d[2] = 0; }
return;
}
ac_gray_delta(d, ldn-1);

// recursion

ulong n = 1UL<<ldn;
ulong nh = n/2;
if ( 0==(ldn&1) )
{
if ( ldn>=6 )
{
reverse(d, nh-1);
for (ulong k=0; k<nh;
}
for (ulong k=0,j=n-2;
d[nh-1] = ldn - 1;

k<j;

++k)

d[k] = (ldn-2) - d[k];

++k,--j)

d[j] = d[k];

}
else
{
for (ulong k=nh-2,j=nh-1; 0!=j; --k,--j) d[j] = d[k] + 1;
for (ulong k=2,j=n-2; k<j; ++k,--j) d[j] = d[k];
d[0] = 0;
d[nh] = 0;
}
}

The program [FXT: comb/acgray-demo.cc] can be used to create AC Gray codes for n ≤ 6. For n ≥ 7
the algorithm produces near-AC Gray codes, where the number of non-AC transitions equals 2n−5 − 1
for odd values of n and 2n−5 − 2 for n even:
# non-AC transitions:
n =0..6 #non-ac = 0
n = 7
#non-ac = 3
n = 8
#non-ac = 6
n = 9
#non-ac = 15
n = 10
#non-ac = 30
n = 11
#non-ac = 63

402
n = 12
...

#non-ac = 126

Near-AC Gray codes with fewer non-AC transitions may exist.

20.4

Edge sorting and lucky paths

The order of the nodes in the representation of the graph does not matter with finding paths as the
algorithm at no point refers to it. The order of the outgoing edges, however, does matter.

20.4.1

Edge sorting

Consider a large graph that has only a few paths. The calling tree of the recursive function next_path()
obviously depends on the edge order. Therefore the first path can appear earlier or later in the search.
‘Later’ may well mean that the path is not found within any reasonable amount of time.
With a bit of luck one might find an ordering of the edges of the graph that will shorten the time until
the first path is found. The program [FXT: graph/graph-monotonicgray-demo.cc] searches for monotonic
Gray codes and optionally sorts the edges of the graph. The following method sorts the outgoing edges
of each node according to a supplied comparison function [FXT: graph/digraph.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

digraph::sort_edges(int (*cmp)(const ulong &, const ulong &))
{
if ( 0==vn_ ) // value == index (in e[])
{
for (ulong k=0; k<ng_; ++k)
{
ulong x = ep_[k];
ulong n = ep_[k+1] - x;
selection_sort(e_+x, n, cmp);
}
}
else // values in vn[]
{
for (ulong k=0; k<ng_; ++k)
{
ulong x = ep_[k];
ulong n = ep_[k+1] - x;
idx_selection_sort(vn_, n, e_+x, cmp);
}
}
}

The comparison function actually used imposes the lexicographic order shown in section 1.26 on page 70:
1
2
3
4
5
6
7
8

int my_cmp(const ulong &a, const ulong &b)
{
if ( a==b ) return 0;
#define CODE(x) lexrev2negidx(x);
ulong ca = CODE(a);
ulong cb = CODE(b);
return (ca<cb ? +1 : -1);
}

The choice was inspired by the observation that the bit-wise difference of successive elements in bit-lex
order is either one or three. We search until the first path for 8-bit words is found: for the unsorted graph
this task takes 1.14 seconds, for the sorted it takes 0.03 seconds.

20.4.2

Lucky paths

The first Gray code found in the hypercube graph with randomized edge order is shown in figure 20.4A (left). The corresponding path, as reported by the method digraph_paths::print_turns [FXT:
graph/digraph-paths.cc], is described in the right column. Here nn is the number of neighbors of node,
xe is the index of the neighbor (next) in the list of edges of node. Finally xf is the index among the
free nodes in the list. The latter corresponds to the value fct-1 in the function next_path() given in

20.5: Gray codes for Lyndon words
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

....
1...
1.1.
111.
1111
.111
..11
..1.
.11.
.1..
11..
11.1
.1.1
...1
1..1
1.11

0
1
2
3
4
3
2
1
2
1
2
3
2
1
2
3

0
8
10
14
15
7
3
2
6
4
12
13
5
1
9
11

1...
..1.
.1..
...1
1...
.1..
...1
.1..
..1.
1...
...1
1...
.1..
1...
..1.
[1.11

403
3
1
2
0
3
2
0
2
1
3
0
3
2
3
1
-]

step: node -> next [xf xe
0:
0 ->
8 [ 0 0
1:
8 -> 10 [ 0 0
2:
10 -> 14 [ 0 0
3:
14 -> 15 [ 0 0
4:
15 ->
7 [ 0 0
5:
7 ->
3 [ 0 1
6:
3 ->
2 [ 1 2
7:
2 ->
6 [ 0 3
8:
6 ->
4 [ 0 0
9:
4 -> 12 [ 1 3
10:
12 -> 13 [ 0 0
11:
13 ->
5 [ 0 1
12:
5 ->
1 [ 0 3
13:
1 ->
9 [ 0 2
14:
9 -> 11 [ 0 0
Path: #non-first-free turns

/ nn]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
/ 4]
= 2

Figure 20.4-A: A Gray code in the hypercube graph with randomized edge order (left) and the path
description (right, see text).
If xf equals zero at some step, the first free neighbor was visited. If xf is nonzero, a dead end was reached
in the course of the search and there was at least one U-turn. If the path is not the first found, the U-turn
might well correspond to a previous path.
If there was no U-turn, the number of non-first-free turns is zero (the number is given as the last line of
the report). If it is zero, we call the path found a lucky path. For each given ordering of the edges and
each starting position of the search there is at most one lucky path and if there is, it is the first path
found.
If the first path is a lucky path, the search effectively ‘falls through’: the number of operations is a
constant times the number of edges. That is, if a lucky path exists it is found almost immediately even
for huge graphs.

20.5

Gray codes for Lyndon words

We search Gray codes for n-bit binary Lyndon words where n is a prime. Here is a Gray code for the
5-bit Lyndon words that is a cycle:
....1
...11
.1.11
.1111
..111
..1.1

An important application of such Gray codes is the construction of single track Gray codes which can be
obtained by appending rotated versions of the block. The following is a single track Gray code based on
the block given. At each stage, the block is rotated by two positions (horizontal format):
######
-####---###
--##-------

--##------######
-####---###

-####---###
--##------######

-----######
-####---###
--##--

---###
--##------######
-####-

The transition count (the number of zero-one transitions) is by construction the same for each track. The
all-zero and the all-one words are missing in the Gray code, its length equals 2n − 2.

20.5.1

Graph search with edge sorting

Gray codes for the 7-bit binary Lyndon words like those shown in figure 20.5-A can easily be found by a
graph search. In fact, all of them can be generated in a short time: for n = 7 there are 395 Gray codes
(starting with the word 0000..001) of which 112 are cycles.
The search for such a path for the next prime, n = 11, does not seem to give a result in reasonable time.


404
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

......1
.....11
....111
...1111
..11111
..11.11
..1..11
..1.111
.11.111
.111111
.1.1111
.1.1.11
...1.11
...1..1
...11.1
..111.1
..1.1.1
....1.1

......1
...1..1
...11.1
..111.1
..1.1.1
..1.111
.11.111
.111111
.1.1111
.1.1.11
...1.11
...1111
..11111
..11.11
..1..11
.....11
....111
....1.1

......1
...1..1
...11.1
..111.1
..11111
.111111
.11.111
..1.111
..1.1.1
....1.1
....111
...1111
.1.1111
.1.1.11
...1.11
..11.11
..1..11
.....11

......1
...1..1
...11.1
....1.1
..1.1.1
..111.1
..11111
..11.11
..1..11
..1.111
.11.111
.111111
.1.1111
.1.1.11
...1.11
...1111
....111
.....11

......1
...1..1
...1.11
.1.1.11
.1.1111
.111111
.11.111
..1.111
..1.1.1
..111.1
...11.1
....1.1
....111
.....11
..1..11
..11.11
..11111
...1111

......1
.....11
....111
....1.1
..1.1.1
..111.1
...11.1
...1..1
...1.11
...1111
..11111
..11.11
..1..11
..1.111
.11.111
.111111
.1.1111
.1.1.11

Figure 20.5-A: Various Gray codes through the length-7 binary Lyndon words. The first four are cycles.
k
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:

[ node]
[
0]
[
1]
[
3]
[
7]
[
13]
[
17]
[
15]
[
10]
[
16]
[
11]
[
5]
[
14]
[
6]
[
12]
[
8]
[
4]
[
9]
[
2]

lyn_dec lyn_bin #rot rot(lyn)
1 ......1 0
......1
3 .....11 0
.....11
7 ....111 0
....111
15 ...1111 0
...1111
31 ..11111 0
..11111
63 .111111 0
.111111
47 .1.1111 0
.1.1111
23 ..1.111 1
.1.111.
55 .11.111 1
11.111.
27 ..11.11 2
11.11..
11 ...1.11 2
.1.11..
43 .1.1.11 2
.1.11.1
13 ...11.1 0
...11.1
29 ..111.1 0
..111.1
19 ..1..11 3
..11..1
9 ...1..1 0
...1..1
21 ..1.1.1 3
.1.1..1
5 ....1.1 3
.1.1...

diff delta
......1 0
.....1. 1
....1.. 2
...1... 3
..1.... 4
.1..... 5
..1.... 4
......1 0
1...... 6
.....1. 1
1...... 6
......1 0
.1..... 5
..1.... 4
....1.. 2
..1.... 4
.1..... 5
......1 0

Figure 20.5-B: A Gray code through the length-7 binary Lyndon words.
If we do not insist on a Gray code through the cyclic minima, but allow for arbitrary rotations of the
Lyndon words, then more Gray codes exist. For that purpose nodes are declared adjacent if there is any
cyclic rotation of the second node’s value that differs in exactly one bit to the first node’s value. The
cyclic rotations can be recovered easily after a path is found. This is done in [FXT: graph/graph-lyndongray-demo.cc] whose output is shown in figure 20.5-B. Still, already for n = 11 we do not get a result.
As the corresponding graph has 186 nodes and 1954 edges, this is not a surprise.
Now we sort the edges according to the comparison function [FXT: graph/lyndon-cmp.cc]
1
2
3
4
5
6
7
8
9
10

int lyndon_cmp0(const ulong &a, const ulong &b)
{
int bc = bit_count_cmp(a, b);
if ( bc ) return -bc; // more bits first
else
{
return (a>b ? +1 : -1); // greater numbers last
}
}

where bit_count_cmp() is defined in [FXT: bits/bitcount.h]:
1
2
3
4
5
6

static inline int bit_count_cmp(const ulong &a, const ulong &b)
{
ulong ca = bit_count(a);
ulong cb = bit_count(b);
return ( ca==cb ? 0 : (ca>cb ? +1 : -1) );
}

We find a Gray code (which also is a cycle) for n = 11 immediately. Same for n = 13, again a cycle. The

k : [ node]
0 : [
0]
1 : [
1]
2 : [
3]
3 : [
7]
4 : [
15]
5 : [
31]
6 : [
63]
7 : [ 125]
8 : [ 239]
9 : [ 417]
10 : [ 589]
11 : [ 629]
12 : [ 618]
13 : [ 514]
14 : [ 624]
15 : [ 550]
16 : [ 626]
17 : [ 567]
18 : [ 627]
19 : [ 576]
20 : [ 628]
21 : [ 581]
22 : [ 404]
23 : [ 614]
24 : [ 508]
25 : [ 584]
[--snip--]
615 : [
4]
616 : [
36]
617 : [
32]
618 : [
33]
619 : [ 153]
620 : [
65]
621 : [ 154]
622 : [
79]
623 : [
16]
624 : [ 126]
625 : [ 145]
626 : [ 130]
627 : [ 188]
628 : [
71]
629 : [
8]

lyn_dec
1
3
7
15
31
63
127
255
511
1023
2047
4095
3071
1535
3583
1791
3839
1919
3967
1983
4031
2015
991
3039
1519
2031
9
73
65
67
323
133
325
161
33
265
305
273
401
145
17

405

lyn_bin #rot
............1 0
...........11 0
..........111 0
.........1111 0
........11111 0
.......111111 0
......1111111 0
.....11111111 0
....111111111 0
...1111111111 0
..11111111111 0
.111111111111 0
.1.1111111111 0
..1.111111111 1
.11.111111111 1
..11.11111111 2
.111.11111111 2
..111.1111111 3
.1111.1111111 3
..1111.111111 4
.11111.111111 4
..11111.11111 5
...1111.11111 5
.1.1111.11111 5
..1.1111.1111 6
..111111.1111 6

rot(lyn)
............1
...........11
..........111
.........1111
........11111
.......111111
......1111111
.....11111111
....111111111
...1111111111
..11111111111
.111111111111
.1.1111111111
.1.111111111.
11.111111111.
11.11111111..
11.11111111.1
11.1111111..1
11.1111111.11
11.111111..11
11.111111.111
11.11111..111
11.11111...11
11.11111.1.11
11.1111..1.11
11.1111..1111

diff delta
............1 0
...........1. 1
..........1.. 2
.........1... 3
........1.... 4
.......1..... 5
......1...... 6
.....1....... 7
....1........ 8
...1......... 9
..1.......... 10
.1........... 11
..1.......... 10
............1 0
1............ 12
...........1. 1
............1 0
..........1.. 2
...........1. 1
.........1... 3
..........1.. 2
........1.... 4
..........1.. 2
.........1... 3
.......1..... 5
..........1.. 2

.........1..1
......1..1..1
......1.....1
......1....11
....1.1....11
.....1....1.1
....1.1...1.1
.....1.1....1
.......1....1
....1....1..1
....1..11...1
....1...1...1
....11..1...1
.....1..1...1
........1...1

....1..1.....
....1..1..1..
....1.....1..
....1....11..
..1.1....11..
..1.1.....1..
..1.1...1.1..
..1.....1.1..
..1.......1..
..1....1..1..
..1....1..11.
..1....1...1.
..1....11..1.
..1.....1..1.
..1........1.

..1.......... 10
..........1.. 2
.......1..... 5
.........1... 3
..1.......... 10
.........1... 3
........1.... 4
....1........ 8
........1.... 4
.......1..... 5
...........1. 1
..........1.. 2
........1.... 4
.......1..... 5
........1.... 4

5
2
2
2
2
8
2
10
10
2
10
10
10
10
10

Figure 20.5-C: Begin and end of a Gray cycle through the 13-bit binary Lyndon words.
graph for n = 13 has 630 nodes and 8,056 edges, so finding a path is quite unexpected. The cycle found
starts and ends as shown in figure 20.5-C.
For next candidate (n = 17) we do not find a Gray code within many hours of search. No surprise for
a graph with 7,710 nodes and 130,828 edges. We try another edge sorting scheme, an ordering based on
the binary Gray code [FXT: graph/lyndon-cmp.cc]:
1
2
3
4
5
6
7

{
#define CODE(x) gray_code(x)
ulong ta = CODE(a), tb = CODE(b);
return ( ta<tb ? +1 : -1);
}

We find a cycle for n = 17 and all smaller primes. All are cycles and all paths are lucky paths. The
following edge sorting scheme also leads to Gray codes for all prime n where 3 ≤ n ≤ 17:
1
2
3
4
5
6
7

{
#define CODE(x) inverse_gray_code(x)
ulong ta = CODE(a), tb = CODE(b);
return ( ta<tb ? +1 : -1);
}

Same for n = 19, the graph has 27,594 nodes and 523,978 edges. Indeed the sorting scheme leads to
cycles for all odd n ≤ 27. All these paths are lucky paths, a fact that we can exploit.

406

20.5.2

n
23
25
27
29
31
33

An optimized algorithm

number of nodes
364,722
1,342,182
4,971,066
18,512,790
69,273,666
260,301,174

tag-size
0.25 MB
1 MB
4 MB
16 MB
64 MB
256 MB

time
1 sec
3 sec
12 sec
1 min
4 min
16 min

n
35
37
39
41
43
45

number of nodes
981,706,830
3,714,566,310
14,096,303,342
53,634,713,550
204,560,302,842
781,874,934,568

tag-size
1 GB
4 GB
16 GB
64 GB
256 GB
1 TB

time
1h
7h
2d
10 d
>40 d
>160 d

Figure 20.5-D: Memory and (approximate) time needed for computing Gray codes with n-bit Lyndon
words. The number of nodes equals the number of length-n necklaces minus 2. The size of the tag array
equals 2n /4 bits or 2n /32 bytes.
With edge sorting functions that lead to a lucky path we can discard most of the data used with graph
searching. We only need to keep track of whether a node has been visited so far. A tag-array ([FXT:
ds/bitarray.h], see section 4.6 on page 164) suffices.
With n-bit Lyndon words the amount of tag-bits needed is 2n . Find an implementation of the algorithm
as [FXT: class lyndon gray in graph/lyndon-gray.h].
If only the cyclic minima of the values are tagged, then only 2n /2 bits are needed if the access to the
single necklace consisting of all ones is treated separately. This variant of the algorithm is activated by
uncommenting the line #define ALT_ALGORITM. As the lowest bit in a necklace is always one, we need
only 2n /4 bits: simply shift the words to the right by one position before testing or writing to the tag
array. This can be activated by additionally uncommenting the line #define ALTALT in the file.
When a node is visited, the algorithm creates a table of neighbors and selects the minimum among the
free nodes with respect to the edge sorting function used. Then the table of neighbors is discarded to
minimize memory usage.
If no neighbor is found, the number of nodes visited so far is returned. If this number equals the number
of n-bit Lyndon words, then a lucky path was found. With composite n a Gray code for n-bit necklaces
(with the exception of the all-ones and the all-zeros word) will be searched.
Four variants of the algorithm have been found so far, corresponding to edge sorting with the 3rd, 5th,
21th, and 29th power of the Gray code. We refer to these functions as comparison functions 0, 1, 2, and
3, respectively. All of these lead to cycles for all primes n ≤ 31. The resources needed with greater values
of n are shown in figure 20.5-D.
Using a 64-bit machine equipped with more than 4 Gigabyte of RAM, it can be verified that three of
the edge sorting functions lead to a Gray cycle also for n = 37, the 3rd power version fails. One of the
sorting functions may lead to a Gray code for n = 41.
A program to compute the Gray codes is [FXT: graph/lyndon-gray-demo.cc], four arguments can be
given:
arg
arg
arg
arg

1:
2:
3:
4:

13 == n [ a prime < BITS_PER_LONG ] default=17
1 == wh [printing: 0==>none, 1==>delta seq., 2==>full output] default=1
3 == ncmp [use comparison function (0,1,2,3)] default=2
0 == testall [special: test all odd values <= value] default=0

An example with full output is given in figure 20.5-E. A 64-bit CRC (see section 41.3 on page 868) is
computed from the delta sequence (rightmost column) and printed with the last word.
For large n one might want to print only the delta sequence, as shown in figure 20.5-F. The CRC is used
to determine whether two delta sequences are different. Different sequences sometimes start identically.


% ./bin 7 2 0 # 7
n = 7
#lyn = 18
1:
......1
2:
...1..1
3:
..1..11
4:
..1.111
5:
.1.1111
6:
.1.1.11
7:
.11.111
8:
.111111
9:
..11111
10:
..111.1
11:
..1.1.1
12:
....1.1
13:
...1.11
14:
..11.11
15:
...11.1
16:
...1111
17:
....111
18:
.....11
last = .....11
n = 7
#lyn = 18

407

bits, full output, comparison function 0
0 ......1
......1
0 ...1..1
...1...
3 ..11..1
..1....
3 .111..1
.1.....
2 .1111.1
....1..
2 .1.11.1
..1....
5 11.11.1
1......
2 11111.1
..1....
2 11111..
......1
2 111.1..
...1...
2 1.1.1..
.1.....
2 ..1.1..
1......
1 ..1.11.
.....1.
1 .11.11.
.1.....
2 .11.1..
.....1.
2 .1111..
...1...
2 ..111..
.1.....
2 ...11..
..1....
crc=0b14a5846c41d57f
#= 18

0
3
4
5
2
4
6
4
0
3
5
6
1
5
1
3
5
4

Figure 20.5-E: A Gray code for 7-bit Lyndon words.
% ./bin 13 1 2 # 13 bits, delta seq. output, comparison function 2
n = 13
#lyn = 630
06B57458354645962546436734A74684A106C0145120825747A745247AC8564567018A7654647484A756A546457CA1ACBC1C
856BA9A64B97456548645659645219425215315BC82BC75BA02926256354267A462475A3ACB9761560C37412583758CA5624
B8C6A6C6A87A9C20CBA4534042014540523129075697651563160204230A7BA31C1485C6105201510490BCA891BA9B1B9AC0
A9A89B898A565B8785745865747845A9546702305A41275315458767465747A8457845470379A8586B0A7698578767976759
A976567686A567656A576B86581305A20AB0ACB0AB53523438235465325247563A432532A372354657643572373624634642
4532397423435235653236423263235234327532342325396926853234232582642436823632346362358423242383242327
523242325323432642324235323423
last = ...........11
crc=568dab04b55aa2fb
n = 13
#lyn = 630
#= 630
% ./bin 13 1 3 # 13 bits, delta seq. output, comparison function 3
n = 13
#lyn = 630
06B57458354645962546436735371CA8B1587BA7610635285A0C2484B9713476B689A897AC98768968B9A106326016261050
1424B8979A78987B97898C98921941315313698314281687BCB9469C489C6210205B050A1A7A4568A9BC5CB79AB647B74812
0AB30BC1A131ACB120B0164CA1CABA121ABACA2B0BACAB1845786784989584867646A8456191654694745787545865490137
40201031012104270171216507457B854606C16BC523801365164130164BC7987A09872CBA9A87A20B787AC9B7CBA834C0C1
3C341C1042010C14C01C414587854645A854C95035A6A9570A9756586B9B5969580A0872C3123B0CB316BC6C0B21B2C0C2C0
5301C0530CB1C1530C01CB0BC20CBC0CB1C87565756865A75A65A40898A898B91CA898A8B898A81BC8A9ACA989AB817A9BC1
BA9ABA9CA9AB918A1CACBAC9BCB0BC
last = ...........11
crc=745def277b1fbed0
n = 13
#lyn = 630
#= 630

Figure 20.5-F: Delta sequences for two diﬀerent Gray codes for 13-bit Lyndon words.
% ./bin 29 0 0 # 29 bits, output=progress, comparison function 0
n = 29
#lyn = 18512790
................
1048576 ( 5.66406 % )
crc=ceabc5f2056be699
................
2097152 ( 11.3281 % )
crc=76dd94f1a554b50d
................
3145728 ( 16.9922 % )
crc=6b39957f1e141f4d
................
4194304 ( 22.6563 % )
crc=53419af1f1185dc0
................
5242880 ( 28.3203 % )
crc=45d45b193f8ee566
................
6291456 ( 33.9844 % )
crc=95a24c824f56e196
................
7340032 ( 39.6484 % )
crc=003ee5af5b248e34
................
8388608 ( 45.3125 % )
crc=23cb74d3ea0c4587
................
9437184 ( 50.9766 % )
crc=896fd04c87dd0d43
................
10485760 ( 56.6406 % )
crc=b00d8c899f0fc791
................
11534336 ( 62.3047 % )
crc=d148f1b95b23eeab
................
12582912 ( 67.9688 % )
crc=82971e2ed4863050
................
13631488 ( 73.6328 % )
crc=f249ad5b4fed252d
................
14680064 ( 79.2969 % )
crc=909821d0c7246a98
................
15728640 ( 84.9609 % )
crc=1c5d68e38e55b3ca
................
16777216 ( 90.625 % )
crc=0e64f82c67c79cf1
................
17825792 ( 96.2891 % )
crc=62c17b9f3c644396
..........
last = ...........................11
crc=5736fc9365da927e
n = 29
#lyn = 18512790
#= 18512790
Figure 20.5-G: Computation of a Gray code through the 29-bit Lyndon words. Most output is suppressed, only the CRC is printed at certain checkpoints.


408

For still greater values of n even the delta sequence tends to get huge (for example, with n = 37 the
sequence would be approximately 3.7 GB). One can suppress all output except for a progress indication,
as shown in figure 20.5-G. Here the CRC checksum is updated only with every (cyclically unadjusted)
216 -th Lyndon word.
Sometimes a Gray code through the necklaces (except for the all-zeros and all-ones words) is also found
for composite n. Comparison functions 0, 1, and 2 lead to Gray codes (which are cycles) for all odd
n ≤ 33. Gray cycles are also found with comparison function 3, except for n = 21, 27, and 33. All
functions give Gray cycles also for n = 4 and n = 6. The values of n for which no Gray code was found
are the even values ≥ 8.

20.5.3

No Gray codes for even n ≥ 8

As the parity of the words in a Gray code sequence alternates between one and zero, the difference
between the numbers words of odd and even weight must be zero or one. If it is one, no Gray cycle can
exist because the parity of the first and last word is identical.
We use the relations from section 18.3.2 on page 382. For Lyndon words of odd length there are the same
number of words for odd and even weight by symmetry, so a Gray code (and also a Gray cycle) can exist.
For even length the sequence of numbers of Lyndon words of odd and even weights start as:
n:
odd:
even:
diff:

2,
1,
0,
1,

4,
2,
1,
1,

6, 8, 10, 12, 14,
16,
18,
20,
22,
24,
26, ...
5, 16, 51, 170, 585, 2048, 7280, 26214, 95325, 349520, 1290555, ...
4, 14, 48, 165, 576, 2032, 7252, 26163, 95232, 349350, 1290240, ...
1, 2, 3,
5,
9,
16,
28,
51,
93,
170,
315, ...

The last row gives the differences, entry A000048 in [312]. All entries for n ≥ 8 are greater than one, so
no Gray code exists.
For the number of necklaces we have, for n = 2, 4, 6, . . .
n:
odd:
even:
diff:

2,
1,
2,
1,

4,
2,
4,
2,

6, 8, 10, 12, 14,
16,
18,
20,
22,
24,
26, ...
6, 16, 52, 172, 586, 2048, 7286, 26216, 95326, 349536, 1290556, ...
8, 20, 56, 180, 596, 2068, 7316, 26272, 95420, 349716, 1290872, ...
2, 4, 4,
8, 10,
20,
30,
56,
94,
180,
316, ...

The (absolute) difference of both sequences is entry A000013 in [312]. We see that for n ≥ 4 the numbers
are greater than one, so no Gray code exists.
If we exclude the all-ones and all-zeros words, then the differences are
n:
diff:

2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, ...
1, 0, 0, 2, 2, 6, 8, 18, 28, 54, 92, 178, 314, ...

And again, no Gray code exists for n ≥ 8. That is, we have found Gray codes, and even cycles, for all
computationally feasible sizes where they can exist.

409

Part III

Fast transforms

410

Chapter 21: The Fourier transform

Chapter 21

The Fourier transform
We introduce the discrete Fourier transform and give algorithms for its fast computation. Implementations and optimization considerations for complex and real-valued transforms are given. The fast Fourier
transforms are the basis of the algorithms for fast convolution described in chapter 22. These are in turn
the core of the fast high precision multiplication routines treated in chapter 28. The number theoretic
transforms are treated in chapter 26. Algorithms for Fourier transforms based on fast convolution like
Bluestein’s algorithm and Rader’s algorithm are given in chapter 22.

21.1

The discrete Fourier transform

The discrete Fourier transform (DFT) of a complex sequence a = [a0 , a1 , . . . , an−1 ] of length n is the
complex sequence c = [c0 , c1 , . . . , cn−1 ] deﬁned by
c
ck

=
:=

F a
1
√
n

(21.1-1a)
n−1

ax z +x k

where

z = e2 π i/n

(21.1-1b)

x=0

z is a primitive n-th root of unity: z n = 1 and z j = 1 for 0 < j < n.
The inverse discrete Fourier transform is
a

=

F −1 c

ax

:=

1
√
n

(21.1-2a)

n−1

ck z −x k

(21.1-2b)

k=0

To see this, consider the element y of the inverse transform of the transform of a:
F −1 F a

y

=
=

1
√
n
1
n

n−1

k=0

1
√
n

(ax z x k ) z −y k

(21.1-3a)

x=0

(z x−y )k

ax
x

n−1

(21.1-3b)

k

Now k (z x−y )k = n for x = y and 0 else. This is because z is an n-th primitive root of unity: with
x = y the sum consists of n times z 0 = 1, with x = y the summands lie on the unit circle (on the vertices
of an equilateral polygon with center 0) and add up to 0. Therefore the whole expression is equal to
1
n
n

ax δx,y
x

= ay

where

δx,y :=

1 if x = y
0 otherwise

(21.1-4)

Here we will call the transform with the plus in the exponent the forward transform. The choice is
actually arbitrary, engineers seem to prefer the minus for the forward transform, mathematicians the
plus. The sign in the exponent is called the sign of the transform.

21.2: Radix-2 FFT algorithms

411

The Fourier transform is linear: for α, β ∈ C we have
F αa + βb

= αF a + βF b

(21.1-5)

Further Parseval’s equation holds, the sum of squares of the absolute values is identical for a sequence
and its Fourier transform:
n−1

n−1
2

|ax |
x=0

2

|ck |

=

(21.1-6)

k=0

A straightforward implementation of the discrete Fourier transform, that is, the computation of n sums
each of length n, requires O(n2 ) operations [FXT: fft/slowft.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void slow_ft(Complex *f, long n, int is)
{
Complex h[n];
const double ph0 = is*2.0*M_PI/n;
for (long w=0; w<n; ++w)
{
Complex t = 0.0;
for (long k=0; k<n; ++k)
{
t += f[k] * SinCos(ph0*k*w);
}
h[w] = t;
}
acopy(h, f, n);
}

The variable is = σ = ±1 is the sign of the transform, the function SinCos(x) returns the complex
√
number cos(x) + i sin(x). Note that the normalization factor 1/ n in front of the sums has been left
out. The inverse of the transform with sign σ is the transform with sign −σ followed by a multiplication
of each element by 1/n. The sum of squares of the original sequence and its transform are equal up to a
√
factor 1/ n.
A fast Fourier transform (FFT) algorithm has complexity O(n log(n)). There are several different FFT
algorithms with many variants.

21.2

Radix-2 FFT algorithms

We fix some notation. In what follows let a be a length-n sequence with n a power of 2.
• Let a(even) and a(odd) denote the length-n/2 subsequences of those elements of a that have even and
odd indices, respectively. That is, a(even) = [a0 , a2 , a4 , a6 , . . . , an−2 ] and a(odd) = [a1 , a3 , . . . , an−1 ].
• Let a(lef t) and a(right) denote the left and right subsequences, respectively. That is, a(lef t) =
[a0 , a1 , . . . , an/2−1 ] and a(right) = [an/2 , an/2+1 , . . . , an−1 ].
• Let c = S k a denote the sequence with elements cx = ax eσ 2 π i k x/n where σ = ±1 is the sign of the
transform. The symbol S shall suggest a shift operator. With radix-2 FFT algorithms only S 1/2 is
needed. Note that the operator S depends on the sign of the transform.
• In relations between sequences we sometimes emphasize the length of the sequences on both sides
n/2

as in a(even) = b(odd) + c(odd) . In these relations the operators + and − are element-wise.

412


21.2.1

Decimation in time (DIT) FFT

The following observation is the key to the (radix-2) decimation in time (DIT) FFT algorithm, also called
the Cooley-Tukey FFT algorithm: For even values of n the k-th element of the Fourier transform is
n/2−1

n−1

F a

k

ax z x k

=
x=0

n/2−1

a2 x z 2 x k +

=
x=0

a2 x+1 z (2 x+1) k

n/2−1

n/2−1

a2 x z 2 x k + z k

=

(21.2-1a)

x=0

x=0

a2 x+1 z 2 x k

(21.2-1b)

x=0

where z = eσ 2 π i/n , σ = ±1 is the sign of the transform, and k ∈ {0, 1, . . . , n − 1}.
The identity tells us how to compute the k-th element of the length-n Fourier transform from the lengthn/2 Fourier transforms of the even and odd indexed subsequences.
To rewrite the length-n transform in terms of length-n/2 transforms, we have to distinguish whether
0 ≤ k < n/2 or n/2 ≤ k < n. In the expressions we rewrite k ∈ {0, 1, 2, . . . , n − 1} as k = j + δ n where
2
j ∈ {0, 1, 2, . . . , n/2 − 1} and δ ∈ {0, 1}:
n/2−1

n/2−1

n−1

ax z x (j+δ

n
2)

(even) 2 x (j+δ
ax
z

=

x=0

n
2)

+ z j+δ

n
2

=








n
2)

(21.2-2a)

x=0

x=0









a(odd) z 2 x (j+δ
x

n/2−1

n/2−1
(even) 2 x j
ax
z
+ zj

a(odd) z 2 x j
x

x=0
n/2−1

for δ = 0

x=0
n/2−1
(even) 2 x j
ax
z
− zj

x=0

(21.2-2b)
a(odd) z 2 x j
x

for δ = 1

x=0

The minus sign in the relation for δ = 1 is due to the equality z j+1·n/2 = z j z n/2 = −z j .
Observing that z 2 is just the root of unity that appears in a length-n/2 transform we can rewrite the last
two equations to obtain the radix-2 DIT FFT step:
F a
F a

(lef t)

n/2

=

F a(even) + S 1/2 F a(odd)

(21.2-3a)

(right)

n/2

F a(even) − S 1/2 F a(odd)

(21.2-3b)

=

The length-n transform has been replaced by two transforms of length n/2. If n is a power of 2, this
scheme can be applied recursively until length-one transforms are reached which are identity (‘do nothing’)
operations.
The complexity is O (n log2 (n)): there are log2 (n) splitting steps, the work in each step is O(n).
21.2.1.1

Recursive implementation

A recursive implementation of radix-2 DIT FFT given as pseudocode (C++ version in [FXT:
ﬀt/recﬀt2.cc]) is
1
2
3
4
5
6
7
8
9
10
11

procedure rec_fft_dit2(a[], n, x[], is)
// complex a[0..n-1] input
// complex x[0..n-1] result
{
complex b[0..n/2-1], c[0..n/2-1]
// workspace
complex s[0..n/2-1], t[0..n/2-1]
// workspace
if n == 1 then // end of recursion
{
x[0] := a[0]
return

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

413

}
nh := n/2
for k:=0 to nh-1 // copy to workspace
{
s[k] := a[2*k]
// even indexed elements
t[k] := a[2*k+1] // odd indexed elements
}
// recursion: call two half-length FFTs:
rec_fft_dit2(s[], nh, b[], is)
rec_fft_dit2(t[], nh, c[], is)
fourier_shift(c[], nh, is*1/2)
for k:=0 to nh-1 // copy back from workspace
{
x[k]
:= b[k] + c[k]
x[k+nh] := b[k] - c[k]
}
}

The parameter is = σ = ±1 is the sign of the transform. The data length n must be a power of 2. The
result is returned in the array x[ ]. Note that normalization (multiplication of each element of x[ ] by
√
1/ n) is not included here.
The procedure uses the subroutine fourier_shift() which modifies the array c[ ] according to the
operation S v : each element c[k] is multiplied by ev 2 π i k/n . It is called with v = ±1/2 for the Fourier
transform. The pseudocode (C++ equivalent in [FXT: fft/fouriershift.cc]) is
1
2
3
4
5
6
7

procedure fourier_shift(c[], n, v)
{
for k:=0 to n-1
{
c[k] := c[k] * exp(v*2.0*PI*I*k/n)
}
}

The recursive FFT-procedure involves O(n) function calls to itself, these can be avoided by rewriting it
in a iterative way. We can even do all operations in-place, no temporary workspace is needed at all. The
price is the necessity of an additional data reordering: the procedure revbin_permute(a[],n) rearranges
the array a[ ] in a way that each element ax is swapped with ax , where x is obtained from x by reversing
˜
˜
its binary digits. Methods for doing this are discussed in section 2.6 on page 118.
21.2.1.2

Iterative implementation

A non-recursive procedure for the radix-2 DIT FFT is (C++ version in [FXT: fft/fftdit2.cc]):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

procedure fft_depth_first_dit2(a[], ldn, is)
// complex a[0..2**ldn-1] input, result
{
n := 2**ldn // length of a[] is a power of 2
revbin_permute(a[], n)
for ldm:=1 to ldn
{
m := 2**ldm
mh := m/2

// log_2(n) iterations

for r:=0 to n-m step m // n/m iterations
{
for j:=0 to mh-1 // m/2 iterations
{
e := exp(is*2*PI*I*j/m) // log_2(n)*n/m*m/2 = log_2(n)*n/2 computations
u := a[r+j]
v := a[r+j+mh] * e
a[r+j]
:= u + v
a[r+j+mh] := u - v
}
}

414
26
27

}

}

This version of a non-recursive FFT procedure already avoids the calling overhead and it works in-place.
But it is a bit wasteful. The (expensive) computation e := exp(is*2*PI*I*j/m) is done n/2 · log2 (n)
times.
21.2.1.3

Saving trigonometric computations

To reduce the number of sine and cosine computations, we can swap the two inner loops, leading to the
first ‘real world’ FFT procedure presented here. A non-recursive procedure for the radix-2 DIT FFT is
(C++ version in [FXT: fft/fftdit2.cc]):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

procedure fft_dit2(a[], ldn, is)
{
n := 2**ldn
for ldm:=1 to ldn
{
m := 2**ldm
mh := m/2

// log_2(n) iterations

for j:=0 to mh-1 // m/2 iterations
{
e := exp(is*2*PI*I*j/m) // 1 + 2 + ... + n/8 + n/4 + n/2 == n-1 computations
for r:=0 to n-m step m
{
u := a[r+j]
v := a[r+j+mh] * e
a[r+j]
:= u + v
a[r+j+mh] := u - v
}
}
}
}

Swapping the two inner loops reduces the number of trigonometric computations to n but leads to a
feature that many FFT implementations share: memory access is highly non-local. For each recursion
stage (value of ldm) the array is traversed mh times with n/m accesses in strides of mh. This memory
access pattern can have a very negative performance impact for large n. If memory access is very slow
compared to the CPU, the naive version can actually be faster.
It is a good idea to extract the ldm==1 stage of the outermost loop. This avoids complex multiplications
with the trivial factors 1+0 i and the computations of these quantities as trigonometric functions. Replace
the line
for ldm:=1 to ldn

by the lines
for r:=0 to n-1 step 2
{
{ a[r], a[r+1] } := { a[r] + a[r+1], a[r] - a[r+1] }
}
for ldm:=2 to ldn

// parallel assignment

The parallel assignment would translate into the following C-code:
Complex tmp1 = a[r] + a[r+1],
a[r] = tmp1;
a[r+1] = tmp2;

21.2.2

tmp2 = a[r] - a[r+1];

Decimation in frequency (DIF) FFT

By splitting the Fourier sum into a left and right half we obtain the decimation in frequency (DIF) FFT
algorithm, also called Sande-Tukey FFT algorithm. For even values of n the k-th element of the Fourier


415

transform is
n/2−1

n−1

F a

k

ax z x k

=
x=0

n−1

ax z x k +

=
x=0

(21.2-4a)

ax+n/2 z (x+n/2) k

(21.2-4b)

x=n/2

n/2−1

=

ax z x k
n/2−1

ax z

xk

+

x=0

x=0

n/2−1

(a(lef t) + z k n/2 a(right) ) z x k
x
x

=

(21.2-4c)

x=0

where z = eσ 2 π i/n , σ = ±1 is the sign of the transform, and k ∈ {0, 1, . . . , n − 1}.
Here one has to distinguish whether k is even or odd. Therefore we rewrite k ∈ {0, 1, 2, . . . , n − 1} as
k = 2 j + δ where j ∈ {0, 1, 2, . . . , n/2 − 1} and δ ∈ {0, 1}:
n/2−1

n−1

ax z

x (2 j+δ)

(a(lef t) + z (2 j+δ) n/2 a(right) ) z x (2 j+δ)
x
x

=

x=0

(21.2-5a)

x=0

=













n/2−1

(a(lef t) + a(right) ) z 2 x j
x
x

for

δ=0

x=0
n/2−1

(21.2-5b)
z x (a(lef t) − a(right) ) z 2 x j
x
x

for

δ=1

x=0

Now z (2 j+δ) n/2 = e±π i δ equals +1 for δ = 0 (even k) and −1 for δ = 1 (odd k). The last two equations,
more compactly written, are the radix-2 DIF FFT step:
F a
F a

(even)

n/2

F a(lef t) + a(right)

(21.2-6a)

(odd)

n/2

F S 1/2 a(lef t) − a(right)

(21.2-6b)

=

=

A recursive implementation of radix-2 DIF FFT is (C++ version given in [FXT: ﬀt/recﬀt2.cc]) is
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

procedure rec_fft_dif2(a[], n, x[], is)
// complex a[0..n-1] input
// complex x[0..n-1] result
{
complex b[0..n/2-1], c[0..n/2-1]
// workspace
complex s[0..n/2-1], t[0..n/2-1]
// workspace
if n == 1 then
{
x[0] := a[0]
return
}
nh := n/2
for k:=0 to nh-1
{
s[k] := a[k]
t[k] := a[k+nh]
}

// ’left’ elements
// ’right’ elements

for k:=0 to nh-1
{
{ s[k], t[k] } := { s[k] + t[k], s[k] - t[k] }
}
fourier_shift(t[], nh, is*0.5)
rec_fft_dif2(s[], nh, b[], is)
rec_fft_dif2(t[], nh, c[], is)


416
32
33
34
35
36
37
38
39

j := 0
for k:=0 to nh-1
{
x[j]
:= b[k]
x[j+1] := c[k]
j := j+2
}

}

The parameter is = σ = ±1 is the sign of the transform. The data length n must be a power of 2. The
result is returned in the array x[ ]. Again, the routine does no normalization.
A non-recursive version is (the C++ equivalent is given in [FXT: ﬀt/ﬀtdif2.cc]):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

procedure fft_dif2(a[],ldn,is)
{
n := 2**ldn
for ldm:=ldn to 1 step -1
{
m := 2**ldm
mh := m/2
for j:=0 to mh-1
{
e := exp(is*2*PI*I*j/m)
for r:=0 to n-m step m
{
u := a[r+j]
v := a[r+j+mh]
a[r+j]
:= (u + v)
a[r+j+mh] := (u - v) * e
}
}
}
}

In DIF FFTs the procedure revbin_permute() is called after the main loop, in the DIT code it is called
before the main loop. As in the procedure for the DIT FFT (section 21.2.1.3 on page 414) the inner loops
were swapped to save trigonometric computations.
Extracting the ldm==1 stage of the outermost loop is again a good idea. Replace the line
for

ldm:=ldn to 1 step -1

for

ldm:=ldn to 2 step -1

by
and insert
{
{ a[r], a[r+1] } := { a[r] + a[r+1], a[r] - a[r+1] }
}


before the call of revbin_permute(a[], n).

21.3

Saving trigonometric computations

The sine and cosine computations are an expensive part of any FFT. There are two apparent ways for
saving CPU cycles, the use of lookup-tables and recursive methods. The CORDIC algorithms for sine
and cosine given in section 33.2.1 on page 646 can be useful when implementing FFTs in hardware.

21.3.1

Using lookup tables

We can precompute and store all necessary values, and later look them up when needed. This is a good
idea when computing many FFTs of the same (small) length. For FFTs of long sequences one needs large

21.3: Saving trigonometric computations

417

lookup tables that can introduce a high cache-miss rate. So we may experience little or no speed gain,
even a notable slowdown is possible.
However, for a length-n FFT we do not need to store all the (n complex or 2 n real) sine/cosine values
exp(2 π i k/n) = cos(2 π k/n) + i sin(2 π k/n) where k = 0, 1, 2, 3, . . . , n − 1. The following symmetry
relations reduce the interval from 0 . . . 2π to 0 . . . π:
cos(π + x)

=

− cos(x)

(21.3-1a)

sin(π + x)

=

− sin(x)

(21.3-1b)

The next relations further reduce the interval to 0 . . . π/2:
cos(π/2 + x)

= − sin(x)

(21.3-2a)

sin(π/2 + x)

=

(21.3-2b)

+ cos(x)

Finally, only the table of cosines is needed:
sin(x)

=

cos(π/2 − x)

(21.3-3)

That is, already a table of the n/4 real values cos(2 π i k/n) for k = 0, 1, 2, 3, . . . , n/4 − 1 suﬃces for a
length-n FFT computation. The size of the table is thereby cut by a factor of 8. Possible cache problems
can sometimes be mitigated by simply storing the trigonometric values in reversed order, as this avoids
many equidistant memory accesses.

21.3.2


We write E(x) for exp(i x) = sin(x) + i cos(x). In FFT computations one typically needs the values
e0 = E (ϕ) , e1 = E (ϕ + 1 γ) , e2 = E (ϕ + 2 γ) , e3 = E (ϕ + 3 γ) , . . . , ek = E (ϕ + k γ) , . . .
in sequence. We could precompute g = E(γ) and e0 = E(ϕ), and compute the values successively as
ek

=

g · ek−1

(21.3-4)

However, the numerical error grows exponentially, rendering the method useless (same for the recursions
35.2-10a and 35.2-10b on page 679). A stable version of a trigonometric recursion for the computation
of the sequence can be stated as follows. Precompute
c0

=

cos ϕ,

(21.3-5a)

s0

=

sin ϕ,

(21.3-5b)

α

1 − cos γ
γ
= 2 sin
2
= sin γ

β

=

[Cancellation!]

(21.3-5c)

2

[OK.]

(21.3-5d)
(21.3-5e)

Then compute the next pair (ck+1 , sk+1 ) from (ck , sk ) via
ck+1

= ck − (α ck + β sk ) ;

(21.3-6a)

sk+1

= sk − (α sk − β ck ) ;

(21.3-6b)

Here we use the relation E(ϕ+γ) = E(ϕ)−E(ϕ)·z, this leads to z = 1−cos γ−i sin γ = 2 sin γ
2

2

−i sin γ.

A certain loss of precision still has to be expected, but even for very long FFTs less than 3 bits of precision
are lost. When working with the C-type double it might be a good idea to use the type long double
with the trigonometric recursion: the generated values will then always be accurate within the precision
of the typedouble, provided long doubles are actually more precise than doubles. With exact integer
convolution this can be mandatory.
We give an example from [FXT: fht/fhtdif.cc], the variable tt is γ in relations 21.3-5d and 21.3-5e:

418


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[--snip--]
double tt = M_PI_4/kh;
// the angle increment
double s1 = 0.0, c1 = 1.0; // start at angle zero
double al = sin(0.5*tt);
al *= (2.0*al);
double be = sin(tt);
for (ulong i=1; i<kh; i++)
{
double t1 = c1;
c1 -= (al*t1+be*s1);
s1 -= (al*s1-be*t1);
// here c1 = cos(tt*i) and s1 = sin(tt*i)
[--snip--]

21.4

Higher radix FFT algorithms

Higher radix FFT algorithms save trigonometric computations. The radix-4 FFT algorithms presented
in what follows replace all multiplications with complex factors (0, ±i) by the obvious simpler operations.
Radix-8 algorithms also simplify the special cases where the sines and cosines equal ± 1/2.
The bookkeeping overhead is also reduced, due to the more unrolled structure. Moreover, the number of
loads and stores is reduced.
We ﬁx more notation. Let a be a length-n sequence where n is a multiple of m.
• Let a(r%m) denote the subsequence of the elements with index x where x ≡ r mod m. For example,
a(0%2) = a(even) and a(3%4) = [a3 , a7 , a11 , a15 , . . . ]. The length of a(r%m) is n/m.
• Let a(r/m) denote the subsequence obtained by splitting a into m parts of length n/m: a =
a(0/m) , a(1/m) , . . . , a((m−1)/m) . For example a(1/2) = a(right) and a(2/3) is the last third of a.

21.4.1

Decimation in time algorithms

We rewrite the radix-2 DIT step (relations 21.2-3a and 21.2-3b on page 412) in the new notation:
F a

(0/2)

n/2

=

S 0/2 F a(0%2) + S 1/2 F a(1%2)

(21.4-1a)

F a

(1/2)

n/2

S 0/2 F a(0%2) − S 1/2 F a(1%2)

(21.4-1b)

=

The operator S is deﬁned in section 21.2 on page 411, note that S 0/2 = S 0 is the identity operator.
The derivation of the radix-4 step is analogous to the radix-2 step, it just involves more writing and does
not give additional insights. So we just state the radix-4 DIT FFT step which can be applied when n is
divisible by 4:
F a

(0/4)

n/4

+S 0/4 F a(0%4) +

F a

(1/4)

n/4

+S 0/4 F a(0%4) + iσS 1/4 F a(1%4) − S 2/4 F a(2%4) − iσS 3/4 F a(3%4) (21.4-2b)

F a

(2/4)

n/4

+S 0/4 F a(0%4) −

F a

(3/4)

n/4

+S 0/4 F a(0%4) − iσS 1/4 F a(1%4) − S 2/4 F a(2%4) + iσS 3/4 F a(3%4) (21.4-2d)

=

=

=
=

S 1/4 F a(1%4) + S 2/4 F a(2%4) +

S 1/4 F a(1%4) + S 2/4 F a(2%4) −

S 3/4 F a(3%4) (21.4-2a)

S 3/4 F a(3%4) (21.4-2c)

The relations can be written more compactly as
F a

(j/4)

n/4

=

+eσ 2 π i 0 j/4 · S 0/4 F a(0%4) + eσ 2 π i 1 j/4 · S 1/4 F a(1%4)
+e

σ 2 π i 2 j/4

·S

2/4

(2%4)

F a

+e

σ 2 π i 3 j/4

·S

3/4

(21.4-3)

(3%4)

F a

where j ∈ {0, 1, 2, 3} and n is a multiple of 4. An even more compact form is
F a

(j/4)

n/4

3

eσ2 π i k j/4 · S k/4 F a(k%4)

=

k=0

j ∈ {0, 1, 2, 3}

(21.4-4)

21.4: Higher radix FFT algorithms

419

where the summation symbol denotes element-wise summation of the sequences. The dot indicates
multiplication of all elements of the sequence by the exponential.
The general radix-r DIT FFT step, applicable when n is a multiple of r, is:
F a

(j/r)

n/r

r−1

eσ 2 π i k j/r · S k/r F a(k%r)

=

j = 0, 1, 2, . . . , r − 1

(21.4-5)

k=0

Our notation turned out to be useful indeed.

21.4.2

Decimation in frequency algorithms

The radix-2 DIF step (relations 21.2-6a and 21.2-6b on page 415), in the new notation, is
F a

(0%2)

n/2

=

F S 0/2 a(0/2) + a(1/2)

(21.4-6a)

F a

(1%2)

n/2

F S 1/2 a(0/2) − a(1/2)

(21.4-6b)

=

The radix-4 DIF FFT step, applicable for n divisible by 4, is
F a

(0%4)

n/4

F S 0/4 a(0/4) +

a(3/4)

(21.4-7a)

F a

(1%4)

n/4

F S 1/4 a(0/4) + i σ a(1/4) − a(2/4) − i σ a(3/4)

(21.4-7b)

F a

(2%4)

n/4

F S 2/4 a(0/4) −

a(3/4)

(21.4-7c)

F a

(3%4)

n/4

F S 3/4 a(0/4) − i σ a(1/4) − a(2/4) + i σ a(3/4)

(21.4-7d)

=

=

=

=

a(1/4) + a(2/4) +

a(1/4) + a(2/4) −

Again, σ = ±1 is the sign of the transform. Written more compactly:
F a

(j%4)

n/4

=

3

F S j/4

eσ 2 π i k j/4 · a(k/4)

j ∈ {0, 1, 2, 3}

(21.4-8)

j ∈ {0, 1, 2, . . . , r − 1}

(21.4-9)

k=0

The general radix-r DIF FFT step is
F a

(j%r)

n/r

=

r−1

F S

j/r

eσ 2 π i k j/r · a(k/r)
k=0

21.4.3

Implementation of radix-r FFTs

For the implementation of a radix-r FFT with r = 2 the revbin_permute routine has to be replaced by
its radix-r version radix_permute. The reordering now swaps elements ax with ax where x is obtained
˜
˜
from x by reversing its radix-r expansion (see section 2.7 on page 121). In most practical cases one
considers r = px where p is a prime. Pseudocode for a radix r = px DIT FFT:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

procedure fftdit_r(a[], n, is)
// complex a[0..n-1] input, result.
// r == power of p (hard-coded)
// n == power of p (not necessarily a power of r)
{
radix_permute(a[], n, p)
lx := log(r) / log(p) // r == p ** lx
ln := log(n) / log(p)
ldm := (log(n)/log(p)) % lx
// lx, ln, abd ldm are all integers
if ( ldm != 0 )
{

// n is not a power of p

420
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

xx := p**lx
for z:=0 to n-xx step xx
{
fft_dit_xx(a[z..z+xx-1], is)
}

// inlined length-xx DIT FFT

}
for ldm:=ldm+lx to ln step lx
{
m := p**ldm
mr := m/r
for j := 0 to mr-1
{
for k:=0 to n-m step m
{
// All code in this block should be inlined and unrolled:
// temporary

u[0..r-1]

for z:=0 to r-1
{
u[z] := a[k+j+mr*z]
}
radix_permute(u[], r, p)
for z:=1 to r-1 // e**0 == 1
{
u[z] := u[z] * e**z
}
r_point_fft(u[], is)
for z:=0 to r-1
{
a[k+j+mr*z] := u[z]
}
}
}
}
}

Of course the loops that use the variable z have to be unrolled, the (length-px ) array u[ ] has to be
replaced by explicit variables (for example, u0, u1, ... ), and the r_point_fft(u[],is) should be
an inlined px -point FFT.
There is one pitfall: if one uses the radix-p permutation instead of a radix-px permutation (for example,
the radix-2 revbin_permute() for a radix-4 FFT), then some additional reordering is necessary in the
innermost loop. In the given pseudocode this is indicated by the radix_permute(u[],p) just before the
p_point_fft(u[],is) line.

21.4.4

Radix-4 DIT FFT

A C++ routine for the radix-4 DIT FFT is given in [FXT: ﬀt/ﬀtdit4l.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static const ulong RX = 4;
static const ulong LX = 2;

// == r
// == log(r)/log(p) == log_2(r)

void
fft_dit4l(Complex *f, ulong ldn, int is)
// Decimation in time radix-4 FFT.
{
double s2pi = ( is>0 ? 2.0*M_PI : -2.0*M_PI );
const ulong n = (1UL<<ldn);
ulong ldm = (ldn&1);
if ( ldm!=0 ) // n is not a power of 4, need a radix-2 step
{
for (ulong r=0; r<n; r+=2)

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

421

{
Complex a0 = f[r];
Complex a1 = f[r+1];
f[r]
= a0 + a1;
f[r+1] = a0 - a1;
}
}
ldm += LX;
for ( ; ldm<=ldn ; ldm+=LX)
{
ulong m = (1UL<<ldm);
ulong m4 = (m>>LX);
double ph0 = s2pi/m;
for (ulong j=0; j<m4; j++)
{
double phi = j*ph0;
Complex e = SinCos(phi);
Complex e2 = SinCos(2.0*phi);
Complex e3 = SinCos(3.0*phi);
for (ulong r=0; r<n; r+=m)
{
ulong i0 = j + r;
ulong i1 = i0 + m4;
ulong i2 = i1 + m4;
ulong i3 = i2 + m4;
Complex
Complex
Complex
Complex

a0
a1
a2
a3

=
=
=
=

f[i0];
f[i2]; // (!)
f[i1]; // (!)
f[i3];

a1 *= e;
a2 *= e2;
a3 *= e3;
Complex t0 = (a0+a2) + (a1+a3);
Complex t2 = (a0+a2) - (a1+a3);
Complex t1 = (a0-a2) + Complex(0,is) * (a1-a3);
Complex t3 = (a0-a2) - Complex(0,is) * (a1-a3);
f[i0]
f[i1]
f[i2]
f[i3]

=
=
=
=

t0;
t1;
t2;
t3;

}
}
}
}

An additional radix-2 step has been prepended which is used when n is an odd power of 2. To improve
performance, the call to the procedure radix_permute(u[],p) of the pseudocode has been replaced by
changing indices in the loops where the a[z] are read. The respective lines are marked with the comment
‘// (!)’.
A reasonably optimized radix-4 DIT FFT implementation is given in [FXT: fft/fftdit4.cc]. The transform
starts with a radix-2 or radix-8 step for the initial pass. The core routine is hard-coded for σ = +1 and
called with swapped real and imaginary part for the inverse transform as explained in section 21.7 on
page 430. The routine uses separate arrays for the real and imaginary parts, which is very problematic
with large transforms: the memory access pattern in large skips will degrade performance.
Radix-4 FFT routines that use the C++ type complex are given in [FXT: fft/cfftdit4.cc]. These should
be preferred for large transforms. The core routine is hard-coded for σ = −1, therefore the name suffix
_m1:
1
2
3

void
fft_dit4_core_m1(Complex *f, ulong ldn)
// Auxiliary routine for fft_dit4().

422
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//
//
//
//
{

Radix-4 decimation in time (DIT) FFT.
ldn := base-2 logarithm of the array length.
Fixed isign = -1.
Input data must be in revbin_permuted order.
if ( n<=2 )
{
if ( n==2 )
return;
}

sumdiff(f[0], f[1]);

ulong ldm = ldn & 1;
if ( ldm!=0 ) // n is not a power of 4, need a radix-8 step
{
for (ulong i0=0; i0<n; i0+=8) fft8_dit_core_m1(f+i0); // isign
}
else
{
for (ulong i0=0; i0<n; i0+=4)
{
ulong i1 = i0 + 1;
ulong i2 = i1 + 1;
ulong i3 = i2 + 1;
Complex x, y, u, v;
sumdiff(f[i0], f[i1], x, u);
sumdiff(f[i2], f[i3], y, v);
v *= Complex(0, -1); // isign
sumdiff(u, v, f[i1], f[i3]);
sumdiff(x, y, f[i0], f[i2]);
}
}
ldm += 2 * LX;
for ( ; ldm<=ldn; ldm+=LX)
{
ulong m4 = (m>>LX);
const double ph0 = -2.0*M_PI/m;

// isign

{
double phi = j * ph0;
Complex e2 = e * e;
Complex e3 = e2 * e;
{
ulong i0 = j + r;
ulong i1 = i0 + m4;
ulong i2 = i1 + m4;
ulong i3 = i2 + m4;
Complex x = f[i1] * e2;
Complex u;
sumdiff3_r(x, f[i0], u);
Complex v = f[i3] * e3;
Complex y = f[i2] * e;
sumdiff(y, v);
}
}
}
}

The sumdiff() function is deﬁned in [FXT: aux0/sumdiﬀ.h]:
1
2

static inline void sumdiff(Type &a, Type &b)

3
4

423

// {a, b} <--| {a+b, a-b}
{ Type t=a-b; a+=b; b=t; }

The routine fft8_dit_core_m1() is an unrolled size-8 DIT FFT (hard-coded for σ = −1) given in
[FXT: fft/fft8ditcore.cc]. We further need a version of the routine for the positive sign. It uses a routine
fft8_dit_core_p1() for the computation of length-8 DIT FFTs with σ = −1. The following changes
need to be made in the core routine [FXT: fft/cfftdit4.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

void
fft_dit4_core_p1(Complex *f, ulong ldn)
// Fixed isign = +1
{
[--snip--]
for (ulong i0=0; i0<n; i0+=8) fft8_dit_core_p1(f+i0);
[--snip--]
v *= Complex(0, +1); // isign
[--snip--]
const double ph0 = +2.0*M_PI/m; // isign
[--snip--]
[--snip--]
}

// isign

The routine called by the user is
1
2
3
4
5
6
7
8
9
10
11

void
fft_dit4(Complex *f, ulong ldn, int is)
// Fast Fourier Transform
// ldn := base-2 logarithm of the array length
// is := sign of the transform (+1 or -1)
// Radix-4 decimation in time algorithm
{
revbin_permute(f, 1UL<<ld);
if ( is>0 ) fft_dit4_core_p1(f, ldn);
else
fft_dit4_core_m1(f, ldn);
}

21.4.5

Radix-4 DIF FFT

A routine for the radix-4 DIF FFT is (the C++ equivalent is given in [FXT: fft/fftdif4l.cc])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

procedure fftdif4(a[], ldn, is)
{
n := 2**ldn
for ldm := ldn to 2 step -2
{
m := 2**ldm
mr := m/4
for j := 0 to mr-1
{
e2 := e * e
e3 := e2 * e
for r := 0 to n-m step m
{
u0 := a[r+j]
u1 := a[r+j+mr]
u2 := a[r+j+mr*2]
u3 := a[r+j+mr*3]
x := u0
y := u1
t0 := x
t2 := x

+
+
+
-

u2
u3
y // == (u0+u2) + (u1+u3)
y // == (u0+u2) - (u1+u3)

x := u0 - u2
y := (u1 - u3)*I*is
t1 := x + y // == (u0-u2) + (u1-u3)*I*is
t3 := x - y // == (u0-u2) - (u1-u3)*I*is
t1 := t1 * e
t2 := t2 * e2

424
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

t3 := t3 * e3
a[r+j]
:=
a[r+j+mr]
:=
a[r+j+mr*2] :=
a[r+j+mr*3] :=

t0
t2
t1
t3

// (!)
// (!)

}
}
}
if is_odd(ldn) then // n not a power of 4
{
{
{a[r], a[r+1]} := {a[r]+a[r+1], a[r]-a[r+1]}
}
}
revbin_permute(a[],n)
}

A reasonably optimized implementation, hard-coded for σ = +1, is [FXT: ﬀt/cﬀtdif4.cc]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

static const ulong RX = 4;
static const ulong LX = 2;
void
fft_dif4_core_p1(Complex *f, ulong ldn)
// Auxiliary routine for fft_dif4().
// Radix-4 decimation in frequency FFT.
// Output data is in revbin_permuted order.
// ldn := base-2 logarithm of the array length.
// Fixed isign = +1
{
if ( n<=2 )
{
if ( n==2 )
return;
}


for (ulong ldm=ldn; ldm>=(LX<<1); ldm-=LX)
{
ulong m4 = (m>>LX);
const double ph0 = 2.0*M_PI/m;

// isign

{
double phi = j * ph0;
Complex e2 = e * e;
Complex e3 = e2 * e;
{
ulong i0 = j + r;
ulong i1 = i0 + m4;
ulong i2 = i1 + m4;
ulong i3 = i2 + m4;
Complex x, y, u, v;
diffsum3(x, y, f[i0]);
f[i1] = y * e2;
sumdiff(u, v, x, y);
f[i3] = y * e3;
f[i2] = x * e;
}
}
}

21.5: Split-radix algorithm
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

425

if ( ldn & 1 ) // n is not a power of 4, need a radix-8 step
{
for (ulong i0=0; i0<n; i0+=8) fft8_dif_core_p1(f+i0); // isign
}
else
{
for (ulong i0=0; i0<n; i0+=4)
{
ulong i1 = i0 + 1;
ulong i2 = i1 + 1;
ulong i3 = i2 + 1;
Complex x, y, u, v;
}
}
}

The routine for σ = −1 needs changes where the comment isign appears [FXT: fft/cfftdif4.cc]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

void
fft_dif4_core_m1(Complex *f, ulong ldn)
// Fixed isign = -1
{
[--snip--]
const double ph0 = -2.0*M_PI/m; // isign
[--snip--]
[--snip--]
for (ulong i0=0; i0<n; i0+=8) fft8_dif_core_m1(f+i0);
[--snip--]
[--snip--]
}

// isign

The routine called by the user is
1
2
3
4
5
6
7
8
9
10
11

void
fft_dif4(Complex *f, ulong ldn, int is)
// Fast Fourier Transform
// ldn := base-2 logarithm of the array length
// is := sign of the transform (+1 or -1)
// radix-4 decimation in frequency algorithm
{
if ( is>0 ) fft_dif4_core_p1(f, ldn);
else
fft_dif4_core_m1(f, ldn);
revbin_permute(f, 1UL<<ldn);
}

A version that uses the separate arrays for real and imaginary part is given in [FXT: fft/fftdif4.cc]. Again,
the type complex version should be preferred for large transforms. To convert a complex array to and
from a pair of real and imaginary arrays, use the zip permutation described in section 2.10 on page 125.

21.5

Split-radix algorithm

The idea underlying the split-radix FFT algorithm is to use both radix-2 and radix-4 decompositions at
the same time. We use one relation from the radix-2 (DIF) decomposition (relation 21.2-6a on page 415,
the one for the even indices) and for the odd indices we use the radix-4 splitting (relations 21.4-7b
and 21.4-7d on page 419) in a slightly reordered form. The radix-4 decimation in frequency (DIF) step

426


for the split-radix FFT is
F a

(0%2)

n/2

F a

(1%4)

n/4

=

F S 1/4

a(0/4) − a(2/4) + i σ a(1/4) − a(3/4)

(21.5-1b)

F a

(3%4)

n/4

F S 3/4

a(0/4) − a(2/4) − i σ a(1/4) − a(3/4)

(21.5-1c)

=

=

F

a(0/2) + a(1/2)

(21.5-1a)

Now we have expressed the length-N = 2n FFT as one length-N/2 and two length-N/4 FFTs. The
operation count of the split-radix FFT is actually lower than that of the radix-4 FFT. With the introduced
notation it is easy to write down the DIT version of the algorithm. The radix-4 decimation in time (DIT)
step for the split-radix FFT is
F a

(0/2)

n/2

=

F a(0%2) + S 1/2 F a(1%2)

F a

(1/4)

n/4

=

F a(0%4) − S 2/4 F a(2%4)

+ iσS 1/4 F a(1%4) − S 2/4 F a(3%4)

(21.5-2b)

F a

(3/4)

n/4

F a(0%4) − S 2/4 F a(2%4)

− iσS 1/4 F a(1%4) − S 2/4 F a(3%4)

(21.5-2c)

=

(21.5-2a)

The split-radix DIF algorithm can be implemented as
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

procedure fft_splitradix_dif(x[], y[], ldn, is)
{
n := 2**ldn
if n<=1 return
n2 := 2*n
for k:=1 to ldn
{
n2 := n2 / 2
n4 := n2 / 4
e := 2 * PI / n2
for j:=0 to n4-1
{
a := j * e
cc1 := cos(a)
ss1 := sin(a)
cc3 := cos(3*a)
ss3 := sin(3*a)
ix := j
id := 2*n2
while ix<n-1
{
i0 := ix
while i0 < n
{
i1 := i0
i2 := i1
i3 := i2
{ x[i0],
{ x[i1],

// == 4*cc1*(cc1*cc1-0.75)
// == 4*ss1*(0.75-ss1*ss1)

+ n4
+ n4
+ n4
r1 } := { x[i0] + x[i2], x[i0] - x[i2] }
r2 } := { x[i1] + x[i3], x[i1] - x[i3] }

{ y[i0], s1 } := { y[i0] + y[i2], y[i0] - y[i2] }
{ y[i1], s2 } := { y[i1] + y[i3], y[i1] - y[i3] }
{ r1, s3 } := { r1+s2, r1-s2 }
{ r2, s2 } := { r2+s1, r2-s1 }
// complex mult: (x[i2],y[i2]) := -(s2,r1) * (ss1,cc1)
x[i2] := r1*cc1 - s2*ss1
y[i2] := -s2*cc1 - r1*ss1
// complex mult: (y[i3],x[i3]) := (r2,s3) * (cc3,ss3)
x[i3] := s3*cc3 + r2*ss3
y[i3] := r2*cc3 - s3*ss3
i0 := i0 + id

21.5: Split-radix algorithm
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

427

}
}

ix := 2 * id - n2 + j
id := 4 * id

}
}
ix := 1
id := 4
while ix<n
{
for i0:=ix-1
{
i1 := i0
{ x[i0],
{ y[i0],
}
}

to n-id step id
+ 1
x[i1] } := { x[i0] + x[i1], x[i0] - x[i1] }
y[i1] } := { y[i0] + y[i1], y[i0] - y[i1] }

ix := 2 * id - 1
id := 4 * id

revbin_permute(x[],n)
revbin_permute(y[],n)
if is>0
{
for j:=1 to n/2-1
{
swap(x[j], x[n-j])
}
for j:=1 to n/2-1
{
swap(y[j], y[n-j])
}
}
}

The C++ implementation given in [FXT: fft/fftsplitradix.cc] uses a DIF core as above which is given
in [129]. The C++ type complex version of the split-radix FFT given in [FXT: fft/cfftsplitradix.cc] uses
a DIF or DIT core, depending on the sign of the transform. Here we just give the DIF version:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

void
split_radix_dif_fft_core(Complex *f, ulong ldn)
// Split-radix decimation in frequency (DIF) FFT.
// ldn := base-2 logarithm of the array length.
// Fixed isign = +1
// Output data is in revbin_permuted order.
{
if ( ldn==0 ) return;
double s2pi = 2.0*M_PI; // pi*2*isign
ulong n2 = 2*n;
for (ulong k=1; k<ldn; k++)
{
n2 >>= 1; // == n>>(k-1) == n, n/2, n/4, ..., 4
const ulong n4 = n2 >> 2; // == n/4, n/8, ..., 1
const double e = s2pi / n2;
{

// j==0:
const ulong j = 0;
ulong ix = j;
ulong id = (n2<<1);
while ( ix<n )
{
for (ulong i0=ix;
{
ulong i1 = i0
ulong i2 = i1
ulong i3 = i2

i0<n; i0+=id)
+ n4;
+ n4;
+ n4;

Complex t0, t1;
sumdiff3(f[i0], f[i2], t0);

428
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88


// t1 *= Complex(0, 1); // +isign
t1 = Complex(-t1.imag(), t1.real());
sumdiff(t0, t1);
f[i2] = t0; // * Complex(cc1, ss1);
f[i3] = t1; // * Complex(cc3, ss3);
}
ix = (id<<1) - n2 + j;
id <<= 2;
}
}
for (ulong j=1; j<n4; j++)
{
double a = j * e;
double cc1,ss1, cc3,ss3;
SinCos(a, &ss1, &cc1);
SinCos(3.0*a, &ss3, &cc3);
ulong ix = j;
ulong id = (n2<<1);
while ( ix<n )
{
for (ulong i0=ix;
{
ulong i1 = i0
ulong i2 = i1
ulong i3 = i2

i0<n; i0+=id)
+ n4;
+ n4;
+ n4;

Complex t0, t1;
t1 = Complex(-t1.imag(), t1.real());
sumdiff(t0, t1);
f[i2] = t0 * Complex(cc1, ss1);
f[i3] = t1 * Complex(cc3, ss3);
}
ix = (id<<1) - n2 + j;
id <<= 2;
}
}
}
for (ulong ix=0, id=4; ix<n; id*=4)
{
for (ulong i0=ix; i0<n; i0+=id) sumdiff(f[i0], f[i0+1]);
ix = 2*(id-1);
}
}

The function sumdiff3() is deﬁned in [FXT: aux0/sumdiﬀ.h]:
1
2
3
4

static inline void sumdiff3(Type &a, Type b, Type &d)
// {a, b, d} <--| {a+b, b, a-b} (used in split-radix FFTs)
{ d=a-b; a+=b; }

21.6

Symmetries of the Fourier transform

A bit of notation again. Let a be the length-n sequence a reversed around the element with index 0:
a0
an/2
ak

:= a0
:= an/2

(21.6-1a)
if n even

:= an−k = a−k

(21.6-1b)
(21.6-1c)

That is, we consider the indices modulo n and a is the sequence a with negated indices. Element zero
stays in its place and for even n there is also an element with index n/2 that stays in place.

21.6: Symmetries of the Fourier transform

429

Example one, length-4: a := [0, 1, 2, 3], then a = [0, 3, 2, 1]
Example two, length-5: a := [0, 1, 2, 3, 4], then a = [0, 4, 3, 2, 1]

(0 and 2 stay).
(only 0 stays).

Let aS and aA denote the symmetric and antisymmetric parts of the sequence a, respectively:
aS

:=

aA

:=

1
(a + a)
2
1
(a − a)
2

(21.6-2a)
(21.6-2b)

The elements with index 0 (and n/2 for even n) of aA are zero. We have
a =

aS + aA

(21.6-3a)

a =

aS − aA

(21.6-3b)

Let c + i d be the transform of the sequence a + i b, then
F (aS + aA ) + i (bS + bA )

=

F aS

=

cS

∈ R

(21.6-4b)

F aA

=

i dA

∈ iR

(21.6-4c)

F i bS

=

i dS

∈ iR

(21.6-4d)

F i bA

=

cA

∈ R

(21.6-4e)

(cS + cA ) + i (dS + dA )

where

(21.6-4a)

Here we write a ∈ R as a short form for a purely real sequence a. Equivalently, we write a ∈ i R for a
purely imaginary sequence. Thus the transform of a complex symmetric or antisymmetric sequence is
symmetric or antisymmetric, respectively:
F aS + i bS

=

cS + i dS

(21.6-5a)

F aA + i bA

=

cA + i dA

(21.6-5b)

The real and imaginary parts of the transform of a symmetric sequence correspond to the real and
imaginary parts of the original sequence. With an antisymmetric sequence the transform of the real and
imaginary parts correspond to the imaginary and real parts of the original sequence.
F (aS + aA )

=

cS + i dA

(21.6-6a)

F i (bS + bA )

=

cA + i dS

(21.6-6b)

If the sequence a is purely real, then we have
F aS

=

+F aS

∈ R

(21.6-7a)

F aA

= −F aA

∈ iR

(21.6-7b)

That is, the transform of a real symmetric sequence is real and symmetric and the transform of a real
antisymmetric sequence is purely imaginary and antisymmetric. Thus the transform of a general real
sequence is the complex conjugate of its reversal:
F a

= F a

∗

f or

a∈R

(21.6-8)

Similarly, for a purely imaginary sequence b ∈ iR, we have
F bS

=

+F bS

∈ iR

(21.6-9a)

F bA

= −F bA

∈ R

(21.6-9b)

430


We compare the results of the Fourier transform and its inverse (the transform with negated sign σ) by
symbolically writing the transforms as a complex multiplication with the trigonometric term (using C
for cosine, S for sine):
F a + ib
F

−1

:

(21.6-10a)

:

a + ib

(a + i b) (C + i S) = (a C − b S) + i (b C + a S)
(a + i b) (C − i S) = (a C + b S) + i (b C − a S)

(21.6-10b)

The terms on the right side can be identified with those in relation 21.6-4a. Changing the sign of the
transform leads to a result where the components due to the antisymmetric parts of the input are negated.
Now write F for the Fourier transform and R for the reversal. We have F 4 = id, F 3 = F −1 , and F 2 = R.
So the inverse transform can be computed as either
F −1

21.7

=

RF = F R

(21.6-11)

Inverse FFT for free

Some FFT implementations are hard-coded for a fixed sign of the transform. If we cannot easily modify
the implementation into the transform with the other sign (the inverse transform), then how can we
compute the inverse FFT?
If the implementation uses separate arrays for the real and imaginary parts of the complex sequences to
be transformed, as in
1
2
3
4
5
6
7
8

procedure my_fft(ar[], ai[], ldn) // only for is==+1 !
// real ar[0..2**ldn-1] input, result, real part
// real ai[0..2**ldn-1] input, result, imaginary part
{
// Incredibly complicated code
// that you cannot see how to modify
// for is==-1
}

Then do as follows: with the forward transform being
my_fft(ar[], ai[], ldn)

// forward FFT

compute the inverse transform as
my_fft(ai[], ar[], ldn)

// inverse FFT

Note the swapped real and imaginary parts! The same trick works for a procedure coded for fixed is= −1.
To see why this works, we note that
F a + ib

= F aS + i σ F aA + i F bS + σ F bA

(21.7-1a)

= F aS + i F bS + i σ F aA − i F bA

(21.7-1b)

For the computation with swapped real and imaginary parts we have
F b + ia

= F bS + i F aS + i σ F bA − i F aA

(21.7-2a)

Now the real and imaginary parts are implicitly swapped at the end of the computation, giving
F aS + i F bS − i σ F aA − i F bA

= F −1 a + i b

(21.7-2b)

When a complex type is used, then the best way to compute the inverse transform may be to reverse the
sequence according to the symmetry of the Fourier transform given as relation 21.6-11: the transform
with negated sign can be computed by reversing the order of the result (use the routine reverse_0() in
[FXT: perm/reverse.h]). The reversal can also happen with the input data before the transform, which is
advantageous if the data has to be copied anyway (use copy_reverse_0() in [FXT: aux1/copy.h]). The
additional work will usually not matter.

21.8: Real-valued Fourier transforms

21.8

431

Real-valued Fourier transforms

The Fourier transform of a purely real sequence c = F a where a ∈ R has a symmetric real part
(Re c = Re c, relation 21.6-8) and an antisymmetric imaginary part (Im c = − Im c). The symmetric
and antisymmetric parts of the original sequence correspond to the symmetric (and purely real) and
antisymmetric (and purely imaginary) parts of the transform, respectively:
F a

=

F aS + i σ F aA

(21.8-1)

Simply using a complex FFT for real input is a waste by a factor 2 of memory and CPU cycles. There
are several alternatives:
• wrapper routines for complex FFTs (section 21.8.3 on the next page),
• usage of the fast Hartley transform (section 25.5 on page 523),
• special versions of the split-radix algorithm (section 21.8.4 on page 434).
All techniques have in common that they store only half of the complex result to avoid the redundancy
due to the symmetries of a complex Fourier transform of purely real input. The result of a real to complex
FFT (R2CFT) contains the purely real components c0 (the ‘DC-part’ of the input signal) and, in case n is
even, cn/2 (the Nyquist frequency part). The inverse procedure, the complex to real transform (C2RFT)
must be compatible to the ordering of the R2CFT.

21.8.1

Sign of the transforms

The sign of the transform can be chosen arbitrarily to be either +1 or −1. Note that the transform with
the ‘other sign’ is not the inverse transform. The R2CFT and its inverse C2RFT must use the same sign.
Some R2CFT and C2RFT implementations are hard-coded for a ﬁxed sign. For the R2CFT with the other
sign, negate the imaginary part after the transform. If we have to copy the data before the transform,
then we can exploit the relation
F a

=

F aS − i σ F aA

(21.8-2)

That is, copy the real data in reversed order to get the transform with the other sign. This technique
does not involve an extra pass and should be virtually for free.
For the complex to real FFTs (C2RFT) we have to negate the imaginary part before the transform to
obtain the transform with the other sign.

21.8.2

Data ordering

Let c be the Fourier transform of the purely real sequence, stored in the array a[ ]. All given procedures
use one of the following schemes for storing the transformed sequence.
A scheme that interleaves real and imaginary parts (‘complex ordering’) is
a[0]

= Re c0

a[1]

= Re cn/2

a[2]

= Re c1

a[3]

= Im c1

a[4]

= Re c2

a[5]

= Im c2
.
.
.

a[n − 2]

= Re cn/2−1

a[n − 1]

= Im cn/2−1

(21.8-3)

432


Note the absence of the elements Im c0 and Im cn/2 which are always zero.
Some routines store the real parts in the lower half and imaginary parts in the upper half. The data in
the lower half will always be ordered as follows:
a[0]

= Re c0

a[1]

= Re c1

a[2]

= Re c2
.
.
.

a[n/2]

(21.8-4)

= Re cn/2

For the imaginary part of the result there are two schemes:
The ‘parallel ordering’ is
a[n/2 + 1]

= Im c1

a[n/2 + 2]

= Im c2

a[n/2 + 3]

(21.8-5)

= Im c3
.
.
.

a[n − 1]

= Im cn/2−1

a[n/2 + 1]

= Im cn/2−1

a[n/2 + 2]

= Im cn/2−2

a[n/2 + 3]

= Im cn/2−3
.
.
.

The ‘antiparallel ordering’ is

a[n − 1]

21.8.3

(21.8-6)

= Im c1

Real-valued Fourier transforms via wrapper routines

A complex length-n FFT can be used to compute a real length-2n FFT. For a real sequence a one feeds
the (length-n) complex sequence f = a(even) + i a(odd) into a complex FFT. Some post-processing is
necessary. This is not the most elegant real FFT available, but it is directly usable to turn complex FFTs
into real FFTs.
A C++ implementation of the real to complex FFT (R2CFT) is given in [FXT: realﬀt/realﬀtwrap.cc],
the sign of the transform is hard-coded to σ = +1:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

void
wrap_real_complex_fft(double *f, ulong ldn)
// Real to complex FFT (R2CFT)
{
fht_fft((Complex *)f, ldn-1, +1);
const ulong n = 1UL<<ldn;
const ulong nh = n/2, n4 =
const double phi0 = M_PI /
for(ulong i=1; i<n4; i++)
{
ulong i1 = 2 * i;
//
ulong i2 = i1 + 1; //
ulong i3 = n - i1;
ulong i4 = i3 + 1;
double f1r, f2i;

// cast

n/4;
nh;
re low [2, 4, ..., n/2-2]
im low [3, 5, ..., n/2-1]

// re hi
// im hi

[n-2, n-4, ..., n/2+2]
[n-1, n-3, ..., n/2+3]

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

433

sumdiff05(f[i3], f[i1], f1r, f2i);
double f2r, f1i;
sumdiff05(f[i2], f[i4], f2r, f1i);
double c, s;
double phi = i*phi0;
SinCos(phi, &s, &c);
double tr, ti;
cmult(c, s, f2r, f2i, tr, ti);
// f[i1] = f1r + tr; // re low
// f[i3] = f1r - tr; // re hi
// =^=
sumdiff(f1r, tr, f[i1], f[i3]);
// f[i4] = is * (ti + f1i); // im hi
// f[i2] = is * (ti - f1i); // im low
// =^=
sumdiff( ti, f1i, f[i4], f[i2]);
}
}

The output is ordered according to relations 21.8-3. The same ordering must be used for the input for
the inverse routine, the complex to real FFT (C2RFT). Again the sign of the transform is hard-coded to
σ = +1:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

void
wrap_complex_real_fft(double *f, ulong ldn)
// Complex to real FFT (C2RFT).
{
const ulong n = 1UL<<ldn;
const ulong nh = n/2, n4 = n/4;
const double phi0 = -M_PI / nh;
for(ulong i=1; i<n4; i++)
{
ulong i1 = 2 * i;
// re low [2, 4, ..., n/2-2]
ulong i2 = i1 + 1; // im low [3, 5, ..., n/2-1]
ulong i3 = n - i1;
ulong i4 = i3 + 1;

// re hi
// im hi

[n-2, n-4, ..., n/2+2]
[n-1, n-3, ..., n/2+3]

double f1r, f2i;
// double f1r = f[i1] + f[i3]; // re symm
// double f2i = f[i1] - f[i3]; // re asymm
// =^=
sumdiff(f[i1], f[i3], f1r, f2i);
double f2r, f1i;
// double f2r = -f[i2] - f[i4]; // im symm
// double f1i = f[i2] - f[i4]; // im asymm
// =^=
sumdiff(-f[i4], f[i2], f1i, f2r);
double c, s;
double phi = i*phi0;
SinCos(phi, &s, &c);
double tr, ti;
cmult(c, s, f2r, f2i, tr, ti);
// f[i1] = f1r + tr; // re low
// f[i3] = f1r - tr; // re hi
// =^=
sumdiff(f1r, tr, f[i1], f[i3]);
// f[i2] = ti - f1i; // im low
// f[i4] = ti + f1i; // im hi
// =^=
sumdiff(ti, f1i, f[i4], f[i2]);
}
if ( nh>=2 )

{ f[nh] *= 2.0; f[nh+1] *= 2.0; }

434
50
51
52


fht_fft((Complex *)f, ldn-1, -1);

// cast

}

21.8.4

Real-valued split-radix Fourier transforms

We give pseudocode for the split-radix real to complex FFT and its inverse. The C++ implementations
are given in [FXT: realﬀt/realﬀtsplitradix.cc]. The code given here follows [130], see also [318] (erratum
for page 859 of [318]: at the start of the D0 32 loop replace the obvious assignments by CC1=COS(A),
SS1=SIN(A), CC3=COS(A3), SS3=SIN(A3)).

21.8.5

Real to complex split-radix FFT

We give a routine for the split-radix R2CFT algorithm, the sign of the transform is hard-coded to σ = −1:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

procedure r2cft_splitradix_dit(x[], ldn)
{
n := 2**ldn
revbin_permute(x[], n);
ix := 1;
id := 4;
do
{
i0 := ix-1
while i0<n
{
i1 := i0 + 1
{ x[i0], x[i1] } := { x[i0] + x[i1], x[i0] - x[i1] } // parallel assignment
i0 := i0 + id
}
ix := 2*id-1
id := 4 * id
}
while ix<n
n2 := 2
nn := n/4
while nn!=0
{
ix := 0
n2 := 2*n2
id := 2*n2
n4 := n2/4
n8 := n2/8
do // ix loop
{
i0 := ix
while i0<n
{
i1 := i0
i2 := i1 + n4
i3 := i2 + n4
i4 := i3 + n4
{ t1, x[i4] } := { x[i4] + x[i3], x[i4] - x[i3] }
{ x[i1], x[i3] } := { x[i1] + t1, x[i1] - t1 }
if
{

n4!=1
i1
i2
i3
i4
t1
t2

:=
:=
:=
:=
:=
:=

i1 + n8
i2 + n8
i3 + n8
i4 + n8
(x[i3]+x[i4]) * sqrt(1/2)
(x[i3]-x[i4]) * sqrt(1/2)

{ x[i4], x[i3] } := { x[i2] - t1, -x[i2] - t1 }
{ x[i1], x[i2] } := { x[i1] + t2, x[i1] - t2 }
}
}

i0 := i0 + id

ix := 2*id - n2
id := 2*id
}
while ix<n
e := 2.0*PI/n2
a := e

69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

for j:=2 to n8
{
cc1 := cos(a)
ss1 := sin(a)
cc3 := cos(3*a)
ss3 := sin(3*a)

435

// == 4*cc1*(cc1*cc1-0.75)
// == 4*ss1*(0.75-ss1*ss1)

a := j*e
ix := 0
id := 2*n2
do // ix-loop
{
i0 := ix
while i0<n
{
i1 := i0 + j - 1
i2 := i1 + n4
i3 := i2 + n4
i4 := i3 + n4
i5 := i0 + n4 - j + 1
i6 := i5 + n4
i7 := i6 + n4
i8 := i7 + n4
// complex mult: (t2,t1) := (x[i7],x[i3]) * (cc1,ss1)
t1 := cc1 * x[i3] + ss1 * x[i7]
t2 := cc1 * x[i7] - ss1 * x[i3]
// complex mult: (t4,t3) := (x[i8],x[i4]) * (cc3,ss3)
t3 := cc3 * x[i4] + ss3 * x[i8]
t4 := cc3 * x[i8] - ss3 * x[i4]
t5 :=
t6 :=
t3 :=
t4 :=
{ t2,
x[i8]
{ t2,
x[i4]
{ t1,
x[i1]
{ t1,
x[i2]
}

t1 + t3
t2 + t4
t1 - t3
t2 - t4
x[i3] }
:= t2
x[i7] }
:= t2
x[i6] }
:= t1
x[i5] }
:= t1

:= { t6 + x[i6], t6 - x[i6] }
:= { x[i2] - t3, -x[i2] - t3 }
:= { x[i1] + t5, x[i1] - t5 }
:= { x[i5] + t4, x[i5] - t4 }

i0 := i0 + id

ix := 2*id - n2
id := 2*id
}
while ix<n

}
nn := nn/2
}
}

The ordering of the output is given as relations 21.8-4 on page 432 for the real part, and relations 21.8-6
for the imaginary part.

21.8.6

Complex to real split-radix FFT

The following routine is the inverse of r2cft_splitradix_dit(). The imaginary part of the input data
must be ordered according to relations 21.8-6 on page 432. We give pseudocode for the split-radix C2RFT
algorithm, the sign of the transform is hard-coded to σ = −1:
1
2
3
4
5
6
7
8
9
10
11
12
13

procedure c2rft_splitradix_dif(x[], ldn)
{
n := 2**ldn
n2 := n/2
nn := n/4
while nn!=0
{
ix := 0
id := n2
n2 := n2/2
n4 := n2/4
n8 := n2/8

436
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

do
{

// ix loop
i0 := ix
while i0<n
{
i1 := i0
i2 := i1
i3 := i2
i4 := i3
{ x[i1],
x[i2] :=
x[i4] :=
{ x[i3],
if
{

+ n4
+ n4
+ n4
t1 } := { x[i1] + x[i3], x[i1] - x[i3] }
2*x[i2]
2*x[i4]
x[i4] } := { t1 + x[i4], t1 - x[i4] }

n4!=1
i1 := i1 + n8
i2 := i2 + n8
i3 := i3 + n8
i4 := i4 + n8
{ x[i1], t1 } := { x[i2] + x[i1], x[i2] - x[i1] }
{ t2, x[i2] } := { x[i4] + x[i3], x[i4] - x[i3] }
x[i3] := -sqrt(2)*(t2+t1)
x[i4] := sqrt(2)*(t1-t2)

}
}

i0 := i0 + id

ix := 2*id - n2
id := 2*id
}
while ix<n
e := 2.0*PI/n2
a := e
for j:=2 to n8
{
cc1 := cos(a)
ss1 := sin(a)
cc3 := cos(3*a)
ss3 := sin(3*a)
a := j*e

// == 4*cc1*(cc1*cc1-0.75)
// == 4*ss1*(0.75-ss1*ss1)

ix := 0
id := 2*n2
do // ix-loop
{
i0 := ix
while i0<n
{
i1 := i0 + j - 1
i2 := i1 + n4
i3 := i2 + n4
i4 := i3 + n4
i5 := i0 + n4 - j + 1
i6 := i5 + n4
i7 := i6 + n4
i8 := i7 + n4
{ x[i1], t1 } := { x[i1]
{ x[i5], t2 } := { x[i5]
{ t3, x[i6] } := { x[i8]
{ t4, x[i2] } := { x[i4]
{ t1, t5 } := { t1 + t4,
{ t2, t4 } := { t2 + t3,

+ x[i6], x[i1]
+ x[i2], x[i5]
+ x[i3], x[i8]
+ x[i7], x[i4]
t1 - t4 }
t2 - t3 }

-

x[i6]
x[i2]
x[i3]
x[i7]

}
}
}
}

// complex mult: (x[i7],x[i3]) := (t5,t4)
x[i3] := cc1 * t5 + ss1 * t4
x[i7] := -cc1 * t4 + ss1 * t5
// complex mult: (x[i4],x[i8]) := (t1,t2)
x[i4] := cc3 * t1 - ss3 * t2
x[i8] := cc3 * t2 + ss3 * t1
}

* (ss1,cc1)

* (cc3,ss3)

i0 := i0 + id

ix := 2*id - n2
id := 2*id

}

}
while ix<n

21.9: Multi-dimensional Fourier transforms
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

437

nn := nn/2
}
ix := 1;
id := 4;
do
{
i0 := ix-1
while i0<n
{
i1 := i0 + 1
{ x[i0], x[i1] } := { x[i0] + x[i1], x[i0] - x[i1] }
i0 := i0 + id
}
ix := 2*id-1
id := 4 * id
}
while ix<n
revbin_permute(x[], n);
}

21.9

Multi-dimensional Fourier transforms

Let ax,y (x = 0, 1, 2, . . . , C − 1 and y = 0, 1, 2, . . . , R − 1) be a 2-dimensional array. That is, an R × C
‘matrix’ of R rows (of length C) and C columns (of length R). Its 2-dimensional Fourier transform is
defined by:
c
ck,h

=
:=

F a
1
√
n

(21.9-1a)
C−1 R−1

ax,y z +(x k/C+y h/R)

where

z = eσ 2 π i

(21.9-1b)

x=0 y=0

where k ∈ {0, 1, 2, . . . , C − 1}, h ∈ {0, 1, 2, . . . , R − 1}, and n = R · C. The inverse transform is
a

=

ax,y

=

F −1 c

(21.9-2a)

C−1 R−1

1
√
n

ck,h z −(x k/C+y h/R)

(21.9-2b)

k=0 h=0

For an m-dimensional array ax (where x = (x1 , x2 , x3 , . . . , xm ) and xi ∈ 0, 1, 2, . . . , Si ) the m-dimensional
Fourier transform ck (where k = (k1 , k2 , k3 , . . . , km ) and ki ∈ 0, 1, 2, . . . , Si ) is defined as
ck

:=

1
√
n

S1 −1 S2 −1

Sm −1

...
x1 =0 x2 =0

ax z (x1 k1 /S1 + x2 k2 /S2 + . . . + xm km /Sm )

(21.9-3a)

xm =0

The inverse transform is, like in the 1-dimensional case, the complex conjugate transform.

21.9.1

The row-column algorithm

The equation of the definition of the 2-dimensional Fourier transform (relation 21.9-1a) can be recast as
ck,h

=

1
√
n

R−1

C−1

exp (y h/R)
y=0

ax,y exp (x k/C)

(21.9-4)

x=0

This shows that the 2-dimensional transform can be computed by applying 1-dimensional transforms,
first on the rows, then on the columns. The same result is obtained when the columns are transformed
first and then the rows.
This leads us directly to the row-column algorithm for 2-dimensional FFTs. Pseudocode to compute the
2-dimensional FFT of a[ ][ ] using the row-column method:

438
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17


procedure rowcol_ft(a[][], R, C, is)
{
complex a[R][C] // R (length-C) rows, C (length-R) columns
for r:=0 to R-1 // FFT rows
{
fft(a[r][], C, is)
}
complex t[R]
// temporary array for columns
for c:=0 to C-1 // FFT columns
{
copy a[0,1,...,R-1][c] to t[] // get column
fft(t[], R, is)
copy t[] to a[0,1,...,R-1][c] // write back column
}
}

Here it is assumed that the rows lie in contiguous memory (as in the C language). The equivalent C++
code is given in [FXT: fft/twodimfft.cc].
Transposing the array before the column pass will, due to a better memory access pattern, improve
performance in most cases:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

procedure rowcol_fft2d(a[][], R, C, is)
{
complex a[R][C] // R (length-C) rows, C (length-R) columns
for r:=0 to R-1 // FFT rows
{
fft(a[r][], C, is)
}
transpose( a[R][C] )

// in-place

for c:=0 to C-1 // FFT columns (which are rows now)
{
fft(a[c][], R, is)
}
transpose( a[C][R] )

// transpose back (note swapped R,C)

}

Transposing back at the end of the routine can be avoided if the inverse transform follows immediately
as is typical for a convolution. The inverse transform must then be called with R and C swapped.

21.10

The matrix Fourier algorithm (MFA)

The matrix Fourier algorithm (MFA) is an algorithm for 1-dimensional FFTs that works for data lengths
n = R C. It is quite similar to the row-column algorithm (relation 21.9-4) for 2-dimensional FFTs. The
only differences are n multiplications with trigonometric factors and a final matrix transposition.
Consider the input array as an R × C-matrix (R rows, C columns), with the rows contiguous in memory.
Let σ be the sign of the transform. The matrix Fourier algorithm (MFA) can be stated as follows:
1. Apply a (length R) FFT on each column.
2. Multiply each matrix element (index r, c) by exp(σ 2 π i r c/n).
3. Apply a (length C) FFT on each row.
4. Transpose the matrix.
Note the elegance! A variant of the MFA is called four step FFT in [28].
A trivial modification is obtained by executing the steps in reversed order. The transposed matrix Fourier
algorithm (TMFA) for the FFT:
2. Apply a (length C) FFT on each row of the matrix.

21.10: The matrix Fourier algorithm (MFA)

439

4. Apply a (length R) FFT on each column of the matrix.
A variant of the MFA that, apart from the transpositions, accesses the memory only in consecutive
address ranges can be stated as
2. Apply a (length C) FFT on each row of the transposed matrix.
4. Transpose the matrix back.
5. Apply a (length R) FFT on each row of the matrix.
6. Transpose the matrix (if the order of the transformed data matters).
The ‘transposed’ version of this algorithm is identical. The performance will depend critically on the
performance of the transposition routine.
√
It is usually a good idea to use factors of the data length n that are close to n. Of course we can
apply the same algorithm for the row (or column) FFTs again: it can be an improvement to split n into
3 factors (as close to n1/3 as possible) if a length-n1/3 FFT ﬁts completely into cache. Especially for
systems where CPU clock speed is much higher than memory clock speed the performance may increase
dramatically. A speedup by a factor of 3 can sometimes be observed, even when compared to otherwise
very well optimized FFTs. Another algorithm that is eﬃcient with large arrays is the localized transform
described (for the Hartley transform) in section 25.8 on page 529.

440

Chapter 22: Convolution, correlation, and more FFT algorithms

Chapter 22

Convolution, correlation, and more
FFT algorithms
We give algorithms for fast convolution that are based on the fast Fourier transform. An efficient algorithm
for the convolution of arrays that do not fit into the main memory (mass storage convolution) is given
for both complex and real data. Further, weighted convolutions and their algorithms are introduced.
We describe how fast convolution can be used for computing the z-transform of sequences of arbitrary
length. Another convolution based algorithm for the Fourier transform of arrays of prime length, Rader’s
algorithm, is described at the end of the chapter.
Convolution algorithms based on the fast Hartley transform are described in section 25.7. The XOR
(dyadic) convolution, which is computed via the Walsh transform is treated in section 23.8. The ORconvolution and the AND-convolution are described in section 23.12.

22.1

Convolution

The cyclic convolution (or circular convolution) of two length-n sequences a = [a0 , a1 , . . . , an−1 ] and
b = [b0 , b1, . . . , bn−1 ] is defined as the length-n sequence h with elements hτ as:
h

=

hτ

a

b

(22.1-1a)

:=

ax by
x+y≡τ

(22.1-1b)

mod n

(22.1-2)

(mod n)

The last equation may be rewritten as
n−1

hτ

:=

ax b(τ −x)
x=0

That is, indices τ − x wrap around, it is a cyclic convolution. A table illustrating the cyclic convolution
of two sequences is shown in figure 22.1-A.

22.1.1

Direct computation

A C++ implementation of the computation by definition is [FXT: convolution/slowcnvl.h]:
1
2
3
4
5
6
7
8
9

void slow_convolution(const Type *f, const Type *g, Type *h, ulong n)
// (cyclic) convolution: h[] := f[] (*) g[]
// n := array length
{
for (ulong tau=0; tau<n; ++tau)
{
Type s = 0.0;

22.1: Convolution

441

+-|
0:
1:
2:
3:

1

2

3

4

5

6

9 10 11

12 13 14 15

1
2
3
4

2
3
4
5

3
4
5
6

4
5
6
7

5
6
7
8

6 7
7 8
8 9
9 10

8 9 10 11
9 10 11 12
10 11 12 13
11 12 13 14

12 13 14 15
13 14 15 0
14 15 0 1
15 0 1 2

4:
5:
6:
7:

4
5
6
7

5
6
7
8

6 7
7 8
8 9
9 10

8 9 10 11
9 10 11 12
10 11 12 13
11 12 13 14

12 13 14 15
13 14 15 0
14 15 0 1
15 0 1 2

8:
9:
10:
11:

8 9 10 11
9 10 11 12
10 11 12 13
11 12 13 14

12 13 14 15
13 14 15 0
14 15 0 1
15 0 1 2

12:
13:
14:
15:

(a)

0
0
1
2
3

12 13 14 15
13 14 15 0
14 15 0 1
15 0 1 2

+-|
0:
1:
2:
3:

0

1

0
1
1
3
4
8
...

2

0
1
2
3
3

1
2
3
4

7

2
3
4
5

3
4
5
6

8

0
1
2
3

1
2
3
4

2
3
4
5

4
5
6
7

5
6
7
8

6 7
7 8
8 9
9 10

0
1
2
3

2
3
4
5

4
5
6
7

3
4
5
6

1
2
3
4

3
4
5
6

5
6
7
8

6 7
7 8
8 9
9 10

8 9 10 11
9 10 11 12
10 11 12 13
11 12 13 14

(b)

2
4
...
5 <--= h[5] contains a[1]*b[2]
9 <--= h[9] contains a[2]*b[2]

Figure 22.1-A: Semi-symbolic table of the cyclic convolution of two sequences (top). The entries denote
where in the convolution the products of the input elements can be found (bottom).
10
11
12
13
14
15
16
17

{
ulong k2 = tau - k;
if ( (long)k2<0 ) k2 += n;
s += (f[k]*g[k2]);

// modulo n

}
h[tau] = s;
}
}

The following version avoids the if statement in the inner loop:
1
2
3
4
5
6
7
8

{
Type s = 0.0;
ulong k = 0;
for (ulong k2=tau; k<=tau; ++k, --k2)
for (ulong k2=n-1; k<n;
++k, --k2)
h[tau] = s;
}

s += (f[k]*g[k2]);
s += (f[k]*g[k2]);

// wrapped around

For length-n sequences this procedure involves O(n2 ) operations, therefore it is slow for large n. For
short lengths the algorithm is just fine. Unrolled routines will offer good performance, especially for
convolutions of fixed length. For medium length convolutions the splitting schemes given in section 28.1
on page 550 and section 40.2 on page 827 are applicable.

22.1.2

Computation via FFT

The fast Fourier transform provides us with an efficient way to compute convolutions that needs only
O (n log(n)) operations. The convolution property of the Fourier transform is
F a

b

=

F a ·F b

(22.1-3)

442


The multiplication indicated by the dot is element-wise. That is, convolution in original space is elementwise multiplication in Fourier space. The statement can be motivated as follows:
F a

k

·F b

k

ax z k x

=
x

by z k y
bτ −x z k (τ −x)

ax z k x

=

(22.1-4a)

y

where

y =τ −x

ax z k x bτ −x z k (τ −x) =

=
x τ −x

F

=

(22.1-4b)

τ −x

x

ax bτ −x
τ

ax bτ −x

=

F a

x

(22.1-4c)

x

b

k

F −1 F a · F b

(22.1-4d)

k

b =

zk τ

Rewriting relation 22.1-3 as
a

(22.1-5)

tells us how to proceed. We give pseudocode for the cyclic convolution of two complex sequences x[ ]
and y[ ], the result is returned in y[ ]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

procedure fft_cyclic_convolution(x[], y[], n)
{
complex x[0..n-1], y[0..n-1]
// transform data:
fft(x[], n, +1)
fft(y[], n, +1)
// element-wise multiplication in transformed domain:
for i:=0 to n-1
{
y[i] := y[i] * x[i]
}
// transform back:
fft(y[], n, -1)
// normalize:
n1 := 1 / n
for i:=0 to n-1
{
y[i] := y[i] * n1
}
}

It is assumed that the procedure fft() does no normalization. For the normalization loop we precompute
1/n and multiply as divisions are usually much slower than multiplications.

22.1.3

Avoiding the revbin permutations

We can save the revbin permutations by observing that any DIF FFT is of the form
DIF_FFT_CORE(f, n);

and any DIT FFT is of the form
DIT_FFT_CORE(f, n);

This way a convolution routine that uses DIF FFTs for the transform and DIT FFTs as inverse transform
can omit the revbin permutations. This is demonstrated in the C++ implementation for the cyclic
convolution of complex sequences [FXT: convolution/ﬀtcocnvl.cc]:
1
2
3
4

#define DIT_FFT_CORE fft_dit4_core_m1 // isign = -1
#define DIF_FFT_CORE fft_dif4_core_p1 // isign = +1
void
fft_complex_convolution(Complex * restrict f, Complex * restrict g,

22.1: Convolution
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//
//
//
//
{

443

ulong ldn, double v/*=0.0*/)
(complex, cyclic) convolution: g[] := f[] (*) g[]
(use zero padded data for usual convolution)
ldn := base-2 logarithm of the array length
Supply a value for v for a normalization factor != 1/n
DIF_FFT_CORE(f, ldn);
DIF_FFT_CORE(g, ldn);
if ( v==0.0 ) v = 1.0/n;
{
Complex t = g[i] * f[i];
g[i] = t * v;
}
DIT_FFT_CORE(g, ldn);

}

The signs of the two FFTs must be different but are otherwise immaterial.
The auto-convolution (or self-convolution) of a sequence is defined as the convolution of a sequence with
itself: h = a a. The corresponding procedure needs only two instead of three FFTs.

22.1.4

Linear convolution
+-|
0:
1:
2:
3:

0

1

2

3

4

5

6

7

0
1
2
3

1
2
3
4

2
3
4
5

3
4
5
6

4
5
6
7

5
6
7
8

6 7
7 8
8 9
9 10

4:
5:
6:
7:

4
5
6
7

5
6
7
8

6 7
7 8
8 9
9 10

8

9 10 11

12 13 14 15

8 9 10 11
9 10 11 12
10 11 12 13
11 12 13 14

12
13
14
15

13
14
15
16

14
15
16
17

15
16
17
18

8 9 10 11
9 10 11 12
10 11 12 13
11 12 13 14

12
13
14
15

13
14
15
16

14
15
16
17

15
16
17
18

16
17
18
19

17
18
19
20

18
19
20
21

19
20
21
22

8:
9:
10:
11:

8 9 10 11
9 10 11 12
10 11 12 13
11 12 13 14

12
13
14
15

13
14
15
16

14
15
16
17

15
16
17
18

16
17
18
19

17
18
19
20

18
19
20
21

19
20
21
22

20
21
22
23

21
22
23
24

22
23
24
25

23
24
25
26

12:
13:
14:
15:

12
13
14
15

16
17
18
19

17
18
19
20

18
19
20
21

19
20
21
22

20
21
22
23

21
22
23
24

22
23
24
25

23
24
25
26

24
25
26
27

25
26
27
28

26
27
28
29

27
28
29
30

13
14
15
16

14
15
16
17

15
16
17
18

Figure 22.1-B: Semi-symbolic table for the linear convolution of two length-16 sequences.
The linear convolution of two length-n sequences a and b is the length-2n sequence h defined as
h

=

a

lin

b

(22.1-6a)

2 n−1

hτ

:=

ax bτ −x

where

τ = 0, 1, 2, . . . , 2 n − 1

(22.1-6b)

x=0

where we set ak = 0 if k < 0 or k ≥ n, and the same for out-of-range elements bk . The linear convolution
is sometimes called acyclic convolution, as there is no wrap around of the indices. We note that h2n−1 ,
the last element of the sequence h, is always zero.
The semi-symbolic table for the acyclic convolution is given in figure 22.1-B. The elements in the lower
right triangle do not ‘wrap around’ anymore, they go into extra buckets. Note there are 31 buckets
labeled 0, 1, . . ., 30.
A routine that computes the linear convolution by the definition is [FXT: convolution/slowcnvl-lin.h]:
1
2
3

void slow_linear_convolution(const Type *f, const Type *g, Type *h, ulong n)
// Linear (acyclic) convolution.

444
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22


// n := array length of a[] and b[]
// The array h[] must have 2*n elements.
{
// compute h0 (left half):
{
Type s0 = 0;
for (ulong k=0, k2=tau; k<=tau;
h[tau] = s0;
}

++k, --k2)

// compute h1 (right half):
{
Type s1 = 0;
for (ulong k2=n-1, k=tau+1; k<n;
h[n+tau] = s1;
}

s0 += (f[k]*g[k2]);

++k, --k2)

s1 += (f[k]*g[k2]);

}

To compute the linear convolution of two length-n sequences a and b, we can use a length-2n cyclic
convolution of the zero padded sequences A and B where
A

:=

[a0 , a1 , a2 , . . . , an−1 , 0, 0, . . . , 0]

(22.1-7a)

B

:=

[a0 , a1 , a2 , . . . , an−1 , 0, 0, . . . , 0]

(22.1-7b)

With fast FFT-based algorithms for the cyclic convolution we can compute the linear convolution with
the same complexity.
Linear convolution is polynomial multiplication: let A = a0 + a1 x + a2 x2 + . . ., B = b0 + b1 x + b2 x2 + . . .,
and C = A B = c0 + c1 x + c2 x2 + . . ., then
ck

=

ai bj

(22.1-8)

i+j=k

This is just another way to write relation 22.1-6a. Chapter 28 on page 550 explains how fast convolution
algorithms can be used for fast multiplication of multiprecision numbers.

22.2

Correlation
+-|
0:
1:
2:
3:

0 1 2 3
0 15 14 13
1 0 15 14
2 1 0 15
3 2 1 0

4:
5:
6:
7:

4
5
6
7

4
12
13
14
15

5
11
12
13
14

6 7
10 9
11 10
12 11
13 12

3
4
5
6

2
3
4
5

1
2
3
4

0 15 14 13
1 0 15 14
2 1 0 15
3 2 1 0

8:
9:
10:
11:

8 7
9 8
10 9
11 10

6
7
8
9

5
6
7
8

4
5
6
7

12:
13:
14:
15:

12
13
14
15

11
12
13
14

10 9
11 10
12 11
13 12

8 9 10 11
8 7 6 5
9 8 7 6
10 9 8 7
11 10 9 8

12 13 14 15
4 3 2 1
5 4 3 2
6 5 4 3
7 6 5 4

12
13
14
15

8 7
9 8
10 9
11 10

11
12
13
14

10 9
11 10
12 11
13 12

3
4
5
6

2
3
4
5

1
2
3
4

0 15 14 13
1 0 15 14
2 1 0 15
3 2 1 0

8 7
9 8
10 9
11 10

6
7
8
9

5
6
7
8

4
5
6
7

3
4
5
6

2
3
4
5

12
13
14
15

1
2
3
4

11
12
13
14

6
7
8
9

5
6
7
8

10 9
11 10
12 11
13 12

0 15 14 13
1 0 15 14
2 1 0 15
3 2 1 0

Figure 22.2-A: Semi-symbolic table for the cyclic correlation of two length-16 sequences.
The cyclic correlation (or circular correlation) of two real length-n sequences a = [a0 , a1 , . . . , an−1 ] and
b = [b0 , b1 , . . . , bn−1 ] can be deﬁned as the length-n sequence h where
hτ

:=

ax by
x−y≡τ mod n

(22.2-1)

22.2: Correlation

445

+-|
0:
1:
2:
3:

3

4

5

6

7

8

0 31 30 29
1 0 31 30
2 1 0 31
3 2 1 0

0

1

2

28
29
30
31

27
28
29
30

26
27
28
29

25
26
27
28

24
25
26

Algorithms for programmers ideas and source code

Algorithms for programmers ideas and source code

Recommended

More Related Content

What's hot (16)

Similar to Algorithms for programmers ideas and source code (20)

Algorithms for programmers ideas and source code