# PartitionedSignal nmigen-aware Cat

Concatenation of Signals is ordinarily straightforward: reduce to the bitlevel and create a sequence. The contributors to that sequence may be of arbitrary length.

However for a PartitionedSignal unless *all* contributors are also
PartitionedSignals, the results cannot be guaranteed to match, at all
partition sizes.

Take two PartitionedSignals:

```
partition: p p p (3 bits)
a : AAA3 AAA2 AAA1 AAA0 (32 bits)
b : BBB3 BBB2 BBB1 BBB0 (32 bits)
```

When the partitions are 32-bit, the output is:

```
partition: p p p (3 bits)
out : AAA3 AAA2 AAA1 AAA0 BBB3 BBB2 BBB1 BBB0 (64 bits)
```

When 2x16, the top 2 halves of A and B are Catted together, and likewise the lower:

```
partition: p p p (3 bits)
out : AAA3 AAA2 BBB3 BBB2 AAA1 AAA0 BBB1 BBB0 (64 bits)
```

Finally when 4x8, each byte is concatenated:

```
partition: p p p (3 bits)
out : AAA3 BBB3 AAA2 BBB2 AAA1 BBB1 AAA0 BBB0 (64 bits)
```

This then generalises regardless of the number of PartitionedSignals
being Concatenated, and regardless of whether the length of
any individual PartitionedSignal is of differing length.
Bearing in mind that Partitions may **only** be on
equal sized points (4x 4-bit, not 3x 3-bit plus one 5-bit):

To confirm that let us assume that A is 16-bit and B is 32-bit:

```
partition: p p p (3 bits)
a : A3 A2 A1 A0 (16 bits)
b : BBB3 BBB2 BBB1 BBB0 (32 bits)
```

Output will always be 48 bits, and the partitions we need to confirm but assume will be 4+8=12 bits. When the partitions are 1x, the output is:

```
partition: 0 0 0 (3 bits)
out : A3 A2 A1 A0 BBB3 BBB2 BBB1 BBB0 (48 bits)
```

When 2x:

```
partition: 0 1 0 (3 bits)
out : A3 A2 BBB3 BBB2 A1 A0 BBB1 BBB0 (48 bits)
```

Finally when 4x:

```
partition: 1 1 1 (3 bits)
out : A3 BBB3 A2 BBB2 A1 BBB1 A0 BBB0 (48 bits)
```

By a lucky coincidence the lengths match up. In the 1x case, the result is a single 48-bit quantity. In the 2x case, the result is two 24-bit quantities. Finally in the 4x case, the result is four 12-bit quantities.

The reason this works is down to the requirement that Partitions be of equal sizes. 4x 4-bit to be Concatenated with 4x 8-bit, in the last example.

Table for 2-way concatenation, divided by partition:

partition | o3 | o2 | o1 | o0 |
---|---|---|---|---|

000 | a3 a2 | a1 a0 | b3 b2 | b1 b0 |

001 | a3 a2 | a1 b3 | b2 b1 | a0 b0 |

010 | a3 a2 | b3 b2 | a1 a0 | b1 b0 |

011 | a3 a2 | b3 b2 | a1 b1 | a0 b0 |

100 | a3 b3 | a2 a1 | a0 b2 | b1 b0 |

101 | a3 b3 | a2 a1 | b2 b1 | a0 b0 |

110 | a3 b3 | a2 b2 | a1 a0 | b1 b0 |

111 | a3 b3 | a2 b2 | a1 b1 | a0 b0 |

Table for 3-way concatenation, divided by partition:

partition | o3 | o2 | o1 | o0 |
---|---|---|---|---|

000 | a3 a2 a1 | a0 b3 b2 | b1 b0 c3 | c2 c1 c0 |

001 | a3 a2 a1 | b3 b2 b1 | c3 c2 c1 | a0 b0 c0 |

010 | a3 a2 b3 | b2 c3 c2 | a1 a0 b1 | b0 c1 c0 |

011 | a3 a2 b3 | b2 c3 c2 | a1 b1 c1 | a0 b0 c0 |

100 | a3 b3 c3 | a2 a1 a0 | b2 b1 b0 | c2 c1 c0 |

101 | a3 b3 c3 | a2 a1 b2 | b1 c2 c1 | a0 b0 c0 |

110 | a3 b3 c3 | a2 b2 c2 | a1 a0 b1 | b0 c1 c0 |

111 | a3 b3 c3 | a2 b2 c2 | a1 b1 c1 | a0 b0 c0 |