Jcd.BitManipulation 2.1.0

Jcd.BitManipulation

A .Net Standard 2.0 library adding syntactic sugar to your bit manipulation experience.

Performance Notes

If you read the code you'll notice a fair number of abstractions at play. These don't have a significant impact on release mode performance. In fact running on at roughly 3.5GHz to 3.8Ghz (my CPU auto-scales performance based on load.) doing the 6 chained operations at the end of the example below, but on the loop index instead of just zero, 10+e9 times completes in roughly 830-890ms in Release mode. 10+e6 iterations in debug mode completes in roughly 50-65ms.

To see how it performs on your system run the code in the Main function of the examples app.

Debug mode run:
1,000,000 iterations with 6 operations per iteration took 51.34 ms for an average of 8.56e-006 ms per operation.

Release mode run:
1,000,000,000 iterations with 6 operations per iteration took 868.58 ms for an average of 1.45e-007 ms per operation.

Examples

ushort data = 0b0000000000000000;
// turn on all the bits
data=data.SetBits(0, 16); // value is now 0b1111111111111111

// this is the equivalent as above
data=data.SetBits();

// Clear the middle 4 bits.
data=data.ClearBits(4, 8); // value is now 0b1111000000001111

// Toggle all the bits.
data=data.ToggleBits(); // value is now 0b0000111111110000

// read the upper byte
var upperByte = (byte)data.ReadBits(8, 8); // upperByte is now 0b00001111

// write 0b1011 into the upper nybble
upperByte=upperByte.StoreBits(0b1011, 4, 4); // upperByte is now 0b10111111

// chaining operations, the same steps and end results
data = 0;
data = data.SetBits(0, 16) // value is now 0b1111111111111111
    .SetBits() // this is the equivalent as above
    .ClearBits(4, 8) // value is now 0b1111000000001111
    .ToggleBits(); // value is now 0b0000111111110000

upperByte = ((byte)data.ReadBits(8, 8)) // extract the upper byte (0b00001111)
    .StoreBits(0b1011, 4, 4);// store the value in the upper 4 bits, now upperByte is now 0b10111111


## Major Version Change Log

### Version 3.0 Released

#### Breaking Changes

1. Moved BitIndexers to BitIndexers namespace.
2. Removed .ToBitIndexerXXXX extension methods. These were redundant with implicit casts.

#### New Features

1. Added numerous byte-level extension methods (to and from an array or span of bytes.)
2. Added various ByteIndexer classes to the ByteIndexers namespace.

### Version 2.1 Released

1. Added `GetBytes` and `GetByte` extension methods for intrinsic data types.
2. Added `StoreBytes` and `StoreByte` extension methods for intrinsic data types.
3. Added `LittleEndianXXXByteIndexer` classes.
4. Added `BigEndianXXXByteIndexer` classes.

### Version 2.0 Released

#### Breaking Changes from v1.x

1. Renamed `BitMask.CreateRange` to `BitMask.FromRange`.
2. Renamed `BitMask.CreateSingleBit` to `BitMask.FromSingleBit`.
3. All `StoreBit` overloads had bit and offset parameters swapped for semantic parity with `StoreBits`
4. Extension methods: `ClearBits`, `SetBits`, `StoreBits`, `ToggleBits`, `ClearBit`, `SetBit`, `StoreBit`,
   and `ToggleBit` no longer take `ref` parameters. Now they return the modified result instead of modifying
   the original variable. This gives a net benefit of being able to use fluent syntax to chain together
   bit manipulation operations.

Build, Code Stats and Nuget

API Documentation