# Crate zigzag[−][src]

A crate which exposes two quasi-extension traits that extend signed integers
with the `ZigZagEncode`

trait and unsigned integers with the
`ZigZagDecode`

trait.

# Zigzag Encoding

Zigzag encoding takes a signed integer and encodes it as an unsigned integer. It does so by counting up, starting at zero, alternating between representing a positive number and a negative number.

To encode any signed integer, `x`

, with a representation length—in bits,
`n`

, the formula is as follows:

```
(x >> n - 1) ^ (x << 1)
```

*Note*: The `^`

operator *is not* exponentiation; rather, it is bitwise
XOR.

For instance, the simplified formula to encode a signed *32-bit* integer
of value `x`

would be as follows:

```
(x >> 31) ^ (x << 1)
```

# Zigzag Decoding

To convert a zigzag-encoded unsigned integer, `x`

, to its decoded signed
counterpart, the formula is as follows:

```
(x >>> 1) ^ -(x & 1)
```

*Note*: The `>>>`

operator is to represent a logical right shift as opposed
to an arithmetic right shift. In Rust, unsigned integer types implement the
right shift operator as logical instead of arithmetic. Therefore, the
formula in Rust is simplified as `(x >> 1) ^ -(x & 1)`

.

# Examples

Encoding a signed integer:

use zigzag::ZigZagEncode; assert_eq!(0i8.zigzag_encode(), 0u8); assert_eq!((-1i8).zigzag_encode(), 1u8); assert_eq!(1i8.zigzag_encode(), 2u8); assert_eq!(i8::MIN.zigzag_encode(), u8::MAX); assert_eq!(i16::MIN.zigzag_encode(), u16::MAX); assert_eq!(i32::MIN.zigzag_encode(), u32::MAX); assert_eq!(i64::MIN.zigzag_encode(), u64::MAX); assert_eq!(i128::MIN.zigzag_encode(), u128::MAX); assert_eq!(isize::MIN.zigzag_encode(), usize::MAX);

Decoding an unsigned integer:

use zigzag::ZigZagDecode; assert_eq!(0u8.zigzag_decode(), 0i8); assert_eq!(1u8.zigzag_decode(), -1i8); assert_eq!(2u8.zigzag_decode(), 1i8); assert_eq!(u8::MAX.zigzag_decode(), i8::MIN); assert_eq!(u16::MAX.zigzag_decode(), i16::MIN); assert_eq!(u32::MAX.zigzag_decode(), i32::MIN); assert_eq!(u64::MAX.zigzag_decode(), i64::MIN); assert_eq!(u128::MAX.zigzag_decode(), i128::MIN); assert_eq!(usize::MAX.zigzag_decode(), isize::MIN);

## Traits

ZigZagDecode | A trait intended to extend unsigned integer types with the ability to get their signed representation as derived by zigzag decoding. |

ZigZagEncode | A trait intended to extend signed integer types with the ability to get their unsigned representation as derived by zigzag encoding. |