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));
            }
        }
Example #2
0
//*********************************************************
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;
}
Example #4
0
//*********************************************************
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;
}
Example #5
0
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 );
    }
}
Example #6
0
//*********************************************************
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;
}