C++ cut函数代码示例

/**

Trims the sound data of a AIFF file for every high low combo in highlow
The size argument specifies how many high low combos are present in highlow

**/
File_Data trimAIFF(highlow_t* highlow, int size){

	File_Data data = processAIFF(stdout, stdin);
	if(!validateData(data)){
		fprintf(stderr, "Error occured in COMM chunk\n");
		exit(-1);
	}
	getSamplesAIFF(NULL, &data);

	int i;

	for(i = 0; i < size; i++){
		cut(&data, highlow[i].low, highlow[i].high);
	}

	writeHeaderAIFF(stdout, data);

	setupSoundAIFF(stdout, data);

	writeSamplesAIFF(stdout, data);
}

int
viyankwholeline(UNUSED(char **args))
{
    int bol = findbol(), oldcs = zlecs;
    int n = zmult;

    startvichange(-1);
    if (n < 1)
	return 1;
    while(n--) {
     if (zlecs > zlell) {
	zlecs = oldcs;
	return 1;
     }
     zlecs = findeol() + 1;
    }
    vilinerange = 1;
    cut(bol, zlecs - bol - 1, CUT_YANK);
    zlecs = oldcs;
    return 0;
}

int main()
{
	freopen("t.in", "r", stdin);
	scanf("%d", &n_org);
	for(int i = 0; i < n_org; i ++)
		scanf("%lf", &org_pnt[i].x);
	for(int i = 0; i < n_org; i ++)
		scanf("%lf", &org_pnt[i].y);

	cur_pnt[0] = Point(- INF + 1, - INF);
	cur_pnt[1] = Point(- INF, INF + 1);
	cur_pnt[2] = Point(INF, INF + 1);
	cur_pnt[3] = Point(INF, - INF+ 1);
	n_cur = 4;
	for(int i = 0; i < n_org - 1; i ++)
	{
		Line l(org_pnt[i], org_pnt[i + 1]);
		cut(l);
	}

	int r = 0;
	for(int i = 1; i < n_cur; i ++)
		if(cur_pnt[i].x > cur_pnt[r].x)
			r = i;
	double ans = INF;
	for(int s = n_org - 2; s >= 0; s --)
	{	
		while(cur_pnt[r].x > org_pnt[s].x)
		{
			while(cur_pnt[r].x > org_pnt[s + 1].x)
				r = (r + 1) % n_cur;
			Line l(org_pnt[s], org_pnt[s + 1]);
			ans = MIN(ans, cur_pnt[r].y - (- l.a / l.b * cur_pnt[r].x - l.c / l.b));
			r = (r + 1) % n_cur;
		}
		Line l(cur_pnt[r], cur_pnt[(r + n_cur - 1) % n_cur]);
		ans = MIN(ans, (- l.a / l.b * org_pnt[s].x - l.c / l.b) - org_pnt[s].y);
	}
	printf("%.3lf\n", ans);
}

CharacterList * CharacterSurface_LoadList()
{
	CharacterList * characters   = NULL;
	FILE          * listFile     = NULL;
	char          * buffer       = calloc(sizeof(char) * 255, sizeof(char));
	char          * orig_buffer  = buffer;
	char          * charFilename = NULL;
	char          * charName      = NULL;

	listFile = fopen(CHARACTER_LIST_FILE, "r");

	if(listFile == NULL)
	{
		fprintf(stderr, "Unable to open %s : ", CHARACTER_LIST_FILE);
		perror(NULL);
	}
	else
	{
		characters = CharacterList_new();
		while(fgets(buffer, 255, listFile) != NULL)
		{

			trim(&buffer);
			if(buffer[0] != '#' && buffer[0] != '\0')
			{
				charFilename = buffer;
				charName = cut(charFilename, '=');
				trim(&charFilename);
				trim(&charName);

				// Load and add the map to the list
				CharacterList_add(characters, charName, CharacterSurface_init(charFilename));
			}
		}
	}

	free(orig_buffer);
	fclose(listFile);
	return characters;
}

