C++ Cost::cost方法代码示例

void AnalyzeInput::evaltrajs(vector<Trajectory*> &trajs){
 //******Calculate Cost, Acceleration, and Distance traveled per time step*******************************
	Cost evalcost;
	this->DR = 0;
	this->C = 0;

	for (int i = 0; i < trajs.size(); i++){
		trajs[i]->R = 0;
		trajs[i]->C = 0;
		double Cmin = 100;
		double Cmax = 0;
		double Rmin = 1E9;
		double Rmax = 0;
		for (int j = 0; j < trajs[i]->particles.size()-1; j++){
			Particle* P = trajs[i]->particles[j];
			Particle* Pn = trajs[i]->particles[j+1];
			P->dr = distance(P,Pn);
			if(P->dr > Rmax)
				Rmax = P->dr;

			if(P->dr < Rmin)
				Rmin = P->dr;

            		trajs[i]->R += P->dr;

            		Pn->vel = P->dr * FRAMESPERSEC;
			if (j>1){
				Particle* Pm = trajs[i]->particles[j-1];
				P->accel = abs(Pn->vel - Pm->vel) * FRAMESPERSEC/2.0;
			}

			if (j >= COST_TRAJ_SIZE - 1){
				int s = (j) - (COST_TRAJ_SIZE -1);
				Trajectory tr;
				for (int x = s; x <= j; x++){
					tr.particles.push_back(trajs[i]->particles[x]);
				}
				Pn->cost = evalcost.cost(&tr, Pn);
			}else{
				Pn->cost = 0.0;
			}

			if(Pn->cost > Cmax)
				Cmax = Pn->cost;

			if(Pn->cost < Cmin && Pn->cost != 0)
				Cmin = Pn->cost;

			trajs[i]->C += Pn->cost;
		}
		trajs[i]->Cl = Cmin;
		trajs[i]->Ch = Cmax;
		trajs[i]->C = trajs[i]->C / ((double) trajs[i]->particles.size());
		this->C += trajs[i]->C;

		trajs[i]->Rl = Rmin;
		trajs[i]->Rh = Rmax;
		trajs[i]->R = trajs[i]->R / ((double) trajs[i]->particles.size());
		this->DR += trajs[i]->R;
	}
    	this->C = this->C / trajs.size();
	this->DR = this->DR / trajs.size();
}

std::vector<std::pair<std::vector<uint>, std::vector<SentenceInfo>  aStar::Suchalgorithmus(char* eingabe, PTree<PTree <Cost> >* blacktree, Lexicon* eLex, Lexicon* fLex){
     igzstream in(eingabe);
     aStar::flex=fLex;
     elex=eLex;
     schwarz=blacktree;


     string token,line;

	  unsigned int lineNumber = 0;
	
     while(getline(in,line)){
	  istringstream ist(line); //Einlesen des Satzes
	  
	  vector<unsigned int> sentence_id;

	  vector<HypothesisNode> Knoten;
	  Knoten.push_back(HypothesisNode());//initialisiert den ersten Knoten
	  Cost startkosten(0);
	  Knoten[0].setBestcost(startkosten);
	  //cout << "start kosten " << Knoten[0].getBestcost().cost() << endl;
	  
	  int aktPos=0; //merkt sich, wieviele Wörter schon eingelesen wurden

	  while ( ist >> token){
	       Word word_id_french=flex->getWord_or_add(token); // das word zum Wort (mit 2 Bits Sprache)
	       unsigned int id_french= word_id_french.wordId(); //die id ohne sprachbits

	       sentence_id.push_back(id_french);
	       aktPos++;
	       
	       HypothesisNode knoten_next= HypothesisNode();//initialisiert den nächsten Knoten mit den bisherigen Kosten
	       
	       for (int laengePhrase=1; laengePhrase<5; laengePhrase++){
		    int posPhraseStart=aktPos-laengePhrase; //gibt die Pos. für den Knoten, auf dem die Phrase beginnt
		    if (posPhraseStart < 0)	break; //wir befinden uns am Satzanfang und es gibt keine Phrasen

		    vector<unsigned int> fphrase;
		    for (int i=posPhraseStart; i<aktPos; i++){
			 fphrase.push_back(sentence_id[i]);
		    }
			PTree<PTree <Cost> >* schwarzRest=schwarz->traverse(fphrase);
			if (!schwarzRest)	continue; //wenn es die französische Phrase nicht gibt, nächste überprüfen
			PTree <Cost>* blauBaum=&schwarzRest->c;
			

		    
		    if (blauBaum){
			 int counter=0; //nur fürs Programmieren, damit alle Fehler ausgemerzt werden 
			 for (PTree<Cost>::iterator it=blauBaum->begin(); it!=blauBaum->end(); it++){
			      //if (counter++==10)	continue;
			      vector<unsigned int> ephrase=it->phrase();
			      
			      Cost relfreq = it->c;
				
			      if (relfreq.cost() == 1./0. )	continue;
			      
			      double cost_till_aktPos=Knoten[posPhraseStart].getBestcost().cost();
			      
			      if (cost_till_aktPos+prune > knoten_next.getBestcost().cost())	continue; //pruning ergibt, das ist eine schlecht Übersetzung
			      
			      if(cost_till_aktPos+relfreq.cost() < knoten_next.getBestcost().cost())	knoten_next.setBestcost(Knoten[posPhraseStart].getBestcost()+relfreq.cost());
			      
			      PartialTranslation* Kante= new PartialTranslation(relfreq,ephrase,&knoten_next,posPhraseStart);
			      Knoten[posPhraseStart].add_PartialTranslation_to_Inbound(Kante);
			      knoten_next.add_PartialTranslation_to_Outbound(Kante);   
			 }
		    }
		
	       }
		if (knoten_next.getOutbound().size() == 0){
			//zuerst in das englische Lexicon einfügen
			string word_string = flex->getString(sentence_id[aktPos-1]);
			unsigned int id_english=elex->getWord_or_add(word_string);

			//dann die Kante anlegen, dabei sollen die Kosten niedrig sein, da sie sowieso genutzt werden muss, kann sie auch direkt exploriert werden
			PartialTranslation* Kante= new PartialTranslation(Cost(0),vector<unsigned int>{id_english},&Knoten[aktPos],aktPos-1);
			knoten_next.setBestcost(Knoten.back().getBestcost());
			knoten_next.add_PartialTranslation_to_Outbound(Kante);
			Knoten.back().add_PartialTranslation_to_Inbound(Kante);
		}
	       Knoten.push_back(knoten_next); //letzter Knoten (node_next) hat keine eingehenden Kanten
	       
	  }
	  
	  //dotGraph(Knoten, elex);
	  aStar astar(Knoten);
	  astar.lineNumber = lineNumber;

	  std::vector<SentenceInfo> sentenceInfos = astar.print(astar.search(), sentence_id, schwarz);
	  
	  for(unsigned int i = 0; i < Knoten.size(); i++){
		 HypothesisNode& hnode = Knoten[i];
		 for(unsigned int j = 0; j < hnode.getOutbound().size(); j++)
		 	delete hnode.getOutbound()[j];
	  }
	  
	  std::pair<std::vector<uint>, std::vector<SentenceInfo> > pair_tmp;
	  pair_tmp.first = sentence_id;
	  pair_tmp.second = sentenceInfos;
//.........这里部分代码省略.........