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();
};
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();
}
}
inline
uint32_t
find_label(uint32_t label, boost::unordered_map<uint32_t, label_info> &labels)
{
boost::unordered_map<uint32_t, label_info>::iterator it;
for (it = labels.find(label); label != it->second.m_alias;) {
label = it->second.m_alias;
it = labels.find(label);
}
return label;
}
bool LLNetMap::mmenableunmark::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
{
LLNetMap *self = mPtr;
BOOL enabled = mPtr->mClosestAgentAtLastRightClick.notNull() && mm_MarkerColors.find(mPtr->mClosestAgentAtLastRightClick) != mm_MarkerColors.end();
self->findControl(userdata["control"].asString())->setValue(enabled);
return true;
}
wcs Symbol::name() const {
boost::unordered_map<sym, wcs>::const_iterator
iter = names.find(this);
if (iter != names.end())
return iter->second;
return 0;
}
size_t count(std::string const& x) const {
auto iter = counts.find(x);
if (iter != counts.end()) {
return iter->second;
}
return 0;
}
inline bool lru_cache_cab::ins_rec(const bucket * buck, const double & curT, bool newFlow)
{
const container_T::left_iterator iter = cache.left.find(buck);
if (iter == cache.left.end()) // cache miss
{
insert(buck, curT);
if (newFlow)
{
++delay_rec[20];
}
++cache_miss;
return true;
}
else // cache hit
{
cache.right.relocate(cache.right.end(),
cache.project_right(iter));
iter->second = curT;
double delay = curT-buffer_check.find(buck)->second;
if (newFlow)
{
++reuse_count;
if(delay < rtt)
{
assert (delay >= 0);
++delay_rec[int(20*(rtt-delay)/rtt)];
}
}
return false;
}
}
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)));
}
}
bool TwoSum::find_sum(long int target) {
long int bucket;
for( auto it = numbers_to_check.begin(); it != numbers_to_check.end(); it++ ) {
if( numbers.find((*it) - target) == numbers.end() ) { continue; };
bucket = numbers.bucket( (*it) - target );
for(auto it_local = numbers.begin(bucket); it_local != numbers.end(bucket); ++it_local) {
if ( ( it_local->first + target ) != (*it) ) { continue; };
if ( it_local->first != target || (it_local->first == target && multi_numbers.find(target) != multi_numbers.end()) ) {
std::cout << target << " + " << it_local->first << " = " << (*it) << " ( " << target + it_local->first << std::endl;
numbers_to_check.erase(it);
return true;
};
};
};
return false;
};
bool dbconn_pool::init_pool(boost::unordered_map<std::string, std::string>& cfg)
{
std::vector<std::string> keys;
{
keys.push_back("host");
keys.push_back("userid");
keys.push_back("passwd");
keys.push_back("database");
keys.push_back("port");
keys.push_back("charset");
keys.push_back("pool_size");
keys.push_back("wait_timeout_sec");
}
boost::unordered_map<std::string, std::string>::iterator found;
for (std::size_t i = 0; i < keys.size(); ++i)
{
found = cfg.find(keys[i]);
if (found == cfg.end())
{
return false;
}
if (keys[i] == "host")
{
host = found->second;
}
else if (keys[i] == "userid")
{
userid = found->second;
}
else if (keys[i] == "passwd")
{
passwd = found->second;
}
else if (keys[i] == "database")
{
database = found->second;
}
else if (keys[i] == "port")
{
port = boost::lexical_cast<unsigned int>(found->second);
}
else if (keys[i] == "charset")
{
charset = found->second;
}
else if (keys[i] == "pool_size")
{
pool_size = boost::lexical_cast<std::size_t>(found->second);
}
else if (keys[i] == "wait_timeout_sec")
{
wait_timeout_sec = boost::lexical_cast<double>(found->second);
}
}
return true;
}
std::string to_name( operators const& val ){
boost::unordered_map< operators, std::string >::const_iterator
find_result_it = enum_to_name.find(val);
if ( find_result_it != enum_to_name.end() ){
return find_result_it->second;
}
return "__unknown_enum_val__";
}
operators from_name( const std::string& name){
boost::unordered_map< std::string, operators >::const_iterator
find_result_it = name_to_enum.find(name);
if ( find_result_it != name_to_enum.end() ){
return find_result_it->second;
}
throw "unexcepted enumuration name!";
}
Cairo::RefPtr<Cairo::ImageSurface> getIcon(string path)
{
auto it = stored.find(path);
if (it != stored.end())
return (*it).second;
Cairo::RefPtr<Cairo::ImageSurface> image = Cairo::ImageSurface::create_from_png(path);
stored[path] = image;
return image;
}
cairo_surface_t* getImage(string path)
{
auto it = images.find(path);
if (it != images.end())
return (*it).second;
cairo_surface_t* image = cairo_image_surface_create_from_png(path.c_str());
images.insert(std::make_pair(path, image));
return image;
}
var Symbol::get(wcs x) const {
boost::unordered_map<sym, Context>::const_iterator
iter = contexts.find(this);
if (iter != contexts.end()) {
Context::const_iterator
iter2 = iter->second.find(reinterpret_cast<uint>(x));
if (iter2 != iter->second.end())
return iter2->second;
}
return null;
}
// finds a promise by ID, returns and unregisters the promise
inline boost::promise<message_reply*>* get_promise(uint64_t promise_id) {
boost::unordered_map<uint64_t, boost::promise<message_reply*>* >
::iterator iter = promises.find(promise_id);
if (iter == promises.end()) return NULL;
else {
boost::promise<message_reply*>* ret = iter->second;
promises.erase(iter);
return ret;
}
}
// Makes sure that no three points all on an original tile edge
// are triangulated.
bool is_legal(const Point_3& a, const Point_3& b, const Point_3& c,
const boost::unordered_map<Point_3, boost::unordered_set<Segment_3_undirected> >& point2edges)
{
static log4cplus::Logger logger = log4cplus::Logger::getInstance("polygon_utils.is_legal");
LOG4CPLUS_TRACE(logger, "is_legal: " << pp(a) << " " << pp(b) << " " << pp(c));
if (point2edges.find(a) == point2edges.end())
return true;
if (point2edges.find(b) == point2edges.end())
return true;
if (point2edges.find(c) == point2edges.end())
return true;
const boost::unordered_set<Segment_3_undirected>& edgesa = point2edges.find(a)->second;
const boost::unordered_set<Segment_3_undirected>& edgesb = point2edges.find(b)->second;
const boost::unordered_set<Segment_3_undirected>& edgesc = point2edges.find(c)->second;
boost::unordered_set<Segment_3_undirected> edges(set_intersection(edgesa, set_intersection(edgesb, edgesc)));
return edges.empty();
}
void PropertyExpressionEngine::buildGraphStructures(const ObjectIdentifier & path,
const boost::shared_ptr<Expression> expression,
boost::unordered_map<ObjectIdentifier, int> & nodes,
boost::unordered_map<int, ObjectIdentifier> & revNodes,
std::vector<Edge> & edges) const
{
std::set<ObjectIdentifier> deps;
/* Insert target property into nodes structure */
if (nodes.find(path) == nodes.end()) {
int s = nodes.size();
revNodes[s] = path;
nodes[path] = s;
}
else
revNodes[nodes[path]] = path;
/* Get the dependencies for this expression */
expression->getDeps(deps);
/* Insert dependencies into nodes structure */
std::set<ObjectIdentifier>::const_iterator di = deps.begin();
while (di != deps.end()) {
Property * prop = di->getProperty();
if (prop) {
ObjectIdentifier cPath(di->canonicalPath());
if (nodes.find(cPath) == nodes.end()) {
int s = nodes.size();
nodes[cPath] = s;
}
edges.push_back(std::make_pair(nodes[path], nodes[cPath]));
}
++di;
}
}
IncrementalScoringFunction::Data IncrementalScoringFunction::create_data(
ParticleIndex pi, RestraintsTemp cr,
const boost::unordered_map<Restraint *, int> &all,
const Restraints &dummies) const {
IMP_LOG_TERSE("Dependent restraints for particle "
<< get_model()->get_particle_name(pi) << " are " << cr
<< std::endl);
Data ret;
for (unsigned int j = 0; j < cr.size(); ++j) {
if (all.find(cr[j]) != all.end()) {
int index = all.find(cr[j])->second;
IMP_INTERNAL_CHECK(
std::find(ret.indexes.begin(), ret.indexes.end(), index) ==
ret.indexes.end(),
"Found duplicate restraint " << Showable(cr[j]) << " in list " << cr);
ret.indexes.push_back(index);
}
}
cr += RestraintsTemp(dummies.begin(), dummies.end());
ret.sf = new IncrementalRestraintsScoringFunction(
cr, 1.0, NO_MAX, get_model()->get_particle_name(pi) + " restraints");
return ret;
}
double get_volume_from_residue_type(ResidueType rt) {
typedef std::pair<ResidueType, double> RP;
static const RP radii[] = {
RP(ResidueType("ALA"), 2.516), RP(ResidueType("ARG"), 3.244),
RP(ResidueType("ASN"), 2.887), RP(ResidueType("ASP"), 2.866),
RP(ResidueType("CYS"), 2.710), RP(ResidueType("GLN"), 3.008),
RP(ResidueType("GLU"), 2.997), RP(ResidueType("GLY"), 2.273),
RP(ResidueType("HIS"), 3.051), RP(ResidueType("ILE"), 3.047),
RP(ResidueType("LEU"), 3.052), RP(ResidueType("LYS"), 3.047),
RP(ResidueType("MET"), 3.068), RP(ResidueType("PHE"), 3.259),
RP(ResidueType("PRO"), 2.780), RP(ResidueType("SER"), 2.609),
RP(ResidueType("THR"), 2.799), RP(ResidueType("TRP"), 3.456),
RP(ResidueType("TYR"), 3.318), RP(ResidueType("VAL"), 2.888)};
static const boost::unordered_map<ResidueType, double> radii_map(
radii, radii + sizeof(radii) / sizeof(RP));
if (radii_map.find(rt) == radii_map.end()) {
IMP_THROW("Can't approximate volume of non-standard residue " << rt,
ValueException);
}
double r = radii_map.find(rt)->second;
IMP_INTERNAL_CHECK(r > 0, "Read garbage r for " << rt);
return algebra::get_volume(
algebra::Sphere3D(algebra::get_zero_vector_d<3>(), r));
}
static std::pair<int, int>
hit(const boost::unordered_map<int, double> &real,
const boost::unordered_map<int, double> &fake,
double thres = 0.0)
{
int a = 0, b = 0;
for (auto it = fake.cbegin(); it != fake.cend(); ++it) {
if (it->second >= thres) {
++b;
if (real.end() != real.find(it->first))
++a;
}
}
return std::make_pair(a, b);
}
static CStrInternInternals* GetString(const char* str, size_t len)
{
// g_Strings is not thread-safe, so complain if anyone is using this
// type in non-main threads. (If that's desired, g_Strings should be changed
// to be thread-safe, preferably without sacrificing performance.)
ENSURE(ThreadUtil::IsMainThread());
#if BOOST_VERSION >= 104200
StringsKeyProxy proxy = { str, len };
boost::unordered_map<StringsKey, shared_ptr<CStrInternInternals> >::iterator it =
g_Strings.find(proxy, StringsKeyProxyHash(), StringsKeyProxyEq());
#else
// Boost <= 1.41 doesn't support the new find(), so do a slightly less efficient lookup
boost::unordered_map<StringsKey, shared_ptr<CStrInternInternals> >::iterator it =
g_Strings.find(str);
#endif
if (it != g_Strings.end())
return it->second.get();
shared_ptr<CStrInternInternals> internals(new CStrInternInternals(str, len));
g_Strings.insert(std::make_pair(internals->data, internals));
return internals.get();
}
double V_F(const int& n, const int& fullObs_cumulativeTime, const int& fullObs_cumulativeQuantity)
{
double v_max;
if (n==N+1)
v_max = 0; //V_{N+1}()=0
else
{
auto parameters = make_tuple(n, fullObs_cumulativeTime, fullObs_cumulativeQuantity);
bool found = false;
//#pragma omp critical (v_map)
{
auto it = v_map.find(parameters);
if (it != v_map.end()) {
found = true;
v_max = it->second;
}
}
if (!found)
{
//no need to search for optimal inventory level x, the myopic inventory level is optimal
int x_opt = find_x_myopic(fullObs_cumulativeTime, fullObs_cumulativeQuantity);
v_max = G_F(n, x_opt, fullObs_cumulativeTime, fullObs_cumulativeQuantity);
if (n==1)
{
cout << x_opt << "\t" << v_max << "\t";
file << x_opt << "\t" << v_max << "\t";
}
//#pragma omp critical (v_map)
{ v_map.emplace(parameters, v_max); }
}
}
return v_max;
}
void State::throw_on_illegal_move(const PlayerMove& pm,
boost::unordered_map<Player, boost::unordered_set<Move> >& legals) const
{
typedef boost::unordered_map<Player, boost::unordered_set<Move> > tmp_t;
const Player& p = pm.first;
const Move& m = pm.second;
tmp_t::const_iterator itp(legals.find(p));
if (itp == legals.end())
{
throw HSFCValueError() << ErrorMsgInfo("Illegal PlayerMove: unknown player");
}
boost::unordered_set<Move>::const_iterator itm(itp->second.find(m));
if (itm == itp->second.end())
{
throw HSFCValueError() << ErrorMsgInfo("Illegal PlayerMove: unknown move");
}
}
/***********************************************************************
* 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);
}
}
}
void styleNodes(const shared_ptr<std::vector<NodeId> >& ids, RenderAttributes& attr) const
{
for (auto id : *ids)
{
Node* n = data->getNode(id);
auto& tags = n->getTags();
auto name = tags.find(CachedString("name"));
if (name != tags.end())
{
auto style = styles.find(name->second);
if (style != styles.end()) {
Style* s = attr.getNewStyle(id);
*s = style->second;
}
}
}
}
bool PhraseOrientation::SpanIsAligned(int index1, int index2, const boost::unordered_map< std::pair<int,int> , std::pair<int,int> > &minAndMaxAligned) const
{
boost::unordered_map< std::pair<int,int> , std::pair<int,int> >::const_iterator itMinAndMaxAligned =
minAndMaxAligned.find(std::pair<int,int>(std::min(index1,index2),std::max(index1,index2)));
if (itMinAndMaxAligned == minAndMaxAligned.end())
{
std::cerr << "PhraseOrientation::SourceSpanIsAligned(): Error" << std::endl;
std::exit(1);
}
else
{
if (itMinAndMaxAligned->second.first == std::numeric_limits<int>::max())
{
return false;
}
}
return true;
}
void TwoSum::read(const char * fn) {
std::ifstream inf (fn);
std::string line;
long int n;
int count = 0;
while (std::getline(inf, line)) {
count++;
};
numbers.reserve(count);
count = 0;
inf.clear();
inf.seekg(0);
while (std::getline(inf, line)) {
n = read_line(line);
if( numbers.find(n) == numbers.end() ) {
numbers[n] = n;
} else {
multi_numbers[n] = true;
};
count++;
};
};
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)));
}
}
HashRouter::Entry& HashRouter::findCreateEntry (uint256 const& index, bool& created)
{
boost::unordered_map<uint256, Entry>::iterator fit = mSuppressionMap.find (index);
if (fit != mSuppressionMap.end ())
{
created = false;
return fit->second;
}
created = true;
int now = UptimeTimer::getInstance ().getElapsedSeconds ();
int expireTime = now - mHoldTime;
// See if any supressions need to be expired
std::map< int, std::list<uint256> >::iterator it = mSuppressionTimes.begin ();
if ((it != mSuppressionTimes.end ()) && (it->first <= expireTime))
{
BOOST_FOREACH (uint256 const & lit, it->second)
mSuppressionMap.erase (lit);
mSuppressionTimes.erase (it);
}