/// <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)); }