void CtcForAll::contract(IntervalVector& x) {
	assert(x.size()==nb_var);

	IntervalVector  box(nb_var+_init.size());
	IntervalVector * sub;
	bool mdiam; int iter =0;
	box.put(0, x);

	std::list<IntervalVector> l;
	l.push_back(_init);
	std::pair<IntervalVector,IntervalVector> cut(_init,_init);

	while ((!l.empty())&&(iter<_max_iter)) {
		cut = _bsc.bisect(l.front());
		l.pop_front();
		sub = &(cut.first);
		for (int j=1;j<=2;j++) {
			if (j==2) sub = &(cut.second);

			for(int i=0; i< _init.size(); i++) {
				box[i+nb_var] = (*sub)[i].mid();
			}
			// it is enough to contract only with the middle, it is more precise and faster.
			try {
				_ctc.contract(box);
			} catch (EmptyBoxException& e) {
				x.set_empty(); throw e;
			}

			mdiam=true;
			for (int i=0;mdiam&&(i<_init.size()); i++) 	mdiam = mdiam&&((*sub)[i].diam()<= _prec);
			if (!mdiam) {
				l.push_back(*sub);
				iter++;
			}
		}
	}
	for(int i=0; i< nb_var; i++)  x[i] &= box[i];
	if (x.is_empty()) throw EmptyBoxException();
}

matrix<Flow> gusfield_all_pairs_min_cut(const Graph &g,
                                        const std::vector<size_t> &rev_edge,
                                        const std::vector<Flow> &capacity) {

  const size_t num_vertices = g.num_vertices();
  std::vector<size_t> parent(num_vertices);
  matrix<Flow> cut({num_vertices, num_vertices},
                   std::numeric_limits<Flow>::max());

  std::vector<bool> source_side;
  for (size_t i = 1; i != num_vertices; ++i) {
    const Flow min_cut =
        min_st_cut(g, i, parent[i], rev_edge, capacity, source_side);
    for (size_t j = i + 1; j != num_vertices; ++j)
      if (source_side[j] && parent[j] == parent[i])
        parent[j] = i;
    cut[{i, parent[i]}] = cut[{parent[i], i}] = min_cut;
    for (size_t j = 0; j != i; ++j)
      cut[{i, j}] = cut[{j, i}] = std::min(min_cut, cut[{parent[i], j}]);
  }
  return cut;
}

void DictionaryTextEdit::keyPressEvent(QKeyEvent *e)
{
    if (e->modifiers() != Qt::ControlModifier)
    {
        QTextEdit::keyPressEvent(e);
        return;
    }
    if (e->key() == Qt::Key_C)    //CTRL+C
    {
        e->accept();
        if (copyAction->isEnabled())
            copy();
    }
    else if (e->key() == Qt::Key_X) //CTRL+X
    {
        e->accept();
        if (cutAction->isEnabled())
            cut();
    }
    else
        QTextEdit::keyPressEvent(e);
}

