EXTERN_ENV #define global extern #include "stdinc.h" /* * HACKGRAV: evaluate grav field at a given particle. */ void hackgrav(bodyptr p, long ProcessId) { Local[ProcessId].pskip = p; SETV(Local[ProcessId].pos0, Pos(p)); Local[ProcessId].phi0 = 0.0; CLRV(Local[ProcessId].acc0); Local[ProcessId].myn2bterm = 0; Local[ProcessId].mynbcterm = 0; Local[ProcessId].skipself = FALSE; hackwalk(ProcessId); Phi(p) = Local[ProcessId].phi0; SETV(Acc(p), Local[ProcessId].acc0); #ifdef QUADPOLE Cost(p) = Local[ProcessId].myn2bterm + NDIM * Local[ProcessId].mynbcterm; #else Cost(p) = Local[ProcessId].myn2bterm + Local[ProcessId].mynbcterm; #endif }
void cAStarHandler::AddOpenNode(cAINode *apAINode, cAStarNode *apParent, float afDistance) { //TODO: free path check with dynamic objects here. //TODO: Some pooling here would be good. cAStarNode *pNode = hplNew( cAStarNode, (apAINode) ); //Check if it is in closed list. tAStarNodeSetIt it = m_setClosedList.find(pNode); if(it != m_setClosedList.end()){ hplDelete(pNode); return; } //Try to add it to the open list std::pair<tAStarNodeSetIt, bool> testPair = m_setOpenList.insert(pNode); if(testPair.second == false){ hplDelete(pNode); return; } pNode->mfDistance = afDistance; pNode->mfCost = Cost(afDistance,apAINode,apParent) + Heuristic(pNode->mpAINode->GetPosition(), mvGoal); pNode->mpParent = apParent; }
void do_repair(shiptype *ship) { reg int drep, cost; reg double maxrep; maxrep = REPAIR_RATE/(double)segments; /* stations repair for free, and ships docked with them */ if(Shipdata[ship->type][ABIL_REPAIR]) cost = 0; else if(ship->docked && ship->whatdest==LEVEL_SHIP && ships[ship->destshipno]->type==STYPE_STATION) cost = 0; else if(ship->docked && ship->whatorbits==LEVEL_SHIP && ships[ship->destshipno]->type==STYPE_STATION) cost=0; else { maxrep *= (double)(ship->popn) / (double)ship->max_crew; cost = (int)(0.005 * maxrep * Cost(ship)); } if (cost <= ship->resource) { use_resource(ship, cost); drep = (int)maxrep; ship->damage = MAX(0, (int)(ship->damage) - drep); } else { /* use up all of the ships resources */ drep = (int)(maxrep*((double)ship->resource/(int)cost)); use_resource(ship, ship->resource); ship->damage = MAX(0, (int)(ship->damage) - drep); } }
void Decoder::readTable(const char filename[], double prune_threshold, unsigned int prune_count){ //==================Einlesen der Phrasentabelle============================ PTree< pair <unsigned int, double> > pruningTree; //speichert für jede Übersetzung die Anzahl der eingelesenen Übersetzungen und die beste Übersetzung pair <unsigned int, double> pruningStart; //die Startkombi für den PruningTree pruningStart.first=0; pruningStart.second=(1./0.); igzstream in(filename); std::string line,token; while(getline(in,line)){ std::stringstream ist(line); double relfreq_f, relfreq_e, source_to_target, target_to_source, unigram_sprachmodell; unsigned int singlecf, singlece; vector<uint> ephrase, fphrase; //Ausgabe: relfreq_f relfreq_e # quellphrase # zielphrase # singlecf singlece # source_to_target target_to_source # unigram-sprachmodell ist >> relfreq_f >> relfreq_e >>token; // token für "#" while(ist>>token && token != "#"){ fphrase.push_back(flex->getWord_or_add(token).wordId()); } while(ist>>token && token != "#"){ ephrase.push_back(elex->getWord_or_add(token).wordId()); } ist >> singlecf >> singlece >> token >> source_to_target >> target_to_source >> token >> unigram_sprachmodell; Cost kosten=Cost(); kosten.calc(relfreq_f, relfreq_e, fphrase, ephrase, singlecf, singlece, source_to_target, target_to_source, unigram_sprachmodell); double kosten_insgesamt=kosten.cost(); pair< unsigned int, double>* pruning_infos=&pruningTree.traverse(fphrase,true,pruningStart)->c; if (kosten_insgesamt > pruning_infos->second+prune_threshold || pruning_infos->first >prune_count) continue; //pruning ergibt, wir wollen es nicht in den Ptree mitaufnehmen //if (kosten_insgesamt< pruning_infos->second) pruning_infos->second=kosten_insgesamt; _jetzt irrelevant, da ich von einer geordneten eingabe ausgehe pruning_infos->first++; schwarz->traverse(fphrase,true)->c.traverse(ephrase,true,Cost(1./0.))->c = kosten; } //cerr << " schwarz erstellt" << endl; }
void FalloffCode::Build(nat32 dim,const math::Distance & dist) { // First sort the nodes in the big array, lowest to highest by cost... data.Sort< SortOp<Node> >(); // Now construct the kd tree, starting with the lowest cost node and so on. // This allows us to check for and delete nodes that have no affect on the cost // terrain... data[0].left = null<Node*>(); data[0].right = null<Node*>(); for (nat32 i=1;i<data.Size();i++) { // Check if the node in question is of sufficiently low cost to be allowed // in... if (Cost(dim,dist,data[i].Pos())<data[i].cost) continue; // Add the node to the kd tree... data[i].left = null<Node*>(); data[i].right = null<Node*>(); nat32 depth = 0; Node * targ = &(data[0]); while (true) { nat32 ord = depth%dim; if (data[i].Pos()[ord]<targ->Pos()[ord]) { // Left... if (targ->left) { targ = targ->left; depth += 1; } else { targ->left = &(data[i]); break; } } else { // Right... if (targ->right) { targ = targ->right; depth += 1; } else { targ->right = &(data[i]); break; } } } } }
ompl::base::Cost ompl::base::goalRegionCostToGo(const State* state, const Goal* goal) { const GoalRegion* goalRegion = goal->as<GoalRegion>(); // Ensures that all states within the goal region's threshold to // have a cost-to-go of exactly zero. return Cost(std::max(goalRegion->distanceGoal(state) - goalRegion->getThreshold(), 0.0)); }
/*------------------------------------------------------------------ * Function: Feasible * Purpose: Check whether nbr could possibly lead to a better * solution if it is added to the current tour. The * function checks whether nbr has already been visited * in the current tour, and, if not, whether adding the * edge from the current city to nbr will result in * a cost less than the current best cost. * In args: All * Global in: * best_tour * Return: TRUE if the nbr can be added to the current tour. * FALSE otherwise */ int Feasible(tour_t tour, city_t city) { city_t last_city = Last_city(tour); if (!Visited(tour, city) && Tour_cost(tour) + Cost(last_city,city) < Tour_cost(best_tour)) return TRUE; else return FALSE; } /* Feasible */
/*------------------------------------------------------------------ * Function: Remove_last_city * Purpose: Remove last city from end of tour * In/out arg: * tour * Note: * Function assumes there are at least two cities on the tour -- * i.e., the hometown in tour->cities[0] won't be removed. */ void Remove_last_city(tour_t tour) { city_t old_last_city = Last_city(tour); city_t new_last_city; tour->cities[tour->count-1] = NO_CITY; (tour->count)--; new_last_city = Last_city(tour); tour->cost -= Cost(new_last_city,old_last_city); } /* Remove_last_city */
/*------------------------------------------------------------------ * Function: Best_tour * Purpose: Determine whether addition of the hometown to the * n-city input tour will lead to a best tour. * In arg: * tour: tour visiting all n cities * Ret val: * TRUE if best tour, FALSE otherwise */ int Best_tour(tour_t tour) { cost_t cost_so_far = Tour_cost(tour); city_t last_city = Last_city(tour); if (cost_so_far + Cost(last_city, home_town) < Tour_cost(best_tour)) return TRUE; else return FALSE; } /* Best_tour */
void Solve(int K,int n){ for(int i=1;i<=n;i++ ) { dp[i][1]=Cost(1,i); } for(int i=2;i<=K;i++) { k=i; Func(1,n,1,n); } cout<<dp[n][k]<<endl; }
direction_t SmallestNeighbourDirection (location_t loc) { direction_t result = NORTH; location_t neighbour; cost_t smallestCost; cost_t cost; smallestCost = MAX_COST; if (HasExit (loc, NORTH)) { neighbour = Neighbour (loc, NORTH); cost = Cost (neighbour); if (cost < smallestCost) { smallestCost = cost; result = NORTH; } } if (HasExit (loc, EAST)) { neighbour = Neighbour (loc, EAST); cost = Cost (neighbour); if (cost < smallestCost) { smallestCost = cost; result = EAST; } } if (HasExit (loc, SOUTH)) { neighbour = Neighbour (loc, SOUTH); cost = Cost (neighbour); if (cost < smallestCost) { smallestCost = cost; result = SOUTH; } } if (HasExit (loc, WEST)) { neighbour = Neighbour (loc, WEST); cost = Cost (neighbour); if (cost < smallestCost) { smallestCost = cost; result = WEST; } } return result; }
// OOD constructor TessLangModEdge::TessLangModEdge(CubeRecoContext *cntxt, int class_id) { root_ = false; cntxt_ = cntxt; dawg_ = NULL; start_edge_ = 0; end_edge_ = 0; edge_mask_ = 0; class_id_ = class_id; str_ = cntxt_->CharacterSet()->ClassString(class_id); path_cost_ = Cost(); }
void ModifiedFlood (location_t here) { direction_t direction; cost_t smallestCost; ListReset(); ListAdd (here); while (!ListIsEmpty()) { here = ListStackPop(); if (Cost (here) == 0) { continue; } direction = SmallestNeighbourDirection (here); smallestCost = Cost (Neighbour (here, direction)); SetDirection (here, direction); if (Cost (here) != smallestCost + 1) { SetCost (here, smallestCost + 1); AddOpenNeighboursToList (here); } } }
signed spellLaunchC::TurnsRequired() { signed cost = Cost(); cost -= Caster->SkillAvl; if(this == Caster->SpellQueue) cost -= Caster->SkillCommitted; if(cost <= 0) return 0; return 1 + (cost / Caster->Skill); }
// leading, trailing punc constructor and single byte UTF char TessLangModEdge::TessLangModEdge(CubeRecoContext *cntxt, const Dawg *dawg, EDGE_REF edge_idx, int class_id) { root_ = false; cntxt_ = cntxt; dawg_ = dawg; start_edge_ = edge_idx; end_edge_ = edge_idx; edge_mask_ = 0; class_id_ = class_id; str_ = cntxt_->CharacterSet()->ClassString(class_id); path_cost_ = Cost(); }
ompl::base::Cost ompl::base::MultiOptimizationObjective::stateCost(const State *s) const { Cost c = identityCost(); for (std::vector<Component>::const_iterator comp = components_.begin(); comp != components_.end(); ++comp) { c = Cost(c.value() + comp->weight * (comp->objective->stateCost(s).value())); } return c; }
ompl::base::Cost ompl::base::StateCostIntegralObjective::motionCost(const State *s1, const State *s2) const { if (interpolateMotionCost_) { Cost totalCost = this->identityCost(); int nd = si_->getStateSpace()->validSegmentCount(s1, s2); State *test1 = si_->cloneState(s1); Cost prevStateCost = this->stateCost(test1); if (nd > 1) { State *test2 = si_->allocState(); for (int j = 1; j < nd; ++j) { si_->getStateSpace()->interpolate(s1, s2, (double)j / (double)nd, test2); Cost nextStateCost = this->stateCost(test2); totalCost = Cost(totalCost.value() + this->trapezoid(prevStateCost, nextStateCost, si_->distance(test1, test2)).value()); std::swap(test1, test2); prevStateCost = nextStateCost; } si_->freeState(test2); } // Lastly, add s2 totalCost = Cost(totalCost.value() + this->trapezoid(prevStateCost, this->stateCost(s2), si_->distance(test1, s2)).value()); si_->freeState(test1); return totalCost; } return this->trapezoid(this->stateCost(s1), this->stateCost(s2), si_->distance(s1, s2)); }
void Func(int l,int r,int x,int y){ if(l>r) return; int mid=(l+r)>>1; if(vis[mid][k]) return; ll &res=dp[mid][k]; res=INT_MAX; int Id=-1; for(int i=x;i<=min(y,mid);i++) { ll Tp=dp[i][k-1]+Cost(i+1,mid); if(res>Tp) { res=Tp,Id=i; } } Func(l,mid-1,x,Id); Func(mid+1,r,Id,y); }
ompl::base::Cost ompl::base::OptimizationObjective::averageStateCost(unsigned int numStates) const { StateSamplerPtr ss = si_->allocStateSampler(); State *state = si_->allocState(); Cost totalCost(this->identityCost()); for (unsigned int i = 0 ; i < numStates ; ++i) { ss->sampleUniform(state); totalCost = this->combineCosts(totalCost, this->stateCost(state)); } si_->freeState(state); return Cost(totalCost.v / (double)numStates); }
int Cost_If_Swap(int current_cost, int i1, int i2) { int x = sol[i1]; int r; x = sol[i1]; sol[i1] = sol[i2]; sol[i2] = x; r = Cost(NULL); sol[i2] = sol[i1]; sol[i1] = x; return r; }
Cost PathLengthDirectInfSampler::heuristicSolnCost(const State* statePtr) const { //Variable //The raw data in the state std::vector<double> rawData(informedSubSpace_->getDimension()); //Get the raw data if ( StateSampler::space_->isCompound() == false ) { informedSubSpace_->copyToReals(rawData, statePtr); } else { informedSubSpace_->copyToReals(rawData, statePtr->as<CompoundState>()->components[informedIdx_]); } //Calculate and return the length return Cost(phsPtr_->getPathLength(informedSubSpace_->getDimension(), &rawData[0])); }
virtual Cost cost(OperationContext &context, QueryExecutionContext &qec) const { return Cost(); }
ompl::base::Cost ompl::base::StateCostIntegralObjective::stateCost(const State *) const { return Cost(1.0); }
ompl::base::Cost ompl::base::PathLengthOptimizationObjective::motionCost(const State *s1, const State *s2) const { return Cost(si_->distance(s1, s2)); }
bool Plan_File::Read (long offset) { //---- check the file status ---- if (!Check_File ()) return (false); if (plan == NULL) return (Status (RECORD_SIZE)); if (File_Access () != READ) return (Status (ERROR)); //---- move to a specified location in the file ---- if (offset >= 0) { if (!Offset (offset)) return (false); } //---- allocate space ---- if (allocate_memory) { if (!Setup_Record ()) return (false); } //---- read the next plan ---- if (Record_Format () == BINARY) { int num_token; if (!Db_File::Read (plan, (sizeof (Plan_Data) - sizeof (int)))) return (false); if (time_sort) { int temp = plan->key1; plan->key1 = plan->key2; plan->key2 = temp; } num_record++; num_plan++; if (Leg () == 2) { num_trip++; } else if (Leg () == 1 && Trip () == 1) { num_traveler++; } num_token = Tokens (); if (num_token > 0) { if (!Check_Size (num_token)) return (false); if (!Db_File::Read (&(plan->data [0]), num_token * sizeof (int))) return (Status (PLAN_FIELDS)); num_record++; } return (true); } else { int field, max_field, value; char buffer [40], *ptr; field = max_field = 0; while (Db_File::Read ()) { num_record++; ptr = Clean_Record (); //---- check for a blank record ---- if (ptr == NULL || *ptr == '\0') continue; //---- process the plan record ---- while (ptr != NULL) { ptr = Get_Token (ptr, buffer, sizeof (buffer)); if (buffer [0] == '\0') break; field++; value = atol (buffer); switch (field) { case 1: //---- traveler id ---- Traveler (value); num_plan++; break; case 2: //---- user field ---- break; case 3: //---- trip id ---- Trip (value); break; case 4: //---- leg id ---- Leg (value); if (value == 2) { num_trip++; } else if (value == 1 && Trip () == 1) { num_traveler++; } break; case 5: //---- time ---- Time (value); break; case 6: //---- start id ---- Start_ID (value); break; case 7: //---- start type ---- Start_Type (value); break; case 8: //---- end id ---- End_ID (value); break; case 9: //---- end type ---- End_Type (value); break; case 10: //---- duration ---- Duration (value); break; case 11: //---- stop time ---- Stop_Time (value); break; case 12: //---- max time flag ---- break; case 13: //---- cost ---- Cost (value); break; case 14: //---- gcf ---- GCF (value); break; case 15: //---- driver flag ---- Driver_Flag (value); break; case 16: //---- mode ---- Mode (value); break; case 17: //---- number of tokens ---- if (value < 0) { Status (PLAN_FIELDS); return (false); } Tokens (value); max_field = value + 17; if (value == 0) return (true); if (!Check_Size (value)) return (false); break; default: //---- token value ---- if (field > max_field) { Status (PLAN_FIELDS); return (false); } plan->data [field - 18] = value; if (field == max_field) return (true); break; } } } if (field != 0) { return (Status (PLAN_FIELDS)); } return (false); } }
bool Plan_File::Write (Plan_Data *data) { int num_token; FILE *file; //---- check the file status ---- if (!Check_File ()) return (false); if (File_Access () == READ) return (Status (ERROR)); Plan_Data *backup = NULL; if (data != NULL) { backup = plan; plan = data; } else { if (plan == NULL) return (Status (RECORD_SIZE)); } //---- write the plan data ---- file = File (); num_token = Tokens (); if (Record_Format () == BINARY) { if (time_sort) { int size, temp; size = sizeof (Plan_Data) - sizeof (int); memcpy (backup, plan, size); temp = backup->key1; backup->key1 = backup->key2; backup->key2 = temp; if (!Db_File::Write (backup, size)) goto reset; } else { if (!Db_File::Write (plan, (sizeof (Plan_Data) - sizeof (int)))) goto reset; } num_record++; num_plan++; if (Leg () == 2) { num_trip++; } else if (Leg () == 1 && Trip () == 1) { num_traveler++; } if (num_token > 0) { if (!Db_File::Write (&(plan->data [0]), num_token * sizeof (int))) goto reset; num_record++; } } else { if (fprintf (file, "%d 0 %d %d\n%d %d %d %d %d\n%d %d %d %d %d\n%d %d\n%d\n", Traveler (), Trip (), Leg (), Time (), Start_ID (), Start_Type (), End_ID (), End_Type (), Duration (), Stop_Time (), 1, Cost (), GCF (), Driver_Flag (), Mode (), num_token) < 0) goto reset; num_record += 5; num_plan++; if (Leg () == 2) { num_trip++; } else if (Leg () == 1 && Trip () == 1) { num_traveler++; } //---- write tokens ---- if (num_token > 0) { int field; int i = 0; switch (Mode ()) { case AUTO_MODE: //---- auto ---- if (Driver_Flag ()) { //---- vehicle ID and number of passengers ---- i = 2; if (fprintf (file, "%d %d\n", plan->data [0], plan->data [1]) < 0) goto reset; num_record++; } break; case TRANSIT_MODE: //---- transit ---- if (Driver_Flag ()) { //---- schedule pairs, vehicle ID, and route ID ---- i = 3; if (fprintf (file, "%d %d %d\n", plan->data [0], plan->data [1], plan->data [2]) < 0) goto reset; num_record++; } break; default: break; } //---- print the rest of the fields in groups of 10 ---- for (field=0; i < num_token; i++, field++) { if (!field) { if (fprintf (file, "%d", plan->data [i]) < 0) goto reset; num_record++; } else if (!(field % 10)) { if (fprintf (file, "\n%d", plan->data [i]) < 0) goto reset; num_record++; } else { if (fprintf (file, " %d", plan->data [i]) < 0) goto reset; } } if (field) { if (fprintf (file, "\n") < 0) goto reset; } } //---- add a blank line at the end of the plan ---- if (fprintf (file, "\n") < 0) goto reset; num_record++; Flush (); } if (data != NULL) { plan = backup; } return (true); reset: if (data != NULL) { plan = backup; } return (false); }
ompl::base::Cost ompl::base::OptimizationObjective::infiniteCost() const { return Cost(std::numeric_limits<double>::infinity()); }
ompl::base::Cost ompl::base::OptimizationObjective::identityCost() const { return Cost(0.0); }
ompl::base::Cost ompl::base::OptimizationObjective::combineCosts(Cost c1, Cost c2) const { return Cost(c1.v + c2.v); }
ompl::base::Cost ompl::base::OptimizationObjective::stateCost(const State *s) const { return Cost(1.0); }