void first(int x)
{
    printf("%d ",x);
    if(L[x]) first(L[x]);
    if(R[x]) first(R[x]);
}
Exemple #2
0
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();
}
Exemple #3
0
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;
}
Exemple #5
0
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;
}
Exemple #6
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);
    }
Exemple #7
0
BPolygon::BPolygon(const QVector<QPointF> & points): QPolygonF(points) {
    if(size() > 3 && first() == last()) pop_back();
}
void VolumeCollection::clear() {
    while (!empty())
        remove(first());
}
Exemple #9
0
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());
}
Exemple #10
0
/*
 *  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;
}
Exemple #11
0
/*
 * 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();
  }
Exemple #13
0
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("");
    }
}
Exemple #14
0
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;
}
Exemple #19
0
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];
    }
  }
}
Exemple #20
0
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;
}
Exemple #21
0
BPolygon::BPolygon(const QPolygon & polygon): QPolygonF(polygon) {
    if(size() > 3 && first() == last()) pop_back();
}
Exemple #22
0
/*!
    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;
}
Exemple #23
0
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)
      }
    }
Exemple #27
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;
}
Exemple #28
0
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);
}