public static BitString To16BitString(short value) { var bytesInLSB = BitConverter.GetBytes(value); var bitArrayInLsb = Helper.LeastSignificantByteArrayToLeastSignificantBitArray(bytesInLSB); return(new BitString(bitArrayInLsb)); }
public static BitString To64BitString(ulong value) { var bytesInLSB = BitConverter.GetBytes(value); var bitArrayLSb = Helper.LeastSignificantByteArrayToLeastSignificantBitArray(bytesInLSB); return(new BitString(bitArrayLSb)); }
/// <summary> /// Create a <see cref="BitString"/> using MSB hex. /// </summary> /// <param name="hexMSB">The MSB hexadecimal string</param> /// <param name="bitLength">The length of the resulting <see cref="BitString"/> by taking that amount of MSBs</param> /// <param name="truncateBitsFromEndOfLastByte">When the bitLength is not a multiple of 8, the hex needs to be truncated in the last byte. This parameter determines which side of the last byte is truncated</param> public BitString(string hexMSB, int bitLength = -1, bool truncateBitsFromEndOfLastByte = true) { if (string.IsNullOrEmpty(hexMSB) || bitLength == 0) { _bits = new BitArray(0); return; } hexMSB = hexMSB.Replace(" ", ""); int numberChars = hexMSB.Length; if (numberChars % 2 != 0) { throw new InvalidBitStringLengthException($"{nameof(BitString)}s are expected to have an even number of hex characters. Value was \"{hexMSB}\"."); } byte[] bytesInMSB = new byte[numberChars / 2]; for (int i = 0; i < numberChars; i += 2) { bytesInMSB[i / 2] = Convert.ToByte(hexMSB.Substring(i, 2), 16); } if (bitLength < 0) { _bits = Helper.MostSignificantByteArrayToLeastSignificantBitArray(bytesInMSB); } else { var bitsNeeded = System.Math.Min(bitLength, numberChars * BITSINBYTE / 2); var bitsInMSB = Helper.MostSignificantByteArrayToMostSignificantBitArray(bytesInMSB); var truncatedBits = new BitArray(bitsNeeded); if (truncateBitsFromEndOfLastByte) { for (var i = 0; i < bitsNeeded; i++) { truncatedBits[i] = bitsInMSB[i]; } } else { var firstBits = bitsNeeded - (bitsNeeded % 8); for (var i = 0; i < firstBits; i++) { truncatedBits[i] = bitsInMSB[i]; } var skippedBits = (bytesInMSB.Length * BITSINBYTE) - bitsNeeded; for (var i = firstBits; i < bitsNeeded; i++) { truncatedBits[i] = bitsInMSB[i + skippedBits]; } } _bits = Helper.ReverseBitArrayBits(truncatedBits); } }
public BitString(byte[] bytesToConcatenate, int bitLengthToHit) { var maxBytes = bitLengthToHit.CeilingDivide(BITSINBYTE); var bytes = new byte[maxBytes]; for (var i = 0; i < maxBytes; i++) { bytes[i] = bytesToConcatenate[i % bytesToConcatenate.Length]; } var shortenedBits = Helper.MostSignificantByteArrayToLeastSignificantBitArray(bytes); if (shortenedBits.Length > bitLengthToHit) { shortenedBits = shortenedBits.SubArray(0, bitLengthToHit); } _bits = shortenedBits; }
public static BitArray Reverse(this BitArray bArray) { return(MsbLsbConversionHelpers.ReverseBitArrayBits(bArray)); }
/// <summary> /// Create <see cref="BitString"/> expecting <see cref="byte[]"/> in Most Significant Byte (MSB) order. /// </summary> /// <param name="msBytes">The MSB bytes to use in the LSb <see cref="BitString"/></param> public BitString(byte[] msBytes) { _bits = Helper.MostSignificantByteArrayToLeastSignificantBitArray(msBytes); }