int CHandresetDetector::BitVectorFiringHandresetMethods() {
int handresetmethods_fired = 0;
// Build a bit-vector of handresetmethods that fire
// Highest (9th) bit is for first method
handresetmethods_fired |= (IsHandresetByDealerChair() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByUserCards() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByHandNumber() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByCommunityCards() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByPotsize() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByNopponentsplaying() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByIncreasingBalance() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByChangingBlindLevel() ? 1 : 0);
handresetmethods_fired <<= 1;
handresetmethods_fired |= (IsHandresetByNewSmallBlind() ? 1 : 0 );
// No shift-left after the last bit
write_log(preferences.debug_handreset_detector(), "[CHandresetDetector] Methods firing this heartbeat: %s\n",
IntToBinaryString(handresetmethods_fired, kNumberOfHandresetMethods));
return handresetmethods_fired;
}
CString CParseTreeTerminalNodeNumber::EvaluateToString(bool log /* = false */) {
double numerical_result = Evaluate(log);
CString result;
if (IsInteger(numerical_result) && EvaluatesToBinaryNumber()) {
// Generqate binary representation;
result.Format("%s", IntToBinaryString(int(numerical_result)));
} else {
// Generate floating-point representation
// with 3 digits precision
result.Format("%.3f", numerical_result);
}
return result;
}
//---------------------------------------------------------------------------
void IntToDecHexBinString(
int iValue, // [in] value to be converted
int num_base, // [in] 2=binary, 10=decimal, 16=hex
int nDigits, // [in] number of fixed digits,
// 0=variable length without leading zeroes
char *psz40Dest) // [out] string, expect up to 33(!) bytes
// Converts an integer into a binary representation (string).
// Beware: nDigits=0 means 'as many digits as necessary'.
// For a 32-bit integer, the binary representation (string) may
// be up to 32 characters long, plus one byte for the trailing zero !
// Thus, for safety, psz40Dest should be a buffer with up to 40 characters.
{
char sz7Format[8] = "%d";
switch( num_base )
{ case 2: // binary: not supported by printf.c : sprintf() -> tfp_format()
IntToBinaryString( iValue, nDigits, psz40Dest );
return;
case 10:
if( nDigits>0 )
{ sprintf( sz7Format+1, "%dd", nDigits );
}
else
{ // default ("%d") already set
}
break;
case 16:
if( nDigits>0 )
{ sprintf( sz7Format+1, "0%dX", nDigits ); // note the leading ZERO
}
else
{ strcpy( sz7Format+1, "%X" ); // note the absence of a leading zero
}
break;
default: // whatever the intention was, it's not supported here yet:
sprintf( psz40Dest, "?base%d?", num_base );
return;
}
// Arrived here ? Should be something supported by the
// small-footprint implementation of sprintf in printf.c !
sprintf( psz40Dest, sz7Format, iValue );
} // end IntToDecHexBinString()
void CHandresetDetector::CalculateIsHandreset() {
// We work with bit-vectors here and not simple counters,
// because we want to make sure that at least N *different*
// fired during the last 3 heartbeats.
// Last 2 heartbeats
_methods_firing_the_last_three_heartbeats[2] = _methods_firing_the_last_three_heartbeats[1];
_methods_firing_the_last_three_heartbeats[1] = _methods_firing_the_last_three_heartbeats[0];
// This heartbeat
_methods_firing_the_last_three_heartbeats[0] = BitVectorFiringHandresetMethods();
// Composed result
int total_methods_firing = _methods_firing_the_last_three_heartbeats[2]
| _methods_firing_the_last_three_heartbeats[1]
| _methods_firing_the_last_three_heartbeats[0];
write_log(preferences.debug_handreset_detector(), "[CHandresetDetector] Methods firing last 3 heartbeat2: %s\n",
IntToBinaryString(total_methods_firing));
int number_of_methods_firing = bitcount(total_methods_firing);
write_log(preferences.debug_handreset_detector(), "[CHandresetDetector] Number of methods firing last 3 heartbeat2: %i\n",
number_of_methods_firing);
if (number_of_methods_firing >= 2) {
write_log(preferences.debug_handreset_detector(), "[CHandresetDetector] Handreset found\n");
_is_handreset_on_this_heartbeat = true;
++_hands_played;
if (p_symbol_engine_active_dealt_playing->nopponentsdealt() == 1) {
// Last hand (data not yet reset) was headsup
++_hands_played_headsup;
} else {
_hands_played_headsup = 0;
}
// Clear data to avoid multiple fast handreset with already used methods,
// if casino needs several heartbeats to update table view.
_methods_firing_the_last_three_heartbeats[0] = 0;
_methods_firing_the_last_three_heartbeats[1] = 0;
_methods_firing_the_last_three_heartbeats[2] = 0;
} else {
write_log(preferences.debug_handreset_detector(), "[CHandresetDetector] No handreset\n");
_is_handreset_on_this_heartbeat = false;
}
}
bool HuffmanCoder::GenerateLengthLimitedHuffman(unsigned int maxCodeLength, unsigned int numberOfWords) {
if (mDebug > kInfo) std::cout << "INFO: Generating length-limited Huffman codes." << std::endl;
if (!mHuffmanTableExists) {
if (mDebug > kError) std::cerr << "ERROR: Can't generate length-limited Huffman table because no Huffman table exists." << std::endl;
return false;
}
mLLMaxCodeLength = maxCodeLength;
mLLNumberOfWords = numberOfWords;
/*
* To generate the length-limited Huffman codes, the so called package-merge algorithm is used.
*/
// 1) fill map with (one-element) vectors containing the value of the Huffman codes,
// sorted by their weight
std::multimap<float, std::vector<int> > LengthLimitedHuffmanMap;
for (std::map<unsigned int, HuffmanCode>::iterator it = mHuffmanTable.begin(); it != mHuffmanTable.end(); ++it) {
std::vector<int> vec(1,it->second.value);
LengthLimitedHuffmanMap.insert(std::pair<float,std::vector<int> >(it->second.weight, vec));
}
// Delete elements with the lowest weight from the map again until the the length of the map is
// at the given limit. The weights are added for the marker.
float weightOfRawDataMarker = 0;
while (LengthLimitedHuffmanMap.size() >= mLLNumberOfWords) {
weightOfRawDataMarker += LengthLimitedHuffmanMap.begin()->first;
LengthLimitedHuffmanMap.erase(LengthLimitedHuffmanMap.begin());
}
std::vector<int> vec(1,-1);
LengthLimitedHuffmanMap.insert(std::pair<float,std::vector<int> >(weightOfRawDataMarker, vec));
int SizeOfSourceAlphabet = LengthLimitedHuffmanMap.size();
// check wether the given alphabet fits into the given max. code range
if (mLLMaxCodeLength < log(SizeOfSourceAlphabet)/log(2.)) {
if (mDebug > kWarning) std::cout << "WARNING: The alphabet doesn't fit into the given maximum code length of " << mLLMaxCodeLength << ". The max. code length has to be greater than / equal to " << log(SizeOfSourceAlphabet)/log(2.) << ". No length-limited Huffman table was generated." << std::endl;
return false;
}
// 2) proceed with the actual package-merge algorithm
std::multimap<float, std::vector<int> > mergedMap = PackageMerge(LengthLimitedHuffmanMap, mLLMaxCodeLength- 1);
// calculate code lengths out of the occurence of the symbols according to the package-merge algorithm
std::multiset<HuffmanCode,HuffmanCodeCompareCodelength> codeSet;
for (int i = -1; i < (int) mHuffmanRange; i++) {
int occurence = 0;
std::multimap<float, std::vector<int> >::iterator it = mergedMap.begin();
for (int set = 0; set < (2*SizeOfSourceAlphabet - 2); set++) {
occurence += std::count(it->second.begin(), it->second.end(), i);
++it;
}
if (occurence == 0) continue;
if (i < 0) {
// raw data marker
mLLRawDataMarkerSize = occurence;
} else {
// rest
HuffmanCode hCode(i, occurence, mHuffmanTable[(unsigned int) i].weight, "");
codeSet.insert(hCode);
}
}
std::cout << mLLRawDataMarkerSize << std::endl;
// manipulate the code lengths in order to allow to fix the length of the raw data marker
if (mLLRawDataMarkerFixedSize != 0 || mLLRawDataMarkerMaxSize != 0) {
// set the target size of the raw data marker
unsigned int targetSize;
if (mLLRawDataMarkerFixedSize != 0)
targetSize = mLLRawDataMarkerFixedSize;
else if (mLLRawDataMarkerSize > mLLRawDataMarkerMaxSize)
targetSize = mLLRawDataMarkerMaxSize;
else
targetSize = mLLRawDataMarkerSize;
if (targetSize != mLLRawDataMarkerSize) {
// check if intended length is possible, if not, set it to a possible value
if (targetSize < codeSet.begin()->length) {
if (mDebug > kWarning) std::cout << "WARNING: Marker is too short. Instead of " << targetSize << " it is set to " << codeSet.begin()->length << std::endl;
targetSize = codeSet.begin()->length;
} else if (targetSize > mLLMaxCodeLength) {
if (mDebug > kWarning) std::cout << "WARNING: Inserted marker size is longer than max code length of length-limited Huffman. It is set to the maximum length of " << mLLMaxCodeLength << std::endl;
targetSize = mLLMaxCodeLength;
}
// until length is not reached, exchange the length of the marker with the length of and
// element wich comes next in the direction to the intended length
while (targetSize != mLLRawDataMarkerSize) {
unsigned int lengthToFind =
(targetSize > mLLRawDataMarkerSize)
? (mLLRawDataMarkerSize+1) // increase the length
: (mLLRawDataMarkerSize-1); // decrease the length
// std::multiset<HuffmanCode,HuffmanCodeCompareCodelength>::iterator lastInsertedElement = codeSet.end();
bool parterFound = false;
for (std::multiset<HuffmanCode,HuffmanCodeCompareCodelength>::iterator it = codeSet.begin(); it != codeSet.end(); ++it) {
// find partner to swap
if (it->length == lengthToFind) { // && it != lastInsertedElement) {
parterFound = true;
// make a copy and delete it from the set
HuffmanCode h_code = *it;
codeSet.erase(it);
// swap the lengths
h_code.length = mLLRawDataMarkerSize;
mLLRawDataMarkerSize = lengthToFind;
// insert the changed code back into the set and save a pointer to
// this element to avoid pushing the same element through the whole list
codeSet.insert(h_code);
//lastInsertedElement = codeSet.insert(h_code);
// stop the for loop
it = codeSet.end();
it++;
}
}
if (!parterFound) {
if (mDebug > kWarning) std::cout << "WARNING: Could not find another partner to swap, raw marker has now a length of " << mLLRawDataMarkerSize << std::endl;
break;
}
}
}
}
// 3) generate actual Huffman codes out of the lengths of the codes
bool processMarker = false;
int length;
int previousValue = -1;
int previousCodeLength = -1;
bool markerIncluded = false;
for (std::multiset<HuffmanCode,HuffmanCodeCompareCodelength>::iterator it = codeSet.begin(); it != codeSet.end(); ++it) {
if (it->length >= mLLRawDataMarkerSize && !markerIncluded) {
it--;
length = mLLRawDataMarkerSize;
processMarker = true;
markerIncluded = true;
} else {
length = it->length;
processMarker = false;
}
if (previousCodeLength == -1) previousCodeLength = length;
std::string code = IntToBinaryString((previousValue+1) << (length - previousCodeLength), length);
if (processMarker) {
mLLRawDataMarker = code;
} else {
HuffmanCode h_code = (*it);
h_code.code = code;
if (mLengthLimitedHuffmanTable.find(h_code.value) == mLengthLimitedHuffmanTable.end()) {
mLengthLimitedHuffmanTable[h_code.value] = h_code;
} else {
if (mDebug > kWarning) std::cout << "WARNING: Huffman code for value " << h_code.value << " exists already in length-limited Huffman table" << std::endl;
}
}
previousValue = (previousValue + 1) << (length - previousCodeLength);
previousCodeLength = length;
}
mLengthLimitedHuffman = true;
mMapToUse = &mLengthLimitedHuffmanTable;
mMarkerToUse = mLLRawDataMarker;
mMarkerLengthToUse = mLLRawDataMarkerSize;
return true;
}
