std::unordered_map<T, std::pair<U, V>> zip(const std::unordered_map<T, U>& a, const std::unordered_map<T, V>& b) { assert(a.size() == b.size()); std::unordered_map<T, std::pair<U, V>> c; for (const auto& e : a) c[e.first] = std::make_pair(a.at(e.first), b.at(e.first)); return std::move(c); }
error_code cellVideoOutGetState(u32 videoOut, u32 deviceIndex, vm::ptr<CellVideoOutState> state) { cellSysutil.trace("cellVideoOutGetState(videoOut=%d, deviceIndex=%d, state=*0x%x)", videoOut, deviceIndex, state); if (deviceIndex) return CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND; switch (videoOut) { case CELL_VIDEO_OUT_PRIMARY: state->state = CELL_VIDEO_OUT_OUTPUT_STATE_ENABLED; state->colorSpace = CELL_VIDEO_OUT_COLOR_SPACE_RGB; state->displayMode.resolutionId = g_video_out_resolution_id.at(g_cfg.video.resolution); // TODO state->displayMode.scanMode = CELL_VIDEO_OUT_SCAN_MODE_PROGRESSIVE; state->displayMode.conversion = CELL_VIDEO_OUT_DISPLAY_CONVERSION_NONE; state->displayMode.aspect = g_video_out_aspect_id.at(g_cfg.video.aspect_ratio); // TODO state->displayMode.refreshRates = CELL_VIDEO_OUT_REFRESH_RATE_59_94HZ; return CELL_OK; case CELL_VIDEO_OUT_SECONDARY: *state = { CELL_VIDEO_OUT_OUTPUT_STATE_DISABLED }; // ??? return CELL_OK; } return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT; }
ReadCompGraph genReadComparisonGraph(const std::vector<T> & reads, aligner & alignerObj, std::unordered_map<std::string, std::unique_ptr<aligner>>& aligners, std::mutex & alignerLock, uint32_t numThreads) { std::function< comparison(const T &, const T &, std::unordered_map<std::string, std::unique_ptr<aligner>>&, aligner&)> getMismatchesFunc = [&alignerLock](const T & read1, const T & read2, std::unordered_map<std::string, std::unique_ptr<aligner>>& aligners, aligner &alignerObj) { alignerLock.lock(); auto threadId = estd::to_string(std::this_thread::get_id()); //std::cout << threadId<< std::endl; if(aligners.find(threadId) == aligners.end()) { aligners.emplace(threadId, std::make_unique<aligner>(alignerObj)); } alignerLock.unlock(); aligners.at(threadId)->alignCache(getSeqBase(read1),getSeqBase(read2), false); aligners.at(threadId)->profilePrimerAlignment(getSeqBase(read1), getSeqBase(read2)); return aligners.at(threadId)->comp_; }; auto distances = getDistanceNonConst(reads, numThreads, getMismatchesFunc, aligners, alignerObj); return ReadCompGraph(distances, reads); }
inline std::pair<bool, AgentPos> help_findAroundDirection(const std::unordered_map<AgentPos, bool>& versionMap, bool iscover, const AgentPos& mypos) { AgentPos around[4] = {{mypos.x+1, mypos.y},{mypos.x-1, mypos.y},{mypos.x, mypos.y+1},{mypos.x, mypos.y-1}}; std::vector<AgentPos> founds; AgentPos notInThree; for (auto pos : around) { if (iscover) { if (versionMap.at(pos) == false) founds.push_back(pos); else notInThree = pos; } else { if (versionMap.at(pos) == true) founds.push_back(pos); else notInThree = pos; } } if (founds.size() == 4) { return {false, {0,0}}; } else if (founds.size() > 0 && founds.size() == 3) { int x = mypos.x == notInThree.x ? mypos.x : notInThree.x < mypos.x ? mypos.x+1: mypos.x -1; int y = mypos.y == notInThree.y ? mypos.y : notInThree.y < mypos.y ? mypos.y +1:mypos.y -1; return {true, {x,y}}; } else if (founds.size() > 0) { return {true, founds[static_cast<int>(rand_0_1()*100)%founds.size()]}; } else { return {false, {0,0}}; } }
void Chain::sample( std::unordered_map<nat,TopologyFile> ¶mId2TopFile , ParameterFile &pFile ) const { auto blParamsUnfixed= std::vector<AbstractParameter*>{} ; AbstractParameter *topoParamUnfixed = nullptr; for(auto ¶m : _params ) { if(param->getCategory() == Category::BRANCH_LENGTHS && param->getPrior()->needsIntegration() ) blParamsUnfixed.push_back(param); else if(param->getCategory() == Category::TOPOLOGY && param->getPrior()->needsIntegration() ) topoParamUnfixed = param ; } if(blParamsUnfixed.size() > 0) { for(auto ¶m : blParamsUnfixed) { nat myId = param->getId(); auto &f = paramId2TopFile.at(myId); f.sample(_traln, getGeneration(), param); } } else if(topoParamUnfixed != nullptr) { auto &f = paramId2TopFile.at(topoParamUnfixed->getId()); f.sample(_traln, getGeneration(), topoParamUnfixed); } pFile.sample( _traln, _params, getGeneration(), _prior.getLnPrior()); }
bool Shader::CompileFromSource(const std::string& pathToFile, const EShaderStage& type, ID3D10Blob *& ref_pBob, std::string& errMsg, const std::vector<ShaderMacro>& macros) { const StrUtil::UnicodeString Path = pathToFile; const WCHAR* PathStr = Path.GetUnicodePtr(); ID3D10Blob* errorMessage = nullptr; int i = 0; std::vector<D3D10_SHADER_MACRO> d3dMacros(macros.size() + 1); std::for_each(RANGE(macros), [&](const ShaderMacro& macro) { d3dMacros[i++] = D3D10_SHADER_MACRO({ macro.name.c_str(), macro.value.c_str() }); }); d3dMacros[i] = { NULL, NULL }; if (FAILED(D3DCompileFromFile( PathStr, d3dMacros.data(), SHADER_INCLUDE_HANDLER, SHADER_ENTRY_POINT_LOOKUP.at(type), SHADER_COMPILER_VERSION_LOOKUP.at(type), SHADER_COMPILE_FLAGS, 0, &ref_pBob, &errorMessage))) { errMsg = GetCompileError(errorMessage, pathToFile); return false; } return true; }
error_code cellVideoOutGetDeviceInfo(u32 videoOut, u32 deviceIndex, vm::ptr<CellVideoOutDeviceInfo> info) { cellSysutil.warning("cellVideoOutGetDeviceInfo(videoOut=%d, deviceIndex=%d, info=*0x%x)", videoOut, deviceIndex, info); if (deviceIndex) return CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND; // Use standard dummy values for now. info->portType = CELL_VIDEO_OUT_PORT_HDMI; info->colorSpace = CELL_VIDEO_OUT_COLOR_SPACE_RGB; info->latency = 100; info->availableModeCount = 1; info->state = CELL_VIDEO_OUT_DEVICE_STATE_AVAILABLE; info->rgbOutputRange = 1; info->colorInfo.blueX = 0xFFFF; info->colorInfo.blueY = 0xFFFF; info->colorInfo.greenX = 0xFFFF; info->colorInfo.greenY = 0xFFFF; info->colorInfo.redX = 0xFFFF; info->colorInfo.redY = 0xFFFF; info->colorInfo.whiteX = 0xFFFF; info->colorInfo.whiteY = 0xFFFF; info->colorInfo.gamma = 100; info->availableModes[0].aspect = g_video_out_aspect_id.at(g_cfg.video.aspect_ratio); info->availableModes[0].conversion = CELL_VIDEO_OUT_DISPLAY_CONVERSION_NONE; info->availableModes[0].refreshRates = CELL_VIDEO_OUT_REFRESH_RATE_60HZ; info->availableModes[0].resolutionId = g_video_out_resolution_id.at(g_cfg.video.resolution); info->availableModes[0].scanMode = CELL_VIDEO_OUT_SCAN_MODE_PROGRESSIVE; return CELL_OK; }
std::vector<std::pair<std::pair<DocId, DocId>, double>> computeSimilarities(std::unordered_map<DocId, Document> docs) { DocSimilarities result = computeIntersections(docs); result.forEach([&docs, &result] (DocId id1, DocId id2, double similarity) mutable { double docsUnion = docs.at(id1).data.size() + docs.at(id2).data.size() - similarity; result.setSimilarity(id1, id2, similarity / docsUnion); }); return result.pairs(); }
void GateModule::init(const std::unordered_map<std::string, std::string>& config) { std::string name = config.at("name"); std::string ip = config.at("ip"); std::string port = config.at("port"); std::string thread_num = config.at("net_thread_num"); set_name(name); init_net(std::stoi(thread_num)); listen(ip, port); }
// 10^nを漢数字に変換する std::string KanjiOf10ToPower(int n) { const std::unordered_map<int, std::string> kanji_scale_map = { {0, "一"}, {1, "十"}, {2, "百"}, {3, "千"}, {4, "万"}, {8, "億"}, }; const int base = n % 4; // 一, 十, 百, 千の4つ const int scale = n / 4 * 4; // ex) n = 5, 5 / 4 = 1, 1 * 4 = 4 return (base == 0 && n > 0 ? "" : kanji_scale_map.at(base)) // n = 4 とか 8 のときは '一' を省略 + (scale > 0 ? kanji_scale_map.at(scale) : ""); }
LUMAFunction selectLumaFunction(unsigned width, unsigned height, unsigned bits, int opt) { LUMAFunction luma = luma_functions.at(KEY(width, height, bits, Scalar)); #if defined(MVTOOLS_X86) if (opt) { try { luma = luma_functions.at(KEY(width, height, bits, SSE2)); } catch (std::out_of_range &) { } } #endif return luma; }
int unsub() { std::string sig(cmd + UNSUB_LEN); if (subs.count(sig) > 0) { subs.at(sig).erase(socket); if (subs.at(sig).size() == 0) { subs.erase(sig); signals.erase(sig); } } return sig.length(); }
error_code cellVideoOutGetResolutionAvailability(u32 videoOut, u32 resolutionId, u32 aspect, u32 option) { cellSysutil.warning("cellVideoOutGetResolutionAvailability(videoOut=%d, resolutionId=0x%x, aspect=%d, option=%d)", videoOut, resolutionId, aspect, option); switch (videoOut) { case CELL_VIDEO_OUT_PRIMARY: return not_an_error( resolutionId == g_video_out_resolution_id.at(g_cfg.video.resolution) && (aspect == CELL_VIDEO_OUT_ASPECT_AUTO || aspect == g_video_out_aspect_id.at(g_cfg.video.aspect_ratio)) ); case CELL_VIDEO_OUT_SECONDARY: return not_an_error(0); } return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT; }
http::doc action(const std::string &verb, const std::unordered_map<std::string, std::string> &args) { if (verb == "refresh") { volumes.refresh(); return http::redirect("/"); } else if (verb == "pref") { std::string old_basedir = prefs::get("basedir"); for (const std::pair<const std::string, std::string> &kvpair : args) { try { prefs::set(kvpair.first, kvpair.second); } catch (std::out_of_range &e) { continue; } } prefs::write(); if (prefs::get("basedir") != old_basedir) volumes.init(prefs::get("basedir")); return http::redirect("/"); } else if (verb == "add") { for (const std::string & reqarg : {"home", "location", "id"}) if (! args.count(reqarg)) return error("Volume Creation Failed", "Required parameter “" + reqarg + "” is missing."); std::string srcdir = args.at("location"); std::string id = args.at("id"); std::unordered_map<std::string, std::string> info; info["home"] = args.at("home"); for (const std::string &property : {"title", "favicon"}) if (args.count(property)) info[property] = args.at(property); std::unordered_set<std::string> keynames{}; for (const std::pair<const std::string, std::string> &pair : args) { std::smatch match{}; if (std::regex_search(pair.first, match, std::regex{"^key_(.*)$"})) keynames.insert(match[1]); } for (const std::string &key : keynames) if (args.count("key_" + key) && args.count("value_" + key)) info[args.at("key_" + key)] = args.at("value_" + key); try { Volume::create(srcdir, prefs::get("basedir"), id, info); } catch(std::runtime_error &e) { return error("Volume Creation Failed", e.what()); } volumes.refresh(); return http::redirect("/"); } else if (verb == "quit") std::exit(0); /*else if (verb == "debug") { std::stringstream buf{}; for (const std::pair<const std::string, std::string> &arg : args) buf << arg.first << " = " << arg.second << "\n"; return http::doc{"text/plain", buf.str()}; }*/ else return error("Bad Request", "Unknown action “" + verb + "”"); }
static PedType findPedType(const std::string& name) { static const std::unordered_map<std::string, PedType> pedTypes{ // III {"PLAYER1", PLAYER1}, {"PLAYER2", PLAYER2}, {"PLAYER3", PLAYER3}, {"PLAYER4", PLAYER4}, {"CIVMALE", CIVMALE}, {"CIVFEMALE", CIVFEMALE}, {"COP", COP}, {"GANG1", GANG1}, {"GANG2", GANG2}, {"GANG3", GANG3}, {"GANG4", GANG4}, {"GANG5", GANG5}, {"GANG6", GANG6}, {"GANG7", GANG7}, {"GANG8", GANG8}, {"GANG9", GANG9}, {"EMERGENCY", EMERGENCY}, {"FIREMAN", FIREMAN}, {"CRIMINAL", CRIMINAL}, {"PROSTITUTE", PROSTITUTE}, {"SPECIAL", SPECIAL}, }; return pedTypes.at(name); }
~client_t() { std::cerr << "~client_t" << std::endl; for (auto it = signals.begin(); it != signals.end(); ++it) { if (subs.count(*it) > 0) { subs.at(*it).erase(socket); if (subs.at(*it).empty()) { subs.erase(*it); } } } delete[] cmd; }
User* obtain_user(std::string name) { try { return &UserTable.at(name); } catch(const std::out_of_range &oor) { return NULL; } }
string tokname(tok t) { struct tokhash { std::size_t operator()(tok t) const { return static_cast<std::size_t>(t); } }; static const std::unordered_map<tok, string, tokhash> names = { { tok::STRING, "string" }, { tok::LABEL, "label" }, { tok::BYTE, "byte" }, { tok::INT, "int" }, { tok::FLOAT, "float" }, { tok::ARRAY, "array" }, { tok::NEWLINE, "new line" }, { tok::END, "end of file" }, { tok::ARG, ".arg" }, { tok::DATA, ".data" }, { tok::EXPORT, ".export" }, { tok::EXTERN, ".extern" }, { tok::IMPORT, ".import" }, { tok::MODULE, ".module" }, { tok::STR, ".str" }, { tok::SUB, ".sub" }, { tok::VAR, ".var" }, }; return names.at(t); }
UIElement* getelement(Element::UIType type) { if (elements.count(type)) return elements.at(type).get(); else return nullptr; }
DexMethod* method_from_s_expr(const s_expr& e) { s_expr tail; s_patn({s_patn("method")}, tail) .must_match(e, "method definitions must start with 'method'"); s_expr access_tokens; std::string method_name; s_patn({s_patn(access_tokens), s_patn(&method_name)}, tail) .must_match(tail, "Expecting access list and method name"); auto method = static_cast<DexMethod*>(DexMethod::make_method(method_name)); DexAccessFlags access_flags = static_cast<DexAccessFlags>(0); for (size_t i = 0; i < access_tokens.size(); ++i) { access_flags |= string_to_access_table.at(access_tokens[i].str()); } s_expr code_expr; s_patn({s_patn(code_expr)}, tail).match_with(tail); always_assert_log(code_expr.is_list(), "Expecting code listing"); bool is_virtual = !is_static(access_flags) && !is_private(access_flags); method->make_concrete( access_flags, ircode_from_s_expr(code_expr), is_virtual); return method; }
JSValueRef JSCExecutor::nativeStartWorker( JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) { if (argumentCount != 3) { *exception = createErrorString(ctx, "Got wrong number of args"); return JSValueMakeUndefined(ctx); } std::string scriptFile = Value(ctx, arguments[0]).toString().str(); JSValueRef worker = arguments[1]; JSValueRef globalObj = arguments[2]; JSCExecutor *executor; try { executor = s_globalContextRefToJSCExecutor.at(JSContextGetGlobalContext(ctx)); } catch (std::out_of_range& e) { *exception = createErrorString(ctx, "Global JS context didn't map to a valid executor"); return JSValueMakeUndefined(ctx); } int workerId = executor->addWebWorker(scriptFile, worker, globalObj); return JSValueMakeNumber(ctx, workerId); }
JSValueRef JSCExecutor::nativeTerminateWorker( JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) { if (argumentCount != 1) { *exception = createErrorString(ctx, "Got wrong number of args"); return JSValueMakeUndefined(ctx); } double workerDouble = JSValueToNumber(ctx, arguments[0], exception); if (workerDouble != workerDouble) { *exception = createErrorString(ctx, "Got invalid worker id"); return JSValueMakeUndefined(ctx); } JSCExecutor *executor; try { executor = s_globalContextRefToJSCExecutor.at(JSContextGetGlobalContext(ctx)); } catch (std::out_of_range& e) { *exception = createErrorString(ctx, "Global JS context didn't map to a valid executor"); return JSValueMakeUndefined(ctx); } executor->terminateOwnedWebWorker((int) workerDouble); return JSValueMakeUndefined(ctx); }
JSValueRef JSCExecutor::nativeRequire( JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) { if (argumentCount != 1) { *exception = makeJSCException(ctx, "Got wrong number of args"); return JSValueMakeUndefined(ctx); } JSCExecutor *executor; try { executor = s_globalContextRefToJSCExecutor.at(JSContextGetGlobalContext(ctx)); } catch (std::out_of_range& e) { *exception = makeJSCException(ctx, "Global JS context didn't map to a valid executor"); return JSValueMakeUndefined(ctx); } double moduleId = JSValueToNumber(ctx, arguments[0], exception); if (moduleId <= (double) std::numeric_limits<uint32_t>::max() && moduleId >= 0.0) { try { executor->loadModule(moduleId); } catch (JSModulesUnbundle::ModuleNotFound&) { *exception = makeInvalidModuleIdJSCException(ctx, arguments[0], exception); } } else { *exception = makeInvalidModuleIdJSCException(ctx, arguments[0], exception); } return JSValueMakeUndefined(ctx); }
JSValueRef JSCExecutor::nativeFlushQueueImmediate( JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) { if (argumentCount != 1) { *exception = createErrorString(ctx, "Got wrong number of args"); return JSValueMakeUndefined(ctx); } JSCExecutor *executor; try { executor = s_globalContextRefToJSCExecutor.at(JSContextGetGlobalContext(ctx)); } catch (std::out_of_range& e) { *exception = createErrorString(ctx, "Global JS context didn't map to a valid executor"); return JSValueMakeUndefined(ctx); } std::string resStr = Value(ctx, arguments[0]).toJSONString(); executor->flushQueueImmediate(resStr); return JSValueMakeUndefined(ctx); }
auto Graph<T, E>::dijkstra_min_edge(const std::vector<Node<T, E>>& s, const std::unordered_map<T, E>& weights) const { const T* min_node1 = nullptr; const T* min_node2 = nullptr; const E* min_weight = nullptr; for (const auto& s_node : s) { for (const auto& neighbor : s_node.neighbors) { const auto found = std::any_of(std::begin(s), std::end(s), [&neighbor] (const auto& n) { return neighbor.first == n.value; }); if (!found) { const auto weight = weights.at(s_node.value) + neighbor.second; if (min_node1 == nullptr || weight < *min_weight) { min_node1 = &s_node.value; min_node2 = &neighbor.first; min_weight = &neighbor.second; } } } } return std::make_tuple(*min_node1, *min_node2, *min_weight); }
TypeGroup groupOfType(const string& type) { if (isPlSqlType(type)) { return TYPES.at(type); } return TypeGroup::Unknown; }
/** * @brief Construct result, by packing process. */ void constructResult() { if (result.empty() == false) return; // 제품과 포장지 그룹, Product와 WrapperGroup의 1:1 매칭 for (size_t i = 0; i < size(); i++) { const std::shared_ptr<Wrapper> &wrapper = at(i); if (result.count(wrapper->key()) == 0) { WrapperGroup *wrapperGroup = new WrapperGroup(wrapper); result.insert({ wrapper->key(), std::shared_ptr<WrapperGroup>(wrapperGroup) }); } std::shared_ptr<WrapperGroup> wrapperGroup = result.at(wrapper->key()); std::shared_ptr<Instance> instance = instanceArray->at(i); if (wrapperGroup->allocate(instance) == false) { // 일개 제품 크기가 포장지보다 커서 포장할 수 없는 경우, // 현재의 염기서열은 유효하지 못하여 폐기됨 valid = false; return; } } // 유효한 염기서열일 때, for (auto it = result.begin(); it != result.end(); it++) { it->second->optimize(); // 세부적(그룹별)으로 bin-packing을 실시함 price += it->second->getPrice(); // 더불어 가격도 합산해둔다 } valid = true; };
/** * This function clears the queue statistics * @param ndi_port_id * @param ndi_queue_id * @param list of queue counter types to clear * @param number of queue counter types specified * return standard error */ t_std_error ndi_qos_clear_queue_stats(ndi_port_t ndi_port_id, ndi_obj_id_t ndi_queue_id, BASE_QOS_QUEUE_STAT_t *counter_ids, uint_t number_of_counters) { sai_status_t sai_ret = SAI_STATUS_FAILURE; nas_ndi_db_t *ndi_db_ptr = ndi_db_ptr_get(ndi_port_id.npu_id); if (ndi_db_ptr == NULL) { NDI_LOG_TRACE(ev_log_t_NDI, "NDI-QOS", "npu_id %d not exist\n", ndi_port_id.npu_id); return STD_ERR(QOS, CFG, 0); } std::vector<sai_queue_stat_counter_t> counter_id_list; std::vector<uint64_t> counters(number_of_counters); for (uint_t i= 0; i<number_of_counters; i++) { counter_id_list.push_back(nas2sai_queue_counter_type.at(counter_ids[i])); } if ((sai_ret = ndi_sai_qos_queue_api(ndi_db_ptr)-> clear_queue_stats(ndi2sai_queue_id(ndi_queue_id), &counter_id_list[0], number_of_counters)) != SAI_STATUS_SUCCESS) { NDI_LOG_TRACE(ev_log_t_NDI, "NDI-QOS", "queue clear stats fails: npu_id %u\n", ndi_port_id.npu_id); return STD_ERR(QOS, CFG, sai_ret); } return STD_ERR_OK; }
Reviewer_pp build(const std::string &profilename, const std::string &userid){ if (lookup.find(userid) != lookup.end()) return lookup.at(userid); Reviewer_pp p(new Reviewer(++idr,profilename, userid)); lookup[userid] = p; rm[p->id] = p; return p; }
void get_largest_graph_component (vertex_map_t &v, std::unordered_map <osm_id_t, int> &com, int &largest_id) { // initialize components map for (auto it = v.begin (); it != v.end (); ++ it) com.insert (std::make_pair (it -> first, -1)); std::unordered_set <osm_id_t> all_verts, component, nbs_todo, nbs_done; for (auto it = v.begin (); it != v.end (); ++ it) all_verts.insert (it -> first); osm_id_t vt = (*all_verts.begin ()); nbs_todo.insert (vt); int compnum = 0; while (all_verts.size () > 0) { vt = (*nbs_todo.begin ()); component.insert (vt); com.at (vt) = compnum; all_verts.erase (vt); osm_vertex_t vtx = v.find (vt)->second; std::unordered_set <osm_id_t> nbs = vtx.get_all_neighbours (); for (auto n: nbs) { component.insert (n); com.at (n) = compnum; if (nbs_done.find (n) == nbs_done.end ()) nbs_todo.insert (n); } nbs_done.insert (vt); nbs_todo.erase (vt); if (nbs_todo.size () == 0 && all_verts.size () > 0) { nbs_todo.insert (*all_verts.begin ()); compnum++; } } std::vector <int> comp_sizes (compnum, 0); for (auto c: com) comp_sizes [c.second]++; auto maxi = std::max_element (comp_sizes.begin (), comp_sizes.end ()); largest_id = std::distance (comp_sizes.begin (), maxi); //int maxsize = comp_sizes [largest_id]; }