void Utils::getDisjointLinks(Path *path1, Path *path2, std::list<StarLink*> &list, int nbLinks){ std::vector<int> indexes(nbLinks); for (int i = 0; i < nbLinks; ++i) { indexes[i] = 0; } for (StarLinkIterator it = path1->begin(); it != path1->end(); ++it) { indexes[(*it)->getIndex()] = 1; } int index = -1; for (StarLinkIterator it = path2->begin(); it != path2->end(); ++it) { StarLink* link = *it; index = link->getIndex(); if (indexes[index] == 0) { list.push_back(link); } else { indexes[index] = -1; } } for (StarLinkIterator it = path1->begin(); it != path1->end(); ++it) { StarLink* link = *it; if (indexes[link->getIndex()] == 1) { list.push_back(link); } } assert(!list.empty()); };
FPType DAGraphBWithStep::calcFlowStep(Path* minPath, Path* maxPath) const{ int nbLinks = net_->getNbLinks(); std::vector<FPType> x(nbLinks); std::vector<FPType> y(nbLinks); std::vector<int> indexes(nbLinks); for(StarLinkIterator it = maxPath->begin(); it != maxPath->end(); ++it){ y[(*it)->getIndex()] = 0.0; } for (StarLinkIterator it = minPath->begin(); it != minPath->end(); ++it) { y[(*it)->getIndex()] = 0.0; } int linkIndex = -1; int size = 0; // projecting path direction onto links FPType descDirection = minPath->getCurrCost() - maxPath->getCurrCost(); FPType oFlow = 0.0; FPType maxPathFlow = std::numeric_limits<FPType>::infinity( ); for(StarLinkIterator it = maxPath->begin(); it != maxPath->end(); ++it){ StarLink* link = *it; linkIndex = link->getIndex(); x[linkIndex] = link->getFlow(); y[linkIndex] += descDirection; indexes[size] = linkIndex; ++size; oFlow = getOriginFlow(linkIndex); if (oFlow < maxPathFlow) maxPathFlow = oFlow; } if (maxPathFlow == 0.0) { return 0.0; } for (StarLinkIterator it = minPath->begin(); it != minPath->end(); ++it) { StarLink* link = *it; linkIndex = link->getIndex(); x[linkIndex] = link->getFlow(); y[linkIndex] -= descDirection; indexes[size] = linkIndex; ++size; } (lineSearch_->getDerivative())->setDataPointers(size, x, y, indexes); // calculating upper bound for line search FPType ub = -maxPathFlow / descDirection; assert(ub > 0.0); return (lineSearch_->execute(0.0, ub) * -descDirection); };
FPType PASWithStep::getFlowShift() { FPType x[nbLinks_]; FPType y[nbLinks_]; int indexes[nbLinks_]; int size = 0; FPType dir[2]; dir[cheapSegm_] = expCost_ - cheapCost_; dir[1 - cheapSegm_] = -dir[cheapSegm_]; StarLink* link = NULL; int linkIndex = -1; for (int i = 0; i < 2; ++i) { for (std::list<StarLink*>::const_iterator it = segments_[i].begin(); it != segments_[i].end(); ++it) { link = *it; linkIndex = link->getIndex(); x[linkIndex] = link->getFlow(); y[linkIndex] = dir[i]; indexes[size] = linkIndex; ++size; } } (lineSearch_->getDerivative())->setDataPointers(size, x, y, indexes); return lineSearch_->execute(0.0, totalShift_ / dir[cheapSegm_]) * dir[cheapSegm_]; };
bool DAGraph::explore(int vertex, bool *visited){ visited[vertex] = true; preVisit(vertex); std::list<StarLink*> &linksList = (nodes_[vertex])->outLinks; int index = -1; bool backEdgeDetected = false; StarLink* link = NULL; for(std::list<StarLink*>::iterator it = linksList.begin(); it != linksList.end(); ++it){ link = *it; index = link->getNodeToIndex(); if (checkPositiveFlow(link->getIndex())) { handleExploredLink(link); if ((nodes_[index])->pre == 0) { backEdgeDetected = explore(index, visited); if (backEdgeDetected) return true; } if ((nodes_[index])->pre > 0 && (nodes_[index])->post == 0) { return handleBackEdge(link); } } } postVisit(vertex); return false; };
void Utils::getCommonLinks(PathBasedFlowMove *paths, std::list<StarLink*> &list, int nbLinks){ std::vector<int> indexes(nbLinks); std::vector<int> indexesTmp(nbLinks); std::vector<StarLink*> links(nbLinks); int size = 0; for (int i = 0; i < nbLinks; ++i) { indexes[i] = 0; indexesTmp[i] = 0; links[i] = NULL; } int index = -1; Path *path = NULL; int nbPaths = 0; for (PathAndDirection *pathDir = paths->beginPathDirection(); pathDir != NULL; pathDir = paths->getNextPathDirection()) { path = pathDir->getPath(); ++nbPaths; for(StarLinkIterator it = path->begin(); it != path->end(); ++it){ StarLink* link = *it; index = link->getIndex(); if (indexes[index] == 0) { indexesTmp[size] = index; ++size; links[index] = link; } ++indexes[index]; } } for (int i = 0; i < size; ++i) { index = indexesTmp[i]; if (indexes[index] == nbPaths) { list.push_back(links[index]); } } };
int findLinkIndex(int tail, int head, StarNetwork* net, int guessIndex){ StarLink* link = net->getLink(guessIndex); assert(link != NULL); if (link->getNodeFrom() == tail && link->getNodeTo() == head) { return link->getIndex(); } return -1; };
FPType DAGraph::checkOFlowsFeasibility(){ int nbNodes = net_->getNbNodes(); FPType total[nbNodes]; for (int i = 0; i < nbNodes; ++i) { total[i] = 0.0; } // load demands for (OriginIterator it = mat_->begin(); it != mat_->end(); ++it){ Origin* origin = *it; if (origin->getIndex() == originIndex_){ for (PairODIterator jt = origin->begin(); jt != origin->end(); ++jt) { PairOD* dest = *jt; FPType demand = dest->getDemand(); total[origin->getIndex()] += demand; total[dest->getIndex()] -= demand; } break; } } //travers network and check int i = -1; StarLink* link = NULL; std::list<StarLink*> inLinks; for (int j = 0; j < nodeSize_; ++j) { i = nodeIndexes_[j]; getInLinks(i, inLinks); for (std::list<StarLink*>::iterator it = inLinks.begin(); it != inLinks.end(); ++it){ link = *it; total[link->getNodeFromIndex()] -= getOriginFlow(link->getIndex()); total[link->getNodeToIndex()] += getOriginFlow(link->getIndex()); } } FPType max = 0.0; for (int i = 0; i < net_->getNbNodes(); ++i) { if (fabs(total[i]) > max) { max = fabs(total[i]); } } return max; };
FPType NonAdditivePC::calculate(Path *path, int odIndex) const{ assert(path != NULL && odIndex >=0); TollType totalToll = 0; FPType totalTime = 0.0; for (StarLinkIterator it = path->begin(); it != path->end(); ++it) { StarLink* link = *it; totalTime += link->getTime(); totalToll += tolls_[link->getIndex()]; } return calculate(totalTime, totalToll, odIndex); };
void assignRndTolls(ShortestPath* shPath, int destIndex, TollContainerType& tolls, FPType probabylity, TollType maxToll){ StarLink *link = shPath->getInComeLink(destIndex); int nextDest = link->getNodeFromIndex(); int linkIndex = -1; while (link != NULL) { linkIndex = link->getIndex(); tolls[linkIndex] = getRndNumberWithProbability(tolls[linkIndex], probabylity, maxToll); nextDest = link->getNodeFromIndex(); link = shPath->getInComeLink(nextDest); } };
void LinkFlows::updateLinkFlows(){ for (StarLink *link = net_->beginOnlyLink(); link != NULL; link = net_->getNextOnlyLink()) { link->setFlow(linkFlows_[link->getIndex()]); link->updateTime(); } };