TEST(CompareTest, CompareIfDigitsAreEquals)
{
BigInt left, right;
left.size = 2;
right.size = 2;
int leftDigits[] = {123, 45};
int rightDigits[] = {123, 45};
SetDigits(&left, leftDigits);
SetDigits(&right, rightDigits);
ASSERT_EQ(true, AreEquals(&left, &right));
ASSERT_EQ(false, IsGreater(&left, &right));
ASSERT_EQ(false, IsLess(&left, &right));
}
void CTableLimits::AdjustForReasonableness()
{
write_log(3, "CTableLimits::CheckForReasonableness()\n");
// SB unknown?
if (IsSmallerOrEqual(tablelimit_unreliable_input.sblind, 0))
{
SetSmallBlind(GuessSmallBlindFromBigBlind());
write_log(3, "CTableLimits: adjusting SB\n");
}
// BB unknown?
if (IsSmallerOrEqual(tablelimit_unreliable_input.bblind, 0))
{
SetBigBlind(GuessBigBlindFromSmallBlind());
write_log(3, "CTableLimits: adjusting BB\n");
}
// BB out of range?
if (IsGreater(tablelimit_unreliable_input.bblind, (tablelimit_unreliable_input.sblind*3)))
{
if (IsGreater(tablelimit_unreliable_input.sblind, 0))
{
SetBigBlind(GuessBigBlindFromSmallBlind());
}
}
// SB out of range?
if (IsGreaterOrEqual(tablelimit_unreliable_input.sblind, tablelimit_unreliable_input.bblind))
{
// Formerly this code was checking for SB > BB,
// but up to now we never saw an online-game with identical blinds.
// SB >= BB does usually mean, that SB did already act and complete.
SetSmallBlind(GuessSmallBlindFromBigBlind());
write_log(3, "CTableLimits: adjusting SB\n");
}
// Always force big-bet = 2 * big-blind
SetBigBet(GuessBigBetFromBigBlind());
write_log(3, "CTableLimits: adjusting big bet\n");
}
void CTeam::SortPlayers(int nSortKey, int nDir)
{
// Sanity checks...
if (nSortKey == TM_KEY_SCORE) return;
if (GetNumPlayers() <= 1) return;
// Remove each player from our list, and insert it, sorted, into a temp list...
CTeamPlayerList lsTemp;
CTeamPlayer* pCurPlr = GetFirstPlayer();
while (pCurPlr)
{
CTeamPlayer* pNextPlr = GetNextPlayer(pCurPlr);
m_lsPlayers.Delete(pCurPlr);
// Insert the player from our main list, sorted, into our temp list...
CTeamPlayer* pTmpPlr = lsTemp.GetFirst();
if (!pTmpPlr)
{
lsTemp.Insert(pCurPlr);
}
else
{
while (pTmpPlr)
{
if (nDir == TM_SORT_DESCENDING && IsGreater(pCurPlr, pTmpPlr, nSortKey))
{
lsTemp.InsertBefore(pTmpPlr, pCurPlr);
pTmpPlr = NULL;
}
else if (nDir == TM_SORT_ASCENDING && IsLess(pCurPlr, pTmpPlr, nSortKey))
{
lsTemp.InsertBefore(pTmpPlr, pCurPlr);
pTmpPlr = NULL;
}
else
{
pTmpPlr = pTmpPlr->GetNext();
if (!pTmpPlr)
{
lsTemp.InsertLast(pCurPlr);
}
}
}
}
pCurPlr = pNextPlr;
}
// Re-insert all items into our main list...
CTeamPlayer* pPlr = lsTemp.GetFirst();
while (pPlr)
{
CTeamPlayer* pNextPlr = pPlr->GetNext();
m_lsPlayers.InsertLast(pPlr);
pPlr = pNextPlr;
}
}
void CTeamMgr::SortTeams(int nSortKey, int nDir)
{
// Sanity check...
if (GetNumTeams() <= 1) return;
// Remove each team from our list, and insert it, sorted, into a temp list...
CTeamList lsTemp;
CTeam* pCurTeam = GetFirstTeam();
while (pCurTeam)
{
CTeam* pNextTeam = GetNextTeam(pCurTeam);
m_lsTeams.Delete(pCurTeam);
// Insert the team from our main list, sorted, into our temp list...
CTeam* pTmpTeam = lsTemp.GetFirst();
if (!pTmpTeam)
{
lsTemp.Insert(pCurTeam);
}
else
{
while (pTmpTeam)
{
if (nDir == TM_SORT_DESCENDING && IsGreater(pCurTeam, pTmpTeam, nSortKey))
{
lsTemp.InsertBefore(pTmpTeam, pCurTeam);
pTmpTeam = NULL;
}
else if (nDir == TM_SORT_ASCENDING && IsLess(pCurTeam, pTmpTeam, nSortKey))
{
lsTemp.InsertBefore(pTmpTeam, pCurTeam);
pTmpTeam = NULL;
}
else
{
pTmpTeam = pTmpTeam->GetNext();
if (!pTmpTeam)
{
lsTemp.InsertLast(pCurTeam);
}
}
}
}
pCurTeam = pNextTeam;
}
// Re-insert all items into our main list...
CTeam* pTeam = lsTemp.GetFirst();
while (pTeam)
{
CTeam* pNextTeam = pTeam->GetNext();
m_lsTeams.InsertLast(pTeam);
pTeam = pNextTeam;
}
}
double CParseTreeNode::EvaluateBinaryExpression(bool log) {
assert(_first_sibbling != NULL);
assert(_second_sibbling != NULL);
assert(_third_sibbling == NULL);
assert(_terminal_name == "");
double value_of_first_sibbling = EvaluateSibbling(_first_sibbling, log);
double value_of_second_sibbling = 0.0;
// Short circuiting
// Don't evaluate unnecessary parts of expressions
if (_node_type == kTokenOperatorLogicalAnd) {
if (value_of_first_sibbling == false) {
return false;
}
value_of_second_sibbling = EvaluateSibbling(_second_sibbling, log);
return (value_of_second_sibbling ? true : false);
} else if (_node_type == kTokenOperatorLogicalOr) {
// Attention!
// We can not look here for "value_of_first_sibbling == true"
// because this way we would only accept true (==1)
// but we want to accept any non-zero value.
// http://www.maxinmontreal.com/forums/viewtopic.php?f=111&t=17899
if (value_of_first_sibbling) {
return true;
}
value_of_second_sibbling = EvaluateSibbling(_second_sibbling, log);
return (value_of_second_sibbling ? true : false);
}
// Short circuiting done
// Now normal evaluation of operators that need both operands
value_of_second_sibbling = EvaluateSibbling(_second_sibbling, log);
switch (_node_type) {
case kTokenOperatorPlus:
return value_of_first_sibbling + value_of_second_sibbling;
case kTokenOperatorMinus:
return value_of_first_sibbling - value_of_second_sibbling;
case kTokenOperatorMultiplication:
return value_of_first_sibbling * value_of_second_sibbling;
case kTokenOperatorDivision:
if (value_of_second_sibbling == 0) {
OH_MessageBox_Error_Warning("Division by zero.");
return kUndefined;
} else {
return value_of_first_sibbling / value_of_second_sibbling;
}
case kTokenOperatorModulo:
if (value_of_second_sibbling == 0) {
OH_MessageBox_Error_Warning("Division by zero.");
return kUndefined;
} else {
return (unsigned long)value_of_first_sibbling
% (unsigned long)value_of_second_sibbling;
}
case kTokenOperatorExponentiation:
return pow(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorEquality:
return IsEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorApproximatellyEqual:
return IsApproximatellyEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorSmaller:
return IsSmaller(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorSmallerOrEqual:
return IsSmallerOrEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorGreater:
return IsGreater(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorGreaterOrEqual:
return IsGreaterOrEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorNotEqual:
case kTokenOperatorLogicalXOr:
return value_of_first_sibbling != value_of_second_sibbling;
case kTokenOperatorBinaryAnd:
return (unsigned long)value_of_first_sibbling
& (unsigned long)value_of_second_sibbling;
case kTokenOperatorBinaryOr:
return (unsigned long)value_of_first_sibbling
| (unsigned long)value_of_second_sibbling;
case kTokenOperatorBinaryXOr:
return (unsigned long)value_of_first_sibbling
^ (unsigned long)value_of_second_sibbling;
case kTokenOperatorBitShiftLeft:
return (unsigned long)value_of_first_sibbling
<< (unsigned long)value_of_second_sibbling;
case kTokenOperatorBitShiftRight:
return (unsigned long)value_of_first_sibbling
>> (unsigned long)value_of_second_sibbling;
case kTokenOperatorPercentage:
return value_of_first_sibbling * value_of_second_sibbling * 0.01;
default: assert(false);
}
return kUndefined;
}
