gf2 2.1.0

# The `BitStore` Trait

## Introduction

The library's vector-like types implement the `BitStore` trait:

| Type          | Description                                                                             |
| ------------- | --------------------------------------------------------------------------------------- |
| [`BitArray`]  | A fixed-size vector of bits (requires compilation with the `unstable` feature enabled). |
| [`BitVector`] | A dynamically-sized vector of bits.                                                     |
| [`BitSlice`]  | A non-owning view into contiguous ranges of bits.                                       |

These types own or view individual bit elements packed into some underlying "store" of [`Unsigned`] words.
The particular choice of `Word` is generic and user selectable from one of the primitive unsigned integer types.
We refer to any type that implements the `BitStore` trait as a _bit-store_.

Bit-stores have _dozens_ of methods in common.
That `BitStore` trait defines the requirements for implementing the shared functionality _once_ as associated methods of the trait.
Each concrete bit-store type inherits those methods.

The functions include bit accessors, mutators, fills, queries, iterators, stringification methods, bit-wise operators, arithmetic operators, and more.
Operations on and between bit-stores work on a whole-word basis, so are inherently parallel.

<div style="border: 2px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px 0; display: flex; align-items: center;">
<div style="font-size: 48px; margin-right: 12px; color: #666;">📝</div>

Users typically will not use this trait directly -- it's an implementation detail to avoid code duplication.
Instead, they will create and use [`BitArray`] and [`BitVector`] objects, and _slices_ from those bit-vectors.
Those concrete types _inherit_ the dozens of methods provided by this trait.

</div>

## Trait Requirements

To implement the [`BitStore`] trait, a type must define the following seven methods:

| Method                  | Expected Return Value/Method Functionality                                       |
| ----------------------- | -------------------------------------------------------------------------------- |
| [`BitStore::len`]       | Returns the number of bits in the store.                                         |
| [`BitStore::store`]     | Read-only access to the first _word_ holding bits in the store.                  |
| [`BitStore::store_mut`] | Read-write access to the first _word_ holding bits in the store.                 |
| [`BitStore::offset`]    | Returns the offset in bits from start of `word(0)` to the store's first element. |
| [`BitStore::words`]     | This is always `Word::words_needed(self.len())` but cached for efficiency.       |
| [`BitStore::word`]      | Returns a "word" from the store; possibly synthesised from two real words.       |
| [`BitStore::set_word`]  | Sets the value of a "word" in the store, possibly altering two real words.       |

<div style="border: 2px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px 0; display: flex; align-items: center;">
<div style="font-size: 48px; margin-right: 12px; color: #666;">📝</div>

We could implement the last three methods above using the first four.
For example, the `words` method is a trivial computation based on `len` and the number of bits per underlying word.
However, all the concrete bit-store types already cache the required value, so we use that instead.
Every hot loop in the library calls `words`, and benchmarking shows that precomputing the value _significantly_ improves performance.
Having optimised versions of the `word` and `set_word` methods has an even larger impact on performance.

</div>

### Other Notes

- The underlying store must contain enough words of storage to accommodate `len` bits.
- The `words` method always returns the same number as `Word::words_needed(len()),` but this value is cached and used in constant use.
- The store's final word can have extra unused bits, but the `word` method should always set those unused bits to zero.
- The `set_word` method sets a "word" to a passed value, affecting only the _accessible_ bits in the store.

### Example

The methods are trivial to implement for [`BitArray`] and [`BitVector`].

Here is a _sketch_ of how they might work for the `BitVector` type, which stores `m_len` bits in a `Vec<Word>` called `m_store`:

```c++
impl<Word: Unsigned> BitStore<Word> for BitVector<Word> {
    fn len(&self) -> usize                 { self.m_len }
    fn store(&self) -> &[Word]             { self.m_store.as_slice() }
    fn store_mut(&mut self) -> &mut [Word] { self.m_store.as_mut_slice() }
    fn offset(&self) -> u32                { 0 }
    fn words(&self) -> usize               { self.m_store.len() }
    fn word(&self, i: usize) -> Word       { self.m_store[i] }                  // <1>
    fn set_word(&mut self, i: usize, word: Word) { self.m_store[i] = word; }    // <2>
};
```

1. The required `BitStore` methods are all trivially implemented, though the real implementation allows for range checks for debug builds.
2. In this simple sketch, the `set_word` method directly sets the underlying word. The real implementation is careful to avoid touching unoccupied bits in the final word.

A sketch of the `BitArray` type is similar, except that the underlying store is a standard fixed array of words rather than a `Vec`.

### Bit-slices

The [`BitSlice`] type is a bit different because it is a non-owning view into some contiguous subset of bits held by another bit-store, and that subset may not align with the underlying words.

However, all the `BitStore`-associated methods operate as if bit element 0 is the **lowest-order** bit of "word" **0**.
This constraint means that the implementation of the `word(i)` and `set_word(i,v)` methods for bit-slice is more complex than for the other two bit-stores because they often have to synthesise words from two underlying words in the real store.

### Sample Layout

