/// <summary>
/// Takes a BitString and adds LSbs to make the BitString hit a byte boundry.
/// Returns the original BitString if already at a byte boundry.
/// </summary>
/// <param name="bs">The BitString to pad.</param>
/// <returns></returns>
public static BitString PadToNextByteBoundry(BitString bs, bool padOntoLsb = true)
{
return(PadToModulus(bs, BITSINBYTE, padOntoLsb));
}
public BitString ConcatenateBits(BitString bitsToAppend)
{
return(BitString.ConcatenateBits(this, bitsToAppend));
}
/// <summary>
/// Gets a substring of bits from the MSB direction.
/// </summary>
/// <param name="bsToSub"></param>
/// <param name="startIndex">Start index from the MSB side. Most significant bit is index 0.</param>
/// <param name="numberOfBits"></param>
/// <returns></returns>
public static BitString MSBSubstring(BitString bsToSub, int startIndex, int numberOfBits)
{
return(Substring(bsToSub, bsToSub.BitLength - startIndex - numberOfBits, numberOfBits));
}
public static BitString GetLeastSignificantBits(int numBits, BitString bitString)
{
return(BitString.Substring(bitString, 0, numBits));
}
public BitString GetLeastSignificantBits(int numBits)
{
return(BitString.GetLeastSignificantBits(numBits, this));
}
public BitString OR(BitString comparisonBitString)
{
return(OR(this, comparisonBitString));
}
public static BitString GetMostSignificantBits(int numBits, BitString bitString)
{
return(BitString.Substring(bitString, bitString.BitLength - numBits, numBits));
}
public BitString BitStringSubtraction(BitString right)
{
return(BitStringSubtraction(this, right));
}
/// <summary>
/// Adds two bit strings together - e.g. "11" (3) + 111 (7) = 1010 (10).
/// Similar to <see cref="AddWithModulo(NIST.CVP.ACVTS.Libraries.Math.BitString,NIST.CVP.ACVTS.Libraries.Math.BitString,int)"/>, but without truncation.
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public BitString BitStringAddition(BitString right)
{
return(BitStringAddition(this, right));
}
public BitString LSBRotate(int distance)
{
return(BitString.LSBRotate(this, distance));
}
public BitString LSBShift()
{
return(BitString.LSBShift(this));
}
/// <summary>
/// Rotates bist in the LSB direction. Rotate puts the bits that 'fall off' onto the end.
/// </summary>
/// <param name="bStr"></param>
/// <param name="distance">Amount the bits to rotate.</param>
/// <returns></returns>
public static BitString LSBRotate(BitString bStr, int distance)
{
var minDistance = distance % bStr.BitLength;
return(BitString.MSBRotate(bStr, bStr.BitLength - minDistance));
}
public static BitString NOT(BitString source)
{
BitString val = source.GetDeepCopy();
return(new BitString(val.Bits.Not()));
}
public BitString AND(BitString comparisonBitString)
{
return(AND(this, comparisonBitString));
}
public static BitString PadToModulusMsb(BitString bs, int modulus)
{
return(PadToModulus(bs, modulus, false));
}
public BitString AddWithModulo(BitString right, int moduloPower)
{
return(AddWithModulo(this, right, moduloPower));
}
public static BitString ReverseByteOrder(BitString input)
{
return(new BitString(MsbLsbConversionHelpers.ReverseByteOrder(input.ToBytes())));
}
private static BitString PadShorterBitStringWithZeroes(BitString longerBitString, BitString shorterBitString)
{
BitArray newArray = new BitArray(longerBitString.BitLength);
for (int i = 0; i < shorterBitString.BitLength; i++)
{
newArray[i] = shorterBitString.Bits[i];
}
return(new BitString(newArray));
}
