void Graph::read(const char * fn) {
std::ifstream inf (fn);
std::string line;
int n;
node_number = 0;
std::vector<int> tmp;
while (std::getline(inf, line)) {
read_line(line, &tmp);
if ( tmp.size() == 2 ) {
if( node_order.find(tmp.at(0)) == node_order.end() ) {
node_order[tmp.at(0)] = node_number;
node_number++;
};
if( node_order.find(tmp.at(1)) == node_order.end() ) {
node_order[tmp.at(1)] = node_number;
node_number++;
};
};
tmp.clear();
};
nodes.resize(node_number);
times.resize(node_number);
visited.insert(visited.begin(), node_number, false);
inf.clear();
inf.seekg(0);
while (std::getline(inf, line)) {
read_line(line, &tmp);
if ( tmp.size() == 2 ) {
nodes.at(node_order[tmp.at(1)]).add_reverse_edge(node_order[tmp.at(0)]);
nodes.at(node_order[tmp.at(0)]).add_edge(node_order[tmp.at(1)]);
};
tmp.clear();
};
node_order.clear();
};
std::string RippleAddress::humanAccountID () const
{
switch (nVersion)
{
case VER_NONE:
throw std::runtime_error ("unset source - humanAccountID");
case VER_ACCOUNT_ID:
{
boost::mutex::scoped_lock sl (rncLock);
boost::unordered_map< Blob , std::string >::iterator it = rncMap.find (vchData);
if (it != rncMap.end ())
return it->second;
if (rncMap.size () > 10000)
rncMap.clear ();
return rncMap[vchData] = ToString ();
}
case VER_ACCOUNT_PUBLIC:
{
RippleAddress accountID;
(void) accountID.setAccountID (getAccountID ());
return accountID.ToString ();
}
default:
throw std::runtime_error (str (boost::format ("bad source: %d") % int (nVersion)));
}
}
void Streamer::processPickups(Player &player, const std::vector<SharedCell> &cells)
{
static boost::unordered_map<int, Item::SharedPickup> discoveredPickups;
for (std::vector<SharedCell>::const_iterator c = cells.begin(); c != cells.end(); ++c)
{
for (boost::unordered_map<int, Item::SharedPickup>::const_iterator p = (*c)->pickups.begin(); p != (*c)->pickups.end(); ++p)
{
boost::unordered_map<int, Item::SharedPickup>::iterator d = discoveredPickups.find(p->first);
if (d == discoveredPickups.end())
{
if (checkPlayer(p->second->players, player.playerID, p->second->interiors, player.interiorID, p->second->worlds, player.worldID))
{
if (boost::geometry::comparable_distance(player.position, p->second->position) <= p->second->streamDistance)
{
boost::unordered_map<int, int>::iterator i = internalPickups.find(p->first);
if (i == internalPickups.end())
{
p->second->worldID = !p->second->worlds.empty() ? player.worldID : -1;
}
discoveredPickups.insert(*p);
}
}
}
}
}
if (processingFinalPlayer)
{
boost::unordered_map<int, int>::iterator i = internalPickups.begin();
while (i != internalPickups.end())
{
boost::unordered_map<int, Item::SharedPickup>::iterator d = discoveredPickups.find(i->first);
if (d == discoveredPickups.end())
{
DestroyPickup(i->second);
i = internalPickups.erase(i);
}
else
{
discoveredPickups.erase(d);
++i;
}
}
for (boost::unordered_map<int, Item::SharedPickup>::iterator d = discoveredPickups.begin(); d != discoveredPickups.end(); ++d)
{
if (internalPickups.size() == visiblePickups)
{
break;
}
int internalID = CreatePickup(d->second->modelID, d->second->type, d->second->position[0], d->second->position[1], d->second->position[2], d->second->worldID);
if (internalID == INVALID_ALTERNATE_ID)
{
break;
}
internalPickups.insert(std::make_pair(d->second->pickupID, internalID));
}
discoveredPickups.clear();
}
}
void read_db_users()
{
m_read_db_users_time = srv_time();
if (!m_use_sql)
return;
try
{
Csql_query q(m_database, "select @uid");
if (m_read_users_can_leech)
q += ", can_leech";
if (m_read_users_peers_limit)
q += ", peers_limit";
if (m_read_users_torrent_pass)
q += ", torrent_pass";
q += ", torrent_pass_version";
if (m_read_users_wait_time)
q += ", wait_time";
q += " from @users";
Csql_result result = q.execute();
// m_users.reserve(result.size());
for (auto& i : m_users)
i.second.marked = true;
m_users_torrent_passes.clear();
while (Csql_row row = result.fetch_row())
{
t_user& user = m_users[row[0].i()];
user.marked = false;
int c = 0;
user.uid = row[c++].i();
if (m_read_users_can_leech)
user.can_leech = row[c++].i();
if (m_read_users_peers_limit)
user.peers_limit = row[c++].i();
if (m_read_users_torrent_pass)
{
if (row[c].size() == 32)
m_users_torrent_passes[to_array<char, 32>(row[c])] = &user;
c++;
}
user.torrent_pass_version = row[c++].i();
if (m_read_users_wait_time)
user.wait_time = row[c++].i();
}
for (auto i = m_users.begin(); i != m_users.end(); )
{
if (i->second.marked)
m_users.erase(i++);
else
i++;
}
}
catch (bad_query&)
{
}
}
//-----------------------------------------------------------------------------
DofMap::DofMap(boost::unordered_map<std::size_t, std::size_t>& collapsed_map,
const DofMap& dofmap_view, const Mesh& mesh)
: _ufc_dofmap(dofmap_view._ufc_dofmap), _global_dimension(0),
_ufc_offset(0)
{
dolfin_assert(_ufc_dofmap);
// Check for dimensional consistency between the dofmap and mesh
check_dimensional_consistency(*_ufc_dofmap, mesh);
// Check that mesh has been ordered
if (!mesh.ordered())
{
dolfin_error("DofMap.cpp",
"create mapping of degrees of freedom",
"Mesh is not ordered according to the UFC numbering convention. "
"Consider calling mesh.order()");
}
// Check dimensional consistency between UFC dofmap and the mesh
check_provided_entities(*_ufc_dofmap, mesh);
// Copy slave-master map (copy or share?)
if (dofmap_view.slave_master_mesh_entities)
slave_master_mesh_entities.reset(new std::map<unsigned int, std::map<unsigned int, std::pair<unsigned int, unsigned int> > >(*dofmap_view.slave_master_mesh_entities));
// Build new dof map
DofMapBuilder::build(*this, mesh, slave_master_mesh_entities, _restriction);
// Dimension sanity checks
dolfin_assert(dofmap_view._dofmap.size() == mesh.num_cells());
dolfin_assert(global_dimension() == dofmap_view.global_dimension());
dolfin_assert(_dofmap.size() == mesh.num_cells());
// FIXME: Could we use a std::vector instead of std::map if the
// collapsed dof map is contiguous (0, . . . , n)?
// Build map from collapsed dof index to original dof index
collapsed_map.clear();
for (std::size_t i = 0; i < mesh.num_cells(); ++i)
{
const std::vector<dolfin::la_index>& view_cell_dofs = dofmap_view._dofmap[i];
const std::vector<dolfin::la_index>& cell_dofs = _dofmap[i];
dolfin_assert(view_cell_dofs.size() == cell_dofs.size());
for (std::size_t j = 0; j < view_cell_dofs.size(); ++j)
collapsed_map[cell_dofs[j]] = view_cell_dofs[j];
}
}
void load(Archive & ar, boost::unordered_map<T,U> & t, unsigned int version)
{
// clear the map
t.clear();
// read the size
typedef typename boost::unordered_map<T,U>::size_type size_type;
size_type size;
ar & BOOST_SERIALIZATION_NVP(size);
for (size_type i = 0; i < size; i++) {
// read a pair
std::pair<T, U> pair;
ar & boost::serialization::make_nvp("pair"+i, pair);
// insert it into the map
t.insert(pair);
}
}
/***********************************************************************
* Internal format to return the legals in a structure that is easy
* to check if some move is legal.
***********************************************************************/
void State::get_legals(boost::unordered_map<Player, boost::unordered_set<Move> >& result) const
{
typedef boost::unordered_map<Player, boost::unordered_set<Move> > tmp_t;
result.clear();
std::vector<PlayerMove> legalMoves;
legals(std::back_inserter(legalMoves));
for(std::vector<PlayerMove>::iterator pm = legalMoves.begin(); pm != legalMoves.end(); pm++) {
tmp_t::iterator iter_moves(result.find(pm->first));
if(iter_moves == result.end()) {
std::pair<tmp_t::iterator, bool> ok = result.emplace(pm->first, boost::unordered_set<Move>());
ok.first->second.emplace(pm->second);
} else {
iter_moves->second.emplace(pm->second);
}
}
}
int main() {
std::cout << "Element size: " << sizeof(map_element) << std::endl;
std::cout << "std::map: ";
run_tests(packet_collector_thread_std_map);
DataCounter.clear();
#ifndef __APPLE__
std::cout << "tbb::concurrent_unordered_map: ";
run_tests(packet_collector_thread_unordered_concurrent_map);
DataCounterUnorderedConcurrent.clear();
#endif
// Boost unordered map
std::cout << "boost::unordered_map: ";
run_tests(packet_collector_thread_boost_unordered_map);
DataCounterBoostUnordered.clear();
// Boost flat_map
DataCounterBoostFlatMap.reserve( number_of_ips );
std::cout << "boost::container::flat_map with preallocated elements: ";
run_tests(packet_collector_thread_flat_map_preallocated);
DataCounterBoostFlatMap.clear();
std::cout << "std::unordered_map C++11: ";
run_tests(packet_collector_thread_unordered_map);
DataCounterUnordered.clear();
// Preallocate hash buckets
DataCounterUnorderedPreallocated.reserve( number_of_ips );
std::cout << "std::unordered_map C++11 preallocated buckets: ";
run_tests(packet_collector_thread_unordered_map_preallocated);
DataCounterUnorderedPreallocated.clear();
// Preallocate vector
DataCounterVector.reserve( number_of_ips );
std::cout << "std::vector preallocated: ";
run_tests(packet_collector_thread_vector);
DataCounterVector.clear();
}
std::string RippleAddress::humanAccountID () const
{
switch (nVersion)
{
case VER_NONE:
throw std::runtime_error ("unset source - humanAccountID");
case VER_ACCOUNT_ID:
{
StaticScopedLockType sl (s_lock, __FILE__, __LINE__);
boost::unordered_map< Blob , std::string >::iterator it = rncMap.find (vchData);
if (it != rncMap.end ())
return it->second;
// VFALCO NOTE Why do we throw everything out? We could keep two maps
// here, switch back and forth keep one of them full and clear the
// other on a swap - but always check both maps for cache hits.
//
if (rncMap.size () > 250000)
rncMap.clear ();
return rncMap[vchData] = ToString ();
}
case VER_ACCOUNT_PUBLIC:
{
RippleAddress accountID;
(void) accountID.setAccountID (getAccountID ());
return accountID.ToString ();
}
default:
throw std::runtime_error (str (boost::format ("bad source: %d") % int (nVersion)));
}
}
int main(int ac, char* av[])
{
//read and parse command line inputs (using boose::program_options)
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
//scenario parameters
("lambda,l", po::value<double>(&lambda_mean)->default_value(10), "mean demand (E[lambda])")
("beta,b", po::value<double>(&beta0)->default_value(1), "beta")
("cost,c", po::value<double>(&cost)->default_value(1), "unit cost")
//file names input
("path,p", po::value<string>(&path), "path for temporary archive files")
("outfile,o", po::value<string>(&resultFile), "file to save result")
;
po::variables_map vm;
po::store(po::parse_command_line(ac, av, desc), vm);
po::notify(vm);
if (vm.count("help")) {
cout << "Usage: options_description [options]\n";
cout << desc;
return 0;
}
//initialize the file names by taking all parameters
modelName = "NVLearning_Full";
if (resultFile == "") resultFile = modelName + ".result.txt";
//Open output file
file.open(resultFile, fstream::app|fstream::out);
if (! file)
{
//if fail to open the file
cerr << "can't open output file NVLearning_Full_result.txt!" << endl;
exit(EXIT_FAILURE);
}
file << setprecision(10);
cout << setprecision(10);
//omp_set_num_threads(omp_get_num_procs());
//cout << "Num of Procs: " << omp_get_num_procs() << endl;
//cout << "Max Num of Threads: " << omp_get_max_threads() << endl;
cout << "Num of periods (N): " << N << endl;
cout << "r\tc\talpha\tbeta\tQ_F\tPi_F\tTime_F\tCPUTime_F\tComp_F" << endl;
//file << "Num of Procs: " << omp_get_num_procs() << endl;
//file << "Max Num of Threads: " << omp_get_max_threads() << endl;
//file << "Num of periods (N): " << N << endl;
file << "r\tc\talpha\tbeta\tQ_F\tPi_F\tTime_F\tCPUTime_F\tComp_F" << endl;
//initialize cost parameters
price = 2;
//lambda_mean = 10;
//cost = 1;
//beta0 = 1;
for (lambda_mean=10; lambda_mean<=50; lambda_mean+=10)
for (beta0=2; beta0>=0.05; beta0/=2)
{
alpha0 = beta0*lambda_mean;
for (cost=1.8; cost>=0.15; cost-=0.1)
{
v_map.clear();
cout << price << "\t" << cost << "\t" << alpha0 << "\t" << beta0 << "\t";
file << price << "\t" << cost << "\t" << alpha0 << "\t" << beta0 << "\t";
auto startTime = chrono::system_clock::now();
clock_t cpu_start = clock();
V_F(1, 0, 0);
clock_t cpu_end = clock();
auto endTime = chrono::system_clock::now();
cout << chrono::duration_cast<chrono::milliseconds> (endTime-startTime).count() << "\t" << 1000.0*(cpu_end-cpu_start)/CLOCKS_PER_SEC << "\t";
file << chrono::duration_cast<chrono::milliseconds> (endTime-startTime).count() << "\t" << 1000.0*(cpu_end-cpu_start)/CLOCKS_PER_SEC << "\t";
scenarioName = ".l" + dbl_to_str(lambda_mean) +".b" + dbl_to_str(beta0) + ".c" + dbl_to_str(cost);
archiveFile = path + modelName + scenarioName + ".oarchive.txt";
archiveVMap(v_map, archiveFile);
auto mapSize = v_map.size();
cout << mapSize+1 << endl;
file << mapSize+1 << endl;
}
}
file.close();
return 0;
}
void Broder86::computeNeighbours(const BipartiteMatching& s,
boost::unordered_map<BipartiteMatching, Rational>& neighbors) const {
// Variables
const int n = g.getNumberOfNodes();
const int k = s.k;
int u, v;
BipartiteMatching s2;
edgelist edges;
neighbors.clear();
// Implementierung der Transitionen nach Vorlage JS89
// Gehe über jede Kante
g.getEdges(edges);
//std::cout << "compute neighbors for s=" << s << std::endl;
// Für jede Wahl einer Kante e=(u,v) wird Transition konstruiert
for (typename edgelist::iterator it = edges.begin(); it != edges.end();
++it) {
u = it->first;
v = it->second;
// create new state as copy of old one
s2 = BipartiteMatching(s);
// Transition 1
if (2 * k == n && s.mates[u] == v) {
// remove edge (u,v)
s2.mates[u] = n;
s2.mates[v] = n;
s2.k = k - 1;
s2.unmatched[0] = u;
s2.unmatched[1] = v;
} else if (2 * k + 2 == n) {
// Transition 2
if (s.mates[u] == n && s.mates[v] == n) {
// add edge (u,v)
s2.mates[u] = v;
s2.mates[v] = u;
s2.k = k + 1;
s2.unmatched[0] = n;
s2.unmatched[1] = n;
}
// Transition 3a
else if (s.mates[u] != n && s.mates[v] == n) {
// remove edge (u, mate[u])
// add edge (u,v)
int w = s.mates[u];
s2.mates[w] = n;
s2.mates[u] = v;
s2.mates[v] = u;
// w=mate[u] (>= n/2) becomes unmatched node in bipartition group 1
s2.unmatched[1] = w;
}
// Transition 3b
else if (s.mates[u] == n && s.mates[v] != n) {
// remove edge (v, mate[v])
// add edge (u,v)
int w = s.mates[v];
s2.mates[w] = n;
s2.mates[u] = v;
s2.mates[v] = u;
// w=mate[v] (< n/2) becomes unmatched node in bipartition group 0
s2.unmatched[0] = w;
} else {
// stay in s
}
}
// sonst
else {
// Verbleibe im aktuellen Zustand
}
neighbors[s2] += Rational(1, edges.size());
//std::cout << std::endl;
}
}
//------------------------------------------------------------------------------
void CleanUp(bool exitvalue) {
pout_values.clear();
xercesc::XMLPlatformUtils::Terminate();
exit(exitvalue);
}