Consider a bit-store `store` with 20 elements, where the `Word` type used to store those bits is an unsigned 8-bit integer.

The `BitStore` methods all naturally expect that `store.len()` returns 20.
Less obviously, they all expect `store.words()` to return `3`, as it takes three 8-bit words to hold 20 bits with four bits to spare.

The methods expect that `store.word(0)` holds the first 8 bits in the bit-store, `store.word(1)` has the following 8 bits, and `store.word(2)` holds the final four elements in its four lowest-order bits.
It also expects that the four highest "unoccupied" bits in `store.word(2)` are set to 0.

If the store is a bit-array or a bit-vector, the implementation of these `BitStore` expectations is easy.
Those types just have to be careful to ensure that any unoccupied high-order bits in the final word remain zeros.

It is a different matter for a bit-slice, which isn't usually zero-aligned with the real underlying array of unsigned words, `w[0]`, `w[1]`, ...
The various bit-store functions still expect that `store.words()` returns three even though the span may touch bits in _four_ underlying words!

For a bit-slice, the return value for `store.word(i)` will often be synthesised from two contiguous "real" words
`w[j]` and `w[j+1]` for some `j`.
`store.word[i]` will use some high-order bits from `w[j]` and low-order bits from `w[j+1]`.

The following diagram shows how bits in a bit-slice lie within the underlying words, which are `u8`s in this example:

<div style="border: 2px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px 0; background-color: #f9f9f9; display: flex; align-items: center; justify-content: center;">

![Embedded Figure][bit-slice-example]

</div>

The `BitSlice` must always behave _as if_ bits from the real underlying store were copied and shuffled down so that element zero is bit 0 of word 0 in the bit-slice. However, it never actually copies anything; instead, it synthesises "words" as needed.

The same principle applies to the `store.set_word(i, value)` method.
The implementation of `set_word` for bit-vectors and bit-arrays is trivial, with the one caveat that we have to be careful not to inadvertently touch any unoccupied bits in the final underlying word, or at least be sure to leave them as zeros.

In the case of a bit-slice, calls to `set_word(i, value)` will generally copy low-order bits from `value` into the high-order bits of some real underlying word `w[j]` and copy the rest of the high-order bits from `value` into the low-order bits of `w[j+1]`. The other bits in `w[j]` and `w[j+1]` will not be touched.

## Overview of Provided Methods

With the trait requirements in place, we can implement dozens of associated methods that all concrete bit-store types inherit.

The provided methods fall into categories:

