Here is an example of the laminate function. Given these statements:

permu_arr_0<5> const a {3, 4, 2, 0, 1}; permu_arr_0<4> const b {1, 2, 0, 3}; permu_arr_0<5*4> const c {a.laminate (b)};the elements of

c: [ 8 9 7 5 6 13 14 12 10 11 3 4 2 0 1 18 19 17 15 16 ]

The following table shows in detail how this is calculated:

8 = 3 + 1 × 5 | 9 = 4 + 1 × 5 | 7 = 2 + 1 × 5 | 5 = 0 + 1 × 5 | 6 = 1 + 1 × 5 |

13 = 3 + 2 × 5 | 14 = 4 + 2 × 5 | 12 = 2 + 2 × 5 | 10 = 0 + 2 × 5 | 11 = 1 + 2 × 5 |

3 = 3 + 0 × 5 | 4 = 4 + 0 × 5 | 2 = 2 + 0 × 5 | 0 = 0 + 0 × 5 | 1 = 1 + 0 × 5 |

18 = 3 + 3 × 5 | 19 = 4 + 3 × 5 | 17 = 2 + 3 × 5 | 15 = 0 + 3 × 5 | 16 = 1 + 3 × 5 |

Lamination is not commutative. Given the following statement:

permu_arr_0<4*5> const d {b.laminate (a)};the elements of

d: [ 13 14 12 15 17 18 16 19 9 10 8 11 1 2 0 3 5 6 4 7 ]The statement constructing

permu_arr_0<b.size()*a.size()> const d {b.laminate (a)};

Following is the equivalent for a one-based array. Given these statements:

permu_arr_1<5> const e {4, 5, 3, 1, 2}; permu_arr_1<4> const f {2, 3, 1, 4}; permu_arr_1<5*4> const g {e.laminate (f)};the elements of

g: [ 9 10 8 6 7 14 15 13 11 12 4 5 3 1 2 19 20 18 16 17 ]

Here is an example of how lamination sometimes amounts to repeated applications of `direct_sum` and `skew_sum`. Given these statements:

permu_arr_0<10> const h {a.direct_sum (a)}; permu_arr_0<15> const i {h.skew_sum (a)}; permu_arr_0<20> const j {i.direct_sum (a)};the elements of

h: [ 3 4 2 0 1 8 9 7 5 6 ] i: [ 8 9 7 5 6 13 14 12 10 11 3 4 2 0 1 ] j: [ 8 9 7 5 6 13 14 12 10 11 3 4 2 0 1 18 19 17 15 16 ]where

Consider the expression `a.laminate(b)`. If `b.separable()` is `true`, a decomposition of the result into direct and skew sums as above will be possible.