public void Test_Random()
{
int REPETITIONS = 100;
#if DEBUG
REPETITIONS = 8;
#endif
int seed = (int)DateTime.Now.Ticks;
Console.WriteLine("Random seed {0}", seed);
Random rand = new Random(seed);
_cardRng = new SequenceRng(seed);
_cardRng.SetSequence(StdDeck.Descriptor.FullDeckIndexes);
for (int r = 0; r < REPETITIONS; ++r)
{
_enumCount = r % 7;
int sharedCount = rand.Next(0, StdDeck.Descriptor.Size + 1 - _enumCount);
int deadCount = rand.Next(0, StdDeck.Descriptor.Size + 1 - sharedCount - _enumCount);
_cardRng.Shuffle(sharedCount + deadCount);
int rc = 0;
_shared = new CardSet();
for (int i = 0; i < sharedCount; ++i)
{
_shared |= StdDeck.Descriptor.CardSets[_cardRng.Sequence[rc++]];
}
_dead = new CardSet();
for (int i = 0; i < deadCount; ++i)
{
_dead |= StdDeck.Descriptor.CardSets[_cardRng.Sequence[rc++]];
}
Debug.Assert(rc == sharedCount + deadCount);
Debug.Assert(!_shared.IsIntersectingWith(_dead));
//Console.WriteLine("B: {0:x16} D:{1:x16}", board, dead);
_combinationsCount = 0;
_lastCs = 0;
CardEnum.Combin(StdDeck.Descriptor, _enumCount, _shared, _dead, VerifyCombination);
Assert.AreEqual(EnumAlgos.CountCombin(StdDeck.Descriptor.Size - sharedCount - deadCount, _enumCount), _combinationsCount);
_combinationsCount1 = 0;
_lastCs1 = 0;
CardEnum.Combin(StdDeck.Descriptor, _enumCount, _shared, _dead, VerifyCombinationParam, _combinationsCount);
Assert.AreEqual(EnumAlgos.CountCombin(StdDeck.Descriptor.Size - sharedCount - deadCount, _enumCount), _combinationsCount1);
_combinationsCount1 = 0;
_lastCs1 = 0;
int[] cards = new int[_enumCount + sharedCount].Fill(-1);
StdDeck.Descriptor.GetIndexesAscending(_shared).ToArray().CopyTo(cards, 0);
int[] deadIdx = StdDeck.Descriptor.GetIndexesAscending(_shared | _dead).ToArray();
CardEnum.Combin(StdDeck.Descriptor, _enumCount, cards, sharedCount, deadIdx, deadIdx.Length, VerifyCombinationParam, _combinationsCount);
Assert.AreEqual(EnumAlgos.CountCombin(StdDeck.Descriptor.Size - sharedCount - deadCount, _enumCount), _combinationsCount1);
}
Console.WriteLine("{0} repetitions done.", REPETITIONS);
}
public void Test_Showdown()
{
int seed = (int)DateTime.Now.Ticks;
Console.WriteLine("RNG seed {0}", seed);
SequenceRng dealer = new SequenceRng(seed, StdDeck.Descriptor.FullDeckIndexes);
HoldemGameRules gr = new HoldemGameRules();
int[][] hands = new int[2][];
UInt32[] ranks = new UInt32[2];
for (int p = 0; p < 2; ++p)
{
hands[p] = new int[7];
}
int repCount = 1000000;
for (int r = 0; r < repCount; ++r)
{
dealer.Shuffle(2 + 2 + 5);
hands[0][0] = dealer.Sequence[0];
hands[0][1] = dealer.Sequence[1];
hands[1][0] = dealer.Sequence[2];
hands[1][1] = dealer.Sequence[3];
for (int i = 0; i < 5; ++i)
{
hands[0][2 + i] = hands[1][2 + i] = dealer.Sequence[4 + i];
}
gr.Showdown(_gd, hands, ranks);
int actResult = -1;
if (ranks[0] > ranks[1])
{
actResult = 1;
}
else if (ranks[0] == ranks[1])
{
actResult = 0;
}
CardSet h0 = _gd.DeckDescr.GetCardSet(hands[0]);
CardSet h1 = _gd.DeckDescr.GetCardSet(hands[1]);
UInt32 v0 = CardSetEvaluator.Evaluate(ref h0);
UInt32 v1 = CardSetEvaluator.Evaluate(ref h1);
int expResult = -1;
if (v0 > v1)
{
expResult = 1;
}
else if (v0 == v1)
{
expResult = 0;
}
Assert.AreEqual(expResult, actResult);
}
}
void TestSort(int arraySize, int [] partSizes, int inMemSortSize, int rngSeed, int shuffleSize, bool isVerbose)
{
string inputDir = Path.Combine(_outDir, "input");
DirectoryExt.Delete(inputDir);
Directory.CreateDirectory(inputDir);
string tempDir = Path.Combine(_outDir, "temp");
int[] array = new int[arraySize];
for (int i = 0; i < array.Length; ++i)
{
array[i] = i;
}
SequenceRng rng = new SequenceRng(rngSeed);
rng.SetSequenceNoCopy(array);
rng.Shuffle(shuffleSize);
TestElement element = new TestElement();
int begin = 0;
for (int p = 0; p < partSizes.Length; ++p)
{
string fileName = Path.Combine(inputDir, string.Format("{0}.dat", p));
using (BinaryWriter writer = new BinaryWriter(new FileStream(fileName, FileMode.Create, FileAccess.Write)))
{
for (int i = begin; i < begin + partSizes[p]; ++i)
{
element.Write(array[i], writer);
}
begin += partSizes[p];
}
}
Assert.AreEqual(arraySize, begin, "Incorrect part sizes.");
string resultFile = Path.Combine(_outDir, "result.dat");
ExternalMergeSort <int> sorter = new ExternalMergeSort <int> {
IsVerbose = isVerbose
};
sorter.Sort(inputDir, tempDir, inMemSortSize, element, resultFile);
int[] result = ReadToArray(resultFile, element);
for (int i = 0; i < arraySize; ++i)
{
Assert.AreEqual(i, result[i]);
}
}
public void Generate(int count)
{
hands = new Hand[count];
for (int h = 0; h < count; ++h)
{
//hands[h] = new RandomHand();
hands[h].Cards = new int[HAND_SIZE];
_cardRng.Shuffle(HAND_SIZE);
for (int i = 0; i < HAND_SIZE; i++)
{
hands[h].AddCard(_cardRng.Sequence[i]);
}
}
}
public void Test_Shuffle()
{
// Make sure that shuffling from some start does not overwrite the beginning of the sequence
int [] sequence = new int[10].Fill(i => i);
SequenceRng sr = new SequenceRng();
for (int start = 0; start <= sequence.Length; start++)
{
sr.SetSequence(sequence);
sr.Shuffle(start, sequence.Length - start);
for (int i = 0; i < start; ++i)
{
Assert.AreEqual(i, sr.Sequence[i]);
}
}
}
public void Benchmark(Random underlyingRng)
{
int[] array = new int[100].Fill(i => i);
SequenceRng rng = new SequenceRng(underlyingRng, array);
int repCount = 500000;
DateTime startTime = DateTime.Now;
for (int i = 0; i < repCount; ++i)
{
rng.Shuffle();
}
TimeSpan time = DateTime.Now - startTime;
long totalRepCount = array.Length * repCount;
Console.Write("{0:#,#} Repetitions done in {1:0.0} s, {2:#,#} shuffles/s",
totalRepCount, time.TotalSeconds, totalRepCount / time.TotalSeconds);
}
void CalculateFastRandomTest(int round, int repCount)
{
int rngSeed = (int)DateTime.Now.Ticks;
Console.WriteLine("CalculateFast random test round {0}, rep count {1}, RNG seed {2}", round, repCount, rngSeed);
Random rng = new Random(rngSeed);
SequenceRng dealer = new SequenceRng(rngSeed, StdDeck.Descriptor.FullDeckIndexes);
int handLength = HeHelper.RoundToHandSize[round];
for (int r = 0; r < repCount; ++r)
{
dealer.Shuffle(handLength);
HsSd.SdKind sdKind = round == 3 ? HsSd.SdKind.Sd3 : (HsSd.SdKind)rng.Next(0, 2);
int sdRound = sdKind == HsSd.SdKind.SdPlus1 ? round + 1 : 3;
float[] hssdFast = HsSd.CalculateFast(dealer.Sequence, handLength, sdKind);
float[] hssd = HsSd.Calculate(dealer.Sequence, handLength, sdRound);
Assert.AreEqual(hssd[0], hssdFast[0], 1e-6);
Assert.AreEqual(hssd[1], hssdFast[1], 1e-6);
}
}
public void Test_SameSeed()
{
int[] sequence = (new int[256]).Fill(i => i);
int seed = 123;
SequenceRng rng1;
SequenceRng rng2;
// Case 1
rng1 = new SequenceRng(seed);
rng2 = new SequenceRng(seed);
rng1.SetSequence(sequence);
rng2.SetSequence(sequence);
rng1.Shuffle();
rng2.Shuffle();
Assert.AreEqual(rng1.Sequence, rng2.Sequence);
// Case 2
rng1 = new SequenceRng(seed, sequence);
rng2 = new SequenceRng(seed, sequence);
rng1.Shuffle();
rng2.Shuffle();
Assert.AreEqual(rng1.Sequence, rng2.Sequence);
// Case 3
rng1 = new SequenceRng(new Random(seed));
rng2 = new SequenceRng(new Random(seed));
rng1.SetSequence(sequence);
rng2.SetSequence(sequence);
rng1.Shuffle();
rng2.Shuffle();
Assert.AreEqual(rng1.Sequence, rng2.Sequence);
// Case 4
rng1 = new SequenceRng(new Random(seed), sequence);
rng2 = new SequenceRng(new Random(seed), sequence);
rng1.Shuffle();
rng2.Shuffle();
Assert.AreEqual(rng1.Sequence, rng2.Sequence);
}
McHand[] CreateMcHands(int round, Bucket parentBucket)
{
if (parentBucket.Length == 0)
{
if (IsVerbose)
{
Console.WriteLine("Empty parent bucket");
}
return(new McHand[0]);
}
int samplesCount = (SamplesCount[round] / parentBucket.Length + 1) * parentBucket.Length;
McHand[] hands = new McHand[samplesCount];
int shuffleCount = HeHelper.RoundToHandSize[round] - HeHelper.RoundToHandSize[round - 1];
int s = 0;
if (IsVerbose)
{
Console.WriteLine("Creating random hands: parent hands: {0}, samples: {1}, deal: {2}",
parentBucket.Length, samplesCount, shuffleCount);
}
for (int h = 0; h < parentBucket.Length; ++h)
{
for (int rep = 0; rep < samplesCount / parentBucket.Length; ++rep)
{
McHand hand = new McHand(parentBucket.Hands[h]);
SequenceRng.Shuffle(_rng, hand.Cards, hand.Length, shuffleCount);
hand.Length += shuffleCount;
hands[s++] = hand;
if (IsVerboseSamples)
{
Console.WriteLine(StdDeck.Descriptor.GetCardNames(hand.Cards, 0, hand.Length));
}
}
}
Debug.Assert(s == samplesCount);
_totalMcSamples += samplesCount;
return(hands);
}
private void RandomTest(int rngSeed, int repCount, int handSizeBegin, int handSizeEnd)
{
Random rng = new Random(rngSeed);
SequenceRng dealer = new SequenceRng(rngSeed, StdDeck.Descriptor.FullDeckIndexes);
DateTime startTime = DateTime.Now;
for (int r = 0; r < repCount; ++r)
{
// Number of cards for the pocket (2) and the board (3-5)
// Skip preflop because it is very slow.
int cardsCnt = rng.Next(handSizeBegin, handSizeEnd);
dealer.Shuffle(cardsCnt);
int[] hand = dealer.Sequence.Slice(0, cardsCnt);
float s = VerifyCalculateFast(hand);
//Console.WriteLine("Hand {0} has strengths {1}", _deck.GetCardNames(hand), s);
}
TimeSpan time = DateTime.Now - startTime;
Console.WriteLine("{0} Repetitions done in {1:0.0} s, {2:0.0} tests/s",
repCount, time.TotalSeconds, repCount / time.TotalSeconds);
}
void CreateFileForDiehard(Random rng, int approxFileSize)
{
int [] sequence = (new int[256]).Fill(i => i);
string fileName = Path.Combine(_outDir, rng.ToString() + ".dat");
SequenceRng seqRng = new SequenceRng(rng, sequence);
int repCount = approxFileSize / sequence.Length + 1;
using (BinaryWriter wr = new BinaryWriter(File.Open(fileName, FileMode.Create, FileAccess.Write)))
{
for (int r = 0; r < repCount; ++r)
{
seqRng.Shuffle();
for (int i = 0; i < seqRng.Sequence.Length; ++i)
{
byte b = (byte)seqRng.Sequence[i];
wr.Write(b);
}
}
}
}
static public void InitHe(Algo algo, int bucketsCount, bool shuffle)
{
algo.Buckets = new Bucket[bucketsCount].Fill(i => new Bucket());
SequenceRng shuffler = new SequenceRng();
shuffler.SetSequence(169);
if (shuffle)
{
shuffler.Shuffle();
}
double handsInBucket = HePocket.Count / bucketsCount;
for (int p = 0; p < HePocket.Count; ++p)
{
int b = (int)(p / handsInBucket);
if (b >= bucketsCount)
{
b = bucketsCount - 1;
}
algo.Buckets[b].Cards.Add(shuffler.Sequence[p]);
}
}