| Category                                        | Description                                                                     |
| ----------------------------------------------- | ------------------------------------------------------------------------------- |
| [Bit Access](#bit-access)                       | Methods to access individual bit elements in a bit-store.                       |
| [Queries](#queries)                             | Methods to query the overall state of a bit-store.                              |
| [Mutators](#mutators)                           | Methods to mutate the overall state of a bit-store.                             |
| [Copies & Fills](#copies-and-fills)             | Methods to fill a bit-store from various sources.                               |
| [Slices](#slices)                               | Methods to create non-owning views over a part of a bit-store --- _bit-slices_. |
| [Sub-vectors](#sub-vectors)                     | Methods to clone a piece of a bit-store as a new bit-vector.                    |
| [Riffling](#riffling)                           | Methods to create vectors that copy a bit-store with interleaved zeros.         |
| [Set/Unset Indices](#indices)                   | Methods to find the indices of set & unset bits in a bit-store.                 |
| [Iterators](#iterators)                         | Methods to create various iterators over a bit-store.                           |
| [Stringification](#stringification)             | Methods to create string representations of a bit-store.                        |
| [Bit Shifts](#shifts)                           | Methods to shift the bits in a bit-store left or right.                         |
| [Bitwise Operations](#bit-wise-operations)      | Methods to combine two bit-stores using logical operations.                     |
| [Arithmetic Operations](#arithmetic-operations) | Methods to add or subtract two bit-stores.                                      |
| [Other Functions](#other-functions)             | Dot products, convolutions, etc. for bit-stores.                                |

## Bit Access

The following methods provide access to individual bit elements in the bit-store.

| Method              | Description                                                       |
| ------------------- | ----------------------------------------------------------------- |
| [`BitStore::get`]   | Returns the value of a single bit element as a read-only boolean. |
| [`BitStore::first`] | Returns the value of the first element in the store.              |
| [`BitStore::last`]  | Returns the value of the last element in the store.               |
| [`BitStore::set`]   | Sets a bit to the given boolean value.                            |
| [`BitStore::flip`]  | Flips the value of the bit element at a given index.              |
| [`BitStore::swap`]  | Swaps the values of bit elements at locations `i` and `j`.        |

We have implemented the [`std::ops::Index`] foreign trait to provide array-like indexing for bit-stores.
That implementation forwards to the `get` method above.

<div style="border: 2px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px 0; display: flex; align-items: center;">
<div style="font-size: 48px; margin-right: 12px; color: #666;">📝</div>

The C++ version of this library also overloads the index operator to provide array-like indexing for bit-stores.
In the C++ case, the operator returns a proxy object that can be used as an l-value or an r-value which allows for natural syntax like `v[i] = true;`.
Rust has no equivalent mechanism, so we must rely on the `set` method.

</div>

## Queries

The following methods let you query the overall state of a bit-store.

| Method                       | Description                                             |
| ---------------------------- | ------------------------------------------------------- |
| [`BitStore::is_empty`]       | Returns true if the store is empty                      |
| [`BitStore::any`]            | Returns true if _any_ bit in the store is set.          |
| [`BitStore::all`]            | Returns true if _every_ bit in the store is set.        |
| [`BitStore::none`]           | Returns true if _no_ bit in the store is set.           |
| [`BitStore::count_ones`]     | Returns the number of set bits in the store.            |
| [`BitStore::count_zeros`]    | Returns the number of unset bits in the store.          |
| [`BitStore::leading_zeros`]  | Returns the number of leading unset bits in the store.  |
| [`BitStore::trailing_zeros`] | Returns the number of trailing unset bits in the store. |

These methods efficiently operate on words at a time, so they are inherently parallel.

## Mutators

The following methods let you mutate the entire store in a single call.

| Method                 | Description                                                                     |
| ---------------------- | ------------------------------------------------------------------------------- |
| [`BitStore::set_all`]  | Sets all the bits in the store to the passed value.                             |
| [`BitStore::flip_all`] | Flips the values of all the bits in the store.                                  |
| [`BitStore::flipped`]  | Returns a new bit-vector that is a copy of the store with all the bits flipped. |

They efficiently operate on words at a time, so they are inherently parallel.

We have implemented the [`std::ops::Not`] foreign trait to provide the unary `!` operator for bit-stores. That implementation forwards to the `flipped` method above.

## Copies and Fills

The following methods let you populate the entire store from multiple sources in a single call.

| Method                                  | Description                                                                      |
| --------------------------------------- | -------------------------------------------------------------------------------- |
| [`BitStore::copy_unsigned`]             | Copies the bit values from any single unsigned value to this store.              |
| [`BitStore::copy_unsigneds`]            | Copies the bit values from an iteration of any unsigned values to this store.    |
| [`BitStore::copy_store`]                | Copies bit values from any source store to this store.                           |
| [`BitStore::copy_fn`]                   | Copies bit values from a function that returns a boolean for an index.           |
| [`BitStore::fill_random_biased_seeded`] | Very general method to fill the store with random 0's and 1's.                   |
| [`BitStore::fill_random_biased`]        | Fill the store with random 0's and 1's, where the RNG it itself randomly seeded. |
| [`BitStore::fill_random`]               | Fill the store with random 0's and 1's from flips of a _fair_ coin.              |

### Copies

- In each case, the _size_ of the source and destinations must match exactly! You can always use a [`BitSlice`] to change/copy a subset of bits if needed.
- However, the underlying _word types_ need **not** match, so you can copy between bit-stores that use different underlying word types. You can use the [`BitStore::copy_store`] method to convert between different `Word` type stores (e.g., from `BitVector<u32>` to `BitVector<u8>`) as long as the size of the source and destinations match.

### Random Fills

The general random fill method uses a random number generator seeded with system entropy, so the results change from run to run.
You can set a specific seed to get reproducible fills (a seed of `0` is reserved to means "use system entropy").

The simplest [`BitStore::fill_random`] method fills the store with random bits from a fair coin so the probability of a 0 or 1 is equal (i.e., 50/50).

## Slices

The following methods let you create a [`BitSlice`], which is a non-owning view of some contiguous subset of bits in the store.

| Method                  | Description                                                                  |
| ----------------------- | ---------------------------------------------------------------------------- |
| [`BitStore::slice`]     | Returns a [`BitSlice`] encompassing the bits in a half-open range.           |
| [`BitStore::slice_mut`] | Returns a _mutable_ [`BitSlice`] encompassing the bits in a half-open range. |

A [`BitSlice`] also implements the [`BitStore`] trait, so you can take a slice of a slice.

## Sub-vectors

The following methods create or fill _independent_ bit-vectors with copies of some contiguous subset of the bits in the store.

| Method                      | Description                                                                              |
| --------------------------- | ---------------------------------------------------------------------------------------- |
| [`BitStore::sub`]           | Returns a new [`BitVector`] encompassing the bits in a half-open range.                  |
| [`BitStore::split_at_into`] | Fills two bit-vectors with the bits in the ranges `[0, at)` and `[at, len())`.           |
| [`BitStore::split_at`]      | Returns two new two bit-vectors with the bits in the ranges `[0, at)` and `[at, len())`. |

The `split_at_into` method takes two pre-existing bit-vectors to fill, thereby avoiding unnecessary allocations in some iterative algorithms that repeatedly use this method.

**Note:** These methods do not alter the underlying store.

## Riffling

We have methods that can interleave (_riffle_) the bits in a store with zeros.

| Method                     | Description                                                                       |
| -------------------------- | --------------------------------------------------------------------------------- |
| [`BitStore::riffled_into`] | Fills a pre-existing bit-vector with the result of riffling this store.           |
| [`BitStore::riffled`]      | Returns a new bit-vector that is this store with its bits interleaved with zeros. |

If the store looks like `v0 v1 ... vn`, then the riffling operation produces the vector `v0 0 v1 0 ... 0 vn` where a zero is interleaved _between_ every bit in the original store (there is no trailing zero at the end).

If you think of a bit-store as representing the coefficients of a polynomial over GF(2), then riffling corresponds to squaring that polynomial.

## Set and Unset Bit Indices

The following methods find the indices of set or unset bits in the store.

| Method                       | Description                                                                         |
| ---------------------------- | ----------------------------------------------------------------------------------- |
| [`BitStore::first_set`]      | Returns the index of the first set bit in the store.                                |
| [`BitStore::last_set`]       | Returns the index of the last set bit in the store.                                 |
| [`BitStore::next_set`]       | Returns the index of the next set bit in the store _after_ the passed index.        |
| [`BitStore::previous_set`]   | Returns the index of the previous set bit in the store _before_ the passed index.   |
| [`BitStore::first_unset`]    | Returns the index of the first unset bit in the store.                              |
| [`BitStore::last_unset`]     | Returns the index of the last unset bit in the store.                               |
| [`BitStore::next_unset`]     | Returns the index of the next unset bit in the store _after_ the passed index.      |
| [`BitStore::previous_unset`] | Returns the index of the previous unset bit in the store _before_ the passed index. |

## Iterators

The following methods create iterators for traversing the bits or underlying words in the store:

- Read-only iteration through the individual bits.
- Read-write iteration through the individual bits.
- Read-only iteration through the indices of the set bits.
- Read-only iteration through the indices of the unset bits.
- Read-write iteration through the underlying store words.

| Method                      | Description                                                                 |
| --------------------------- | --------------------------------------------------------------------------- |
| [`BitStore::bits`]          | Returns a [`Bits`] iterator over the bits in the store.                     |
| [`BitStore::set_bits`]      | Returns a [`SetBits`] iterator to view the indices of all the set bits.     |
| [`BitStore::unset_bits`]    | Returns a [`UnsetBits`] iterator to view the indices of all the unset bits. |
| [`BitStore::store_words`]   | Returns a [`Words`] iterator to view the "words" underlying the store.      |
| [`BitStore::to_words`]      | Returns a copy of the "words" underlying the bit-store.                     |
| [`BitStore::to_words_into`] | Fills a destination vector with the "words" underlying the bit-store.       |

## Stringification

The following functions returns a string representation of a bit store.
The string can be in the obvious binary format or a more compact hex format.

| Method                                | Description                                                                                   |
| ------------------------------------- | --------------------------------------------------------------------------------------------- |
| [`BitStore::to_custom_binary_string`] | Returns a binary string representation for a bit-store with various customisation parameters. |
| [`BitStore::to_binary_string`]        | Returns the simplest binary binary string representation for a bit-store.                     |
| [`BitStore::to_pretty_string`]        | Returns a "pretty" binary string representation for a bit-store.                              |
| [`BitStore::to_hex_string`]           | Returns a compact hex string representation for a bit-store.                                  |
| [`std::string::ToString::to_string`]  | Delegates to [`BitStore::to_binary_string`].                                                  |
| [`BitStore::describe`]                | Returns a multi-line string describing the bit-store in some detail.                          |

A bit-store has two different string representations: as a binary string or as a compact hex string.
The two encodings are:

### Binary String Encoding

The straightforward character encoding for a bit-store is a _binary_ string containing just 0's and 1's, for example, `"10101"`.
Each character in a binary string represents a single element in the store.
The `to_binary_string` method produces this string.
The method allows for an optional prefix, suffix, and separator between each bit.

The `to_string` calls `to_binary_string` to produce the most compact output, e.g. `"10101"`.
The `to_pretty_string` method produces a more human-friendly version, e.g., `"[1 0 1 0 1]"`.

The format used by the output stream operator is the same as that used by `to_string`.
That is also the default format used by the `std::formatter` specialisation.
However, you can use a `:p` format specifier to get the "pretty" version instead.
For example, if `std::format("{}, v)` is `"1010101010"`, then `std::format("{:p}", v)` is `"[1 0 1 0 1 0 1 0 1 0]"`.

**Note:** The output is in _vector order_ `v[0] v[1] v[2] ...` with the first element in the vector on the left.

### Hex String Encoding

The other supported encoding for bit-stores is a compact hex-type string containing just the 16 hex characters `0123456789ABCDEF`.
For example, the string `"3ED02"`.
We allow for hex strings with an optional prefix `"0x"` or `"0X"`, for example `"0x3ED02"`.

Each hex character translates to _four_ elements in a `BitStore`.
The hex string `0x0` is equivalent to the binary string `0000`, and so on, up to the string `0xF`, which is equivalent to the binary string `1111`.

The hex pair `0x0F` will be interpreted in the store as the eight-bit value `00001111`.
Of course, this is the advantage of hex.
It is a more compact format that occupies a quarter of the space needed to write out the equivalent binary string.

However, what happens if you want to encode a vector whose size is _not_ a multiple of 4?
We handle that by allowing the final character in the string to have a base that is _not_ 16.
To accomplish that, we allow for an optional _suffix_, which must be one of `.2`, `.4`, or `.8`.
If present, the suffix gives the base for just the _preceding_ character in the otherwise hex-based string.
If there is no suffix, the final character is assumed to be hex-encoded, as with all the others.

Therefore, the string `0x1` (without a suffix, so the last character is the default hexadecimal base 16) is equivalent to `0001`.
On the other hand, the string `0x1.8` (the last character is base 8) is equivalent to `001`.
Similarly, the string `0x1.4` (the last character is base 4) is equivalent to `01,` and finally, the string `0x1.2` (the previous character is base 2) is comparable to `1`

In the string `0x3ED01.8`, the first four characters, `3`, `E`, `D`, and `0`, are interpreted as hex values, and each will translate to four slots in the store.
However, the final 1.8 is parsed as an octal 1, which takes up three slots (001).
Therefore, this store has a size of 19 (i.e., 4 × 4 + 3).

The `std::formatter` specialisation recognises the `:x` format specifier as a request to produce a hex string representation of a bit-store.
For example, if `std::format("{}, v)` is `"1010101010"`, then `std::format("{:x}", v)` is `"AA2.4"`.

## Bit Shifts

We have methods to shift the bits in a store left or right.

These methods act in vector space, so if the vector is `v_0, v_1, ..., v_n-1, v_n` then a right shift produces the vector `0, v_0, v_1, ..., v_n-1` where we have shifted out the last element and shifted in a zero at the start.
Similarly, a left shift produces the vector `v_1, ..., v_n-1, v_n, 0` where we have shifted out the first element and shifted in a zero at the end.

Contrast this to shifts in bit space, where if a bit container is `b_n, b_n-1, ..., b_1, b_0`, then a right shift produces `0, b_n, b_n-1, ..., b_1` and a left shift produces `b_n-1, ..., b_1, b_0, 0`.

Essentially, right shifts in vector space correspond to left shifts in bit space, and vice versa.

| Methods                     | Description                                                        |
| --------------------------- | ------------------------------------------------------------------ |
| [`BitStore::left_shift`]    | Left shifts in-place.                                              |
| [`BitStore::right_shift`]   | Right shifts in-place.                                             |
| [`BitStore::left_shifted`]  | Copies the store to a new bit-vector and left shifts that vector.  |
| [`BitStore::right_shifted`] | Copies the store to a new bit-vector and right shifts that vector. |

**Note:** We have also implemented the [`std::ops::ShlAssign`], [`std::ops::ShrAssign`], [`std::ops::Shl`], and [`std::ops::Shr`] foreign traits to provide operator overloads for the shift operations. Those implementations forward to the associated methods above.

## Bitwise Operations

We have methods that combine two bit-stores using the logical operations `XOR`, `AND`, and `OR`.

<div style="border: 2px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px 0; display: flex; align-items: center;">
<div style="font-size: 48px; margin-right: 12px; color: #666;">❗</div>

These methods require that the two bit-stores use the same underlying word type.
They also require that the left-hand-side and right-hand-side bit-store operands are the same size.
That precondition is always checked.
Interactions between bit-stores with different word types are only possible at the cost of increased code complexity, and are not a common use case.

</div>

The methods can act in place, mutating the left-hand side caller: `lhs.xor_eq(rhs)`.
There is also non-mutating versions like `result = lhs.xor(rhs)`, which returns a new `result` _bit-vector_ in each case.

| Method               | Description                                                                         |
| -------------------- | ----------------------------------------------------------------------------------- |
| [`BitStore::xor_eq`] | In-place `XOR` operation of equal-sized bit-stores: `lhs = lhs ^ rhs`.              |
| [`BitStore::and_eq`] | In-place `AND` operation of equal-sized bit-stores: `lhs = lhs & rhs`.              |
| [`BitStore::or_eq`]  | In-place `OR` operation of equal-sized bit-stores: `lhs = lhs \| rhs`.              |
| [`BitStore::xor`]    | Returns the `XOR` of this store with another equal-sized store as a new bit-vector. |
| [`BitStore::and`]    | Returns the `AND` of this store with another equal-sized store as a new bit-vector. |
| [`BitStore::or`]     | Returns the `OR` of this store with another equal-sized store as a new bit-vector.  |

**Note:** We have also implemented the [`std::ops::BitXorAssign`], [`std::ops::BitAndAssign`], [`std::ops::BitOrAssign`], [`std::ops::BitXor`], [`std::ops::BitAnd`], and [`std::ops::BitOr`] foreign traits to provide operator overloads for the bit-wise operations. Those implementations forward to the associated methods above.

## Arithmetic Operations

In GF(2), the arithmetic operators `+` and `-` are both the `XOR` operator.

| Method                 | Description                                                                  |
| ---------------------- | ---------------------------------------------------------------------------- |
| [`BitStore::plus_eq`]  | Adds the passed (equal-sized) `rhs` bit-store to this one.                   |
| [`BitStore::minus_eq`] | Subtracts the passed (equal-sized) `rhs` bit-store from this one.            |
| [`BitStore::plus`]     | Adds two equal-sized bit-stores and returns the result as a bit-vector.      |
| [`BitStore::minus`]    | Subtracts two equal-sized bit-stores and returns the result as a bit-vector. |

**Note:** We have also implemented the [`std::ops::AddAssign`], [`std::ops::SubAssign`], [`std::ops::Add`], and [`std::ops::Sub`] foreign traits to provide operator overloads for the arithmetic operations. Those implementations forward to the associated methods above.

## Other Functions

| Method                       | Description                                                         |
| ---------------------------- | ------------------------------------------------------------------- |
| [`BitStore::dot`]            | Returns the dot product of two equal-sized bit-stores as a boolean. |
| [`BitStore::convolved_with`] | Returns the convolution of two bit-stores as a new bit-vector.      |

### Note

We have implement the [`std::ops::Mul`] foreign trait to provide an operator overload for the dot product operation.

## Foreign Traits

There are many foreign traits in the Rust standard library that we would like to implement for all bit-store types. However, Rust's orphan rules prevent us from doing this in a blanket way. If you try, you will get compiler errors and somewhat opaque complaints about "coherence and overlap" issues.

You cannot implement foreign traits for any `BitStore` type in a blanket manner. The compiler worries that someone might later define a new type that implements `BitStore` and also implements its own version of the foreign trait, leading to ambiguity. There is no way to close a trait in Rust to prevent this from happening.

Instead, you have to implement the foreign traits for each concrete type separately, leading to a lot of code duplication, particularly as many of the foreign traits of interest work on _pairs_ of bit-stores (for example, the [`std::ops::Add`] trait). We have three bit-store types, so there are nine possible pairs to consider, and that is before you consider whether each argument was passed by value or by reference.

<div style="border: 2px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px 0; display: flex; align-items: center;">
<div style="font-size: 48px; margin-right: 12px; color: #666;">📝</div>

This is not an issue for the C++ version of this library because C++ allows for blanket implementations of operator overloads.

</div>

To this crate, to avoid code duplication, we defined macros that implemented the foreign traits for all bit-store types uniformly.

## Foreign Traits for Individual Bit-Stores

The simplest case is where a foreign trait acts on a single bit-store type:

| Trait Name              | Description                                  |
| ----------------------- | -------------------------------------------- |
| [`std::ops::Index`]     | Forwarded to [`BitStore::get`].              |
| [`std::ops::Not`]       | Forwarded to [`BitStore::flipped`].          |
| [`std::fmt::Display`]   | Forwarded to [`BitStore::to_binary_string`]. |
| [`std::fmt::Binary`]    | Forwarded to [`BitStore::to_binary_string`]. |
| [`std::fmt::UpperHex`]  | Forwarded to [`BitStore::to_hex_string`].    |
| [`std::fmt::LowerHex`]  | Forwarded to [`BitStore::to_hex_string`].    |
| [`std::ops::ShlAssign`] | Forwarded to [`BitStore::left_shift`].       |
| [`std::ops::ShrAssign`] | Forwarded to [`BitStore::right_shift`].      |
| [`std::ops::Shl`]       | Forwarded to [`BitStore::left_shifted`].     |
| [`std::ops::Shr`]       | Forwarded to [`BitStore::right_shifted`].    |

The [`std::ops::Not`] trait is implemented for each concrete bit-store both by value and by reference.

Our `impl_unary_traits!` macro implements these foreign traits for any _concrete_ bit-store type.
For example, we can invoke `impl_unary_traits!(BitVector)` to implement all these traits for the `BitVector` type.

## Foreign Traits for Pairs of Bit-Stores

Other foreign traits act on _pairs_ of bit-store types:

| Trait Name                 | Description                         |
| -------------------------- | ----------------------------------- |
| [`std::ops::BitXorAssign`] | Forwarded to [`BitStore::xor_eq`]   |
| [`std::ops::BitAndAssign`] | Forwarded to [`BitStore::and_eq`]   |
| [`std::ops::BitOrAssign`]  | Forwarded to [`BitStore::or_eq`]    |
| [`std::ops::AddAssign`]    | Forwarded to [`BitStore::plus_eq`]  |
| [`std::ops::SubAssign`]    | Forwarded to [`BitStore::minus_eq`] |
| [`std::ops::BitXor`]       | Forwarded to [`BitStore::xor`]      |
| [`std::ops::BitAnd`]       | Forwarded to [`BitStore::and`]      |
| [`std::ops::BitOr`]        | Forwarded to [`BitStore::or`]       |
| [`std::ops::Add`]          | Forwarded to [`BitStore::plus`]     |
| [`std::ops::Sub`]          | Forwarded to [`BitStore::minus`]    |
| [`std::ops::Mul`]          | Forwarded to [`BitStore::dot`]      |

Our `impl_binary_traits!` macro implements these foreign traits for any _concrete pair_ of bit-store types.
For example, we can invoke `impl_binary_traits!(BitVector, BitSlice)` to implement all these traits for the `BitVector` type interacting with a `BitSlice` type.

Moreover, the macro implements the traits for all combinations of references and values for the two types, so `impl_binary_traits!(BitVector, BitSlice)` implements the traits for the following pairs:

- `BitVector` and `BitSlice`
- `&BitVector` and `BitSlice`
- `BitVector` and `&BitSlice`
- `&BitVector` and `&BitSlice`

This includes all combinations of the two types being passed by either by value or by reference.
For example, if `u` and `v` are two `BitVector` instances, then the following expressions will all work:

```rust
use gf2::*;
let u: BitVector = BitVector::random(10);
let v: BitVector = BitVector::random(10);
let a = &u + &v;    // `a` is a new `BitVector`; `u` and `v` are both preserved.
let b = &u + v;     // `b` is a new `BitVector`; we cannot use `v` again.
let c = u + &b;     // `c` is a new `BitVector`; we cannot use `u` again.
let d = b + c;      // `d` is a new `BitVector`; we cannot use either `b` or `c` again.
```

This is very different from C++, where operator overloads are typically defined to preserve both arguments.

```cpp
auto u = gf2::BitVector::random(10);
auto v = gf2::BitVector::random(10);
auto a = u + v;     // `a` is a new `BitVector`; `u` and `v` are both preserved.
```

In C++, you don't have to write `a = &u + &v` to preserve both operands, instead, you just write `a = u + v` with no ampersands.
The syntax is cleaner for the most common use case.

### The Macros

The macros are lengthy but straightforward, with a few arms that funnel to a single match arm that actually does something.

The one twist is that while all of our bit-store types have a generic `Word: Unsigned` parameter, some types have an extra generic parameter (a lifetime for `BitSlice`, and a `const N: usize` for `BitArray`).

- `BitVector<Word>` has a single generic parameter.
- `BitSlice<'a, Word>` has two generic parameters, the first of which is a lifetime.
- `BitArray<const N, Word>` has two generic parameters, the first of which is `const usize`.

Handling the existence/non-existence of these extra generic parameters is the main complexity in the macros.

<!-- Internal Reference Links -->

[`BitArray`]: crate::BitArray
[`BitVector`]: crate::BitVector
[`BitSlice`]: crate::BitSlice
[`Unsigned`]: crate::Unsigned

<!-- Base64 Encoded Image: rustdoc is extremely primitive and cannot embed images in any reasonable manner -->

[bit-slice-example]: data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xl="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="45.5 388.552 763.5 131.5402" width="763.5" height="131.5402">
  <defs/>
  <g id="Canvas_1" fill-opacity="1" stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none">
    <title>Canvas 1</title>
    <g id="Canvas_1_Layer_1">
      <title>Layer 1</title>
      <g id="Graphic_108">
        <rect x="616" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="616" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(621 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_109">
        <rect x="635" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="635" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(640 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_110">
        <rect x="654" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="654" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(659 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_111">
        <rect x="673" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="673" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(678 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_36">
        <rect x="198" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="198" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(203 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_37">
        <rect x="217" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="217" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(222 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_38">
        <rect x="236" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="236" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(241 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_39">
        <rect x="255" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="255" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(260 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_43">
        <rect x="274" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="274" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(279 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_42">
        <rect x="293" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="293" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(298 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_41">
        <rect x="312" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="312" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(317 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_40">
        <rect x="331" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="331" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(336 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_51">
        <rect x="350" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="350" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(355 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_50">
        <rect x="369" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="369" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(374 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_49">
        <rect x="388" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="388" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(393 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_48">
        <rect x="407" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="407" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(412 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_47">
        <rect x="426" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="426" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(431 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_46">
        <rect x="445" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="445" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(450 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_45">
        <rect x="464" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="464" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(469 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_44">
        <rect x="483" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="483" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(488 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_59">
        <rect x="502" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="502" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(507 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_58">
        <rect x="521" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="521" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(526 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_57">
        <rect x="540" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="540" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(545 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_56">
        <rect x="559" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="559" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(564 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_55">
        <rect x="578" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="578" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(583 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_54">
        <rect x="597" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="597" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(602 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_53">
        <rect x="616" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="616" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(621 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_52">
        <rect x="635" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="635" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(640 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_67">
        <rect x="654" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="654" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(659 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_66">
        <rect x="673" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="673" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(678 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_65">
        <rect x="692" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="692" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(697 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_64">
        <rect x="711" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="711" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(716 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_63">
        <rect x="730" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="730" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(735 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_62">
        <rect x="749" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="749" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(754 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_61">
        <rect x="768" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="768" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(773 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_60">
        <rect x="787" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="787" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(792 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_75">
        <rect x="46" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="46" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(51 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_74">
        <rect x="65" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="65" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(70 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_73">
        <rect x="84" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="84" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(89 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_72">
        <rect x="103" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="103" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(108 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_71">
        <rect x="122" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="122" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(127 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_70">
        <rect x="141" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="141" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(146 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_69">
        <rect x="160" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="160" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(165 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_68">
        <rect x="179" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="179" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(184 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_84">
        <rect x="236" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="236" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(241 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_83">
        <rect x="255" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="255" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(260 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_82">
        <rect x="274" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="274" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(279 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_81">
        <rect x="293" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="293" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(298 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_80">
        <rect x="312" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="312" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(317 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_79">
        <rect x="331" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="331" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(336 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_78">
        <rect x="350" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="350" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(355 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_77">
        <rect x="369" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="369" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(374 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_92">
        <rect x="388" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="388" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(393 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_91">
        <rect x="407" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="407" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(412 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_90">
        <rect x="426" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="426" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(431 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_89">
        <rect x="445" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="445" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(450 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_88">
        <rect x="464" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="464" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(469 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_87">
        <rect x="483" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="483" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(488 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_86">
        <rect x="502" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="502" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(507 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_85">
        <rect x="521" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="521" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(526 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_97">
        <rect x="540" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="540" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(545 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_96">
        <rect x="559" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="559" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(564 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_95">
        <rect x="578" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="578" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(583 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_94">
        <rect x="597" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="597" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(602 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_105">
        <rect x="236" y="466.6442" width="152" height="25" stroke="#b1001c" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_106">
        <rect x="388" y="466.6442" width="152" height="25" stroke="#b1001c" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_113">
        <rect x="540" y="466.6442" width="152" height="25" stroke="#b1001c" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Line_126">
        <path d="M 236 442 L 236 442 C 236 450.29954 242.7281 457.02765 251.02765 457.02765 L 297.5128 457.02765 C 302.45403 457.02765 306.91434 459.9881 308.83333 464.5415 L 308.83333 464.5415 C 309.5704 466.2904 311.58567 467.11064 313.33458 466.37357 C 314.16093 466.0253 314.8184 465.36783 315.16667 464.5415 L 315.16667 464.5415 C 317.08566 459.9881 321.54597 457.02765 326.4872 457.02765 L 372.97235 457.02765 C 381.2719 457.02765 388 450.29954 388 442 L 388 442" stroke="#a5a5a5" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Line_127">
        <path d="M 389 442 L 389 442 C 389 450.29954 395.7281 457.02765 404.02765 457.02765 L 450.5128 457.02765 C 455.45403 457.02765 459.91434 459.9881 461.83333 464.5415 L 461.83333 464.5415 C 462.5704 466.2904 464.5857 467.11064 466.3346 466.37357 C 467.1609 466.0253 467.8184 465.36783 468.16667 464.5415 L 468.16667 464.5415 C 470.08566 459.9881 474.54597 457.02765 479.4872 457.02765 L 525.97235 457.02765 C 534.2719 457.02765 541 450.29954 541 442 L 541 442" stroke="#a5a5a5" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Line_128">
        <path d="M 542 442.03426 L 542 442.03426 C 542 450.3338 548.7281 457.0619 557.02765 457.0619 L 568.2463 457.0619 C 572.7114 457.0619 576.5609 460.20176 577.4583 464.57574 L 577.4583 464.57574 C 577.633 465.4272 578.4649 465.9758 579.3163 465.8011 C 579.9331 465.67454 580.4151 465.19254 580.5417 464.57574 L 580.5417 464.57574 C 581.4391 460.20176 585.2886 457.0619 589.7537 457.0619 L 600.97235 457.0619 C 609.2719 457.0619 616 450.3338 616 442.03426 L 616 442.03426" stroke="#a5a5a5" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_130">
        <title>span[0]</title>
        <text transform="translate(286.1421 496.6442)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="7887024e-19" y="15" xml:space="preserve">slice[0]</tspan>
        </text>
      </g>
      <g id="Graphic_131">
        <title>span[1]</title>
        <text transform="translate(440.264 496.6442)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="7887024e-19" y="15" xml:space="preserve">slice[1]</tspan>
        </text>
      </g>
      <g id="Graphic_132">
        <text transform="translate(591.264 496.6442)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="7887024e-19" y="15" xml:space="preserve">slice[2]</tspan>
        </text>
      </g>
      <g id="Graphic_139">
        <rect x="47.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_140">
        <rect x="199.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_141">
        <rect x="351.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_142">
        <rect x="503.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_143">
        <rect x="655.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_144">
        <text transform="translate(116.844 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[0]</tspan>
        </text>
      </g>
      <g id="Graphic_145">
        <text transform="translate(266.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[1]</tspan>
        </text>
      </g>
      <g id="Graphic_146">
        <text transform="translate(415.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[2]</tspan>
        </text>
      </g>
      <g id="Graphic_147">
        <text transform="translate(564.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[3]</tspan>
        </text>
      </g>
      <g id="Graphic_148">
        <text transform="translate(713.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[4]</tspan>
        </text>
      </g>
    </g>
  </g>
</svg>
