/// <summary> /// Initializes a new instance of the <see cref="Board{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IList{ICard{V}}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public Board(IList <ICard <V> > collection, int capacity = 9, HashBits bits = HashBits.bit64) : this(capacity > collection.Count ? capacity : collection.Count, bits) { foreach (var c in collection) { this.Add(c); } }
/// <summary> /// Initializes a new instance of the <see cref="BaseCatalog{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IList{V}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public BaseCatalog(IList <V> collection, int capacity = 17, HashBits bits = HashBits.bit64) : this(capacity > collection.Count ? capacity : collection.Count, bits) { foreach (var c in collection) { this.Add(c); } }
/// <summary> /// Initializes a new instance of the <see cref="BaseCatalog{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IEnumerable{V}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public BaseCatalog(IEnumerable <V> collection, int capacity = 17, HashBits bits = HashBits.bit64) : this(capacity, bits) { foreach (var c in collection) { this.Add(c); } }
private HashTarget FindHashTarget(HashBits initialNounce, ulong maxItterations, CancellationToken cancellationToken) { return(_feedback.Execute("FindHashTarget", () => { var cryptography = new Cryptography(); ulong itterations = 0; try { var nounce = initialNounce.ToHash(); do { var hash = cryptography.CalculateHash(_signedBlockBytes, nounce); if (hash.Compare(_hashTarget) < 0) { return new HashTarget(nounce, hash); } nounce.Increment(1); } while (++itterations < maxItterations && !cancellationToken.IsCancellationRequested); return null; } finally { _feedback.MiningHashProgress(itterations); } }, () => $"{nameof(initialNounce)}: {initialNounce}, {nameof(maxItterations)}: {maxItterations}")); }
/// <summary> /// Initializes a new instance of the <see cref="Deck{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IEnumerable{IUnique{V}}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public Deck(IEnumerable <IUnique <V> > collection, int capacity = 17, HashBits bits = HashBits.bit64) : this(capacity, bits) { foreach (var c in collection) { this.Add(c); } }
/// <summary> /// Initializes a new instance of the <see cref="BaseMassDeck{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IEnumerable{V}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public BaseMassDeck(IEnumerable <V> collection, int capacity = 17, HashBits bits = HashBits.bit64) : base(capacity, bits) { foreach (var c in collection) { this.Add(c); } }
/// <summary> /// Initializes a new instance of the <see cref="Deck{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IList{IUnique{V}}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public Deck(IList <IUnique <V> > collection, int capacity = 17, HashBits bits = HashBits.bit64) : this(capacity > collection.Count ? capacity : collection.Count, bits) { foreach (var c in collection) { this.Add(c); } }
public CardList(IEnumerable <Card <V> > collection, int capacity = 16, HashBits bits = HashBits.bit64) : base(capacity, bits) { foreach (var c in collection) { this.Add(c); } }
public static Hash ToHash(this HashBits @this) { // TODO: make it to shift bits instead bytes var result = Genesis.Hash; var bitsOffset = @this.GetBitOffset(); var bytesOffset = bitsOffset / Hash.SegmentBitSize; var byteBitsOffset = bitsOffset % Hash.SegmentBitSize; var byteBitsFractionMask = Hash.SegmentMask >> byteBitsOffset; var byteBitsReminderMask = ~byteBitsFractionMask; var byteBitsReminderOffset = Hash.SegmentBitSize - byteBitsOffset; var fractionBytes = @this.GetFraction().ToBinary().Reverse().Skip(HashBits.OffsetByteSize).ToArray();//reverse bigendian to lowendian and skip bytes reserverd for offset byte reminderBits = 0; int i = 0; for (; i < fractionBytes.Length && bytesOffset + i < Hash.SegmentsLength; i++) { var fractionBits = (byte)((fractionBytes[i] >> byteBitsOffset) & byteBitsFractionMask); var currentBits = (byte)(fractionBits | reminderBits); reminderBits = (byte)((fractionBytes[i] << byteBitsReminderOffset) & byteBitsReminderMask); result.Value[bytesOffset + i] = currentBits; } if (bytesOffset + i < Hash.SegmentsLength) { result.Value[bytesOffset + i] = reminderBits; } /*else * //Loose precision as reminder do not fit in lowest byte in hash */ return(result); }
public SharedAlbum(IEnumerable <V> collection, int capacity = 16, HashBits bits = HashBits.bit64) : this(capacity, bits) { foreach (var c in collection) { this.Add(c); } }
public SharedAlbum(IList <V> collection, int capacity = 16, HashBits bits = HashBits.bit64) : this(capacity > collection.Count ? capacity : collection.Count, bits) { foreach (var c in collection) { this.Add(c); } }
/// <summary> /// Initializes a new instance of the <see cref="Board{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IEnumerable{ICard{V}}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public Board(IEnumerable <ICard <V> > collection, int capacity = 9, HashBits bits = HashBits.bit64) : this(capacity, bits) { foreach (var c in collection) { this.Add(c); } }
public CardList(IList <Card <V> > collection, int capacity = 16, HashBits bits = HashBits.bit64) : base(capacity > collection.Count ? capacity : collection.Count, bits) { foreach (var c in collection) { this.Add(c); } }
public static string GetSHA2Hash(HashBits bits, string message) { HashAlgorithm ha = null; switch (bits) { case HashBits.n256: ha = SHA256.Create(); break; case HashBits.n384: ha = SHA384.Create(); break; case HashBits.n512: ha = SHA512.Create(); break; } byte[] data = ha.ComputeHash(Encoding.Default.GetBytes(message)); StringBuilder sBuilder = new StringBuilder(); for (int i = 0; i < data.Length; i++) { sBuilder.Append(data[i].ToString("x2")); } return(sBuilder.ToString()); }
public void TargetHashBits_Adjust_OneSixthTime_Validate_HalfAdjustmentLimit() { var thb = HashBits.Create(6, 0xffffffffffffff); var adjustedthb = thb.Adjust(1, 6, 50, HashBits.MinTarget); Assert.AreEqual(6, adjustedthb.GetBitOffset()); Assert.AreEqual(0xaaaaaaaaaaaaaaUL, adjustedthb.GetFraction()); }
/// <summary> /// Initializes a new instance of the <see cref="BaseMassAlbum{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IList{V}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public BaseMassAlbum(IList <V> collection, int capacity = 17, HashBits bits = HashBits.bit64) : this(capacity > collection.Count ? capacity : collection.Count, bits) { list = EmptyBaseDeck(capacity); foreach (var c in collection) { this.Add(c); } }
public void TargetHashBits_Adjust_SixTime_Validate_HalfAdjustmentLimit() { var thb = HashBits.Create(6, 0xffffffffffffff); var adjustedthb = thb.Adjust(600, 100, 50, HashBits.MinTarget); Assert.AreEqual(5, adjustedthb.GetBitOffset()); Assert.AreEqual(0xbfffffffffffffUL, adjustedthb.GetFraction()); }
public void TargetHashBits_Adjust_OneSixthTime_Validate_OffsetAndFraction() { var thb = HashBits.Create(6, 0xffffffffffffff); var adjustedthb = thb.Adjust(1, 6, 10000, HashBits.MinTarget); Assert.AreEqual(8, adjustedthb.GetBitOffset()); Assert.IsTrue(thb.GetFraction() > adjustedthb.GetFraction()); }
public void TargetHashBits_Adjust_SameTime_Validate_OffsetAndFraction() { var thb = HashBits.Create(6, 0xffffffffffffff); var adjustedthb = thb.Adjust(1, 1, 10000, HashBits.MinTarget); Assert.AreEqual(6, adjustedthb.GetBitOffset()); Assert.AreEqual(thb.GetFraction(), adjustedthb.GetFraction()); }
public void TargetHashBits_Adjust_ThirthHalfTime_Validate_Offset() { var thb = HashBits.Create(5, 0xffffffffffffff); var adjustedthb = thb.Adjust(3000, 2000, 10000, HashBits.MinTarget); Assert.AreEqual(4, adjustedthb.GetBitOffset()); Assert.IsTrue(thb.GetFraction() > adjustedthb.GetFraction()); }
public void TargetHashBits_Adjust_DoubleMinusTime_FullFraction_Validate_OffsetAndFraction() { var thb = HashBits.Create(2, 0xffffffffffffff); var adjustedthb = thb.Adjust(1999, 1000, 10000, HashBits.MinTarget); Assert.AreEqual(1, adjustedthb.GetBitOffset()); Assert.IsTrue(thb.GetFraction() > adjustedthb.GetFraction()); }
/// <summary> /// Initializes a new instance of the <see cref="BaseMassAlbum{V}"/> class. /// </summary> /// <param name="collection">The collection<see cref="IEnumerable{V}"/>.</param> /// <param name="capacity">The capacity<see cref="int"/>.</param> /// <param name="bits">The bits<see cref="HashBits"/>.</param> public BaseMassAlbum(IEnumerable <V> collection, int capacity = 17, HashBits bits = HashBits.bit64) : this(capacity, bits) { list = EmptyBaseDeck(capacity); foreach (var c in collection) { this.Add(c); } }
public CardBook(IEnumerable <V> collection, int capacity = 16, HashBits bits = HashBits.bit64) : this(capacity, bits) { list = EmptyCardList(capacity); foreach (var c in collection) { this.Add(c); } }
public CardBook(IList <V> collection, int capacity = 16, HashBits bits = HashBits.bit64) : this(capacity > collection.Count ? capacity : collection.Count, bits) { list = EmptyCardList(capacity); foreach (var c in collection) { this.Add(c); } }
public void TargetHashBits_Adjust_SixTime_Validate_MinimumTarget() { var thb = HashBits.Create(6, 0xffffffffffffff); var minTarget = HashBits.Create(0x0f, 0xffffffffffffff); var adjustedthb = thb.Adjust(600, 100, 50, minTarget); Assert.AreEqual(minTarget.GetBitOffset(), adjustedthb.GetBitOffset()); Assert.AreEqual(minTarget.GetFraction(), adjustedthb.GetFraction()); }
public KeyedSet(int capacity = 17, HashBits bits = HashBits.bit64) : base(bits) { size = capacity; minSize = capacity; maxId = (uint)(capacity - 1); table = EmptyCardTable(capacity); first = EmptyCard(); last = first; }
public Hashdeck(int capacity = 16, HashBits bits = HashBits.bit64) : base(bits) { size = capacity; minSize = capacity; table = EmptyCardTable(capacity); first = EmptyCard(); last = first; mixMask = Submix.Mask((ulong)capacity); msbId = Submix.MsbId(capacity); }
public Tetradeck(int capacity = 16, HashBits bits = HashBits.bit64) : base(bits) { size = capacity; minSize = capacity; tsize = new TetraSize(capacity); tcount = new TetraCount(); table = new TetraTable <V>(this, capacity); first = EmptyCard(); last = first; }
/// <summary> /// Initializes a new instance of the <see cref="Uniqueness"/> class. /// </summary> /// <param name="hashBits">The hashBits<see cref="HashBits"/>.</param> public Uniqueness(HashBits hashBits) { if (hashBits == HashBits.bit32) { unique = Unique.Bit32; } else { unique = Unique.Bit64; } }
public void TargetHashBits_Adjust_HalfMinusTime_Validate_OffsetAndFraction() { var thb = HashBits.Create(6, 0xffffffffffffff); var adjustedthb = thb.Adjust(99, 200, 10000, HashBits.MinTarget); var hash = adjustedthb.ToHash().SerializeToJson(); Console.WriteLine($"o({adjustedthb.GetBitOffset()}),\tf(0x{adjustedthb.GetFraction():X16}),\th({hash})"); Assert.AreEqual(7, adjustedthb.GetBitOffset()); Assert.IsTrue(thb.GetFraction() > adjustedthb.GetFraction()); }