public void BuildCodingTableTest5() { HuffmanEncoder encoder = new HuffmanEncoder(); HuffmanTree tree = HuffmanTreeHelper.Builder().NewInternalNode(44) .WithLeft(19, 'C') .WithRightInternal(25) .GoToRight() .WithLeft(11, 'B') .WithRightInternal(14) .GoToRight() .WithRight(9, 'E') .WithLeftInternal(5) .GoToLeft() .WithLeft(2, 'D') .WithRight(3, 'A') .CreateTree(); CodingTable codingTable = encoder.BuildCodingTable(tree); Assert.IsNotNull(codingTable); Pair <byte, BitSequence>[] expected = { new Pair <byte, BitSequence>((byte)'A', BitSequence.FromString("1101")), new Pair <byte, BitSequence>((byte)'B', BitSequence.FromString("10")), new Pair <byte, BitSequence>((byte)'C', BitSequence.FromString("0")), new Pair <byte, BitSequence>((byte)'D', BitSequence.FromString("1100")), new Pair <byte, BitSequence>((byte)'E', BitSequence.FromString("111")), }; CollectionAssert.AreEquivalent(expected, codingTable); }
/// <summary> /// エンコードされたデータのバイト配列を返します。 /// </summary> public override byte[] GetBytes() { var bs = new BitSequence(); int bitLength = 10; for (int i = 0; i <= (_codeWords.Count - 1) - 1; ++i) { bs.Append(_codeWords[i], bitLength); } switch (_charCounter % 3) { case 1: bitLength = 4; break; case 2: bitLength = 7; break; default: bitLength = 10; break; } bs.Append(_codeWords[_codeWords.Count - 1], bitLength); return(bs.GetBytes()); }
/// <summary> /// Converts the string representation of an IPv4 address (1.2.3.4) to its IPv4 address equivalent. /// A return value indicates whether the conversion succeeded. /// </summary> /// <param name="value">A string containing the IPv4 address to convert (1.2.3.4).</param> /// <param name="result"> /// When this method returns, contains the IPv4 address value equivalent of the IPv4 address contained in s, if the conversion succeeded, /// or zero IPv4 address if the conversion failed. /// The conversion fails if the s parameter is null or String.Empty or is not of the correct format. This parameter is passed uninitialized. /// </param> /// <returns>True iff parsing was successful.</returns> public static bool TryParse(string value, out IpV4Address result) { if (value == null) { result = Zero; return(false); } string[] valuesStrings = value.Split('.'); if (valuesStrings.Length != 4) { result = Zero; return(false); } byte[] values = new byte[4]; for (int i = 0; i != 4; ++i) { if (!byte.TryParse(valuesStrings[i], NumberStyles.None, CultureInfo.InvariantCulture, out values[i])) { result = Zero; return(false); } } result = new IpV4Address(BitSequence.Merge(values[0], values[1], values[2], values[3])); return(true); }
private void WriteSegments(BitSequence bs) { foreach (QRCodeEncoder segment in _segments) { bs.Append(segment.ModeIndicator, ModeIndicator.LENGTH); bs.Append(segment.CharCount, CharCountIndicator.GetLength( _currVersion, segment.EncodingMode) ); byte[] data = segment.GetBytes(); for (int i = 0; i < data.Length - 1; ++i) { bs.Append(data[i], 8); } int codewordBitLength = segment.BitCount % 8; if (codewordBitLength == 0) { codewordBitLength = 8; } bs.Append(data[data.Length - 1] >> (8 - codewordBitLength), codewordBitLength); } }
private void WritePaddingBits(BitSequence bs) { if (bs.Length % 8 > 0) { bs.Append(0x0, 8 - (bs.Length % 8)); } }
public void AppendByteWorks() { var bits = new BitSequence(); var bytes = new Dictionary<byte, bool[]>() { { 0, new[] { false, false, false, false, false, false, false, false } }, { 1, new[] { true, false, false, false, false, false, false, false } }, { 7, new[] { true, true, true, false, false, false, false, false } }, { 8, new[] { false, false, false, true, false, false, false, false } }, { 77, new[] { true, false, true, true, false, false, true, false } }, { 127, new[] { true, true, true, true, true, true, true, false } }, { 128, new[] { false, false, false, false, false, false, false, true } }, { 196, new[] { false, false, true, false, false, false, true, true } }, { 255, new[] { true, true, true, true, true, true, true, true } }, }; foreach (var @byte in bytes.Keys) { bits.AppendByte(@byte); } var actual = bits.ToBitArray(); var expected = bytes.Values.SelectMany(v => v).ToArray(); CollectionAssert.AreEqual(actual, expected); }
public void EqualsSimpleTest() { sequence = new BitSequence(); Assert.IsFalse(sequence.Equals(null)); Assert.IsTrue(sequence.Equals(sequence)); Assert.IsTrue(sequence.Equals(new BitSequence())); }
private void WriteTerminator(BitSequence bs) { int terminatorLength = Math.Min( ModeIndicator.LENGTH, _dataBitCapacity - _dataBitCounter); bs.Append(ModeIndicator.TERMINATOR_VALUE, terminatorLength); }
public static string Decode(byte[] data) { using var ms = new MemoryStream(data); int dictLen = ms.ReadByte(); // ilość znaków var dict = new Dictionary <BitSequence, char>(); // odczytanie słownika for (int i = 0; i < dictLen; i++) { char c = (char)ms.ReadByte(); // znak int seqLen = ms.ReadByte(); // długośc znaku BitSequence seq = new BitSequence(seqLen); // kod ms.Read(seq.rawData, 0, seq.ByteCapacity); seq.PushLength(seqLen); // odczytanie kodu dict[seq] = c; // dodanie do słownika } int padding = ms.ReadByte(); // margines int encodedLen = ms.Capacity - (int)ms.Position; byte[] encoded = new byte[encodedLen]; ms.Read(encoded, 0, encodedLen); string decoded = Decode(encoded, padding, dict); // odkowowanie return(decoded); }
public void BuildCodingTableTest4() { HuffmanEncoder encoder = new HuffmanEncoder(); HuffmanTree tree = HuffmanTreeHelper.Builder().NewInternalNode(133) .WithRight(85, 'f') .WithLeftInternal(48) .GoToLeft() .WithLeftInternal(21) .WithRightInternal(27) .GoToRight() .WithLeft(13, 'd') .WithRight(14, 'e') .GoToSibling() .WithRight(12, 'a') .WithLeftInternal(9) .GoToLeft() .WithRight(7, 'c') .WithLeft(2, 'b') .CreateTree(); CodingTable codingTable = encoder.BuildCodingTable(tree); Assert.IsNotNull(codingTable); Pair <byte, BitSequence>[] expected = { new Pair <byte, BitSequence>((byte)'a', BitSequence.FromString("001")), new Pair <byte, BitSequence>((byte)'b', BitSequence.FromString("0000")), new Pair <byte, BitSequence>((byte)'c', BitSequence.FromString("0001")), new Pair <byte, BitSequence>((byte)'d', BitSequence.FromString("010")), new Pair <byte, BitSequence>((byte)'e', BitSequence.FromString("011")), new Pair <byte, BitSequence>((byte)'f', BitSequence.FromString("1")), }; CollectionAssert.AreEquivalent(expected, codingTable); }
/// <summary> /// 1bppビットマップファイルのバイトデータを返します。 /// </summary> /// <param name="moduleSize">モジュールサイズ(px)</param> /// <param name="foreRgb">前景色</param> /// <param name="backRgb">背景色</param> private byte[] GetBitmap1bpp(int moduleSize, string foreRgb, string backRgb) { Color foreColor = ColorTranslator.FromHtml(foreRgb); Color backColor = ColorTranslator.FromHtml(backRgb); int[][] moduleMatrix = QuietZone.Place(GetModuleMatrix()); int width, height; width = height = moduleSize * moduleMatrix.Length; int rowBytesLen = (width + 7) / 8; int pack8bit = 0; if (width % 8 > 0) { pack8bit = 8 - (width % 8); } int pack32bit = 0; if (rowBytesLen % 4 > 0) { pack32bit = 8 * (4 - (rowBytesLen % 4)); } int rowSize = (width + pack8bit + pack32bit) / 8; byte[] bitmapData = new byte[rowSize * height]; int offset = 0; for (int r = moduleMatrix.Length - 1; r >= 0; --r) { var bs = new BitSequence(); foreach (int v in moduleMatrix[r]) { int color = Values.IsDark(v) ? 0 : 1; for (int i = 1; i <= moduleSize; ++i) { bs.Append(color, 1); } } bs.Append(0, pack8bit); bs.Append(0, pack32bit); byte[] bitmapRow = bs.GetBytes(); for (int i = 1; i <= moduleSize; ++i) { Array.Copy(bitmapRow, 0, bitmapData, offset, rowSize); offset += rowSize; } } return(DIB.Build1bppDIB(bitmapData, width, height, foreColor, backColor)); }
public void AppendOffBitWorks() { var bits = new BitSequence(); bits.AppendBit(false); bits.AppendOffBit(); CollectionAssert.AreEqual(new[] { false, false }, bits.ToBitArray()); }
public void AppendOnBitWorks() { var bits = new BitSequence(); bits.AppendBit(true); bits.AppendOnBit(); CollectionAssert.AreEqual(new[] { true, true }, bits.ToBitArray()); }
public static Double HEXtoF64(Byte[] src, BitSequence seq = BitSequence.LittleEndian) { if (src.Length != 8) { throw new ArgumentOutOfRangeException("LibHex.Core.HexTools.HEXtoF64 : Source array must contain 8 elements."); } MidDouble m = MidDouble.Init(); m.intValue = HEXtoU64(src, seq); return m.doubleValue; }
/// <summary> /// A hash code out of the combination of the authentication prohibited, confidentiality prohibited, experimental, user associated, IPSec, email, /// name type, signatory, protocol, algorithm, flags extension and public key fields. /// </summary> public override int GetHashCode() { return(Sequence.GetHashCode( BitSequence.Merge(BitSequence.Merge(AuthenticationProhibited, ConfidentialityProhibited, Experimental, UserAssociated, IpSec, Email), (byte)NameType, (byte)Signatory, (byte)Protocol), BitSequence.Merge((byte)Algorithm, (ushort)(FlagsExtension.HasValue ? FlagsExtension.Value : 0)), PublicKey)); }
static void AssertSequence(BitSequence sequence, params int[] bits) { int[] actual = new int[sequence.Size]; for (int n = 0; n < sequence.Size; n++) { actual[n] = sequence[n] == Bit.Zero ? 0 : 1; } CollectionAssert.AreEqual(bits, actual); }
public void AppendBitsWorks() { var bits = new BitSequence(); bits.AppendBits(true, false, true, false); bits.AppendBits(Enumerable.Range(0, 4).Select(i => i % 2 == 1)); CollectionAssert.AreEqual(new[] { true, false, true, false, false, true, false, true }, bits.ToBitArray()); }
public IpV4Address(string value) { if (value == null) { throw new ArgumentNullException("value"); } string[] strArray = value.Split('.'); this._value = BitSequence.Merge(byte.Parse(strArray[0], (IFormatProvider)CultureInfo.InvariantCulture), byte.Parse(strArray[1], (IFormatProvider)CultureInfo.InvariantCulture), byte.Parse(strArray[2], (IFormatProvider)CultureInfo.InvariantCulture), byte.Parse(strArray[3], (IFormatProvider)CultureInfo.InvariantCulture)); }
/// <summary> /// Returns a hash code for the layer. /// The hash code is a XOR of a combination of the protocol type and operation and the hash codes of the layer length and data link. /// </summary> public override int GetHashCode() { return(base.GetHashCode() ^ BitSequence.Merge((ushort)ProtocolType, (ushort)Operation).GetHashCode() ^ SenderHardwareAddress.BytesSequenceGetHashCode() ^ SenderProtocolAddress.BytesSequenceGetHashCode() ^ TargetHardwareAddress.BytesSequenceGetHashCode() ^ TargetProtocolAddress.BytesSequenceGetHashCode()); }
private static (byte[] encoded, int padding) Encode(string text, Dictionary <char, BitSequence> dictionary) { BitSequence sequence = new BitSequence(8 * text.Length); foreach (char c in text) // pętla przez każdy znak tekstu { sequence.Push(dictionary[c]); // dodaje do sekwencji bitów kod odpowiadajacy znakowi } return(sequence.GetBytes()); }
public void AppendBitWorks() { var bits = new BitSequence(); bits.AppendBit(true); Assert.IsTrue(bits.Pop()); bits.AppendBit(false); Assert.IsFalse(bits.Pop()); }
public void CloneTest2() { sequence[0] = Bit.One; sequence[3] = Bit.One; sequence[5] = Bit.Zero; sequence[11] = Bit.One; BitSequence clonedSequence = sequence.Clone(); Assert.AreEqual(12, clonedSequence.Size); AssertSequence(clonedSequence, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1); }
public void EqualityTest() { var seq1 = new BitSequence(16); var seq2 = new BitSequence(16); seq1.Push(true); seq1.Push(true); seq2.Push(seq1); Assert.Equal(seq1, seq2); Assert.Equal(seq1.GetHashCode(), seq2.GetHashCode()); }
/// <summary> /// エンコードされたデータのバイト配列を返します。 /// </summary> public override byte[] GetBytes() { var bs = new BitSequence(); foreach (int wd in _codeWords) { bs.Append(wd, 13); } return(bs.GetBytes()); }
private void WriteStructuredAppendHeader(BitSequence bs) { bs.Append(ModeIndicator.STRUCTURED_APPEND_VALUE, ModeIndicator.LENGTH); bs.Append(_position, SymbolSequenceIndicator.POSITION_LENGTH); bs.Append(_parent.Count - 1, SymbolSequenceIndicator.TOTAL_NUMBER_LENGTH); bs.Append(_parent.Parity, StructuredAppend.PARITY_DATA_LENGTH); }
public void KeysTest() { Dictionary <BitSequence, char> dict = new Dictionary <BitSequence, char>(); var seq1 = new BitSequence(16); var seq2 = new BitSequence(16); seq1.Push(true); seq1.Push(true); seq2.Push(seq1); dict[seq1] = 'c'; Assert.True(dict.ContainsKey(seq2)); }
public static Byte[] ToBinary(this UInt16 src, BitSequence seq = BitSequence.LittleEndian) { Byte[] result = new Byte[2]; result[1] = Convert.ToByte(src & 0xFF); result[0] = Convert.ToByte((src >> 8) & 0xFF); if (seq == BitSequence.LittleEndian) { Array.Reverse(result); } return result; }
public void ToStringTest() { var seq = new BitSequence(16); seq.Push(); seq.Push(true); seq.Push(false); seq.Push(true); seq.Push(true); seq.Push(false); Assert.Equal("010110", seq.ToString()); }
public MacAddress(string address) { if (address == null) { throw new ArgumentNullException("address"); } string[] strArray = address.Split(':'); if (strArray.Length != 6) { throw new ArgumentException("Failed parsing " + (object)address + " as mac address. Expected 6 hexes and got " + (string)(object)strArray.Length + " hexes", "address"); } this._value = BitSequence.Merge(Convert.ToByte(strArray[0], 16), Convert.ToByte(strArray[1], 16), Convert.ToByte(strArray[2], 16), Convert.ToByte(strArray[3], 16), Convert.ToByte(strArray[4], 16), Convert.ToByte(strArray[5], 16)); }
/// <summary> /// Creates an address from an address string (1.2.3.4). /// </summary> public IpV4Address(string value) { if (value == null) { throw new ArgumentNullException("value"); } string[] values = value.Split('.'); _value = BitSequence.Merge(byte.Parse(values[0], CultureInfo.InvariantCulture), byte.Parse(values[1], CultureInfo.InvariantCulture), byte.Parse(values[2], CultureInfo.InvariantCulture), byte.Parse(values[3], CultureInfo.InvariantCulture)); }
private void WritePadCodewords(BitSequence bs) { int numDataCodewords = DataCodeword.GetTotalNumber( _parent.ErrorCorrectionLevel, _currVersion); bool flag = true; while (bs.Length < 8 * numDataCodewords) { bs.Append(flag ? 236 : 17, 8); flag = !flag; } }
public void IndexerGetterTest() { var seq = new BitSequence(16); seq.rawData = new byte[] { 3, 5 }; Assert.False(seq[0]); Assert.True(seq[6]); Assert.True(seq[7]); Assert.False(seq[8]); Assert.False(seq[9]); Assert.True(seq[13]); Assert.True(seq[15]); Assert.Throws <ArgumentOutOfRangeException>(() => seq[16]); }
public void BuildCodingTableTest2() { HuffmanEncoder encoder = new HuffmanEncoder(); HuffmanTree tree = HuffmanTreeHelper.Builder().NewNode(1, 'X').CreateTree(); CodingTable codingTable = encoder.BuildCodingTable(tree); Assert.IsNotNull(codingTable); Pair <byte, BitSequence>[] expected = { new Pair <byte, BitSequence>((byte)'X', BitSequence.FromString("0")) }; CollectionAssert.AreEquivalent(expected, codingTable); }
public static StunMessageAttribute Parse(BitSequence bits) { var type = (StunMessageAttributeType)(BitConverter.ToUInt16(bits.PopLittleEndianBytes(2), 0)); var length = BitConverter.ToUInt16(bits.PopLittleEndianBytes(2), 0); switch (type) { case StunMessageAttributeType.XorMappedAddress: { return ParseXorMappedAddress(bits); } } throw new InvalidOperationException("Invalid attribute."); }
public void PushSequenceTest() { var seq1 = new BitSequence(16); var seq2 = new BitSequence(8); seq1.Push(); seq1.Push(true); seq2.Push(); seq2.Push(true); seq2.Push(true); seq2.Push(true); seq1.Push(seq2); Assert.Equal("010111", seq1.ToString()); Assert.Equal(6, seq1.Length); }
/// <summary> /// Get the value from the dehydrated data which is always in the last byte /// </summary> /// <param name="data"></param> /// <param name="offset"></param> /// <param name="length"></param> /// <returns></returns> private static byte GetVersion(IByteArray data, int offset, int length) { if ((data == null) || data.IsEmpty) { return(CURRENT_DEFAULT_VERSION); } var slice = data.Span.Slice(offset, length); //always the last byte byte entry = slice[slice.Length - 1]; BitSequence sequence = new BitSequence(entry, DataDehydrator.entries); return((byte)sequence.GetEntryValue(0)); }
/// <summary> /// Create the address from a string in the format XX:XX:XX:XX:XX:XX. /// </summary> /// <param name="address">The string value in hexadecimal format. Every two digits are separated by a colon.</param> public MacAddress(string address) { if (address == null) { throw new ArgumentNullException("address"); } string[] hexes = address.Split(':'); if (hexes.Length != 6) { throw new ArgumentException("Failed parsing " + address + " as mac address. Expected 6 hexes and got " + hexes.Length + " hexes", "address"); } _value = BitSequence.Merge(Convert.ToByte(hexes[0], 16), Convert.ToByte(hexes[1], 16), Convert.ToByte(hexes[2], 16), Convert.ToByte(hexes[3], 16), Convert.ToByte(hexes[4], 16), Convert.ToByte(hexes[5], 16)); }
/// <summary> /// コード語に変換するメッセージビット列を返します。 /// </summary> private byte[] GetMessageBytes() { var bs = new BitSequence(); if (_parent.Count > 1) { WriteStructuredAppendHeader(bs); } WriteSegments(bs); WriteTerminator(bs); WritePaddingBits(bs); WritePadCodewords(bs); return(bs.GetBytes()); }
public static Byte[] ToBinary(this Double src, BitSequence seq = BitSequence.LittleEndian) { MidDouble m = MidDouble.Init(); m.doubleValue = src; return m.intValue.ToBinary(seq); }
public static UInt64 HEXtoU64(Byte[] src, BitSequence seq = BitSequence.LittleEndian) { if (src.Length != 8) { throw new ArgumentOutOfRangeException("LibHex.Core.HexTools.HEXtoU64 : Source array must contain 8 elements."); } if (seq == BitSequence.LittleEndian) { Array.Reverse(src); } UInt64 result = src[7]; for (int i = 1; i < 8; i++) { result |= Convert.ToUInt64(Convert.ToUInt64(src[7 - i]) << (i * 8)); } return result; }
public static Byte[] I16toHEX(Int16 src, BitSequence seq = BitSequence.LittleEndian) { return U16toHEX((UInt16)src, seq); }
public void WriteLong(Int64 b, BitSequence seq = BitSequence.LittleEndian) { Write(HexTools.I64toHEX(b, seq), 0, 8); }
public static Byte[] ToBinary(this UInt32 src, BitSequence seq = BitSequence.LittleEndian) { Byte[] result = new Byte[4]; for (int i = 0; i < 4; i++) { result[3 - i] = Convert.ToByte(src & 0xFF); src >>= 8; } if (seq == BitSequence.LittleEndian) { Array.Reverse(result); } return result; }
//Hexadecimal -> Decimal public static UInt16 HEXtoU16(Byte[] src, BitSequence seq = BitSequence.LittleEndian) { if (src.Length != 2) { throw new ArgumentOutOfRangeException("LibHex.Core.HexTools.HEXtoU16 : Source array must contain 2 elements."); } if (seq == BitSequence.LittleEndian) { Array.Reverse(src); } UInt16 result = src[1]; result |= Convert.ToUInt16(Convert.ToUInt16(src[0]) << 8); return result; }
public static UInt16 ToUInt16(this Byte[] src, Int32 offset, BitSequence seq = BitSequence.LittleEndian) { if (offset < 0 || offset > src.Length - 2) throw new ArgumentOutOfRangeException("offset", "Byte[].ToUInt16(): Offset out of source array bounds"); UInt16 result; if (seq == BitSequence.LittleEndian) { result = src[0]; result |= Convert.ToUInt16(Convert.ToUInt16(src[1]) << 8); } else { result = src[1]; result |= Convert.ToUInt16(Convert.ToUInt16(src[0]) << 8); } return result; }
public static Int32 HEXtoI32(Byte[] src, BitSequence seq = BitSequence.LittleEndian) { if (src.Length != 4) { throw new ArgumentOutOfRangeException("LibHex.Core.HexTools.HEXtoI32 : Source array must contain 4 elements."); } return Sign(HEXtoU32(src, seq)); }
public Int64 ReadLong(BitSequence seq = BitSequence.LittleEndian) { return HexTools.HEXtoI64(ReadBytes(8), seq); }
public UInt32 ReadUInt(BitSequence seq = BitSequence.LittleEndian) { return HexTools.HEXtoU32(ReadBytes(4), seq); }
public UInt64 ReadULong(BitSequence seq = BitSequence.LittleEndian) { return HexTools.HEXtoU64(ReadBytes(8), BitSequence.LittleEndian); }
public UInt16 ReadUShort(BitSequence seq = BitSequence.LittleEndian) { return HexTools.HEXtoU16(ReadBytes(2), seq); }
public void WriteInt(Int32 b, BitSequence seq = BitSequence.LittleEndian) { Write(HexTools.I32toHEX(b, seq), 0, 4); }
public static Int64 ToInt64(this Byte[] src, Int32 offset, BitSequence seq = BitSequence.LittleEndian) { if (offset < 0 || offset > src.Length - 8) throw new ArgumentOutOfRangeException("offset", "Byte[].ToInt64(): Offset out of source array bounds"); return Sign(src.ToUInt64(offset, seq)); }
public static Single ToSingle(this Byte[] src, Int32 offset, BitSequence seq = BitSequence.LittleEndian) { if (offset < 0 || offset > src.Length - 4) throw new ArgumentOutOfRangeException("offset", "Byte[].ToSingle(): Offset out of source array bounds"); MidSingle m = MidSingle.Init(); m.intValue = src.ToUInt32(offset, seq); return m.singleValue; }
public static Byte[] F64toHEX(Double src, BitSequence seq = BitSequence.LittleEndian) { MidDouble m = MidDouble.Init(); m.doubleValue = src; return U64toHEX(m.intValue, seq); }
public static UInt64 ToUInt64(this Byte[] src, Int32 offset, BitSequence seq = BitSequence.LittleEndian) { if (offset < 0 || offset > src.Length - 8) throw new ArgumentOutOfRangeException("offset", "Byte[].ToUInt64(): Offset out of source array bounds"); UInt64 result; if (seq == BitSequence.LittleEndian) { result = src[0]; for (int i = 1; i < 8; i++) { result |= Convert.ToUInt64(Convert.ToUInt64(src[i]) << (i * 8)); } } else { result = src[7]; for (int i = 1; i < 8; i++) { result |= Convert.ToUInt64(Convert.ToUInt64(src[7 - i]) << (i * 8)); } } return result; }
public static Byte[] F32toHEX(Single src, BitSequence seq = BitSequence.LittleEndian) { MidSingle m = MidSingle.Init(); m.singleValue = src; return U32toHEX(m.intValue, seq); }
public static Byte[] ToBinary(this Int16 src, BitSequence seq = BitSequence.LittleEndian) { return Unsign(src).ToBinary(seq); }
public static Byte[] U64toHEX(UInt64 src, BitSequence seq = BitSequence.LittleEndian) { Byte[] result = new Byte[8]; for (int i = 0; i < 8; i++) { result[7 - i] = Convert.ToByte(src & 0xFF); src >>= 8; } if (seq == BitSequence.LittleEndian) { Array.Reverse(result); } return result; }
public static Byte[] I64toHEX(Int64 src, BitSequence seq = BitSequence.LittleEndian) { return U64toHEX(Unsign(src), seq); }
public void WriteShort(Int16 b, BitSequence seq = BitSequence.LittleEndian) { Write(HexTools.I16toHEX(b, seq), 0, 2); }