public BaseChunk(int length) { Length = length; _data = new byte[4 + 4 + Length + 4]; BitOperation.Int32ToBytes(Length).CopyTo(_data, 0); Name.FillChunk(_data); }
/// <summary> /// Append value to stream. /// </summary> /// <param name="value"></param> public void Write(UInt64 value) { if (IsDisposed) { throw new ObjectDisposedException("this"); } // Offset value to allow zeros value++; // Count length var length = BitOperation.CountUsed(value); // Check not too large if (length > (LengthBits + 2) * 8) { throw new ArgumentOutOfRangeException("Value is greater than maximum of " + (UInt64.MaxValue >> 64 - LengthBits - 1) + ". Increase length bits to support larger numbers."); } // Clip MSB, it's redundant length--; // Write length Output.Write((UInt64)length, LengthBits); // Write number Output.Write(value, length); }
private UInt64[] DecompressMany(String value, int count) { var input = new MemoryStream(BitOperation.ParseToBytes(value)); var output = Codec.DecompressUnsigned(input, count); return(output.ToArray()); }
public static void Initialize(int pageSize, int threadPoolSize, int totalPoolSize) { lock (typeof(UnmanagedAllocator)) { if (UnmanagedAllocator.pageSize != 0) { throw new InvalidOperationException("Already initialized."); } } if (pageSize <= 0 || BitOperation.SmallestPow2((uint)pageSize) != (uint)pageSize) { throw new ArgumentException("pageSize must be positive power of 2"); } if (threadPoolSize <= 0 || threadPoolSize % pageSize != 0) { throw new ArgumentException("threadPoolSize must be multiple of pageSize"); } if (totalPoolSize <= 0 || totalPoolSize % threadPoolSize != 0) { throw new ArgumentException("totalPoolSize must be multiple of threadPoolSize"); } UnmanagedAllocator.pageSize = pageSize; UnmanagedAllocator.threadPoolSize = threadPoolSize; UnmanagedAllocator.totalPoolSize = totalPoolSize; }
public string ToString(BitOperation parentBitOp) // { //This bit is a constant if (operation == BitOperation.NONE) { return(ValToString(value)); } //This bit is ONE parameter operation ex : (not A) if (B == null) { return(OpToString(operation) + A.ToString(operation)); } //This bit is TWO parameter operation ex : (A & B) string operationString = A.ToString(operation) + OpToString(operation) + B.ToString(operation); if (operation != parentBitOp) { return("(" + operationString + ")"); } else { return(operationString); } }
public Bit(BitOperation aOperation, Bit aA, Bit aB) { operation = aOperation; A = aA; B = aB; Initialize(); }
public async Task <ActionResult <string> > Post(AK ak) { BigInteger a; uint k; try { if (ak.a == null || ak.k == null) { throw new FormatException(); } a = BitOperation.BinStrToBigInteger(ak.a); k = Convert.ToUInt32(ak.k, 10); if (k > 31 || ak.a.Length > 32) { throw new FormatException(); } } catch (FormatException) { ModelState.AddModelError("Error", "Некорректные параметры"); return(BadRequest(ModelState)); } return(await Task.Run(() => BitOperation.BigIntegerToBinStr(BitOperation.GetBit(a, k)))); }
public async Task <ActionResult <string> > Post(AM am) { BigInteger a; uint m; try { if (am.a == null || am.m == null) { throw new FormatException(); } a = BitOperation.BinStrToBigInteger(am.a); m = Convert.ToUInt32(am.m, 10); if (m > 32 || am.a.Length > 32) { throw new FormatException(); } } catch (FormatException) { ModelState.AddModelError("Error", "Некорректные параметры"); return(BadRequest(ModelState)); } return(await Task.Run(() => BitOperation.BigIntegerToBinStr(BitOperation.ZeroSmallBits(a, m)))); }
public void OperateBitGetInt() { if (!args.HasBit) { return; } Key key = new Key(args.ns, args.set, "opbkey17"); client.Delete(null, key); byte[] bytes = new byte[] { 0x01, 0x42, 0x03, 0x04, 0x05 }; client.Put(null, key, new Bin(binName, bytes)); Record record = client.Operate(null, key, BitOperation.GetInt(binName, 8, 16, false) ); AssertRecordFound(key, record); long v = (long)record.GetValue(binName); Assert.AreEqual(16899, v); }
public async Task <ActionResult <string> > Post(AIL ail) { BigInteger a; uint i, l; try { if (ail.a == null || ail.i == null || ail.l == null) { throw new FormatException(); } a = BitOperation.BinStrToBigInteger(ail.a); i = Convert.ToUInt32(ail.i, 10); l = Convert.ToUInt32(ail.l, 10); if (i > l) { throw new FormatException(); } } catch (FormatException) { ModelState.AddModelError("Error", "Некорректные параметры"); return(BadRequest(ModelState)); } return(await Task.Run(() => BitOperation.BigIntegerToBinStr(BitOperation.GlueBits(a, i, l)))); }
private SuccinctBitVector(uint[] bits, int length) { Length = length; this.bits = bits; count = new byte[bits.Length]; largeCount = new int[(bits.Length + BLOCK_PER_LARGEBLOCK - 1) >> BLOCK_PER_LARGEBLOCK_BITS]; byte sum = 0; for (int i = 0; i < bits.Length - 1; i++) { var popcnt = BitOperation.PopCount(bits[i]); if (((i + 1) & (BLOCK_PER_LARGEBLOCK - 1)) == 0) { int ind = (i + 1) >> BLOCK_PER_LARGEBLOCK_BITS; largeCount[ind] = largeCount[ind - 1] + sum + popcnt; sum = 0; } else { sum += popcnt; count[i + 1] = sum; } count0 += BITBLOCK_LENGTH - popcnt; count1 += popcnt; } var lastpopcnt = BitOperation.PopCount(bits[bits.Length - 1]); count0 += BITBLOCK_LENGTH - lastpopcnt; count1 += lastpopcnt; }
public void OperateBitResize() { if (!args.HasBit) { return; } Key key = new Key(args.ns, args.set, "opbkey1"); client.Delete(null, key); byte[] bytes = new byte[] { 0x01, 0x42 }; client.Put(null, key, new Bin(binName, bytes)); Record record = client.Operate(null, key, BitOperation.Resize(BitPolicy.Default, binName, 4, BitResizeFlags.DEFAULT), Operation.Get(binName) ); AssertRecordFound(key, record); IList list = record.GetList(binName); byte[] b = (byte[])list[1]; //Console.WriteLine(ByteUtil.BytesToHexString(b)); Assert.IsTrue(Util.ByteArrayEquals(new byte[] { 0x01, 0x42, 0x00, 0x00 }, b)); }
/// <summary> /// Simple example of bit functionality. /// </summary> public void RunSimpleExample(AerospikeClient client, Arguments args) { Key key = new Key(args.ns, args.set, "bitkey"); string binName = args.GetBinName("bitbin"); // Delete record if it already exists. client.Delete(args.writePolicy, key); byte[] bytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 }; client.Put(args.writePolicy, key, new Bin(binName, bytes)); // Set last 3 bits of bitmap to true. Record record = client.Operate(args.writePolicy, key, BitOperation.Set(BitPolicy.Default, binName, -3, 3, new byte[] { 0xE0 }), Operation.Get(binName) ); IList list = record.GetList(binName); byte[] val = (byte[])list[1]; foreach (byte b in val) { console.Info(Convert.ToString(b)); } }
/// <summary> /// Append value to stream. /// </summary> /// <param name="value"></param> public void Write(UInt64 value) { if (IsDisposed) { throw new ObjectDisposedException("this"); } // Offset value to allow zeros value++; // #1 Separate X into the highest power of 2 it contains (2N) and the remaining N binary digits. Int32 n = 0; while (Math.Pow(2, n + 1) <= value) { n++; } var r = value - (UInt64)Math.Pow(2, n); // #2 Encode N+1 with Elias gamma coding. var np = (UInt64)n + 1; var len = BitOperation.CountUsed(np); Output.Write(0, len - 1); Output.Write(np, len); // #3 Append the remaining N binary digits to this representation of N+1. Output.Write(r, n); }
/// <summary> /// Calculate the length of an encoded value in bits. /// </summary> /// <param name="allowZeros">(non-standard) Support zeros by automatically offsetting all values by one.</param> /// <param name="value"></param> /// <returns></returns> public static Int32?CalculateBitLength(UInt64 value) { var result = 0; // Offset for zero value++; // #1 Separate X into the highest power of 2 it contains (2N) and the remaining N binary digits. Byte n = 0; while (Math.Pow(2, n + 1) <= value) { n++; } var r = value - (UInt64)Math.Pow(2, n); // #2 Encode N+1 with Elias gamma coding. var np = (Byte)(n + 1); var len = BitOperation.CountUsed(np); result += len - 1; result += len; // #3 Append the remaining N binary digits to this representation of N+1. result += n; return(result); }
public PhysDimension(int xAxis, int yAxis, byte unit) : base(9) { BitOperation.Int32ToBytes(xAxis).CopyTo(_data, 8); BitOperation.Int32ToBytes(yAxis).CopyTo(_data, 12); _data[16] = unit; GetCRC(_data.Skip(4).Take(4 + Length).ToArray()).CopyTo(_data, 8 + Length); }
public void OperateBitRemove() { if (!args.HasBit) { return; } Key key = new Key(args.ns, args.set, "opbkey3"); client.Delete(null, key); byte[] bytes = new byte[] { 0x01, 0x42, 0x03, 0x04, 0x05 }; client.Put(null, key, new Bin(binName, bytes)); Record record = client.Operate(null, key, BitOperation.Remove(BitPolicy.Default, binName, 2, 3), Operation.Get(binName) ); AssertRecordFound(key, record); IList list = record.GetList(binName); byte[] b = (byte[])list[1]; Assert.IsTrue(Util.ByteArrayEquals(new byte[] { 0x01, 0x42 }, b)); }
/// <summary> /// Calculate the length of an encoded value in bits. /// </summary> /// <param name="allowZeros">(non-standard) Support zeros by automatically offsetting all values by one.</param> /// <param name="value"></param> /// <returns></returns> public static Int32?CalculateBitLength(UInt64 value) { // Offset for zero value++; return(BitOperation.CountUsed(value) * 2 - 1); }
public async Task <ActionResult <string> > Post(AIJ aij) { BigInteger a; uint i, j; try { if (aij.a == null || aij.i == null || aij.j == null) { throw new FormatException(); } a = BitOperation.BinStrToBigInteger(aij.a); i = Convert.ToUInt32(aij.i, 10); j = Convert.ToUInt32(aij.j, 10); if (i > 31 || j > 31 || aij.a.Length > 32) { throw new FormatException(); } } catch (FormatException) { ModelState.AddModelError("Error", "Некорректные параметры"); return(BadRequest(ModelState)); } return(await Task.Run(() => BitOperation.BigIntegerToBinStr(BitOperation.SwapBit(a, i, j)))); }
public void Decompress_OutputPerfectSize() { var input = new MemoryStream(BitOperation.ParseToBytes("11 000000")); var output = Codec.DecompressUnsigned(input, 1).ToList(); Assert.AreEqual(1, output.Count()); Assert.AreEqual((UInt64)0, output.First()); }
/// <summary> /// Returns the MurmurHash3_x86_32 hash. /// Original source/tests at <a href="https://github.com/yonik/java_util/">https://github.com/yonik/java_util/</a>. /// </summary> public static int Murmurhash3_x86_32(byte[] data, int offset, int len, int seed) { const int c1 = unchecked ((int)0xcc9e2d51); const int c2 = 0x1b873593; int h1 = seed; int roundedEnd = offset + (len & unchecked ((int)0xfffffffc)); // round down to 4 byte block for (int i = offset; i < roundedEnd; i += 4) { // little endian load order int k1 = (((sbyte)data[i]) & 0xff) | ((((sbyte)data[i + 1]) & 0xff) << 8) | ((((sbyte)data[i + 2]) & 0xff) << 16) | (((sbyte)data[i + 3]) << 24); k1 *= c1; k1 = BitOperation.RotateLeft(k1, 15); k1 *= c2; h1 ^= k1; h1 = BitOperation.RotateLeft(h1, 13); h1 = h1 * 5 + unchecked ((int)0xe6546b64); } // tail int k2 = 0; switch (len & 0x03) { case 3: k2 = (((sbyte)data[roundedEnd + 2]) & 0xff) << 16; // fallthrough goto case 2; case 2: k2 |= (((sbyte)data[roundedEnd + 1]) & 0xff) << 8; // fallthrough goto case 1; case 1: k2 |= (((sbyte)data[roundedEnd]) & 0xff); k2 *= c1; k2 = BitOperation.RotateLeft(k2, 15); k2 *= c2; h1 ^= k2; break; } // finalization h1 ^= len; // fmix(h1); h1 ^= (int)((uint)h1 >> 16); h1 *= unchecked ((int)0x85ebca6b); h1 ^= (int)((uint)h1 >> 13); h1 *= unchecked ((int)0xc2b2ae35); h1 ^= (int)((uint)h1 >> 16); return(h1); }
public void Read_15_15_15() { using (var stream = new MemoryStream(BitOperation.ParseToBytes("10100100 00010100 10000010 10010000 00000000"))) { using (var reader = new EliasOmegaUnsignedReader(stream)) { Assert.AreEqual((ulong)15, reader.Read()); Assert.AreEqual((ulong)15, reader.Read()); Assert.AreEqual((ulong)15, reader.Read()); } } }
public void Read_13_13_13() { using (var stream = new MemoryStream(BitOperation.ParseToBytes("10000111 00001110 00011000"))) { using (var reader = new FibonacciUnsignedReader(stream)) { Assert.AreEqual((ulong)13, reader.Read()); Assert.AreEqual((ulong)13, reader.Read()); Assert.AreEqual((ulong)13, reader.Read()); } } }
public void Read_1_1_1() { using (var stream = new MemoryStream(BitOperation.ParseToBytes("10000001 10000001 10000001"))) { using (var reader = new VLQUnsignedReader(stream)) { Assert.AreEqual((ulong)1, reader.Read()); Assert.AreEqual((ulong)1, reader.Read()); Assert.AreEqual((ulong)1, reader.Read()); } } }
public unsafe UnmanagedAllocatorContext(short id) { this.id = id; int num = 27 - BitOperation.CountLeadingZeroes(UnmanagedAllocator.ThreadPoolSize); this.chunkHeader = new byte *[num]; this.allocHandle = UnmanagedAllocator.RequestPool(); this.currentPage = this.allocHandle; this.releaseHead = IntPtr.Zero; }
public void Read_2_2_2() { using (var stream = new MemoryStream(BitOperation.ParseToBytes("01101101 10000000"))) { using (var reader = new EliasGammaUnsignedReader(stream)) { Assert.AreEqual((ulong)2, reader.Read()); Assert.AreEqual((ulong)2, reader.Read()); Assert.AreEqual((ulong)2, reader.Read()); } } }
public void Read_4_4_4() { using (var stream = new MemoryStream(BitOperation.ParseToBytes("00001001 00001001 00001001"))) { using (var reader = new ThompsonAlphaUnsignedReader(stream)) { Assert.AreEqual((ulong)4, reader.Read()); Assert.AreEqual((ulong)4, reader.Read()); Assert.AreEqual((ulong)4, reader.Read()); } } }
private int GetChunkIndex(int size) { int num = BitOperation.CountLeadingZeroes(size - 1); int num2 = 28 - num; if (num2 < 0) { num2 = 0; } return(num2); }
public static string ResultDefault(this BitOperation op) { switch (op) { case BitOperation.Test: return("false"); default: return(""); } }
public static string ResultType(this BitOperation op) { switch (op) { case BitOperation.Test: return("bool"); default: return("void"); } }
public BitInstruction(int offset, BitOperation operation, Operand destination, Operand source) : base(offset, destination, source) { this.operation = operation; }