void ChatBase::initMenuBar()
{
  // Icons: /opt/kde2/share/icons/hicolor/16x16/actions

  menuBar()->clear();

  KPopupMenu* fileMenu = new KPopupMenu(menuBar(), "FileMenu");
  fileMenu->insertItem(SmallIcon("filesave"), i18n("&Save (Formatted)"), this, SLOT(saveHTML()),
		       ALT+Key_S );
  fileMenu->insertItem(SmallIcon("filesave"), i18n("S&ave (Unformatted)"), this, SLOT(saveText()), ALT+Key_A );
  fileMenu->insertItem( i18n("&Close"), this, SLOT(quit()) );
  menuBar()->insertItem( i18n("&File"), fileMenu );
  
  KPopupMenu* editMenu = new KPopupMenu(menuBar(), "EditMenu");
  editMenu->insertItem(SmallIcon("editcopy"), i18n("&Copy"), this, SLOT(copy()), CTRL+Key_C );
  editMenu->insertItem(SmallIcon("editcut"), i18n("C&ut"), this, SLOT(cut()), CTRL+Key_X );
  editMenu->insertItem(SmallIcon("editpaste"), i18n("&Paste"), this, SLOT(paste()), CTRL+Key_V );
  menuBar()->insertItem( i18n("&Edit"), editMenu);


#if 0
	KPopupMenu* buddyMenu = new KPopupMenu(menuBar(), "BuddyMenu");
	buddyMenu->insertItem("&Profile",this,SLOT(profile()),CTRL+Key_P);
  menuBar()->insertItem("&Buddy", buddyMenu);

  KPopupMenu viewMenu = new KPopupMenu(menuBar, "ViewMenu");
  menuBar->insertItem("&View", viewMenu);

  KPopupMenu insertMenu = new KPopupMenu(menuBar, "InsertMenu");
  menuBar->insertItem("&Insert", insertMenu);

  KPopupMenu insertFaceMenu = new KPopupMenu(insertMenu, "FaceMenu");

  KPopupMenu helpMenu = new KPopupMenu(kmenuBar, "HelpMenu");
  menuBar->insertItem("&Help", helpMenu);
	
#endif

} // initMenuBar

