void PrioritizedSweeping<M>::stepUpdateQ(size_t s, size_t a) {
auto & values = std::get<VALUES>(vfun_);
{ // Update q[s][a]
double newQValue = 0;
for ( size_t s1 = 0; s1 < S; ++s1 ) {
double probability = model_.getTransitionProbability(s,a,s1);
if ( checkDifferentSmall( probability, 0.0 ) )
newQValue += probability * ( model_.getExpectedReward(s,a,s1) + model_.getDiscount() * values[s1] );
}
qfun_(s, a) = newQValue;
}
double p = values[s];
{
// Update value and action
values[s] = qfun_.row(s).maxCoeff(&std::get<ACTIONS>(vfun_)[s]);
}
p = std::fabs(values[s] - p);
// If it changed enough, we're going to update its parents.
if ( p > theta_ ) {
auto it = queueHandles_.find(s);
if ( it != std::end(queueHandles_) && std::get<PRIORITY>(*(it->second)) < p )
queue_.increase(it->second, std::make_tuple(p, s));
else
queueHandles_[s] = queue_.push(std::make_tuple(p, s));
}
}
//*********************************************************
bool Turn(QueueType & pQueue, VecSetType & squadSetVec, MapSquadType & squadMap, ArsenalType & arsenal){
bool over= false;
Player * p;
p= pQueue.front();
pQueue.pop();
p->ResetMomentum();
if( p->IsHuman())
{
HumanTurn(squadMap, arsenal, p);
}
else
{
BugTurn(squadMap, arsenal, p);
}
pQueue.push(p);
DeletePlayers(pQueue, squadSetVec, squadMap);
over= CheckOver(squadSetVec);
return over;
}
unsigned UnwrappedLineFormatter::analyzeSolutionSpace(LineState &InitialState,
bool DryRun) {
std::set<LineState *, CompareLineStatePointers> Seen;
// Increasing count of \c StateNode items we have created. This is used to
// create a deterministic order independent of the container.
unsigned Count = 0;
QueueType Queue;
// Insert start element into queue.
StateNode *Node =
new (Allocator.Allocate()) StateNode(InitialState, false, nullptr);
Queue.push(QueueItem(OrderedPenalty(0, Count), Node));
++Count;
unsigned Penalty = 0;
// While not empty, take first element and follow edges.
while (!Queue.empty()) {
Penalty = Queue.top().first.first;
StateNode *Node = Queue.top().second;
if (!Node->State.NextToken) {
DEBUG(llvm::dbgs() << "\n---\nPenalty for line: " << Penalty << "\n");
break;
}
Queue.pop();
// Cut off the analysis of certain solutions if the analysis gets too
// complex. See description of IgnoreStackForComparison.
if (Count > 10000)
Node->State.IgnoreStackForComparison = true;
if (!Seen.insert(&Node->State).second)
// State already examined with lower penalty.
continue;
FormatDecision LastFormat = Node->State.NextToken->Decision;
if (LastFormat == FD_Unformatted || LastFormat == FD_Continue)
addNextStateToQueue(Penalty, Node, /*NewLine=*/false, &Count, &Queue);
if (LastFormat == FD_Unformatted || LastFormat == FD_Break)
addNextStateToQueue(Penalty, Node, /*NewLine=*/true, &Count, &Queue);
}
if (Queue.empty()) {
// We were unable to find a solution, do nothing.
// FIXME: Add diagnostic?
DEBUG(llvm::dbgs() << "Could not find a solution.\n");
return 0;
}
// Reconstruct the solution.
if (!DryRun)
reconstructPath(InitialState, Queue.top().second);
DEBUG(llvm::dbgs() << "Total number of analyzed states: " << Count << "\n");
DEBUG(llvm::dbgs() << "---\n");
return Penalty;
}
//*********************************************************
void LoadQueue(QueueType & pQueue, vector<Player *> bugs, vector<Player *> squad){
vector<Player *> all;
all= SortAll(bugs, squad);
int len= all.size();
for (int i= 0; i < len; i++)
{
pQueue.push(all[i]);
}
all.clear();
return;
}
void spsc_queue_avail_test_run(QueueType & q)
{
BOOST_REQUIRE_EQUAL( q.write_available(), 16 );
BOOST_REQUIRE_EQUAL( q.read_available(), 0 );
for (size_t i = 0; i != 8; ++i) {
BOOST_REQUIRE_EQUAL( q.write_available(), 16 - i );
BOOST_REQUIRE_EQUAL( q.read_available(), i );
q.push( 1 );
}
// empty queue
int dummy;
while (q.pop(dummy))
{}
for (size_t i = 0; i != 16; ++i) {
BOOST_REQUIRE_EQUAL( q.write_available(), 16 - i );
BOOST_REQUIRE_EQUAL( q.read_available(), i );
q.push( 1 );
}
}
//*********************************************************
bool DeletePlayers(QueueType & pQueue, VecSetType & squadSetVec, MapSquadType & squadMap){
Player * p;
int qSize= pQueue.size();
bool del= false;
for (int i= 0; i < qSize; i++)
{
p= pQueue.front();
pQueue.pop();
if (p->IsDead())
{
if (squadSetVec[squadMap[p->Name()]].count(p->Name()))
{
squadSetVec[squadMap[p->Name()]].erase(p->Name());
del= true;
}
//PrintVectorOfSquads(cout , squadSetVec);
}
pQueue.push(p);
}
return del;
}