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