Question: I have the following DataSet on a SSRS report:

```
SELECT
  VariationCode.Code
  ,VariationCoding.Comment
  ,VariationCoding.SubmissionDate
  ,VariationCoding.Id
FROM
  VariationCode
  INNER JOIN VariationCoding
    ON VariationCode.Id = VariationCoding.VariationCodeId
WHERE VariationId = @VariationId

```

I am showing static headers on the left and data on the right which works fine but I'm struggling to group the results by ID and show them as a separate table per grouping.

Grouping the row by parent using VariationCoding.Id shows one table with no grouping at all. I suspect having the headers on the left is the problem since most solutions I've seen have the headers on top.

How can I show static headers on the left and group the results by VariationCoding.Id in such a way that each result will be displayed in a separate table?

Answer: 
Consider the values you can achieve with 2 bits:

```
00 : 0
01 : 1
10 : 2
11 : 3

```

There are 4 of them, 2 to the power of 2.  

But the highest value is not 4, it is 3.  

The highest value is 2 to the power of 2 minus 1. I.e. in your representation 

2^2-1  

or 22-1

Add a bit and you get twice the number, by adding

```
100 : 4
101 : 5
110 : 6
111 : 7

```

Total number 8, but highest number 7.

So the "-1" is because always the first of the total of 2n is used for 0,  

the 2nd is used for 1, the 3rd is used for 2.  

In the end (2n)th one is not available for 2n, it is already used for 2n-1.
Where did you find this incorrect paragraph? It appears to be about 2's complement but has the `-1` in the wrong place.

For C implementations using one's complement or sign/magnitude signed integers, the range is symmetric around zero (with 2 bit patterns that both represent `0`, so the positive range and the negative range are the same size).

Basically nothing ever uses that these days, but the ISO C standard specifies that signed integers are binary and use either two's complement, one's complement, or sign/magnitude.

---

In [2's complement](https://en.wikipedia.org/wiki/Two%27s_complement) (nearly universal these days), the range of representable values using n bits is 
[- 2n-1 , 2n-1 - 1 ]. **One bit-pattern (all bits zero) represents the value zero**. Every bit has a place-value of `2^i`, except the final one which has a place value of `-2^(n-1)`.

The bit-pattern with all bits set represents `-1` because `sum(2^i, i=0..n-1)` is one less than `2^n`.

**With *only* the sign bit set, we get the most-negative number**: `-INT_MIN` is signed overflow (undefined behaviour) because it's not representable as an `int`; it requires a wider integer. Or with wrapping, `-INT_MIN = INT_MIN`. This is the "2's complement anomaly". <https://en.wikipedia.org/wiki/Two%27s_complement#Most_negative_number>

You can avoid widening if you're doing an absolute value operation: e.g.  

`unsigned abs = i >= 0 ? i : -(unsigned)i;`

(Converting a negative value to `unsigned` in C has well-defined behaviour of modulo-reducing until it's in the representable range. In C this is independent of the signed-integer encoding; what matters is the *value*. So `(uint8_t)-1` is *always* 255. For 2's complement it just copies the bit-pattern. For sign/magnitude or one's complement a C implementation would have to do some math to cast from signed to signed. Notice that I did this *before* negation, which means `0 - i` with the usual unsigned wrapping.)