void first(int x) { printf("%d ",x); if(L[x]) first(L[x]); if(R[x]) first(R[x]); }
void Board::load(std::string filename, bool _rearrange) { rearrange = _rearrange; load(filename); //Rearrange here // Get first 2 moves while(curr_node->x == -1 && curr_node->y == -1) next(); Point f(curr_node->x, curr_node->y); next(); Point s(curr_node->x, curr_node->y); /* Find its quadrant on the board 1 | 2 --.-- 4 | 3 */ int m = std::floor(size/2.0); int bfirst = 2; int bsecond = 4; if (f.x < m && f.y < m) bfirst = 1; if (f.x >= m && f.y < m) bfirst = 2; if (f.x >= m && f.y >= m) bfirst = 3; if (f.x < m && f.y >= m) bfirst = 4; if (s.x < m && s.y < m) bsecond = 1; if (s.x >= m && s.y < m) bsecond = 2; if (s.x >= m && s.y >= m) bsecond = 3; if (s.x < m && s.y >= m) bsecond = 4; switch(bfirst){ case 1: if (bsecond == 1 || bsecond == 2) rotate = 1; else if (bsecond == 3 || bsecond == 4) flipH = true; break; case 2: if (bsecond == 1){ rotate = 1; flipV = true; } break; case 3: if (bsecond == 1) rotate = -1; else if (bsecond == 2) flipV = true; else if (bsecond == 3) flipV = true; else if (bsecond == 4) rotate = -1; break; case 4: if (bsecond == 1 || bsecond == 2 || bsecond == 4){ flipV = true; flipH = true; } else if (bsecond == 3){ rotate = 1; flipH = true; } break; default: break; } // first(); }
u64 bt_first (BtTree_s *tree) { return first(tree->root); }
/* Activate pending timers, returning how many where activated. */ int QTimerInfoList::activateTimers() { if (qt_disable_lowpriority_timers || isEmpty()) return 0; // nothing to do bool firstTime = true; timeval currentTime; int n_act = 0, maxCount = count(); QTimerInfo *saveFirstTimerInfo = firstTimerInfo; QTimerInfo *saveCurrentTimerInfo = currentTimerInfo; firstTimerInfo = currentTimerInfo = 0; while (maxCount--) { currentTime = updateCurrentTime(); if (firstTime) { repairTimersIfNeeded(); firstTime = false; } if (isEmpty()) break; currentTimerInfo = first(); if (currentTime < currentTimerInfo->timeout) break; // no timer has expired if (!firstTimerInfo) { firstTimerInfo = currentTimerInfo; } else if (firstTimerInfo == currentTimerInfo) { // avoid sending the same timer multiple times break; } else if (currentTimerInfo->interval < firstTimerInfo->interval || currentTimerInfo->interval == firstTimerInfo->interval) { firstTimerInfo = currentTimerInfo; } // remove from list removeFirst(); // determine next timeout time currentTimerInfo->timeout += currentTimerInfo->interval; if (currentTimerInfo->timeout < currentTime) currentTimerInfo->timeout = currentTime + currentTimerInfo->interval; // reinsert timer timerInsert(currentTimerInfo); if (currentTimerInfo->interval.tv_usec > 0 || currentTimerInfo->interval.tv_sec > 0) n_act++; if (!currentTimerInfo->inTimerEvent) { // send event, but don't allow it to recurse currentTimerInfo->inTimerEvent = true; QTimerEvent e(currentTimerInfo->id); QCoreApplication::sendEvent(currentTimerInfo->obj, &e); if (currentTimerInfo) currentTimerInfo->inTimerEvent = false; } } firstTimerInfo = saveFirstTimerInfo; currentTimerInfo = saveCurrentTimerInfo; return n_act; }
int __malloc_set_state (void *msptr) { struct malloc_save_state *ms = (struct malloc_save_state *) msptr; size_t i; mbinptr b; disallow_malloc_check = 1; ptmalloc_init (); if (ms->magic != MALLOC_STATE_MAGIC) return -1; /* Must fail if the major version is too high. */ if ((ms->version & ~0xffl) > (MALLOC_STATE_VERSION & ~0xffl)) return -2; (void) mutex_lock (&main_arena.mutex); /* There are no fastchunks. */ clear_fastchunks (&main_arena); if (ms->version >= 4) set_max_fast (ms->max_fast); else set_max_fast (64); /* 64 used to be the value we always used. */ for (i = 0; i < NFASTBINS; ++i) fastbin (&main_arena, i) = 0; for (i = 0; i < BINMAPSIZE; ++i) main_arena.binmap[i] = 0; top (&main_arena) = ms->av[2]; main_arena.last_remainder = 0; for (i = 1; i < NBINS; i++) { b = bin_at (&main_arena, i); if (ms->av[2 * i + 2] == 0) { assert (ms->av[2 * i + 3] == 0); first (b) = last (b) = b; } else { if (ms->version >= 3 && (i < NSMALLBINS || (largebin_index (chunksize (ms->av[2 * i + 2])) == i && largebin_index (chunksize (ms->av[2 * i + 3])) == i))) { first (b) = ms->av[2 * i + 2]; last (b) = ms->av[2 * i + 3]; /* Make sure the links to the bins within the heap are correct. */ first (b)->bk = b; last (b)->fd = b; /* Set bit in binblocks. */ mark_bin (&main_arena, i); } else { /* Oops, index computation from chunksize must have changed. Link the whole list into unsorted_chunks. */ first (b) = last (b) = b; b = unsorted_chunks (&main_arena); ms->av[2 * i + 2]->bk = b; ms->av[2 * i + 3]->fd = b->fd; b->fd->bk = ms->av[2 * i + 3]; b->fd = ms->av[2 * i + 2]; } } } if (ms->version < 3) { /* Clear fd_nextsize and bk_nextsize fields. */ b = unsorted_chunks (&main_arena)->fd; while (b != unsorted_chunks (&main_arena)) { if (!in_smallbin_range (chunksize (b))) { b->fd_nextsize = NULL; b->bk_nextsize = NULL; } b = b->fd; } } mp_.sbrk_base = ms->sbrk_base; main_arena.system_mem = ms->sbrked_mem_bytes; mp_.trim_threshold = ms->trim_threshold; mp_.top_pad = ms->top_pad; mp_.n_mmaps_max = ms->n_mmaps_max; mp_.mmap_threshold = ms->mmap_threshold; check_action = ms->check_action; main_arena.max_system_mem = ms->max_sbrked_mem; mp_.n_mmaps = ms->n_mmaps; mp_.max_n_mmaps = ms->max_n_mmaps; mp_.mmapped_mem = ms->mmapped_mem; mp_.max_mmapped_mem = ms->max_mmapped_mem; /* add version-dependent code here */ if (ms->version >= 1) { /* Check whether it is safe to enable malloc checking, or whether it is necessary to disable it. */ if (ms->using_malloc_checking && !using_malloc_checking && !disallow_malloc_check) __malloc_check_init (); else if (!ms->using_malloc_checking && using_malloc_checking) { __malloc_hook = NULL; __free_hook = NULL; __realloc_hook = NULL; __memalign_hook = NULL; using_malloc_checking = 0; } } if (ms->version >= 4) { mp_.arena_test = ms->arena_test; mp_.arena_max = ms->arena_max; narenas = ms->narenas; } check_malloc_state (&main_arena); (void) mutex_unlock (&main_arena.mutex); return 0; }
void create_widget(const dictionary_t& parameters, size_enum_t, listbox_t*& listbox) { std::string name; std::string alt_text; long characters(25); long rows(0); bool sort(false); name_t sort_order("ascending"); name_t selections("single"); bool user_delete(false); bool browse_updates(false); array_t items; listbox_t::item_set_t item_set; GG::Clr color(GG::CLR_GRAY); GG::Clr interior_color(GG::CLR_ZERO); GG::Clr hilite_color(GG::CLR_SHADOW); GG::Clr label_color(GG::CLR_BLACK); GG::Clr item_text_color(GG::CLR_BLACK); name_t signal_id; array_t allowed_drop_types; implementation::get_localized_string(parameters, key_name, name); implementation::get_localized_string(parameters, key_alt_text, alt_text); get_value(parameters, key_characters, characters); get_value(parameters, static_name_t("rows"), rows); get_value(parameters, static_name_t("sort"), sort); get_value(parameters, static_name_t("sort_order"), sort_order); get_value(parameters, static_name_t("selections"), selections); get_value(parameters, static_name_t("user_delete"), user_delete); get_value(parameters, static_name_t("browse_updates"), browse_updates); get_value(parameters, key_items, items); implementation::get_color(parameters, static_name_t("color"), color); implementation::get_color(parameters, static_name_t("interior_color"), interior_color); implementation::get_color(parameters, static_name_t("hilite_color"), hilite_color); implementation::get_color(parameters, static_name_t("label_color"), label_color); implementation::get_color(parameters, static_name_t("item_text_color"), item_text_color); get_value(parameters, static_name_t("signal_id"), signal_id); get_value(parameters, static_name_t("allowed_drop_types"), allowed_drop_types); GG::Flags<GG::ListBoxStyle> style; if (!sort) style |= GG::LIST_NOSORT; get_sort_order_style(sort_order, style); get_selection_style(selections, style); if (user_delete) style |= GG::LIST_USERDELETE; if (browse_updates) style |= GG::LIST_BROWSEUPDATES; for (array_t::iterator first(items.begin()), last(items.end()); first != last; ++first) { item_set.push_back(any_regular_t(first->cast<dictionary_t>())); dictionary_t& back = item_set.back().cast<dictionary_t>(); get_value(back, key_value); dictionary_t::iterator it = back.find(key_name); if (it != back.end() && it->second.type_info() == type_info<adobe::string_t>()) { it->second.assign(localization_invoke(it->second.cast<std::string>())); } } if (!rows && items.empty()) rows = 8; std::vector<std::string> drop_types; for (array_t::iterator first(allowed_drop_types.begin()), last(allowed_drop_types.end()); first != last; ++first) { drop_types.push_back(first->cast<std::string>()); } listbox = new listbox_t(name, alt_text, characters, rows, style, item_set, color, interior_color, hilite_color, label_color, item_text_color, drop_types, signal_id); }
BPolygon::BPolygon(const QVector<QPointF> & points): QPolygonF(points) { if(size() > 3 && first() == last()) pop_back(); }
void VolumeCollection::clear() { while (!empty()) remove(first()); }
extern void run(OpenCVWindow * window) try{ const auto images_names= CoreUtility::getConfigurationFile().getInputImagesNames("images:000001"); assert(images_names.size()); QImage image_input(images_names.first()); image_input=image_input.convertToFormat(QImage::Format_Grayscale8); window->insertImage(image_input)->setWindowTitle(u8"原始图像"_qs); cv::Mat mat_input=OpenCVUtility::tryRead(image_input); assert( mat_input.channels() == 1 )/*这应当是一个灰度图像*/; /*计算获得dft变换所需要的长宽*/ auto height_ = cv::getOptimalDFTSize(mat_input.rows); auto width_ = cv::getOptimalDFTSize(mat_input.cols); cv::Mat dft_real; /*扩展边界*/ cv::copyMakeBorder(mat_input,dft_real, 0/*top*/,height_-mat_input.rows/*bottom*/, 0/*left*/,width_-mat_input.cols/*right*/, cv::BORDER_CONSTANT,cv::Scalar::all(0) ); dft_real.convertTo(dft_real,CV_64FC1); cv::Mat dft_imag=cv::Mat::zeros(dft_real.size(),CV_64FC1); { cv::Mat dft_output; cv::merge( std::vector<cv::Mat>{ dft_real,dft_imag}, dft_output); /*进行dft变换*/ cv::dft(dft_output,dft_output); cv::split(dft_output,std::vector<cv::Mat>{ dft_real,dft_imag}); } cv::Mat magI ; cv::magnitude(dft_real,dft_imag,magI); magI+=1; cv::log(magI,magI);//取对数 magI= magI(cv::Rect(0,0,width_,height_)); cv::normalize(magI,magI,0,255,CV_MINMAX); window->insertImage( OpenCVUtility::tryRead(magI ) ) ->setWindowTitle(u8"变换后图像"_qs); { const auto w_2=width_/2; const auto h_2=height_/2; cv::Mat q0(magI,cv::Rect(0,0,w_2,h_2)); cv::Mat q1(magI,cv::Rect(w_2,0,w_2,h_2)); cv::Mat q2(magI,cv::Rect(0,h_2,w_2,h_2)); cv::Mat q3(magI,cv::Rect(w_2,h_2,w_2,h_2)); cv::flip(q0,q0,-1); cv::flip(q1,q1,-1); cv::flip(q2,q2,-1); cv::flip(q3,q3,-1); } window->insertImage( OpenCVUtility::tryRead(magI ) ) ->setWindowTitle(u8"中心化后图像"_qs); } catch (const cv::Exception &e) { opencv_exception::error(e,"get opencv exception",opencv_line(),opencv_file(),opencv_func()); }
/* * Insert an item in the list, but only if it is unique * otherwise, the item is returned non inserted * * Returns: item if item inserted * other_item if same value already exists (item not inserted) */ void *dlist::binary_insert(void *item, int compare(void *item1, void *item2)) { int comp; int low, high, cur; void *cur_item; if (num_items == 0) { //Dmsg0(000, "Append first.\n"); append(item); return item; } if (num_items == 1) { comp = compare(item, first()); if (comp < 0) { prepend(item); //Dmsg0(000, "Insert before first.\n"); return item; } else if (comp > 0) { insert_after(item, first()); //Dmsg0(000, "Insert after first.\n"); return item; } else { //Dmsg0(000, "Same as first.\n"); return first(); } } /* Check against last item */ comp = compare(item, last()); if (comp > 0) { append(item); //Dmsg0(000, "Appended item.\n"); return item; } else if (comp == 0) { //Dmsg0(000, "Same as last.\n"); return last(); } /* Check against first item */ comp = compare(item, first()); if (comp < 0) { prepend(item); //Dmsg0(000, "Inserted item before.\n"); return item; } else if (comp == 0) { //Dmsg0(000, "Same as first.\n"); return first(); } if (num_items == 2) { insert_after(item, first()); //Dmsg0(000, "Inserted item after.\n"); return item; } low = 1; high = num_items; cur = 1; cur_item = first(); while (low < high) { int nxt; nxt = (low + high) / 2; while (nxt > cur) { cur_item = next(cur_item); cur++; } while (nxt < cur) { cur_item = prev(cur_item); cur--; } //Dmsg1(000, "Compare item to %d\n", cur); comp = compare(item, cur_item); //Dmsg2(000, "Compare item to %d = %d\n", cur, comp); if (comp < 0) { high = cur; //Dmsg2(000, "set high; low=%d high=%d\n", low, high); } else if (comp > 0) { low = cur + 1; //Dmsg2(000, "set low; low=%d high=%d\n", low, high); } else { //Dmsg1(000, "Same as item %d\n", cur); return cur_item; } } if (high == cur) { insert_before(item, cur_item); //Dmsg1(000, "Insert before item %d\n", cur); } else { insert_after(item, cur_item); //Dmsg1(000, "Insert after item %d\n", cur); } return item; }
/* * Search for item */ void *dlist::binary_search(void *item, int compare(void *item1, void *item2)) { int comp; int low, high, cur; void *cur_item; if (num_items == 0) { return NULL; } cur_item = first(); if (num_items == 1) { comp = compare(item, cur_item); if (comp == 0) { return cur_item; } else { return NULL; } } low = 1; high = num_items; cur = 1; cur_item = first(); while (low < high) { int nxt; nxt = (low + high) / 2; /* Now get cur pointing to nxt */ while (nxt > cur) { cur_item = next(cur_item); cur++; } while (nxt < cur) { cur_item = prev(cur_item); cur--; } comp = compare(item, cur_item); //Dmsg2(000, "Compare item to %d = %d\n", cur, comp); if (comp < 0) { high = cur; //Dmsg2(000, "set high; low=%d high=%d\n", low, high); } else if (comp > 0) { low = cur + 1; //Dmsg2(000, "set low; low=%d high=%d\n", low, high); } else { return cur_item; } } /* * low == high can only happen if low just * got incremented from cur, and we have * not yet tested cur+1 */ if (low == high) { cur_item = next(cur_item); comp = compare(item, cur_item); if (comp == 0) { return cur_item; } } return NULL; }
void PILISModelGenerator::getModel(HiddenMarkovModel& model) { UInt visible_model_depth = (UInt)param_.getValue("visible_model_depth"); UInt model_depth = (UInt)param_.getValue("model_depth"); model.addNewState(new HMMState("endcenter", false)); model.addNewState(new HMMState("end", false)); model.addNewState("BBcenter"); model.addNewState("AAcenter"); model.addNewState("CRcenter"); model.addNewState("Acenter"); model.addNewState("SCcenter"); model.addNewState("ASCcenter"); model.addNewState(new HMMState("axyz_center-prefix-ions", false)); model.addNewState(new HMMState("axyz_center-suffix-ions", false)); model.addNewState(new HMMState("axyz_center-prefix")); model.addNewState(new HMMState("axyz_center-suffix")); model.addNewState(new HMMState("bxyz_center-prefix-ions", false)); model.addNewState(new HMMState("bxyz_center-suffix-ions", false)); model.addNewState(new HMMState("bxyz_center-prefix")); model.addNewState(new HMMState("bxyz_center-suffix")); model.addNewState(new HMMState("D_center-prefix-ions", false)); model.addNewState(new HMMState("D_center-suffix-ions", false)); model.addNewState(new HMMState("D_center-prefix")); model.addNewState(new HMMState("D_center-suffix")); model.addNewState(new HMMState("E_center-prefix-ions", false)); model.addNewState(new HMMState("E_center-suffix-ions", false)); model.addNewState(new HMMState("E_center-prefix")); model.addNewState(new HMMState("E_center-suffix")); model.addNewState(new HMMState("K_center-prefix-ions", false)); model.addNewState(new HMMState("K_center-suffix-ions", false)); model.addNewState(new HMMState("K_center-prefix")); model.addNewState(new HMMState("K_center-suffix")); model.addNewState(new HMMState("R_center-prefix-ions", false)); model.addNewState(new HMMState("R_center-suffix-ions", false)); model.addNewState(new HMMState("R_center-prefix")); model.addNewState(new HMMState("R_center-suffix")); model.addNewState(new HMMState("H_center-prefix-ions", false)); model.addNewState(new HMMState("H_center-suffix-ions", false)); model.addNewState(new HMMState("H_center-prefix")); model.addNewState(new HMMState("H_center-suffix")); model.addNewState("bxyz"); model.addNewState("axyz"); model.addNewState("D"); model.addNewState("E"); model.addNewState("AABase1"); model.addNewState("AABase2"); model.addNewState("K"); model.addNewState("H"); model.addNewState("R"); // set<const Residue*> residues(ResidueDB::getInstance()->getResidues("Natural20")); StringList variable_modifications = param_.getValue("variable_modifications"); for (StringList::const_iterator it = variable_modifications.begin(); it != variable_modifications.end(); ++it) { residues.insert(ResidueDB::getInstance()->getModifiedResidue(*it)); } cerr << "Using " << residues.size() << " residues" << endl; //const String residues("ACDEFGHIKLMNPQRSTVWY"); // create the residue states states for (set<const Residue*>::const_iterator it = residues.begin(); it != residues.end(); ++it) { AASequence first_aa; first_aa += *it; String first(first_aa.toString()); model.addNewState(first + "_D"); model.addNewState(first + "_E"); model.addNewState(first + "_K"); model.addNewState(first + "_H"); model.addNewState(first + "_R"); for (set<const Residue*>::const_iterator jt = residues.begin(); jt != residues.end(); ++jt) { AASequence second_aa; second_aa += *jt; String second(second_aa.toString()); model.addNewState(first + second + "_bxyz"); model.addNewState(first + second + "_axyz"); } model.addNewState(first + "_bk-1"); model.addNewState(first + "_bk-2"); } model.addNewState("bk-1"); model.addNewState("bk-2"); model.addNewState(new HMMState("bk-1_-ions", false)); model.addNewState(new HMMState("bk-2_-ions", false)); model.addNewState(new HMMState("bk-1_-prefix-ions", false)); model.addNewState(new HMMState("bk-1_-suffix-ions", false)); model.addNewState(new HMMState("bk-1_-prefix")); model.addNewState(new HMMState("bk-1_-suffix")); model.addNewState(new HMMState("bk-2_-prefix-ions", false)); model.addNewState(new HMMState("bk-2_-suffix-ions", false)); model.addNewState(new HMMState("bk-2_-prefix")); model.addNewState(new HMMState("bk-2_-suffix")); for (Size i = 1; i <= visible_model_depth; ++i) { // these states are really created // charge states String num(i); model.addNewState("BB" + num); model.addNewState("BBk-" + num); model.addNewState("CR" + num); model.addNewState("CRk-" + num); model.addNewState("SC" + num); model.addNewState("SCk-" + num); // states for trans mapping model.addNewState("AA" + num); model.addNewState("AAk-" + num); model.addNewState("A" + num); model.addNewState("Ak-" + num); model.addNewState("ASC" + num); model.addNewState("ASCk-" + num); // emitting ion states model.addNewState(new HMMState("axyz_" + num + "-prefix-ions", false)); model.addNewState(new HMMState("axyz_" + num + "-suffix-ions", false)); model.addNewState(new HMMState("axyz_" + num + "-prefix")); model.addNewState(new HMMState("axyz_" + num + "-suffix")); model.addNewState(new HMMState("axyz_k-" + num + "-prefix-ions", false)); model.addNewState(new HMMState("axyz_k-" + num + "-suffix-ions", false)); model.addNewState(new HMMState("axyz_k-" + num + "-prefix")); model.addNewState(new HMMState("axyz_k-" + num + "-suffix")); model.addNewState(new HMMState("bxyz_" + num + "-prefix-ions", false)); model.addNewState(new HMMState("bxyz_" + num + "-suffix-ions", false)); model.addNewState(new HMMState("bxyz_" + num + "-prefix")); model.addNewState(new HMMState("bxyz_" + num + "-suffix")); model.addNewState(new HMMState("bxyz_k-" + num + "-prefix-ions", false)); model.addNewState(new HMMState("bxyz_k-" + num + "-suffix-ions", false)); model.addNewState(new HMMState("bxyz_k-" + num + "-prefix")); model.addNewState(new HMMState("bxyz_k-" + num + "-suffix")); String sc_and_cr("DEHKR"); for (String::ConstIterator it = sc_and_cr.begin(); it != sc_and_cr.end(); ++it) { String aa(*it); model.addNewState(new HMMState(aa + "_" + num + "-prefix-ions", false)); model.addNewState(new HMMState(aa + "_" + num + "-suffix-ions", false)); model.addNewState(new HMMState(aa + "_" + num + "-prefix")); model.addNewState(new HMMState(aa + "_" + num + "-suffix")); model.addNewState(new HMMState(aa + "_k-" + num + "-prefix-ions", false)); model.addNewState(new HMMState(aa + "_k-" + num + "-suffix-ions", false)); model.addNewState(new HMMState(aa + "_k-" + num + "-prefix")); model.addNewState(new HMMState(aa + "_k-" + num + "-suffix")); } model.addNewState(new HMMState("end" + num, false)); model.addNewState(new HMMState("endk-" + num, false)); // post AA collector states model.addNewState("bxyz" + num); model.addNewState("bxyzk-" + num); model.addNewState("axyz" + num); model.addNewState("axyzk-" + num); model.addNewState("D" + num); model.addNewState("Dk-" + num); model.addNewState("E" + num); model.addNewState("Ek-" + num); model.addNewState("K" + num); model.addNewState("Kk-" + num); model.addNewState("H" + num); model.addNewState("Hk-" + num); model.addNewState("R" + num); model.addNewState("Rk-" + num); // map the residue states for (set<const Residue*>::const_iterator it = residues.begin(); it != residues.end(); ++it) { AASequence first_aa; first_aa += *it; String first(first_aa.toString()); model.addNewState(first + "_D" + num); model.addNewState(first + "_Dk-" + num); model.addNewState(first + "_E" + num); model.addNewState(first + "_Ek-" + num); model.addNewState(first + "_K" + num); model.addNewState(first + "_Kk-" + num); model.addNewState(first + "_H" + num); model.addNewState(first + "_Hk-" + num); model.addNewState(first + "_R" + num); model.addNewState(first + "_Rk-" + num); for (set<const Residue*>::const_iterator jt = residues.begin(); jt != residues.end(); ++jt) { AASequence second_aa; second_aa += *jt; String second(second_aa.toString()); model.addNewState(first + second + "_bxyz" + num); model.addNewState(first + second + "_bxyzk-" + num); model.addNewState(first + second + "_axyz" + num); model.addNewState(first + second + "_axyzk-" + num); } } } model.setTransitionProbability("AABase1", "AABase2", 1); // CR bk-1, bk-2 for (set<const Residue*>::const_iterator it = residues.begin(); it != residues.end(); ++it) { AASequence first_aa; first_aa += *it; String first(first_aa.toString()); model.addSynonymTransition("AABase1", "AABase2", "Ak-1", first + "_bk-1"); model.setTransitionProbability(first + "_bk-1", "bk-1", 0.5); model.setTransitionProbability(first + "_bk-1", "endk-1", 0.5); model.addSynonymTransition("AABase1", "AABase2", "Ak-2", first + "_bk-2"); model.setTransitionProbability(first + "_bk-2", "bk-2", 0.5); model.setTransitionProbability(first + "_bk-2", "endk-2", 0.5); } model.setTransitionProbability("bk-1_-prefix", "bk-1_-prefix-ions", 0.9); model.setTransitionProbability("bk-1_-prefix", "endk-1", 0.1); model.setTransitionProbability("bk-1_-suffix", "bk-1_-suffix-ions", 0.9); model.setTransitionProbability("bk-1_-suffix", "endk-1", 0.1); model.setTransitionProbability("bk-2_-prefix", "bk-2_-prefix-ions", 0.9); model.setTransitionProbability("bk-2_-prefix", "endk-1", 0.1); model.setTransitionProbability("bk-2_-suffix", "bk-2_-suffix-ions", 0.9); model.setTransitionProbability("bk-2_-suffix", "endk-1", 0.1); // set the initial transitions for (Size i = 1; i <= visible_model_depth; ++i) { String num(i); if (i <= model_depth) { model.setTransitionProbability("axyz_" + num + "-prefix", "axyz_" + num + "-prefix-ions", 0.9); model.setTransitionProbability("axyz_" + num + "-prefix", "end" + num, 0.1); model.setTransitionProbability("axyz_" + num + "-suffix", "axyz_" + num + "-suffix-ions", 0.9); model.setTransitionProbability("axyz_" + num + "-suffix", "end" + num, 0.1); model.setTransitionProbability("axyz_k-" + num + "-prefix", "axyz_k-" + num + "-prefix-ions", 0.9); model.setTransitionProbability("axyz_k-" + num + "-prefix", "endk-" + num, 0.1); model.setTransitionProbability("axyz_k-" + num + "-suffix", "axyz_k-" + num + "-suffix-ions", 0.9); model.setTransitionProbability("axyz_k-" + num + "-suffix", "endk-" + num, 0.1); model.setTransitionProbability("bxyz_" + num + "-prefix", "bxyz_" + num + "-prefix-ions", 0.9); model.setTransitionProbability("bxyz_" + num + "-prefix", "end" + num, 0.1); model.setTransitionProbability("bxyz_" + num + "-suffix", "bxyz_" + num + "-suffix-ions", 0.9); model.setTransitionProbability("bxyz_" + num + "-suffix", "end" + num, 0.1); model.setTransitionProbability("bxyz_k-" + num + "-prefix", "bxyz_k-" + num + "-prefix-ions", 0.9); model.setTransitionProbability("bxyz_k-" + num + "-prefix", "endk-" + num, 0.1); model.setTransitionProbability("bxyz_k-" + num + "-suffix", "bxyz_k-" + num + "-suffix-ions", 0.9); model.setTransitionProbability("bxyz_k-" + num + "-suffix", "endk-" + num, 0.1); String sc_and_cr("DEHRK"); for (String::ConstIterator it = sc_and_cr.begin(); it != sc_and_cr.end(); ++it) { String aa(*it); model.setTransitionProbability(aa + "_" + num + "-prefix", aa + "_" + num + "-prefix-ions", 0.9); model.setTransitionProbability(aa + "_" + num + "-prefix", "end" + num, 0.1); model.setTransitionProbability(aa + "_" + num + "-suffix", aa + "_" + num + "-suffix-ions", 0.9); model.setTransitionProbability(aa + "_" + num + "-suffix", "end" + num, 0.1); model.setTransitionProbability(aa + "_k-" + num + "-prefix", aa + "_k-" + num + "-prefix-ions", 0.9); model.setTransitionProbability(aa + "_k-" + num + "-prefix", "endk-" + num, 0.1); model.setTransitionProbability(aa + "_k-" + num + "-suffix", aa + "_k-" + num + "-suffix-ions", 0.9); model.setTransitionProbability(aa + "_k-" + num + "-suffix", "endk-" + num, 0.1); } model.setTransitionProbability("BB" + num, "end" + num, 0.5); model.setTransitionProbability("BBk-" + num, "endk-" + num, 0.5); model.setTransitionProbability("SC" + num, "end" + num, 0.5); model.setTransitionProbability("SCk-" + num, "endk-" + num, 0.5); model.setTransitionProbability("CR" + num, "end" + num, 0.5); model.setTransitionProbability("CRk-" + num, "endk-" + num, 0.5); model.setTransitionProbability("BB" + num, "AA" + num, 0.5); model.setTransitionProbability("BBk-" + num, "AAk-" + num, 0.5); model.setTransitionProbability("CR" + num, "A" + num, 0.5); model.setTransitionProbability("CRk-" + num, "Ak-" + num, 0.5); model.setTransitionProbability("SC" + num, "ASC" + num, 0.5); model.setTransitionProbability("SCk-" + num, "ASCk-" + num, 0.5); } else { model.addSynonymTransition("axyz_center-prefix", "axyz_center-prefix-ions", "axyz_" + num + "-prefix", "axyz_" + num + "-prefix-ions"); model.addSynonymTransition("axyz_center-prefix", "endcenter", "axyz_" + num + "-prefix", "end" + num); model.addSynonymTransition("axyz_center-suffix", "axyz_center-suffix-ions", "axyz_" + num + "-suffix", "axyz_" + num + "-suffix-ions"); model.addSynonymTransition("axyz_center-suffix", "endcenter", "axyz_" + num + "-suffix", "end" + num); model.addSynonymTransition("axyz_center-prefix", "axyz_center-prefix-ions", "axyz_k-" + num + "-prefix", "axyz_k-" + num + "-prefix-ions"); model.addSynonymTransition("axyz_center-prefix", "endcenter", "axyz_k-" + num + "-prefix", "endk-" + num); model.addSynonymTransition("axyz_center-suffix", "axyz_center-suffix-ions", "axyz_k-" + num + "-suffix", "axyz_k-" + num + "-suffix-ions"); model.addSynonymTransition("axyz_center-suffix", "endcenter", "axyz_k-" + num + "-suffix", "endk-" + num); model.addSynonymTransition("bxyz_center-prefix", "bxyz_center-prefix-ions", "bxyz_" + num + "-prefix", "bxyz_" + num + "-prefix-ions"); model.addSynonymTransition("bxyz_center-prefix", "endcenter", "bxyz_" + num + "-prefix", "end" + num); model.addSynonymTransition("bxyz_center-suffix", "bxyz_center-suffix-ions", "bxyz_" + num + "-suffix", "bxyz_" + num + "-suffix-ions"); model.addSynonymTransition("bxyz_center-suffix", "endcenter", "bxyz_" + num + "-suffix", "end" + num); model.addSynonymTransition("bxyz_center-prefix", "bxyz_center-prefix-ions", "bxyz_k-" + num + "-prefix", "bxyz_k-" + num + "-prefix-ions"); model.addSynonymTransition("bxyz_center-prefix", "endcenter", "bxyz_k-" + num + "-prefix", "endk-" + num); model.addSynonymTransition("bxyz_center-suffix", "bxyz_center-suffix-ions", "bxyz_k-" + num + "-suffix", "bxyz_k-" + num + "-suffix-ions"); model.addSynonymTransition("bxyz_center-suffix", "endcenter", "bxyz_k-" + num + "-suffix", "endk-" + num); String sc_and_cr("DEHRK"); for (String::ConstIterator it = sc_and_cr.begin(); it != sc_and_cr.end(); ++it) { String aa(*it); model.addSynonymTransition(aa + "_center-prefix", aa + "_center-prefix-ions", aa + "_" + num + "-prefix", aa + "_" + num + "-prefix-ions"); model.addSynonymTransition(aa + "_center-prefix", "endcenter", aa + "_" + num + "-prefix", "end" + num); model.addSynonymTransition(aa + "_center-prefix", aa + "_center-prefix-ions", aa + "_k-" + num + "-prefix", aa + "_k-" + num + "-prefix-ions"); model.addSynonymTransition(aa + "_center-prefix", "endcenter", aa + "_k-" + num + "-prefix", "endk-" + num); model.addSynonymTransition(aa + "_center-suffix", aa + "_center-suffix-ions", aa + "_" + num + "-suffix", aa + "_" + num + "-suffix-ions"); model.addSynonymTransition(aa + "_center-suffix", "endcenter", aa + "_" + num + "-suffix", "end" + num); model.addSynonymTransition(aa + "_center-suffix", aa + "_center-suffix-ions", aa + "_k-" + num + "-suffix", aa + "_k-" + num + "-suffix-ions"); model.addSynonymTransition(aa + "_center-suffix", "endcenter", aa + "_k-" + num + "-suffix", "endk-" + num); } model.addSynonymTransition("BBcenter", "endcenter", "BB" + num, "end" + num); model.addSynonymTransition("BBcenter", "endcenter", "BBk-" + num, "endk-" + num); model.setTransitionProbability("BBcenter", "endcenter", 0.5); model.addSynonymTransition("CRcenter", "endcenter", "CR" + num, "end" + num); model.addSynonymTransition("CRcenter", "endcenter", "CRk-" + num, "endk-" + num); model.setTransitionProbability("CRcenter", "endcenter", 0.5); model.addSynonymTransition("SCcenter", "endcenter", "SC" + num, "end" + num); model.addSynonymTransition("SCcenter", "endcenter", "SCk-" + num, "endk-" + num); model.setTransitionProbability("SCcenter", "endcenter", 0.5); model.addSynonymTransition("BBcenter", "AAcenter", "BB" + num, "AA" + num); model.addSynonymTransition("BBcenter", "AAcenter", "BBk-" + num, "AAk-" + num); model.setTransitionProbability("BBcenter", "AAcenter", 0.5); model.addSynonymTransition("CRcenter", "Acenter", "CR" + num, "A" + num); model.addSynonymTransition("CRcenter", "Acenter", "CRk-" + num, "Ak-" + num); model.setTransitionProbability("CRcenter", "Acenter", 0.5); model.addSynonymTransition("SCcenter", "ASCcenter", "SC" + num, "ASC" + num); model.addSynonymTransition("SCcenter", "ASCcenter", "SCk-" + num, "ASCk-" + num); model.setTransitionProbability("SCcenter", "ASCcenter", 0.5); } for (set<const Residue*>::const_iterator it = residues.begin(); it != residues.end(); ++it) { AASequence first_aa; first_aa += *it; String first(first_aa.toString()); // CR D model.addSynonymTransition("AABase1", "AABase2", "A" + num, first + "_D" + num); model.addSynonymTransition("AABase1", "AABase2", "Ak-" + num, first + "_Dk-" + num); model.addSynonymTransition(first + "_D", "D", first + "_D" + num, "D" + num); model.addSynonymTransition(first + "_D", "end", first + "_D" + num, "end" + num); model.addSynonymTransition(first + "_D", "D", first + "_Dk-" + num, "Dk-" + num); model.addSynonymTransition(first + "_D", "end", first + "_Dk-" + num, "endk-" + num); model.setTransitionProbability(first + "_D", "D", 0.5); model.setTransitionProbability(first + "_D", "end", 0.5); // CR E model.addSynonymTransition("AABase1", "AABase2", "A" + num, first + "_E" + num); model.addSynonymTransition("AABase1", "AABase2", "Ak-" + num, first + "_Ek-" + num); model.addSynonymTransition(first + "_E", "E", first + "_E" + num, "E" + num); model.addSynonymTransition(first + "_E", "end", first + "_E" + num, "end" + num); model.addSynonymTransition(first + "_E", "E", first + "_Ek-" + num, "Ek-" + num); model.addSynonymTransition(first + "_E", "end", first + "_Ek-" + num, "endk-" + num); model.setTransitionProbability(first + "_E", "E", 0.5); model.setTransitionProbability(first + "_E", "end", 0.5); // SC K model.addSynonymTransition("AABase1", "AABase2", "ASC" + num, first + "_K" + num); model.addSynonymTransition("AABase1", "AABase2", "ASCk-" + num, first + "_Kk-" + num); model.addSynonymTransition(first + "_K", "K", first + "_K" + num, "K" + num); model.addSynonymTransition(first + "_K", "end", first + "_K" + num, "end" + num); model.addSynonymTransition(first + "_K", "K", first + "_Kk-" + num, "Kk-" + num); model.addSynonymTransition(first + "_K", "end", first + "_Kk-" + num, "endk-" + num); model.setTransitionProbability(first + "_K", "K", 0.5); model.setTransitionProbability(first + "_K", "end", 0.5); // SC H model.addSynonymTransition("AABase1", "AABase2", "ASC" + num, first + "_H" + num); model.addSynonymTransition("AABase1", "AABase2", "ASCk-" + num, first + "_Hk-" + num); model.addSynonymTransition(first + "_H", "H", first + "_H" + num, "H" + num); model.addSynonymTransition(first + "_H", "end", first + "_H" + num, "end" + num); model.addSynonymTransition(first + "_H", "H", first + "_Hk-" + num, "Hk-" + num); model.addSynonymTransition(first + "_H", "end", first + "_Hk-" + num, "endk-" + num); model.setTransitionProbability(first + "_H", "H", 0.5); model.setTransitionProbability(first + "_H", "end", 0.5); // SC R model.addSynonymTransition("AABase1", "AABase2", "ASC" + num, first + "_R" + num); model.addSynonymTransition("AABase1", "AABase2", "ASCk-" + num, first + "_Rk-" + num); model.addSynonymTransition(first + "_R", "R", first + "_R" + num, "R" + num); model.addSynonymTransition(first + "_R", "end", first + "_R" + num, "end" + num); model.addSynonymTransition(first + "_R", "R", first + "_Rk-" + num, "Rk-" + num); model.addSynonymTransition(first + "_R", "end", first + "_Rk-" + num, "endk-" + num); model.setTransitionProbability(first + "_R", "R", 0.5); model.setTransitionProbability(first + "_R", "end", 0.5); for (set<const Residue*>::const_iterator jt = residues.begin(); jt != residues.end(); ++jt) { AASequence second_aa; second_aa += *jt; String second(second_aa.toString()); model.addSynonymTransition("AABase1", "AABase2", "AA" + num, first + second + "_bxyz" + num); model.addSynonymTransition("AABase1", "AABase2", "AAk-" + num, first + second + "_bxyzk-" + num); model.addSynonymTransition("AABase1", "AABase2", "AA" + num, first + second + "_axyz" + num); model.addSynonymTransition("AABase1", "AABase2", "AAk-" + num, first + second + "_axyzk-" + num); if (i <= 2) { model.setTransitionProbability(first + second + "_bxyz" + num, "bxyz" + num, 0.5); model.addSynonymTransition(first + second + "_bxyz" + num, "end", first + second + "_bxyz" + num, "end" + num); model.setTransitionProbability(first + second + "_bxyz" + num, "end", 0.5); model.setTransitionProbability(first + second + "_axyz" + num, "axyz" + num, 0.5); model.addSynonymTransition(first + second + "_axyz" + num, "end", first + second + "_axyz" + num, "end" + num); model.setTransitionProbability(first + second + "_axyz" + num, "end", 0.5); } else { model.addSynonymTransition(first + second + "_bxyz", "bxyz", first + second + "_bxyz" + num, "bxyz" + num); model.addSynonymTransition(first + second + "_bxyz", "end", first + second + "_bxyz" + num, "end" + num); model.addSynonymTransition(first + second + "_axyz", "axyz", first + second + "_axyz" + num, "axyz" + num); model.addSynonymTransition(first + second + "_axyz", "end", first + second + "_axyz" + num, "end" + num); } model.addSynonymTransition(first + second + "_bxyz", "bxyz", first + second + "_bxyzk-" + num, "bxyzk-" + num); model.addSynonymTransition(first + second + "_bxyz", "end", first + second + "_bxyzk-" + num, "endk-" + num); model.setTransitionProbability(first + second + "_bxyz", "bxyz", 0.5); model.setTransitionProbability(first + second + "_bxyz", "end", 0.5); model.addSynonymTransition(first + second + "_bxyz", "end", first + second + "_bxyzk-" + num, "end" + num); model.addSynonymTransition(first + second + "_axyz", "axyz", first + second + "_axyzk-" + num, "axyzk-" + num); model.addSynonymTransition(first + second + "_axyz", "end", first + second + "_axyzk-" + num, "endk-" + num); model.setTransitionProbability(first + second + "_axyz", "axyz", 0.5); model.setTransitionProbability(first + second + "_axyz", "end", 0.5); model.addSynonymTransition(first + second + "_axyz", "end", first + second + "_axyzk-" + num, "end" + num); } } } model.disableTransitions(); }
void Viewport::updateInfo() { // Then add a text label in the lower-left corner // giving mouse coordinates (if we're near an axis) if (getAxis().first && hover) { QPair<char, float> axis = getAxis(); QPointF mouse_pos = mapToScene(mapFromGlobal(QCursor::pos())); if (!sceneRect().contains(mouse_pos)) axis.first = '\0'; auto p = sceneToWorld(mouse_pos); int value = axis.second * 200; mouse_info->setDefaultTextColor(QColor(value, value, value)); if (axis.first == 'z') mouse_info->setPlainText(QString("X: %1\nY: %2") .arg(p.x()).arg(p.y())); else if (axis.first == 'y') mouse_info->setPlainText(QString("X: %1\nZ: %2") .arg(p.x()).arg(p.z())); else if (axis.first == 'x') mouse_info->setPlainText(QString("Y: %1\nZ: %2") .arg(p.y()).arg(p.z())); } else { mouse_info->setPlainText(" \n "); } if (hover) { QString info; auto proxies = getProxiesAtPosition(_current_pos); if (proxies.size() > 0) { auto n = proxies.first()->getNode(); QString desc = QString::fromStdString(n->getName()); // + " (" + n->getTitle() + ")"; if (proxies.size() > 1) info = QString("Current: %1, (%2 more below)") .arg(desc).arg(proxies.size()-1); else info = QString("Current: %1").arg(desc); } else { info = QString("Current: <none>"); } /* display scale, pitch, and yaw */ info += QString("\nScale: %1").arg(scale/100); info += QString("\nPitch: %1").arg(getPitch()); info += QString("\nYaw: %1").arg(getYaw()); scene_info->setPlainText(info); } else { scene_info->setPlainText(""); } }
K3b::Msf K3b::Device::Toc::firstSector() const { return isEmpty() ? K3b::Msf() : first().firstSector(); }
QString ApplicationHelpers::currentLanguage() const { const auto languages = QLocale().uiLanguages(); return languages.first(); }
plain_termlist simplify(plain_termlist initial_list) { levellist levels; plain_termlist simplified; classlist temp_classlist; level *current_level; Class *current_class; term *current_term; termlist used_initial_minterms; termlist unused_simplified_minterms; unsigned char minterm_size; /***********/ /* Phase 1 */ /***********/ /* initialize the list "levels" for fututre use */ initialize(levels); /* initialize the list "simplified" for future use */ initialize(simplified); /* check the input for an empty list and return a likewise */ /* empty list as an answer as there can't be any simplifications */ if (empty(initial_list)) return 0; /* count the number of variables. the size of a minterm in */ /* memory will be that number plus 1 and will be needed by */ /* the other functions. */ minterm_size = count_variables(content(first(initial_list))) + 1; /* divide the given list of minterms in classes of */ /* increasing number of "1"s and add the list of */ /* classes as the first level. */ addtostart(divide_in_classes(initial_list,minterm_size),levels,level); /* put "current_level" to point to the first level */ current_level = first(levels); /* while new levels can be created... */ while (temp_classlist = create_next_level(content(current_level),minterm_size)) { /* add the new level to the "levels" list */ add(temp_classlist,current_level,level); /* make "current_level" point to the newly added level */ current_level = next(current_level); } /***********/ /* Phase 2 */ /***********/ /* initialize the list "used_initial_minterms" for future use */ initialize(used_initial_minterms); /*******************************************************************/ /* the variables "current_class" and "current_term" are used here */ /* in favor of clarity as they allow us to avoid expressions like: */ /* "content(first(content(first(content(first(levels))))))" */ /*******************************************************************/ /* disperse the first level */ current_level = first(levels); current_class = first(content(current_level)); while (current_class) { current_term = first(content(current_class)); while (current_term) { if (current_term->used) { addtostart(content(current_term),used_initial_minterms,term); first(used_initial_minterms)->used = 0; initialize(first(used_initial_minterms)->represented); } else addtostart(content(current_term),simplified,plain_term); current_term = next(current_term); deletefirst(content(current_class)); } current_class = next(current_class); deletefirst(content(current_level)); } current_level = next(current_level); deletefirst(levels); /* filter the minterms in all levels and keep only those who weren't used */ unused_simplified_minterms = filter(&levels); { term *current_simplified_minterm; term *designated_for_deletion; plain_term *current_represented_minterm; termlist rest_initial_minterms; /* initialize the list "rest_initial_minterms" for future use */ initialize(rest_initial_minterms); while (used_initial_minterms) { current_simplified_minterm = first(unused_simplified_minterms); while (current_simplified_minterm) { current_represented_minterm = first(current_simplified_minterm->represented); while (current_represented_minterm) { if (!strcmp(content(first(used_initial_minterms)),content(current_represented_minterm))) if (first(used_initial_minterms)->represented) { addtostart(content(first(used_initial_minterms)),rest_initial_minterms,term); initialize(first(rest_initial_minterms)->represented); /* requires rest_initial_minterms to be a termlist */ deletefirst(used_initial_minterms); goto label; } else { first(used_initial_minterms)->represented = (plain_termlist)current_simplified_minterm; break; } current_represented_minterm = next(current_represented_minterm); } current_simplified_minterm = next(current_simplified_minterm); } designated_for_deletion = (term*)first(used_initial_minterms)->represented; while (first(designated_for_deletion->represented)) { deleteterm(content(first(designated_for_deletion->represented)),(plain_termlist*)&rest_initial_minterms); deleteterm(content(first(designated_for_deletion->represented)),(plain_termlist*)&used_initial_minterms); deletefirst(designated_for_deletion->represented); } addtostart(content(designated_for_deletion),simplified,plain_term); deleteterm(content(designated_for_deletion),(plain_termlist*)&unused_simplified_minterms); label: ; } rest_initial_minterms = find_implication_lists(rest_initial_minterms,unused_simplified_minterms); simplified = choose_least_subset(rest_initial_minterms,simplified); } return simplified; }
int main() { list_parent L1; list_child L2; addressp p,r,s; addressc q; infotype_parent x1,cari1; infotype_child x2, cari2; createListChild(L2); createListParent(L1); int pil,pol; char lagi='Y'; while (lagi=='Y'){ system("cls"); cout << endl; cout << " ========================================================= \n"; cout << " * RESTAURANT MANAGEMENT APPLICATION * \n" << " ========================================================= \n" << " * 1. Tambah Rumah Makan * \n" << " * 2. Edit Rumah Makan * \n" << " * 3. Cari Rumah Makan Berdasarkan Id * \n" << " * 4. Cari Menu Berdasarkan Id * \n" << " * 5. Tambah Menu Suatu Rumah Makan * \n" << " * 6. Hapus Menu Suatu Rumah Makan * \n" << " * 7. Hapus Rumah Makan Beserta Menu * \n" << " * 8. Lihat List Menu Suatu Rumah Makan * \n" << " * 9. Lihat List Rumah Makan * \n" << " * 10. Sort Rumah Makan by Id * \n" << " * 11. Menu Favorit Suatu Rumah Makan * \n" << " * 12. Keuntungan Suatu Rumah Makan * \n" << " * 13. Menu Terbanyak * \n" << " * 14. Keluar * \n" << " ========================================================= \n \n" << " ========================================================= \n" << " * Masukkan Pilihan Anda : * \n"; cout << " ========================================================= \n"; gotoxy(35,21); cin >> pil; cin.ignore(); if (pil >1 || pil <10){ pol=pil; } else{ lagi='Y'; } switch (pol){ case 1: system("cls"); cout << endl; cout << "==================================================== \n" << "* TAMBAH RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; TambahRumahMakan(x1); p=alokasiParent(x1); r=first(L1); s=CariRumahMakan(L1,x1); if(s==nil){ insertLastParent(L1,p); cout << endl; cout << " INSERT DATA SUKSES ! \n "; } else{ cout << " ID RUMAH MAKAN SAMA ! \n"; } getch(); break; case 2: system("cls"); cout << endl; cout << "==================================================== \n" << "* EDIT RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; cout << " Masukkan Id Rumah Makan : "; getline(cin,cari1.id); p=CariRumahMakan(L1,cari1); if (p==nil){ cout << endl; cout << " ID RUMAH MAKAN TIDAK DITEMUKAN "; } else{ cout << endl; editRumahMakan(L1,p); } getch(); break; case 3: system("cls"); cout << endl; cout << "==================================================== \n" << "* CARI RUMAH MAKAN BERDASARKAN ID * \n" << "==================================================== \n"; cout << endl; cout << " Masukkan ID : "; getline(cin,cari1.id); p=CariRumahMakan(L1,cari1); if (p==nil){ cout << endl << endl; cout << " ID RUMAH MAKAN TIDAK DITEMUKAN \n"; } else{ cout << endl; cout << " RUMAH MAKAN DITEMUKAN \n \n"; cout << " ID Rumah Makan : " << info(p).id << endl; cout << " Nama Rumah Makan : " << info(p).nama << endl; cout << " Alamat Rumah Makan : " << info(p).alamat << endl; cout << " Tanggal Pembuatan : " << info(p).tanggal << endl; cout << " Pajak Rumah Makan : " << info(p).pajak << endl << endl << endl; } getch(); break; case 4: system("cls"); cout << endl; cout << "==================================================== \n" << "* CARI MENU BERDASARKAN ID * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; cout << " Masukkan Id Rumah Makan : "; getline(cin,x1.id); cout << " Masukkan Id Menu : "; getline(cin,x2.id); p=CariRumahMakan(L1,x1); q=cariMenu2(L1,p,x2); cout << endl << endl; if (p==nil){ cout << " RUMAH MAKAN TIDAK DITEMUKAN \n"; } else{ if(q!=nil){ cout << " MENU DITEMUKAN \n \n"; cout << " ID Menu : " << info(q).id << endl; cout << " Nama Menu : " << info(q).nama << endl; cout << " Harga : " << info(q).harga << endl; } else{ cout << endl; cout << " MENU TIDAK DITEMUKAN \n \n"; } } getch(); break; case 5: system("cls"); cout << endl; cout << "==================================================== \n" << "* TAMBAH MENU SUATU RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; TambahMenuSuatuRumahMakan(L1,x2); getch(); break; case 6: system("cls"); cout << endl; cout << "==================================================== \n" << "* HAPUS MENU SUATU RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; hapusMenuRumahMakan(L1); getch(); break; case 7: system("cls"); cout << endl; cout << "==================================================== \n" << "* HAPUS RUMAH MAKAN BESERTA MENU * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; hapusRumahMakan(L1); getch(); break; case 8: system("cls"); cout << endl; cout << "==================================================== \n" << "* LIHAT LIST MENU SUATU RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; lihatMenuRumahMakan(L1); getch(); break; case 9: system("cls"); cout << endl; cout << "==================================================== \n" << "* LIHAT LIST RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; printinfo(L1); getch(); break; case 10: system("cls"); cout << endl; cout << "==================================================== \n" << "* SORT RUMAH MAKAN BY ID * \n" << "==================================================== \n"; cout << endl; if (first(L1)==nil){ cout << endl; cout << " LIST MASIH KOSONG \n"; } else{ char Sort; Sort='W'; while (Sort!='Y' && Sort !='N'){ cout << " Sort Rumah Makan By Id ? Y/N : "; cin >> Sort; } if (Sort=='Y'){ sortRumahMakanById(L1); cout << " SORT RUMAH MAKAN BERHASIL ! \n"; cout << endl; printinfo(L1); } } getch(); break; case 11: system("cls"); cout << endl; cout << "==================================================== \n" << "* MENU FAVORIT SUATU RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; cout << " Masukkan Id Rumah Makan : "; getline(cin,cari1.id); p=CariRumahMakan(L1,cari1); cout << endl; if (p==nil){ cout << " RUMAH MAKAN TIDAK ADA \n"; } else{ cout << " RUMAH MAKAN DITEMUKAN ! \n \n"; q=menuFavorit(L1,p); if (q==nil){ cout << " MENU KOSONG \n"; } else{ cout << " Menu Favorit : " << info(q).nama <<endl; cout << " Terjual : " << info(q).terjual << endl << endl; } } getch(); break; case 12: system("cls"); cout << endl; cout << "==================================================== \n" << "* KEUNTUNGAN SUATU RUMAH MAKAN * \n" << "==================================================== \n"; cout << endl; cout << " List Id Rumah Makan : "; printIdRumahMakan(L1); cout << endl; cout << " Masukkan Id Rumah Makan : "; getline(cin,cari1.id); p=CariRumahMakan(L1,cari1); cout << endl; if (p==nil){ cout << " RUMAH MAKAN TIDAK ADA \n"; } else{ int x; x=profitRumahMakan(L1,p); cout << " Keuntungan Rumah Makan " << info(p).nama << " adalah " << x; } getch(); break; case 13: system("cls"); cout << endl; cout << "==================================================== \n" << "* MENU TERBANYAK * \n" << "==================================================== \n"; cout << endl; if (first(L1)==nil){ cout << " RUMAH MAKAN TIDAK ADA \n"; } else{ p=first(L1); int x=MenuTerbanyak(L1,p); if (x==0){ cout << " MENU TIDAK ADA \n"; } else{ cout << " Rumah Makan " << info(p).nama << " Memiliki Menu " << endl; cout << " Terbanyak, yaitu " << x << " Buah Menu"; } } getch(); break; case 14: lagi='N'; break; default: lagi='Y'; } } getch(); return 0; }
plain_termlist getterms(void) { /* Declarations */ unsigned char counter,minterm_size; plain_termlist minterms; char *buffer; char temp; plain_term *current_node; /* initialize the list of minterms for future use */ initialize(minterms); /* irint instractions to the user */ printf("Give the minterms, one in each line.\n"); printf("They must all have the same number of variables.\n"); printf("Anything apart from \"0\"s and \"1\"s in a line will signal the end of input.\n"); /* Note: minterms are kept in memory as strings. */ /* Allocate an initial buffer to hold the first minterm. */ /* The size is the number of bits used to represent a */ /* memory address and thus more than enough to hold a */ /* minterm of the fuction with the largest number of */ /* variables this machine can process to simplify */ if(!(buffer = malloc(8*sizeof(buffer)))) { /* if there is not enough memory, terminate. */ fprintf(stderr,"Not enough memory. Terminating...\n"); system("PAUSE"); exit(1); } /* read the first minterm and save it's size in memory */ /* the next minterms should be of that size */ counter = 0; while ((temp = getchar()) == '1' || temp == '0') *(buffer + counter++) = temp; *(buffer + counter) = '\0'; minterm_size = counter; /* if the first character is null the user didn't give any minterms. Possibly the zero funcion. */ if (temp == '\n') { /* create the first node and but the given minterm in it. */ /* then free the buffer. the new buffer will be smaller */ addtostart(malloc(minterm_size),minterms,plain_term); strcpy(content(first(minterms)),buffer); free(buffer); /* put "current_node" at the start of the list */ current_node = first(minterms); for(;;) { /* allocate memory for another minterm */ if (!(buffer = malloc(minterm_size))) { /* if there is not enough memory, terminate. */ fprintf(stderr,"Not enough memory. Terminating...\n"); system("PAUSE"); exit(1); } /* read another minterm */ counter = 0; while ((temp = getchar()) == '1' || temp == '0') *(buffer + counter++) = temp; *(buffer + counter) = '\0'; /* check for end of input */ /* newline means another term is to be read */ if (temp == '\n') { /* Note: the findterm is declared to take a termlist as it's */ /* input, but because both structs have the same first two */ /* members it should work fine with a plain_termlist too. */ if (findterm(buffer,(termlist)minterms)) { /* a minterm is given twice, notify he user */ printf("The last minterm was ignored as it has already been given.\n"); } else { /* add the term to the list */ add(buffer,current_node,plain_term); /* move "current_node" to the newly created node, */ /* so that the next node will be inserted after it */ current_node = next(current_node); } } else { /* the input has ended, so the last buffer wasn't used and it can be freed */ free(buffer); break; } } } else free(buffer); return minterms; }
void ParticleSet::randomizeFromSource (ParticleSet &src) { SpeciesSet& srcSpSet(src.getSpeciesSet()); SpeciesSet& spSet(getSpeciesSet()); int srcChargeIndx = srcSpSet.addAttribute("charge"); int srcMemberIndx = srcSpSet.addAttribute("membersize"); int ChargeIndex = spSet.addAttribute("charge"); int MemberIndx = spSet.addAttribute("membersize"); int Nsrc = src.getTotalNum(); int Nptcl = getTotalNum(); int NumSpecies = spSet.TotalNum; int NumSrcSpecies = srcSpSet.TotalNum; //Store information about charges and number of each species vector<int> Zat, Zspec, NofSpecies, NofSrcSpecies, CurElec; Zat.resize(Nsrc); Zspec.resize(NumSrcSpecies); NofSpecies.resize(NumSpecies); CurElec.resize(NumSpecies); NofSrcSpecies.resize(NumSrcSpecies); for(int spec=0; spec<NumSrcSpecies; spec++) { Zspec[spec] = (int)round(srcSpSet(srcChargeIndx,spec)); NofSrcSpecies[spec] = (int)round(srcSpSet(srcMemberIndx,spec)); } for(int spec=0; spec<NumSpecies; spec++) { NofSpecies[spec] = (int)round(spSet(MemberIndx,spec)); CurElec[spec] = first(spec); } int totQ=0; for(int iat=0; iat<Nsrc; iat++) totQ+=Zat[iat] = Zspec[src.GroupID[iat]]; app_log() << " Total ion charge = " << totQ << endl; totQ -= Nptcl; app_log() << " Total system charge = " << totQ << endl; // Now, loop over ions, attaching electrons to them to neutralize // charge int spToken = 0; // This is decremented when we run out of electrons in each species int spLeft = NumSpecies; vector<PosType> gaussRand (Nptcl); makeGaussRandom (gaussRand); for (int iat=0; iat<Nsrc; iat++) { // Loop over electrons to add, selecting round-robin from the // electron species int z = Zat[iat]; while (z > 0 && spLeft) { int sp = spToken++ % NumSpecies; if (NofSpecies[sp]) { NofSpecies[sp]--; z--; int elec = CurElec[sp]++; app_log() << " Assigning " << (sp ? "down" : "up ") << " electron " << elec << " to ion " << iat << " with charge " << z << endl; double radius = 0.5* std::sqrt((double)Zat[iat]); R[elec] = src.R[iat] + radius * gaussRand[elec]; } else spLeft--; } } // Assign remaining electrons int ion=0; for (int sp=0; sp < NumSpecies; sp++) { for (int ie=0; ie<NofSpecies[sp]; ie++) { int iat = ion++ % Nsrc; double radius = std::sqrt((double)Zat[iat]); int elec = CurElec[sp]++; R[elec] = src.R[iat] + radius * gaussRand[elec]; } } }
FSOExecutable FSOExecutable::GetBinaryVersion(wxString binaryname) { wxLogDebug(_T("Making version struct for the executable '%s'"), binaryname.c_str()); FSOExecutable ver; wxStringTokenizer tok(binaryname, _T("_.- ()[]/")); ver.executablename = binaryname; if ( !tok.HasMoreTokens() ) { wxLogError( _T("Did not find initial 'fs2' or 'fred2' token in executable '%s'"), binaryname.c_str()); return ver; } wxString first(tok.GetNextToken()); if ( tok.HasMoreTokens() && (!first.CmpNoCase(_T("fred2")) || !first.CmpNoCase(_T("fs2"))) ) { wxString second(tok.GetNextToken()); if ( !second.CmpNoCase(_T("open")) ) { if ( !first.CmpNoCase(_T("fs2")) ) { ver.binaryname = _T("FS2 Open"); } else { ver.binaryname = _T("FRED2 Open"); } } else { wxLogWarning(_T("was expecting 'open'; got %s in executable %s"), second.c_str(), binaryname.c_str()); return ver; } } else { wxLogWarning(_T("executable name '%s' too short"), binaryname.c_str()); return ver; } while ( tok.HasMoreTokens() ) { wxString token = tok.GetNextToken(); wxString temp; long tempVersion; if (token.IsEmpty()) { // can happen in OS X nightly debug builds // do nothing } else if ( !token.CmpNoCase(_T("exe")) ) { ; // do nothing #if IS_APPLE } else if ( !token.CmpNoCase(_T("app")) ) { break; // we've reached the end of the app name #endif } else if ( token.ToLong(&tempVersion) && token.size() == 8 ) { // must be a date from a nightly build; add it to the string if (!ver.string.IsEmpty()) { ver.string += _T(" "); } // add it in YYYY-MM-DD format ver.string += token.Mid(0, 4); ver.string += _T("-"); ver.string += token.Mid(4, 2); ver.string += _T("-"); ver.string += token.Mid(6, 2); } else if ( token.ToLong(&tempVersion) && ver.antipodes && ver.antNumber == 0) { // must be antipodes number if ( tempVersion > 0 ) { ver.antNumber = (int)tempVersion; } else { wxLogWarning( _T("antipodes number out of range (%ld) in executable %s"), tempVersion, binaryname.c_str()); } } else if ( token.ToLong(&tempVersion) && ver.major == 0 ) { // must be major version number if ( tempVersion < 1000 && tempVersion > 0 ) { ver.major = (int)tempVersion; } else { wxLogWarning( _T("major version number out of range (%ld) in executable %s"), tempVersion, binaryname.c_str()); } } else if ( token.ToLong(&tempVersion) && ver.minor == 0 ) { // must be minor version number if ( tempVersion < 1000 && tempVersion >= 0 ) { ver.minor = (int)tempVersion; } else { wxLogWarning( _T("minor version number out of range (%ld) in executable %s"), tempVersion, binaryname.c_str()); } } else if ( token.ToLong(&tempVersion) && ver.revision == 0) { // must be revision version number if ( tempVersion < 1000 && tempVersion >= 0 ) { ver.revision = (int)tempVersion; } else { wxLogWarning( _T("Revision version number out of range (%ld) in executable %s"), tempVersion, binaryname.c_str()); } } else if ( !token.CmpNoCase(_T("d")) || !token.CmpNoCase(_T("debug")) ) { ver.debug = true; } else if ( token.Lower().EndsWith(_T("d"), &temp) ) { if ( temp.ToLong(&tempVersion) ) { // is the revision version number if ( tempVersion < 1000 && tempVersion >= 0 ) { ver.revision = (int)tempVersion; ver.debug = true; } else { wxLogWarning( _T("Revision version number out of range (%ld) in executable %s"), tempVersion, binaryname.c_str()); } } else { wxLogWarning( _T("Token ending in 'd' is not a number (%s) in executable %s"), token.c_str(), binaryname.c_str()); ver.string += wxString::Format(ver.string.IsEmpty() ? _T("%s") : _T(" %s") , token.c_str()); } } else if ( token.Lower().EndsWith(_T("r"), &temp) ) { if (temp.IsEmpty()) { // do nothing, the 'r' wasn't preceded by a number } else if ( temp.ToLong(&tempVersion) ) { // is the revision version number if ( tempVersion < 1000 && tempVersion >= 0 ) { ver.revision = (int)tempVersion; ver.debug = false; } else { wxLogWarning( _T("Revision version number out of range (%ld) in executable %s"), tempVersion, binaryname.c_str()); } } else { wxLogWarning( _T("Token ending in 'r' is not a number (%s) in executable %s"), token.c_str(), binaryname.c_str()); ver.string += wxString::Format(ver.string.IsEmpty() ? _T("%s") : _T(" %s"), token.c_str()); } } else if ( token.StartsWith(_T("r"), &temp) && temp.ToLong(&tempVersion) ) { // must be a revision number from SirKnightly's builds if ( tempVersion > 0 ) { ver.build = (int)tempVersion; } else { wxLogWarning( _T("SirKnightly build number out of range (%ld) in executable %s"), tempVersion, binaryname.c_str()); } } else if ( !token.CmpNoCase(_T("ant")) ) { ver.antipodes = true; } else if ( token.Lower().StartsWith(_T("ant"), &temp) && !ver.antipodes ) { ver.antipodes = true; // in case the token is of the format, e.g., "Ant8" long antNumber; if (temp.ToLong(&antNumber)) { if (antNumber > 0) { ver.antNumber = antNumber; } else { wxLogWarning(_T("Invalid antipodes number %ld in executable %s"), antNumber, binaryname.c_str()); } } } else if ( !token.CmpNoCase(_T("avx")) ) { ver.sse = 3; } else if ( !token.CmpNoCase(_T("sse2")) ) { ver.sse = 2; } else if ( !token.CmpNoCase(_T("sse")) ) { if (ver.string.Lower().EndsWith(_T("no"))) { // probably NO SSE ver.sse = -1; const int lastSpaceIndex = ver.string.Find(_T(' '), true); if (lastSpaceIndex == wxNOT_FOUND) { wxASSERT(ver.string.Lower() == _T("no")); ver.string = wxEmptyString; } else { ver.string = ver.string.Mid(0, lastSpaceIndex); } } else { ver.sse = 1; } } else if ( !token.CmpNoCase(_T("inf")) || !token.CmpNoCase(_T("inferno"))) { ver.inferno = true; } else { if (!ver.string.IsEmpty()) { ver.string += _T(" "); } ver.string += token; } } return ver; }
BPolygon::BPolygon(const QPolygon & polygon): QPolygonF(polygon) { if(size() > 3 && first() == last()) pop_back(); }
/*! Returns a Qt version of the given \a sys_fmt Symbian locale format string. */ static QString s60ToQtFormat(const QString &sys_fmt) { TLocale *locale = _s60Locale.GetLocale(); QString result; QString other; QString qtformatchars = QString::fromLatin1("adhmsyzAHM"); QChar c; int i = 0; bool open_escape = false; bool abbrev_next = false; bool locale_indep_ordering = false; bool minus_mode = false; bool plus_mode = false; bool n_mode = false; TTimeFormat tf = locale->TimeFormat(); while (i < sys_fmt.size()) { c = sys_fmt.at(i); // let formatting thru if (c.unicode() == '%') { // if we have gathered string, concat it if (!other.isEmpty()) { result += other; other.clear(); } // if we have open escape, end it if (open_escape) { result += QLatin1Char('\''); open_escape = false; } ++i; if (i >= sys_fmt.size()) break; c = sys_fmt.at(i); // process specials abbrev_next = c.unicode() == '*'; plus_mode = c.unicode() == '+'; minus_mode = c.unicode() == '-'; if (abbrev_next || plus_mode || minus_mode) { ++i; if (i >= sys_fmt.size()) break; c = sys_fmt.at(i); if (plus_mode || minus_mode) { // break on undefined plus/minus mode if (c.unicode() != 'A' && c.unicode() != 'B') break; } } switch (c.unicode()) { case 'F': { // locale indep mode on locale_indep_ordering = true; break; } case '/': { // date sep 0-3 ++i; if (i >= sys_fmt.size()) break; c = sys_fmt.at(i); if (c.isDigit() && c.digitValue() <= 3) { TChar s = locale->DateSeparator(c.digitValue()); TUint val = s; // some indexes return zero for empty if (val > 0) result += QChar(val); } break; } case 'D': { if (!locale_indep_ordering) break; if (!abbrev_next) result += QLatin1String("dd"); else result += QLatin1Char('d'); break; } case 'M': { if (!locale_indep_ordering) break; if (!n_mode) { if (!abbrev_next) result += QLatin1String("MM"); else result += QLatin1String("M"); } else { if (!abbrev_next) result += QLatin1String("MMMM"); else result += QLatin1String("MMM"); } break; } case 'N': { n_mode = true; if (!locale_indep_ordering) break; if (!abbrev_next) result += QLatin1String("MMMM"); else result += QLatin1String("MMM"); break; } case 'Y': { if (!locale_indep_ordering) break; if (!abbrev_next) result += QLatin1String("yyyy"); else result += QLatin1String("yy"); break; } case 'E': { if (!abbrev_next) result += QLatin1String("dddd"); else result += QLatin1String("ddd"); break; } case ':': { // timesep 0-3 ++i; if (i >= sys_fmt.size()) break; c = sys_fmt.at(i); if (c.isDigit() && c.digitValue() <= 3) { TChar s = locale->TimeSeparator(c.digitValue()); TUint val = s; // some indexes return zero for empty if (val > 0) result += QChar(val); } break; } case 'J': { if (tf == ETime24 && !abbrev_next) result += QLatin1String("hh"); else result += QLatin1Char('h'); break; } case 'H': { if (!abbrev_next) result += QLatin1String("hh"); else result += QLatin1Char('h'); break; } case 'I': { result += QLatin1Char('h'); break; } case 'T': { if (!abbrev_next) result += QLatin1String("mm"); else result += QLatin1Char('m'); break; } case 'S': { if (!abbrev_next) result += QLatin1String("ss"); else result += QLatin1Char('s'); break; } case 'B': { // only done for 12h clock if (tf == ETime24) break; } // fallthru to A case 'A': { // quickie to get capitalization, can't use s60 string as is because Qt 'hh' format's am/pm logic TAmPmName ampm = TAmPmName(); TChar first(ampm[0]); QString qtampm = QString::fromLatin1(first.IsUpper() ? "AP" : "ap"); int pos = locale->AmPmSymbolPosition(); if ((minus_mode && pos != ELocaleBefore) || (plus_mode && pos != ELocaleAfter)) break; if (!abbrev_next && locale->AmPmSpaceBetween()) { if (pos == ELocaleBefore) qtampm.append(QLatin1Char(' ')); else qtampm.prepend(QLatin1Char(' ')); } result += qtampm; } break; case '.': { // decimal sep TChar s = locale->DecimalSeparator(); TUint val = s; if (val > 0) result += QChar(val); } break; case 'C': { // six digits in s60, three digits in qt if (!abbrev_next) { result += QLatin1String("zzz"); } else { // next char is number from 0-6, how many digits to display ++i; if (i >= sys_fmt.size()) break; c = sys_fmt.at(i); if (c.isDigit()) { // try to match wanted digits QChar val(c.digitValue()); if (val >= 3) { result += QLatin1String("zzz"); } else if (val > 0) { result += QLatin1Char('z'); } } } break; } // these cases fallthru case '1': case '2': case '3': case '4': case '5': { // shouldn't parse these with %F if (locale_indep_ordering) break; TDateFormat df = locale->DateFormat(); const char **locale_dep; switch (df) { default: // fallthru to american case EDateAmerican: locale_dep = us_locale_dep; break; case EDateEuropean: locale_dep = eu_locale_dep; break; case EDateJapanese: locale_dep = jp_locale_dep; break; } int offset = 0; if (abbrev_next) offset += 5; if (n_mode) offset += 10; result += QLatin1String(locale_dep[offset + (c.digitValue()-1)]); break; } case '%': // fallthru percent { // any junk gets copied as is } default: { result += c; break; } case 'Z': // Qt doesn't support these :( case 'X': case 'W': { break; } } } else { // double any single quotes, don't begin escape if (c.unicode() == '\'') { // end open escape if (open_escape) { result += other; other.clear(); result += QLatin1Char('\''); open_escape = false; } other += c; } // gather chars and escape them in one go if any format chars are found if (!open_escape && qtformatchars.indexOf(c) != -1) { result += QLatin1Char('\''); open_escape = true; } other += c; } ++i; } if (!other.isEmpty()) result += other; if (open_escape) result += QLatin1Char('\''); return result; }
int main() { first(0xc0decafe); return 0; }
inline bool isEmpty() const { Iterator iter; return ! first(iter); }
bool BiomMetadataReader::readEmbMetadata(const QString& fileName) { DEBUG_FUNC_NAME // open file QFile dataFile(fileName); if (!dataFile.open(QIODevice::ReadOnly | QIODevice::Text)) { // error opening file qDebug() << "Error: Cannot open" << fileName << "file"; return false; } // read file QSettings settings(fileName, QSettings::IniFormat); // try old format first settings.beginGroup(BmIni::INIGROUP_VARS_OLD); // iterate through instrument list auto numVars = countEmbVariables(settings.allKeys()); // if no variables are found, try new format if (numVars == 0) { settings.endGroup(); settings.beginGroup(BmIni::INIGROUP_VARS); numVars = countEmbVariables(settings.allKeys()); } for (auto k = 0; k < numVars; ++k) { auto prefix = BmIni::INI_PREFIX; prefix += QString::number(k + 1); prefix += QStringLiteral("_"); auto var = settings.value(prefix + BmIni::INI_VARS_0, QString()).toString(); // NOTE: not really needed for now auto id = settings.value(prefix + BmIni::INI_VARS_1, QString()).toString(); // skip entries with no type ('variable' field in the biomet metadata // file) defined if (var.isEmpty()) { continue; } // variables types the GUI is allowed to show and manage for now QStringList allowedVarIDs; allowedVarIDs << getVAR_TA() << getVAR_PA() << getVAR_RH() << getVAR_RG() << getVAR_LWIN() << getVAR_PPFD(); // get components of the variable type field // it can be simple or with positional notation defined auto type_components_list = var.split(QLatin1Char('_')); auto extracted_type = QString(); // entry with positional notation and underscore(s) // in the variable name (e.g. P_RAIN_1_1_1) auto type_components_size = type_components_list.size(); if (type_components_size > 4) { QStringList extracted_var_name = type_components_list.mid(0, type_components_size - 3); extracted_type = extracted_var_name.join(QStringLiteral("_")); } // entry with positional notation and no underscore // in the variable name (e.g. PA_1_1_1) // or entry with no positional notation (e.g. DATE) else { extracted_type = type_components_list.first(); } auto allowedVar = allowedVarIDs.filter(extracted_type); // skip not allowed entries if (allowedVar.isEmpty()) { continue; } // add allowed biogeo variables biomMetadata_->append(BiomItem(var, id, k + 1)); } settings.endGroup(); dataFile.close(); return true; }
void add_edges_sorted_internal( BidirectionalIteratorOrig first_sorted, BidirectionalIteratorOrig last_sorted, EPIterOrig ep_iter_sorted, const GlobalToLocal& global_to_local) { typedef boost::reverse_iterator<BidirectionalIteratorOrig> BidirectionalIterator; typedef boost::reverse_iterator<EPIterOrig> EPIter; // Flip sequence BidirectionalIterator first(last_sorted); BidirectionalIterator last(first_sorted); typedef Vertex vertex_t; typedef Vertex vertex_num; typedef EdgeIndex edge_num; edge_num new_edge_count = std::distance(first, last); EPIter ep_iter(ep_iter_sorted); std::advance(ep_iter, -(std::ptrdiff_t)new_edge_count); edge_num edges_added_before_i = new_edge_count; // Count increment to add to rowstarts m_column.resize(m_column.size() + new_edge_count); inherited_edge_properties::resize(inherited_edge_properties::size() + new_edge_count); BidirectionalIterator current_new_edge = first, prev_new_edge = first; EPIter current_new_edge_prop = ep_iter; for (vertex_num i_plus_1 = m_rowstart.size() - 1; i_plus_1 > 0; --i_plus_1) { vertex_num i = i_plus_1 - 1; prev_new_edge = current_new_edge; // edges_added_to_this_vertex = #mbrs of new_edges with first == i edge_num edges_added_to_this_vertex = 0; while (current_new_edge != last) { if (get(global_to_local, current_new_edge->first) != i) break; ++current_new_edge; ++current_new_edge_prop; ++edges_added_to_this_vertex; } edges_added_before_i -= edges_added_to_this_vertex; // Invariant: edges_added_before_i = #mbrs of new_edges with first < i edge_num old_rowstart = m_rowstart[i]; edge_num new_rowstart = m_rowstart[i] + edges_added_before_i; edge_num old_degree = m_rowstart[i + 1] - m_rowstart[i]; edge_num new_degree = old_degree + edges_added_to_this_vertex; // Move old edges forward (by #new_edges before this i) to make room // new_rowstart > old_rowstart, so use copy_backwards if (old_rowstart != new_rowstart) { std::copy_backward(m_column.begin() + old_rowstart, m_column.begin() + old_rowstart + old_degree, m_column.begin() + new_rowstart + old_degree); inherited_edge_properties::move_range(old_rowstart, old_rowstart + old_degree, new_rowstart); } // Add new edges (reversed because current_new_edge is a // const_reverse_iterator) BidirectionalIterator temp = current_new_edge; EPIter temp_prop = current_new_edge_prop; for (; temp != prev_new_edge; ++old_degree) { --temp; --temp_prop; m_column[new_rowstart + old_degree] = temp->second; inherited_edge_properties::write_by_index(new_rowstart + old_degree, *temp_prop); } m_rowstart[i + 1] = new_rowstart + new_degree; if (edges_added_before_i == 0) break; // No more edges inserted before this point // m_rowstart[i] will be fixed up on the next iteration (to avoid // changing the degree of vertex i - 1); the last iteration never changes // it (either because of the condition of the break or because // m_rowstart[0] is always 0) } }
// Find smileys with original positions SmileyList SmileyList::fromText(QString text) { // Get current smileypack Settings &settings = Settings::getInstance(); Smileypack pack(settings.getSmileyPack()); // Reconvert emoji if (!pack.isEmoji()) { text = Smileypack::deemojify(text); } SmileyList result; ClickableList clickables = ClickableList::fromString(text); // Whlie smileys found to replace bool found; int searchStart = 0; int offset = 0; do { found = false; // Fill a map with positions of possible smileys QMap<int, QStringList> possibleTexts; for (const auto& pair : pack.getList()) { for (const QString& smileytext : pair.second) { int pos = text.indexOf(smileytext, searchStart); if (pos > -1) { possibleTexts.insertMulti(pos, {smileytext, pair.first}); found = true; } } } // check the first smiley alternative representations QMapIterator<int, QStringList> first(possibleTexts); if (first.hasNext()) { first.next(); int length = first.value().first().count(); QString repSrt = first.value().first(); int repPos = first.key(); QString repRep = first.value().at(1); QMapIterator<int, QStringList> i(possibleTexts); i.next(); // Search for a longer smileyrepresentation at same position while (i.hasNext() && i.key() < first.key() + length) { i.next(); // If there is a longer smileyrepresentation, use it if (i.value().count() > length) { repPos = i.key(); repSrt = i.value().first(); repRep = i.value().at(1); } } // Check if there is a clickable if(!clickables.atCursorPos(repPos).isValid()) { // Add found smiley to List Smiley smile = Smiley(repSrt, repRep, repPos, repPos - offset, (pack.isEmoji()) ? Smiley::Emoji : Smiley::Pixmap ); if (pack.isEmoji() && settings.isCurstomEmojiFont()) { QFont f = QApplication::font(); f.setFamily(settings.getEmojiFontFamily()); f.setPointSize(settings.getEmojiFontPointSize()); smile.setEmojiFont(f); } result.append(smile); // calculate offset for next smiley offset += repSrt.count() - ((pack.isEmoji()) ? repRep.count() : 1); } searchStart = repPos + repSrt.count(); } } while (found); return result; }
void NamesView::MouseMoved (BPoint myPoint, uint32 transitcode, const BMessage *dragMessage) { if ((dragMessage != NULL) && (dragMessage->HasRef("refs"))) { // make sure the ref isn't a dir entry_ref ref; dragMessage->FindRef("refs", &ref); BDirectory dir (&ref); if (dir.InitCheck() != B_OK) { int32 nameIndex (IndexOf(myPoint)); if (nameIndex >= 0) Select(nameIndex); } } else if (fTracking) { if (transitcode == B_INSIDE_VIEW) { BListItem *item = ItemAt (IndexOf(myPoint)); if (item) { BListItem *lastitem (NULL); int32 first (CurrentSelection (0)); int32 last (first); int32 i (1); while ((last = CurrentSelection(i++)) != -1) lastitem = ItemAt(last); if (lastitem) last = IndexOf(lastitem); else last = first; int32 current (IndexOf (myPoint)); if (current >= 0) { if (current < first) { // sweep up Select (current, last, true); } else if (current > last) { // sweep down Select (first, current, true); } else if (fCurrentindex > current) { // backtrack up DeselectExcept (first, current); } else if (fCurrentindex < current) { // backtrack down DeselectExcept (current, last); } fCurrentindex = current; } } } } else BListView::MouseMoved (myPoint, transitcode, dragMessage); }
int main(int argc, const char *argv[]) { { //vector<T, Alloc> //支持随机元素访问的动态数组(序列) std::vector<int> V; V.insert(V.begin(), 3); assert(V.size() == 1 && V.capacity() >= 1 && V[0] == 3); //扩大vector的容量到指定值,除非已经超过指定值 std::cout << "size:" << V.size() << ",capacity:" << V.capacity() << std::endl; V.reserve(3); std::cout << "size:" << V.size() << ",capacity:" << V.capacity() << std::endl; //用构造函数复制vector,容量会自动压缩 std::vector<int> temp(V.begin(), V.end()); std::cout << "Use vector's ctor copy:" << std::endl; std::cout << "size:" << temp.size() << ",capacity:" << temp.capacity() << std::endl; //用swap把序列转移到新的vector,容量不会改变, //而且原来的vector会被修改(交换了内容) std::vector<int> temp_swap; temp_swap.swap(V); std::cout << "Use vector's swap:" << std::endl; std::cout << "temp_swap's size:" << temp_swap.size() << ",capacity:" << temp_swap.capacity() << std::endl; std::cout << "V's size:" << V.size() << ",capacity:" << V.capacity() << std::endl; //把序列复制到vector,通常用于输入流 //用法类似std::copy std::cout << "Please input double array (NaN is EOF):" << std::endl; std::istream_iterator<double> first(std::cin); std::istream_iterator<double> eof; std::vector<double> buf(first, eof); std::cout << "input double numbers are:" << std::endl; std::copy(buf.begin(), buf.end(), std::ostream_iterator<double>(std::cout, "\n")); std::cout << std::flush; } { //list<T, Alloc> //双向链表 std::list<int> L; L.push_back(0); L.push_front(1); L.insert(++L.begin(), 2); std::cout << "list:" << std::endl; std::copy(L.begin(), L.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; //排序 L.sort(); std::cout << "sorted list:" << std::endl; std::copy(L.begin(), L.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; //合并 std::list<int> L2; L2.push_back(3); L2.push_back(2); L2.push_back(1); L.merge(L2); std::cout << "merged list:" << std::endl; std::copy(L.begin(), L.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; //颠倒次序 L.reverse(); std::cout << "reversed list:" << std::endl; std::copy(L.begin(), L.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; } { //slist<T, Alloc> //单向链表 //从begin()插入 __gnu_cxx::slist<int> L; L.push_front(0); L.push_front(1); L.insert_after(L.begin(), 2); std::cout << "slist, insert to begin:" << std::endl; std::copy(L.begin(), L.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; //从end()插入 __gnu_cxx::slist<int>::iterator back = L.previous(L.end()); back = L.insert_after(back, 3); back = L.insert_after(back, 4); back = L.insert_after(back, 5); std::cout << "slist, insert to end:" << std::endl; std::copy(L.begin(), L.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; } { //deque<T, Alloc> //双端队列,类似vector, //支持随机访问和双端插入, //但不支持capacity()和reserve() std::deque<int> Q; Q.push_back(3); Q.push_front(1); Q.insert(Q.begin() + 1, 2); Q[2] = 0; std::cout << "deque:" << std::endl; std::copy(Q.begin(), Q.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; } { //set<Key, Compare, Alloc> //集合,不重复的序列,可执行交、并、差集 const int N = 6; const char* a[N] = {"isomer", "ephemeral", "prosaic", "nugatory", "artichoke", "serif"}; const char* b[N] = {"flat", "this", "artichoke", "frigate", "prosaic", "isomer"}; std::set<const char*, ltstr> A(a, a + N); std::set<const char*, ltstr> B(b, b + N); std::set<const char*, ltstr> C; std::cout << "Set A: "; std::copy(A.begin(), A.end(), std::ostream_iterator<const char*>(std::cout, " ")); std::cout << std::endl; std::cout << "Set B: "; std::copy(B.begin(), B.end(), std::ostream_iterator<const char*>(std::cout, " ")); std::cout << std::endl; std::cout << "Union: "; std::set_union(A.begin(), A.end(), B.begin(), B.end(), std::ostream_iterator<const char*>(std::cout, " "), ltstr()); std::cout << std::endl; std::cout << "Intersection: "; std::set_intersection(A.begin(), A.end(), B.begin(), B.end(), std::ostream_iterator<const char*>(std::cout, " "), ltstr()); std::cout << std::endl; std::set_difference(A.begin(), A.end(), B.begin(), B.end(), std::inserter(C, C.begin()), ltstr()); std::cout << "Set C (difference of A and B): "; std::copy(C.begin(), C.end(), std::ostream_iterator<const char*>(std::cout, " ")); std::cout << std::endl; } { //map<Key, Data, Compare, Alloc> //关联数组,映射表,键不可重复 std::map<const char*, int, ltstr> months; months["january"] = 31; months["february"] = 28; months["march"] = 31; months["april"] = 30; months["may"] = 31; months["june"] = 30; months["july"] = 31; months["august"] = 31; months["september"] = 30; months["october"] = 31; months["november"] = 30; months["december"] = 31; std::cout << "june -> " << months["june"] << std::endl; std::map<const char*, int, ltstr>::iterator cur = months.find("june"); std::map<const char*, int, ltstr>::iterator prev = cur; std::map<const char*, int, ltstr>::iterator next = cur; ++next; --prev; std::cout << "Previous (in alphabetical order) is " << (*prev).first << std::endl; std::cout << "Next (in alphabetical order) is " << (*next).first << std::endl; //另一种插入键值对的方法(可以判断是否插入成功) std::map<const char*, int, ltstr> M; std::pair<std::map<const char*, int>::iterator, bool> p = M.insert(std::make_pair("A", 17)); //第二返回值表示插入是否成功 if(p.second) std::cout << "insert pair is " << p.first->first << ", " << p.first->second << std::endl; //<< "pair:" << "," << p.second } { //multiset<Key, Compare, Alloc> //允许元素重复的集合 const int N = 10; int a[N] = {4, 1, 1, 1, 1, 1, 0, 5, 1, 0}; int b[N] = {4, 4, 2, 4, 2, 4, 0, 1, 5, 5}; std::multiset<int> A(a, a + N); std::multiset<int> B(b, b + N); std::multiset<int> C; std::cout << "Set A: "; std::copy(A.begin(), A.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; std::cout << "Set B: "; std::copy(B.begin(), B.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; std::cout << "Union: "; std::set_union(A.begin(), A.end(), B.begin(), B.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; std::cout << "Intersection: "; std::set_intersection(A.begin(), A.end(), B.begin(), B.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; std::set_difference(A.begin(), A.end(), B.begin(), B.end(), std::inserter(C, C.begin())); std::cout << "Set C (difference of A and B): "; std::copy(C.begin(), C.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; } { //multimap<Key, Data, Compare, Alloc> //键允许重复的关联数组 std::multimap<const char*, int, ltstr> m; m.insert(std::pair<const char* const, int>("a", 1)); m.insert(std::pair<const char* const, int>("c", 2)); m.insert(std::pair<const char* const, int>("b", 3)); m.insert(std::pair<const char* const, int>("b", 4)); m.insert(std::pair<const char* const, int>("a", 5)); m.insert(std::pair<const char* const, int>("b", 6)); std::cout << "Number of elements with key a: " << m.count("a") << std::endl; std::cout << "Number of elements with key b: " << m.count("b") << std::endl; std::cout << "Number of elements with key c: " << m.count("c") << std::endl; std::cout << "Elements in m: " << std::endl; for (std::multimap<const char*, int, ltstr>::iterator it = m.begin(); it != m.end(); ++it) std::cout << " [" << (*it).first << ", " << (*it).second << "]" << std::endl; } { //hash_set<Key, HashFcn, EqualKey, Alloc> //支持哈希查找的集合,不允许元素重复 __gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, eqstr> Set; Set.insert("kiwi"); Set.insert("plum"); Set.insert("apple"); Set.insert("mango"); Set.insert("apricot"); Set.insert("banana"); lookup(Set, "mango"); lookup(Set, "apple"); lookup(Set, "durian"); } { //hash_map<Key, Data, HashFcn, EqualKey, Alloc> //支持哈希查找的关联数组,不允许键重复 __gnu_cxx::hash_map<const char*, int, __gnu_cxx::hash<const char*>, eqstr> months; months["january"] = 31; months["february"] = 28; months["march"] = 31; months["april"] = 30; months["may"] = 31; months["june"] = 30; months["july"] = 31; months["august"] = 31; months["september"] = 30; months["october"] = 31; months["november"] = 30; months["december"] = 31; std::cout << "september -> " << months["september"] << std::endl; std::cout << "april -> " << months["april"] << std::endl; std::cout << "june -> " << months["june"] << std::endl; std::cout << "november -> " << months["november"] << std::endl; } { //hash_multiset<Key, HashFcn, EqualKey, Alloc> //支持哈希查找的集合,允许元素重复 __gnu_cxx::hash_multiset<const char*, __gnu_cxx::hash<const char*>, eqstr> Set; Set.insert("mango"); Set.insert("kiwi"); Set.insert("apple"); Set.insert("kiwi"); Set.insert("mango"); Set.insert("mango"); Set.insert("apricot"); Set.insert("banana"); Set.insert("mango"); lookup(Set, "mango"); lookup(Set, "apple"); lookup(Set, "durian"); } { //hash_multimap<Key, Data, HashFcn, EqualKey, Alloc> //支持哈希查找的集合,允许键重复 map_type M; M.insert(map_type::value_type("H", 1)); M.insert(map_type::value_type("H", 2)); M.insert(map_type::value_type("C", 12)); M.insert(map_type::value_type("C", 13)); M.insert(map_type::value_type("O", 16)); M.insert(map_type::value_type("O", 17)); M.insert(map_type::value_type("O", 18)); M.insert(map_type::value_type("I", 127)); lookup(M, "I"); lookup(M, "O"); lookup(M, "Rn"); } { //stack<T, Sequence> //堆栈,后进先出 std::stack<int> S; S.push(8); S.push(7); S.push(4); assert(S.size() == 3); assert(S.top() == 4); S.pop(); assert(S.top() == 7); S.pop(); assert(S.top() == 8); S.pop(); assert(S.empty()); } { //queue<T, Sequence> //队列,先进先出 std::queue<int> Q; Q.push(8); Q.push(7); Q.push(6); Q.push(2); assert(Q.size() == 4); assert(Q.back() == 2); assert(Q.front() == 8); Q.pop(); assert(Q.front() == 7); Q.pop(); assert(Q.front() == 6); Q.pop(); assert(Q.front() == 2); Q.pop(); assert(Q.empty()); } { //priority_queue<T, Sequence, Compare> //优先队列,最先弹出的是队列中的最大值 std::priority_queue<int> Q; Q.push(1); Q.push(4); Q.push(2); Q.push(8); Q.push(5); Q.push(7); assert(Q.size() == 6); assert(Q.top() == 8); Q.pop(); assert(Q.top() == 7); Q.pop(); assert(Q.top() == 5); Q.pop(); assert(Q.top() == 4); Q.pop(); assert(Q.top() == 2); Q.pop(); assert(Q.top() == 1); Q.pop(); assert(Q.empty()); //让队列中最小元素的先出列 //其中,模板的第二参数表示它的底层实现是std::vector<int> std::priority_queue< int, std::vector<int>, std::greater<int> > Q2; Q2.push(4); Q2.push(2); assert(Q2.top() == 2); Q2.pop(); assert(Q2.top() == 4); } //标准C++允许main不返回,但标准C要求必须返回 return 0; }
void MainWindow::populateNodeMenu(QMenu* menu, bool recenter, Viewport* v) { QDirIterator bitr(App::instance()->bundledNodePath(), QDirIterator::Subdirectories); QDirIterator uitr(App::instance()->userNodePath(), QDirIterator::Subdirectories); QList<QRegExp> title_regexs= {QRegExp(".*title\\('+([^']+)'+\\).*"), QRegExp(".*title\\(\"+([^\"]+)\"+\\).*")}; // Extract all of valid filenames into a QStringList. QStringList node_filenames; for (auto itr : {&bitr, &uitr}) { while (itr->hasNext()) { auto n = itr->next(); if (n.endsWith(".node")) node_filenames.append(n); } } // Sort the list, then populate menus. QMap<QString, QPair<QStringList, NodeConstructorFunction>> nodes; QStringList node_titles; for (auto n : node_filenames) { QFile file(n); if (!file.open(QIODevice::ReadOnly)) continue; QTextStream in(&file); QString txt = in.readAll(); // Find the menu structure for this node auto split = n.split('/'); while (split.first() != "nodes") split.removeFirst(); split.removeFirst(); // Attempt to extract the title with a regex; // falling back to the node's filename otherwise. QString title = split.last().replace(".node",""); split.removeLast(); for (auto& regex : title_regexs) if (regex.exactMatch(txt)) title = regex.capturedTexts()[1]; QString name = "n*"; if (title.size() > 0 && title.at(0).isLetter()) name = title.at(0).toLower() + QString("*"); NodeConstructorFunction constructor = [=](Graph *r){ return new Node(name.toStdString(), txt.toStdString(), r); }; nodes[title] = QPair<QStringList, NodeConstructorFunction>( split, constructor); node_titles.append(title); } // Put all of the nodes into the Add menu, deferring Export nodes // until the end (after a separator). node_titles.sort(); QStringList deferred; for (auto title : node_titles) if (nodes[title].first.contains("Export")) deferred << title; else addNodeToMenu(nodes[title].first, title, menu, recenter, nodes[title].second, v); menu->addSeparator(); for (auto title : deferred) addNodeToMenu(nodes[title].first, title, menu, recenter, nodes[title].second, v); }