void MainWindow::initConnects()
{
    connect(ui->newFileAct, SIGNAL(triggered()), this, SLOT(newFileSlot()));
    connect(ui->openFileAct, SIGNAL(triggered()), this, SLOT(openFileSlot()));
    connect(ui->saveAct, SIGNAL(triggered()), this, SLOT(saveSlot()));
    connect(ui->saveasAct, SIGNAL(triggered()), this, SLOT(saveAsSlot()));
    connect(ui->exitAct, SIGNAL(triggered()), this, SLOT(close()));

    connect(ui->undoAct, SIGNAL(triggered()), ui->textEdit, SLOT(undo()));
    connect(ui->cutAct, SIGNAL(triggered()), ui->textEdit, SLOT(cut()));
    connect(ui->copyAct, SIGNAL(triggered()), ui->textEdit, SLOT(copy()));
    connect(ui->pasteAct, SIGNAL(triggered()), ui->textEdit, SLOT(paste()));

    connect(ui->fontAct, SIGNAL(triggered()), this, SLOT(selectFontSlot()));

    connect(ui->statuBarAct, SIGNAL(triggered()), this, SLOT(changStatuBarSlot()));

    connect(ui->aboutAct, SIGNAL(triggered()), this, SLOT(openAboutSlot()));
    connect(ui->aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
    connect(ui->findAct, SIGNAL(triggered()), this, SLOT(openFindDialog()));
    connect(ui->dateAct, SIGNAL(triggered()), this, SLOT(newDateSlot()));
}

// celociselne deleni 2 dlouhych cisel (stredoskolsky algoritmus)
// -- viz http://courses.cs.vt.edu/~cs1104/BuildingBlocks/divide.030.html
LNum operator/(LNum & dividend, LNum & divisor) {
  LNum quotient(1);
  quotient[0] = 0;
  to_normal_form(dividend);
  to_normal_form(divisor);

  // deleni nulou !!
  if (divisor.get_size() == 1 && divisor[0] == 0) {
    cout << "Division by zero!! Returning \"0\"!" << endl;
    return quotient;
  }

  // deleni mensiho cisla vetsim -> podil == 0
  if (dividend < divisor) {
    LNum oh(1);
    return oh;
  }

  // zarovnej delitel do leveho rohu delence
  int lock = dividend.get_size() - divisor.get_size();  // zarazka zpracovavane
                                                        // cifry v dividendu
  LNum portion = cut(dividend, lock, dividend.get_size()-1);

  do {
    if (!(portion<divisor)) {
      portion = portion - divisor;
      quotient.append(1);
    } else {
      quotient.append(0);
    }
    if (--lock >= 0) {
      portion.append(dividend[lock]);
    }
  } while (lock >= 0);

  to_normal_form(quotient);

  return quotient;
}

rid *dcRSys::cmd(rid *r) {

	if(is_rid(r,"put")){
		// put rid data
		if(r->cr != NULL) put_rid(cur,r->cr);
		else printf("need more parameter");

		return cur;
	}

	if(is_rid(r,"ls")) {
		cout_rid(cur);
		return cur;
	}

	if(is_rid(r,"go")){
		if(r->cr != NULL) cur = go(cur, r->cr);
		else cur = go(cur, last);
		cur_path();
		return cur;
	}

	if(is_rid(r,"path")){
		cur_path();
		return cur;
	}


	if(is_rid(r,"cut")){
		if(r->cr != NULL) cur = cut(cur, r->cr);
	}




	return cur;
	//print_rid(cur);

}

int
main (int argc, char **argv) {
  char *city;
  char *cities[] = {"bos", "ny", "la"};
  int box, store;
  int oneortwo[] = {2, 1};

  /* nd_debug = 1; */

  choose(city, 3, cities);
  mark();
  choose(store, 2, oneortwo);
  choose(box, 2, oneortwo);
  printf("(%s %d %d) ", city, store, box);
  if (coinp(city, store, box)) {
    cut();
    printf("C ");
  }
  fail();
  printf("\n");
  exit(0);
}

char	*point(t_mysh *ptr)
{
  char	*path;
  int	last_slash;
  int	index;
  int	flag;

  last_slash = index = flag = 0;
  if (my_getenv("PWD", ptr) == 0)
    return (0);
  path = ptr->recup_getenv;
  while (path[index] != '\0')
    if (path[index++] == '/')
      last_slash++;
  index = 0;
  while (flag < last_slash)
    if (path[index++] == '/')
      flag++;
  if ((path = cut(path, index)) == 0)
    return (0);
  return (path);
}

ILOUSERCUTCALLBACK4( CtCallback, IloNumVarArray, vars, int**, graph, int, num_cuts, int, max_deep ) {
	
	if( current_deep > max_deep ){
		//cout << "aa " << current_deep << endl;
		return;
	}
	
	IloNumArray vals(getEnv());
	getValues(vals, vars);
	IntegerFeasibilityArray feas( getEnv() );
	getFeasibilities( feas, vars );
	int old_win[vals.getSize()];
	memset(old_win, 0, sizeof(old_win));
	for(int n=0;  n<num_cuts; n++){
		static int cont=0;
		int cnt=0;
		for( int i = 0; i < 2; ++i ){
			IloRange cut( getEnv(), 0, 1 );
			if( getCut( vals, vars, CLQ2B, i, feas, cut, graph, old_win ) ){
				add(cut);
				cnt++;
				
			}
			else if( getCut( vals, vars, CLQ2A, i, feas, cut, graph, old_win ) ){
				cnt++;
				add(cut);
			}else{ //se nao encotrar algum corte, sai
				
								
			}
			cut.end();
		}
		if(n>1 && cnt==0)break;
	
			
	}
	feas.end();
	vals.end();
}

	bool TextField::handleHotkeys(const KeyEvent &keyEvent )
	{
		if(!wantsHotkeys())
		{
			return false;
		}
		bool  isKeyDown = false;
		#ifdef __APPLE__
				isKeyDown = keyEvent.meta();
		#else
				isKeyDown = keyEvent.control();
		#endif


		if(isKeyDown && keyEvent.getKey() == KEY_A )
		{
			selectAll();
		}
		else if(isKeyDown && keyEvent.getKey() == KEY_C )
		{
			copy();
		}
		else if(isKeyDown && keyEvent.getKey() == KEY_X )
		{
			cut();
		}
		else if(isKeyDown && keyEvent.getKey() == KEY_V )
		{
			paste();
		}
		else
		{
			return false;
		}

		return true;


	}